Absortio

Email → Summary → Bookmark → Email

Add New Statistics About
← Back to list
Previous Next

GitHub - Dhaxor/super-utils-plus

https://github.com/Dhaxor/super-utils-plus • May 25, 2025 06:30

Extracto

Contribute to Dhaxor/super-utils-plus development by creating an account on GitHub.

Resumen

Resumen Principal

SuperUtilsPlus emerge como una alternativa superior a Lodash, diseñada específicamente para las exigencias del desarrollo moderno, ofreciendo un conjunto de utilidades robusto y eficiente. Se distingue por su soporte nativo de TypeScript, donde las definiciones de tipos son una prioridad, garantizando una mayor seguridad y predictibilidad en el código. Desarrollado para JavaScript ES2020+, asegura compatibilidad total con módulos ESM y CommonJS, facilitando su integración en cualquier entorno. La biblioteca ha sido optimizada para el rendimiento, con un enfoque en la velocidad y la eficiencia, y destaca por ser tree-shakable, lo que permite importar únicamente las funciones necesarias, reduciendo significativamente el tamaño del bundle. Además, su arquitectura de cero dependencias elimina el bloat innecesario, y su cobertura exhaustiva de pruebas garantiza un código fiable y predecible tanto en navegadores como en Node.js, elevando la experiencia del desarrollador.

Elementos Clave

  • Integración Superior con TypeScript y Modern JavaScript: SuperUtilsPlus se construye con TypeScript de primera clase, lo que significa que las definiciones de tipos están profundamente integradas, no son un añadido. Esto asegura una experiencia de desarrollo totalmente tipada y previene errores comunes en tiempo de compilación. Su desarrollo para ES2020+ y la compatibilidad con ESM y CommonJS lo posicionan como una herramienta de vanguardia para proyectos modernos, aprovechando las últimas características del lenguaje.
  • Optimización de Rendimiento y Tamaño del Bundle: La librería está enfocada en el rendimiento, con un código optimizado para la velocidad y la eficiencia. Una característica crucial es su capacidad de ser tree-shakable, lo que permite a los desarrolladores importar solo las funciones específicas que necesitan (ej., chunk de super-utils/array), resultando en bundles más pequeños y tiempos de carga más rápidos. La política de cero dependencias contribuye aún más a su ligereza, eliminando la carga de librerías externas.
  • Funcionalidad Extendida y Ejemplos Prácticos Diversos: SuperUtilsPlus va más allá de Lodash en su oferta de funciones de utilidad, abarcando una amplia gama de necesidades. Esto incluye manipulación de arrays (como compactNil, differenceDeep, groupBy), operaciones de objetos (get, deepClone), manejo de cadenas (camelCase), utilidades de funciones (debounce con opciones avanzadas), comprobación de tipos (isNumber con un comportamiento más intuitivo para NaN, isObject diferenciando arrays) y utilidades aleatorias (randomInt, randomString, randomUUID). Los ejemplos proporcionados demuestran la facilidad de uso y la versatilidad de estas funciones.
  • Robustez del Código y Flexibilidad de Uso: La biblioteca presume de una extensa cobertura de pruebas, garantizando la fiabilidad y consistencia de su código. Además, su diseño permite una gran flexibilidad en la forma de consumir sus funciones, tanto a través de importaciones globales (ej., import { chunk } from 'super-utils';) como mediante importaciones específicas de módulos para un tree-shaking óptimo (ej., import { chunk } from 'super-utils/array';), lo cual es fundamental para proyectos con restricciones de tamaño de paquete.

Análisis e Implicaciones

La adopción de SuperUtilsPlus implica una mejora directa en la calidad y eficiencia del código base, al aprovechar la seguridad de tipos de TypeScript y optimizaciones de rendimiento. Esto se traduce en una mayor productividad del desarrollador y una reducción en los errores en producción, siendo ideal para aplicaciones que requieren alto rendimiento y mantenibilidad a largo plazo.

Contexto Adicional

SuperUtilsPlus se distribuye bajo la Licencia MIT, fomentando su uso y modificación libre en proyectos de cualquier escala, y su capacidad para operar en entornos de navegador y Node.js subraya su amplia aplicabilidad en el ecosistema JavaScript.

Contenido

SuperUtilsPlus

A superior alternative to Lodash with improved performance, TypeScript support, and developer experience.

Features

  • Full TypeScript Support: Type definitions are first-class citizens
  • Modern JavaScript: Written for ES2020+ with full ESM and CommonJS support
  • Tree-Shakable: Only import what you need
  • Zero Dependencies: Lightweight and no bloat
  • Extensive Testing: High test coverage for reliable code
  • Extended Functionality: More utility functions than Lodash
  • Performance Focused: Optimized for speed and efficiency
  • Browser & Node.js: Works everywhere JavaScript runs

Installation

npm install super-utils-plus
# or
yarn add super-utils-plus
# or
pnpm add super-utils-plus

Usage Examples

Array Functions

import { chunk, compact, difference, flatten, flattenDeep, groupBy } from 'super-utils';

// Create chunks of arrays
chunk([1, 2, 3, 4, 5], 2);
// => [[1, 2], [3, 4], [5]]

// Remove falsy values from array
compact([0, 1, false, 2, '', 3, null, undefined, NaN]);
// => [1, 2, 3]

// Remove only null and undefined values
compactNil([0, 1, false, 2, '', 3, null, undefined, NaN]);
// => [0, 1, false, 2, '', 3, NaN]

// Find values not included in other arrays
difference([2, 1], [2, 3]);
// => [1]

// Find values not included using deep equality
differenceDeep([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }]);
// => [{ 'x': 2 }]

// Find values not included using a custom iteratee
differenceBy([2.1, 1.2], Math.floor, [2.3, 3.4]);
// => [1.2]

// Flatten an array one level
flatten([1, [2, [3, [4]], 5]]);
// => [1, 2, [3, [4]], 5]

// Recursively flatten an array
flattenDeep([1, [2, [3, [4]], 5]]);
// => [1, 2, 3, 4, 5]

// Group array elements by a key or function
groupBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': [4.2], '6': [6.1, 6.3] }

groupBy(['one', 'two', 'three'], 'length');
// => { '3': ['one', 'two'], '5': ['three'] }

Object Functions

import { get, deepClone } from 'super-utils';

// Get a value from an object with a path
const object = { 'a': [{ 'b': { 'c': 3 } }] };

get(object, 'a[0].b.c');
// => 3

get(object, ['a', '0', 'b', 'c']);
// => 3

get(object, 'a.b.c', 'default');
// => 'default'

// Create a deep clone of an object
const original = { a: 1, b: { c: 2 } };
const clone = deepClone(original);

original.b.c = 99;
// clone.b.c is still 2

String Functions

import { camelCase } from 'super-utils';

// Convert a string to camel case
camelCase('Foo Bar');
// => 'fooBar'

camelCase('--foo-bar--');
// => 'fooBar'

camelCase('__FOO_BAR__');
// => 'fooBar'

Function Utilities

import { debounce } from 'super-utils';

// Create a debounced function
const debouncedSave = debounce(saveFunction, 300, { leading: true, trailing: true });

// Call it multiple times, but it will only execute once after 300ms of inactivity
debouncedSave();
debouncedSave();
debouncedSave();

// Cancel the debounced function
debouncedSave.cancel();

// Immediately invoke the debounced function
debouncedSave.flush();

Type Checking

import { 
  isNil, isUndefined, isNull, isNumber, isString, isBoolean,
  isFunction, isArray, isObject, isPlainObject, isEmpty, isEqual 
} from 'super-utils';

// Check types
isNumber(123);      // => true
isNumber('123');    // => false
isNumber(NaN);      // => false (more intuitive than Lodash)

isString('hello');  // => true
isObject({});       // => true
isObject([]);       // => false (unlike Lodash, arrays are not objects)
isArray([]);        // => true

// Check for null or undefined
isNil(null);        // => true
isNil(undefined);   // => true
isNil(0);           // => false

// Deep equality comparison
isEqual({ a: 1, b: 2 }, { a: 1, b: 2 });  // => true
isEqual([1, 2, 3], [1, 2, 3]);            // => true

Random Utilities

import { random, randomInt, randomString, randomUUID } from 'super-utils';

// Generate a random number between min and max
random(1, 10);  // => 4.237...

// Generate a random integer between min and max (inclusive)
randomInt(1, 10);  // => 7

// Generate a random string
randomString(10);  // => "a1b2c3d4e5"
randomString(5, 'ABC');  // => "BACAB"

// Generate a random UUID
randomUUID();  // => "1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed"

Tree-Shaking with Module Imports

For optimal bundle size, import only what you need:

// Import only what you need from specific modules
import { chunk, difference } from 'super-utils/array';
import { get } from 'super-utils/object';
import { debounce } from 'super-utils/function';
import { isArray } from 'super-utils/utils';

TypeScript Support

SuperUtilsPlus is written in TypeScript and provides full type definitions:

import { get } from 'super-utils';

interface User {
  name: string;
  profile: {
    age: number;
    email: string;
  };
}

// Type-safe access with generics
const user = get<User>(data, 'users[0]');

License

MIT

Fuente: GitHub