utilitish 0.0.7 → 0.0.9

package/README.md

@@ -3,3 +3,63 @@
 Ce projet est distribué sous licence [GPL v3](https://www.gnu.org/licenses/gpl-3.0.html) © 2025 Donovan Ferreira.
 
 Ceci est une petite librairie qui ajoute plusieurs méthodes au prototype JavaScript.
+
+## Configuration Slugify
+
+La méthode `slugify()` peut être personnalisée pour répondre à vos besoins spécifiques. Consultez la JSDoc dans votre IDE pour voir tous les exemples disponibles.
+
+### Configuration globale
+
+Vous pouvez définir une configuration globale qui s'appliquera à tous les appels `slugify()` :
+
+```typescript
+import { setSlugifyConfig } from 'utilitish';
+
+// Configuration pour remplacer les symboles de genre
+setSlugifyConfig({
+    customReplacements: {
+        '♀': 'feminin',
+        '♂': 'masculin',
+    },
+    separator: '_',
+});
+
+'Test ♀'.slugify(); // "test_feminin"
+'User♂@domain.com'.slugify(); // "user_masculin_at_domain_com"
+```
+
+### Configuration par appel
+
+Vous pouvez aussi passer une configuration spécifique à chaque appel :
+
+```typescript
+// Utilise la config globale
+'Hello World'.slugify(); // "hello-world"
+
+// Override la config pour cet appel
+'Hello World'.slugify({ separator: '_' }); // "hello_world"
+```
+
+### Options de configuration
+
+- **`customReplacements`**: Remplacer des caractères spécifiques (ex: "♀" → "feminin")
+- **`separator`**: Caractère de séparation (défaut: "-")
+- **`lowercase`**: Convertir en minuscules (défaut: true)
+- **`removeAccents`**: Supprimer les accents (défaut: true)
+- **`allowedChars`**: Regex des caractères autorisés (défaut: /[a-zA-Z0-9]/)
+- **`maxLength`**: Longueur maximale du slug
+- **`transformers`**: Fonctions de transformation personnalisées
+
+### Gestion de la configuration
+
+```typescript
+import { getSlugifyConfig, resetSlugifyConfig } from 'utilitish';
+
+// Obtenir la config actuelle
+const currentConfig = getSlugifyConfig();
+
+// Réinitialiser aux valeurs par défaut
+resetSlugifyConfig();
+```
+
+Pour plus d'exemples et cas d'usage avancés, consultez les JSDoc intégrées dans votre IDE.

package/dist/array/array-constructor.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface ArrayConstructor {
         /**
@@ -97,3 +96,4 @@ declare global {
 }
 type MultiDimensionalArray<T, Dims extends number[]> = Dims extends [number, ...infer Rest extends number[]] ? MultiDimensionalArray<T[], Rest> : T;
 type WidenLiterals<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T;
+export {};

package/dist/array/array-prototype.d.ts

@@ -1,5 +1,4 @@
 import { Selector } from '../utils/core.utils';
-export {};
 declare global {
     interface Array<T> {
         /**
@@ -48,7 +47,7 @@ declare global {
          * - Returns 0 for empty arrays regardless of type
          */
         sum(this: number[]): number;
-        sum(this: T[], selector?: Selector<T, number>): number;
+        sum(this: T[], selector: Selector<T, number>): number;
         /**
          * Returns a new array with only unique elements based on strict equality (===).
          * Preserves order of first occurrence.
@@ -188,7 +187,8 @@ declare global {
          * - Returns new array; does not mutate original
          * - Empty arrays return empty array
          */
-        sortAsc(this: T[], selector?: Selector<T, number | string>): T[];
+        sortAsc(this: (number | string)[]): T[];
+        sortAsc(this: T[], selector: Selector<T, number | string>): T[];
         /**
          * Returns a new sorted copy of the array in descending order.
          * Creates a new array without modifying the original.
@@ -211,7 +211,8 @@ declare global {
          * - Returns new array; does not mutate original
          * - Empty arrays return empty array
          */
-        sortDesc(this: T[], selector?: Selector<T, number | string>): T[];
+        sortDesc(this: (number | string)[]): T[];
+        sortDesc(this: T[], selector: Selector<T, number | string>): T[];
         /**
          * Swaps the elements at two indices within the array.
          * Modifies the array in place and returns the array itself (for chaining).

package/dist/array/array-prototype.js

@@ -121,8 +121,26 @@ const logic_utils_1 = require("../utils/logic.utils");
     return map;
 });
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'toObject', function (keySelector, valueSelector) {
-    const map = this.toMap(keySelector, valueSelector);
-    return (0, logic_utils_1.mapToObject)(map);
+    let entries;
+    if (!keySelector && this.length && this.every((item) => Array.isArray(item) && item.length === 2)) {
+        entries = this;
+    }
+    else {
+        const getKey = (0, core_utils_1.resolveSelector)(keySelector, (_, index) => index);
+        const getValue = (0, core_utils_1.resolveSelector)(valueSelector, (item) => item);
+        entries = this.map((item, index) => [getKey(item, index), getValue(item)]);
+    }
+    // Validate keys
+    for (const [key] of entries) {
+        if (key === null || key === undefined) {
+            throw new TypeError(`Invalid key: key cannot be null or undefined. Key received: ${String(key)}`);
+        }
+        const keyType = typeof key;
+        if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
+            throw new TypeError(`Invalid key type: keys must be string, number, or symbol, received ${keyType}. Key value: ${String(key)}`);
+        }
+    }
+    return Object.fromEntries(entries);
 });
 (0, core_utils_1.defineIfNotExists)(Array.prototype, 'toSet', function (selector) {
     const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);

package/dist/index.d.ts

@@ -4,3 +4,4 @@ import './map/map-prototype';
 import './object/object-prototype';
 import './set/set-prototype';
 import './string/string-prototype';
+export { getSlugifyConfig, resetSlugifyConfig, setSlugifyConfig, type SlugifyConfig } from './utils/slugify.config';

package/dist/index.js

@@ -1,8 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSlugifyConfig = exports.resetSlugifyConfig = exports.getSlugifyConfig = void 0;
 require("./array/array-constructor");
 require("./array/array-prototype");
 require("./map/map-prototype");
 require("./object/object-prototype");
 require("./set/set-prototype");
 require("./string/string-prototype");
+// Export slugify configuration functions
+var slugify_config_1 = require("./utils/slugify.config");
+Object.defineProperty(exports, "getSlugifyConfig", { enumerable: true, get: function () { return slugify_config_1.getSlugifyConfig; } });
+Object.defineProperty(exports, "resetSlugifyConfig", { enumerable: true, get: function () { return slugify_config_1.resetSlugifyConfig; } });
+Object.defineProperty(exports, "setSlugifyConfig", { enumerable: true, get: function () { return slugify_config_1.setSlugifyConfig; } });

package/dist/map/map-prototype.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface Map<K, V> {
         /**
@@ -83,3 +82,4 @@ declare global {
         ensureArray<L extends Array<any>>(this: Map<K, L>, key: K): L;
     }
 }
+export {};

package/dist/map/map-prototype.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_utils_1 = require("../utils/core.utils");
-const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Map.prototype.toList
  */
@@ -34,7 +33,17 @@ const logic_utils_1 = require("../utils/logic.utils");
  * @see Map.prototype.toObject
  */
 (0, core_utils_1.defineIfNotExists)(Map.prototype, 'toObject', function () {
-    return (0, logic_utils_1.mapToObject)(this);
+    const entries = Array.from(this.entries());
+    for (const [key] of entries) {
+        if (key === null || key === undefined) {
+            throw new TypeError(`Invalid key: key cannot be null or undefined. Key received: ${String(key)}`);
+        }
+        const keyType = typeof key;
+        if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
+            throw new TypeError(`Invalid key type: keys must be string, number, or symbol, received ${keyType}. Key value: ${String(key)}`);
+        }
+    }
+    return Object.fromEntries(entries);
 });
 /**
  * @see Map.prototype.ensureArray

package/dist/object/object-prototype.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface Object {
         /**
@@ -71,5 +70,44 @@ declare global {
          * - null and undefined are handled correctly
          */
         deepEquals(other: unknown): boolean;
+        /**
+         * Converts the object to a stable string representation with sorted keys.
+         * The resulting string is deterministic: the same object will always produce the same string.
+         *
+         * @returns {string} A stable string representation of the object
+         *
+         * @example
+         * const obj = { b: 2, a: 1 };
+         * obj.stableStringify(); // '{"a":1,"b":2}'
+         *
+         * const obj2 = { a: 1, b: 2 };
+         * obj2.stableStringify(); // '{"a":1,"b":2}' (same result, different key order)
+         *
+         * @remarks
+         * - Object keys are sorted alphabetically to ensure stable output
+         * - Arrays maintain their element order
+         * - Null and primitives are handled using JSON.stringify
+         */
+        stableStringify(): string;
+        /**
+         * Generates a stable hash of the object using FNV-1a algorithm.
+         * The hash is deterministic: the same object will always produce the same hash.
+         *
+         * @returns {string} A hexadecimal string representing the hash of the object
+         *
+         * @example
+         * const obj = { b: 2, a: 1 };
+         * obj.stableHash(); // '7a8c9f2b'
+         *
+         * const obj2 = { a: 1, b: 2 };
+         * obj2.stableHash(); // '7a8c9f2b' (same hash, different key order)
+         *
+         * @remarks
+         * - Uses FNV-1a (Fowler–Noll–Vo) hashing algorithm
+         * - The object is first converted to a stable string using stableStringify()
+         * - The hash is returned as a hexadecimal string
+         */
+        stableHash(): string;
     }
 }
+export {};

package/dist/object/object-prototype.js

@@ -1,26 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const defineIfNotExists = (name, fn) => {
-    const descriptor = Object.getOwnPropertyDescriptor(Object.prototype, name);
-    if (!descriptor || descriptor.writable || descriptor.configurable) {
-        Object.defineProperty(Object.prototype, name, {
-            value: fn,
-            enumerable: false,
-            configurable: true,
-            writable: true,
-        });
-    }
-};
+const core_utils_1 = require("../utils/core.utils");
 /**
  * @see Object.prototype.deepClone
  */
-defineIfNotExists('deepClone', function () {
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepClone', function () {
     return structuredClone(this);
 });
 /**
  * @see Object.prototype.deepMerge
  */
-defineIfNotExists('deepMerge', function (source) {
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepMerge', function (source) {
     if (typeof source !== 'object' || source === null) {
         throw new TypeError('Source must be a non-null object');
     }
@@ -43,7 +33,7 @@ defineIfNotExists('deepMerge', function (source) {
 /**
  * @see Object.prototype.deepEquals
  */
-defineIfNotExists('deepEquals', function (other) {
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepEquals', function (other) {
     function eq(a, b) {
         // Functions: always false (even if code is the same)
         if (typeof a === 'function' || typeof b === 'function') {
@@ -95,3 +85,33 @@ defineIfNotExists('deepEquals', function (other) {
     }
     return eq(this, other);
 });
+/**
+ * @see Object.prototype.stableStringify
+ */
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'stableStringify', function () {
+    const stringify = (v) => {
+        if (v === null || typeof v !== 'object') {
+            return JSON.stringify(v);
+        }
+        if (Array.isArray(v)) {
+            return '[' + v.map(stringify).join(',') + ']';
+        }
+        const obj = v;
+        const keys = Object.keys(obj).sort();
+        const entries = keys.map((key) => JSON.stringify(key) + ':' + stringify(obj[key]));
+        return '{' + entries.join(',') + '}';
+    };
+    return stringify(this);
+});
+/**
+ * @see Object.prototype.stableHash
+ */
+(0, core_utils_1.defineIfNotExists)(Object.prototype, 'stableHash', function () {
+    const str = this.stableStringify();
+    let hash = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16);
+});

package/dist/object/object-prototype.spec.js

@@ -107,4 +107,78 @@ describe('Object.prototype', () => {
             });
         });
     });
+    describe('stableStringify()', () => {
+        it('should stringify plain objects with sorted keys', () => {
+            const obj = { b: 2, a: 1 };
+            expect(obj.stableStringify()).toBe('{"a":1,"b":2}');
+        });
+        it('should produce same string regardless of key order', () => {
+            const obj1 = { b: 2, a: 1, c: 3 };
+            const obj2 = { c: 3, a: 1, b: 2 };
+            expect(obj1.stableStringify()).toBe(obj2.stableStringify());
+        });
+        it('should stringify arrays with element order preserved', () => {
+            const arr = [1, 2, 3];
+            expect(arr.stableStringify()).toBe('[1,2,3]');
+        });
+        it('should handle nested objects', () => {
+            const obj = { b: { d: 4, c: 3 }, a: 1 };
+            expect(obj.stableStringify()).toBe('{"a":1,"b":{"c":3,"d":4}}');
+        });
+        it('should handle arrays within objects', () => {
+            const obj = { a: [1, 2], b: 2 };
+            expect(obj.stableStringify()).toBe('{"a":[1,2],"b":2}');
+        });
+        it('should handle empty objects and arrays', () => {
+            expect({}.stableStringify()).toBe('{}');
+            expect([].stableStringify()).toBe('[]');
+        });
+        it('should handle undefined values in objects', () => {
+            const obj = { a: undefined, b: 1 };
+            expect(obj.stableStringify()).toBe('{"a":undefined,"b":1}');
+        });
+    });
+    describe('stableHash()', () => {
+        it('should generate same hash for objects with different key order', () => {
+            const obj1 = { b: 2, a: 1 };
+            const obj2 = { a: 1, b: 2 };
+            expect(obj1.stableHash()).toBe(obj2.stableHash());
+        });
+        it('should generate different hashes for different objects', () => {
+            const obj1 = { a: 1, b: 2 };
+            const obj2 = { a: 1, b: 3 };
+            expect(obj1.stableHash()).not.toBe(obj2.stableHash());
+        });
+        it('should generate consistent hashes', () => {
+            const obj = { a: 1, b: 2 };
+            const hash1 = obj.stableHash();
+            const hash2 = obj.stableHash();
+            expect(hash1).toBe(hash2);
+        });
+        it('should generate hex string', () => {
+            const obj = { a: 1 };
+            const hash = obj.stableHash();
+            expect(/^[0-9a-f]+$/.test(hash)).toBe(true);
+        });
+        it('should handle arrays', () => {
+            const arr1 = [1, 2, 3];
+            const arr2 = [1, 2, 3];
+            expect(arr1.stableHash()).toBe(arr2.stableHash());
+        });
+        it('should handle different arrays', () => {
+            const arr1 = [1, 2, 3];
+            const arr2 = [3, 2, 1];
+            expect(arr1.stableHash()).not.toBe(arr2.stableHash());
+        });
+        it('should handle nested structures', () => {
+            const obj1 = { a: [1, { b: 2 }], c: 3 };
+            const obj2 = { c: 3, a: [1, { b: 2 }] };
+            expect(obj1.stableHash()).toBe(obj2.stableHash());
+        });
+        it('should handle empty objects', () => {
+            const obj1 = {};
+            const obj2 = {};
+            expect(obj1.stableHash()).toBe(obj2.stableHash());
+        });
+    });
 });

package/dist/set/set-prototype.d.ts

@@ -1,4 +1,3 @@
-export {};
 declare global {
     interface Set<T> {
         /**
@@ -103,3 +102,4 @@ declare global {
         intersection(...others: Set<T>[]): Set<T>;
     }
 }
+export {};

package/dist/string/string-prototype.d.ts

@@ -1,4 +1,4 @@
-export {};
+import { SlugifyConfig } from '../utils/slugify.config';
 declare global {
     interface String {
         /**
@@ -138,24 +138,61 @@ declare global {
         /**
          * Converts the string into a URL-friendly slug format.
          * Combines normalization, lowercasing, whitespace handling, and special character removal.
+         * Can be customized using global configuration or per-call options.
          *
          * @this {string} The string to slugify
+         * @param {SlugifyConfig} [config] - Optional configuration to override global settings
          * @returns {string} A URL-safe slug version of the string
          *
          * @example
+         * // Basic usage (default config)
          * 'Hello World'.slugify(); // 'hello-world'
          * 'Héllo Wørld'.slugify(); // 'hello-world'
          * 'Hello  World!!!'.slugify(); // 'hello-world'
          *
+         * @example
+         * // Custom replacements
+         * 'Test ♀'.slugify({ customReplacements: { "♀": "feminin" } }); // 'test-feminin'
+         * 'User♂@domain.com'.slugify({ customReplacements: { "♂": "masculin", "@": "at" } }); // 'usermasculinatdomain-com'
+         *
+         * @example
+         * // Custom separator
+         * 'Hello World'.slugify({ separator: "_" }); // 'hello_world'
+         * 'Hello World'.slugify({ separator: "--" }); // 'hello--world'
+         *
+         * @example
+         * // Preserve accents
+         * 'Éléphant'.slugify({ removeAccents: false }); // 'éléphant'
+         *
+         * @example
+         * // Disable lowercasing
+         * 'Hello World'.slugify({ lowercase: false }); // 'Hello-World'
+         *
+         * @example
+         * // Max length
+         * 'Very long string'.slugify({ maxLength: 8 }); // 'very-lon'
+         *
+         * @example
+         * // Custom transformers
+         * 'hello world'.slugify({
+         *   transformers: [(str) => str.replace(/world/g, 'universe')]
+         * }); // 'hello-universe'
+         *
          * @remarks
-         * - Normalizes Unicode characters (NFD decomposition)
-         * - Removes accents and diacritical marks
-         * - Converts to lowercase
-         * - Replaces spaces and special characters with hyphens
-         * - Removes leading/trailing hyphens
-         * - Collapses multiple consecutive hyphens into one
+         * - Uses global configuration by default (see setSlugifyConfig)
+         * - Normalizes Unicode characters (NFD decomposition) by default
+         * - Removes accents and diacritical marks by default
+         * - Converts to lowercase by default
+         * - Replaces spaces and special characters with separator (hyphen by default)
+         * - Removes leading/trailing separators
+         * - Collapses multiple consecutive separators into one
+         *
+         * @see setSlugifyConfig
+         * @see getSlugifyConfig
+         * @see resetSlugifyConfig
          */
         slugify(): string;
+        slugify(config: SlugifyConfig): string;
         /**
          * Replaces a substring between `start` and `end` indices with a given string.
          * Provides precise control over which portion of the string to replace.

package/dist/string/string-prototype.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_utils_1 = require("../utils/core.utils");
+const slugify_utils_1 = require("../utils/slugify.utils");
 /**
  * @see String.prototype.splitWords
  */
@@ -61,12 +62,8 @@ const core_utils_1 = require("../utils/core.utils");
 /**
  * @see String.prototype.slugify
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugify', function () {
-    return this.normalize('NFD')
-        .replace(/[̀-ͯ]/g, '')
-        .replace(/[^a-zA-Z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .toLowerCase();
+(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugify', function (config) {
+    return (0, slugify_utils_1.slugifyString)(this, config);
 });
 /**
  * @see String.prototype.capitalize

package/dist/string/string-prototype.spec.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../string/string-prototype");
+const slugify_config_1 = require("../utils/slugify.config");
 describe('String.prototype', () => {
     describe('capitalize()', () => {
         it('should capitalize the first character', () => {
@@ -67,11 +68,80 @@ describe('String.prototype', () => {
         });
     });
     describe('slugify()', () => {
-        it('should slugify a string', () => {
+        beforeEach(() => {
+            (0, slugify_config_1.resetSlugifyConfig)(); // Reset to defaults before each test
+        });
+        it('should slugify a string with default config', () => {
             expect('Hello World!'.slugify()).toBe('hello-world');
             expect("Éléphant à l'été".slugify()).toBe('elephant-a-l-ete');
             expect('  --Hello__World--  '.slugify()).toBe('hello-world');
         });
+        describe('custom replacements', () => {
+            it('should apply custom replacements per call', () => {
+                expect('Test ♀'.slugify({ customReplacements: { '♀': 'feminin' } })).toBe('test-feminin');
+                expect('User♂@domain.com'.slugify({ customReplacements: { '♂': 'masculin', '@': 'at' } })).toBe('usermasculinatdomain-com');
+            });
+            it('should handle special regex characters in replacements', () => {
+                expect('Test [bracket]'.slugify({ customReplacements: { '[': 'left', ']': 'right' } })).toBe('test-leftbracketright');
+            });
+        });
+        describe('separator customization', () => {
+            it('should use custom separator globally', () => {
+                (0, slugify_config_1.setSlugifyConfig)({ separator: '_' });
+                expect('Hello World'.slugify()).toBe('hello_world');
+                expect('Test String'.slugify()).toBe('test_string');
+            });
+            it('should use custom separator per call', () => {
+                expect('Hello World'.slugify({ separator: '_' })).toBe('hello_world');
+                expect('Test String'.slugify({ separator: '__' })).toBe('test__string');
+            });
+        });
+        describe('case transformation', () => {
+            it('should respect lowercase setting globally', () => {
+                (0, slugify_config_1.setSlugifyConfig)({ lowercase: false });
+                expect('Hello World'.slugify()).toBe('Hello-World');
+            });
+            it('should respect lowercase setting per call', () => {
+                expect('Hello World'.slugify({ lowercase: false })).toBe('Hello-World');
+            });
+        });
+        describe('accent removal', () => {
+            it('should respect removeAccents setting per call', () => {
+                expect('Éléphant'.slugify({ removeAccents: false })).toBe('éléphant');
+            });
+        });
+        describe('allowed characters', () => {
+            it('should use custom allowed characters', () => {
+                expect('Hello123!@#'.slugify({ allowedChars: /[a-zA-Z0-9_]/ })).toBe('hello123');
+            });
+        });
+        describe('max length', () => {
+            it('should truncate to max length', () => {
+                expect('very-long-string-here'.slugify({ maxLength: 10 })).toBe('very-long');
+                expect('short'.slugify({ maxLength: 10 })).toBe('short');
+            });
+            it('should remove trailing separator after truncation', () => {
+                expect('hello-world-test'.slugify({ maxLength: 8 })).toBe('hello-wo');
+            });
+        });
+        describe('custom transformers', () => {
+            it('should apply custom transformers', () => {
+                const config = {
+                    transformers: [
+                        (str) => str.replace(/test/g, 'example'),
+                        (str) => str.toUpperCase(),
+                    ],
+                    lowercase: false,
+                };
+                expect('this is a test'.slugify(config)).toBe('THIS-IS-A-EXAMPLE');
+            });
+        });
+        describe('configuration merging', () => {
+            it('should merge global and local config correctly', () => {
+                // Local config should override global defaults
+                expect('Test ♀'.slugify({ separator: '_', customReplacements: { '♀': 'female' } })).toBe('test_female');
+            });
+        });
     });
     describe('replaceRange()', () => {
         it('should replace a single character at the given index', () => {

package/dist/utils/logic.utils.d.ts

@@ -1,3 +1,2 @@
 import { Selector } from './core.utils';
-export declare function mapToObject<K extends PropertyKey, V>(map: Map<K, V>): Record<K, V>;
 export declare function sortBy<T>(arr: T[], direction: 'asc' | 'desc', selector?: Selector<T, number | string>): T[];

package/dist/utils/logic.utils.js

@@ -1,24 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapToObject = mapToObject;
 exports.sortBy = sortBy;
 const core_utils_1 = require("./core.utils");
-function mapToObject(map) {
-    const obj = {};
-    for (const [key, value] of map) {
-        // Validate that key is not null or undefined
-        if (key === null || key === undefined) {
-            throw new TypeError(`Invalid key: key cannot be null or undefined. Key received: ${String(key)}`);
-        }
-        const keyType = typeof key;
-        // Only allow string, number, or symbol
-        if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
-            throw new TypeError(`Invalid key type: keys must be string, number, or symbol, received ${keyType}. Key value: ${String(key)}`);
-        }
-        obj[key] = value;
-    }
-    return obj;
-}
 function sortBy(arr, direction, selector) {
     if (arr.length === 0)
         return arr.slice();

package/dist/utils/slugify.config.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Configuration types and interfaces for the slugify functionality.
+ * Provides comprehensive customization options for URL slug generation.
+ */
+export interface SlugifyConfig {
+    /**
+     * Custom character replacements applied before other transformations.
+     * Useful for replacing special symbols with words or other characters.
+     *
+     * @example
+     * { "♀": "feminin", "♂": "masculin", "@": "at" }
+     */
+    customReplacements?: Record<string, string>;
+    /**
+     * Character used to separate words in the slug.
+     * @default "-"
+     */
+    separator?: string;
+    /**
+     * Whether to convert the result to lowercase.
+     * @default true
+     */
+    lowercase?: boolean;
+    /**
+     * Whether to remove accents and diacritical marks.
+     * @default true
+     */
+    removeAccents?: boolean;
+    /**
+     * Regular expression pattern for characters to keep.
+     * Characters not matching this pattern will be replaced with the separator.
+     * @default "/[a-zA-Z0-9]/"
+     */
+    allowedChars?: RegExp;
+    /**
+     * Maximum length of the resulting slug (excluding separator trimming).
+     * If exceeded, the slug will be truncated.
+     * @default undefined (no limit)
+     */
+    maxLength?: number;
+    /**
+     * Custom transformation functions applied in order.
+     * Each function receives the current string state and should return the transformed string.
+     *
+     * @example
+     * [(str) => str.replace(/custom-pattern/g, 'replacement')]
+     */
+    transformers?: Array<(str: string) => string>;
+}
+/**
+ * Default configuration for slugify operations.
+ * Provides sensible defaults that can be overridden by users.
+ */
+export declare const defaultSlugifyConfig: SlugifyConfig;
+/**
+ * Sets the global slugify configuration that will be used by default.
+ * Merges the provided config with the existing global config.
+ *
+ * @param config - Partial configuration object to merge with current global config
+ *
+ * @example
+ * setSlugifyConfig({
+ *   customReplacements: { "♀": "feminin", "♂": "masculin" },
+ *   separator: "_"
+ * });
+ */
+export declare function setSlugifyConfig(config: SlugifyConfig): void;
+/**
+ * Gets the current global slugify configuration.
+ * Returns a copy to prevent external mutations.
+ *
+ * @returns Current global configuration object
+ */
+export declare function getSlugifyConfig(): SlugifyConfig;
+/**
+ * Resets the global slugify configuration to default values.
+ */
+export declare function resetSlugifyConfig(): void;

package/dist/utils/slugify.config.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Configuration types and interfaces for the slugify functionality.
+ * Provides comprehensive customization options for URL slug generation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSlugifyConfig = void 0;
+exports.setSlugifyConfig = setSlugifyConfig;
+exports.getSlugifyConfig = getSlugifyConfig;
+exports.resetSlugifyConfig = resetSlugifyConfig;
+/**
+ * Default configuration for slugify operations.
+ * Provides sensible defaults that can be overridden by users.
+ */
+exports.defaultSlugifyConfig = {
+    customReplacements: {},
+    separator: '-',
+    lowercase: true,
+    removeAccents: true,
+    allowedChars: undefined, // Will be determined dynamically based on removeAccents
+    maxLength: undefined,
+    transformers: [],
+};
+/**
+ * Global configuration instance that can be modified by users.
+ * Starts with default values but can be updated via setSlugifyConfig().
+ */
+let globalSlugifyConfig = { ...exports.defaultSlugifyConfig };
+/**
+ * Sets the global slugify configuration that will be used by default.
+ * Merges the provided config with the existing global config.
+ *
+ * @param config - Partial configuration object to merge with current global config
+ *
+ * @example
+ * setSlugifyConfig({
+ *   customReplacements: { "♀": "feminin", "♂": "masculin" },
+ *   separator: "_"
+ * });
+ */
+function setSlugifyConfig(config) {
+    globalSlugifyConfig = { ...globalSlugifyConfig, ...config };
+}
+/**
+ * Gets the current global slugify configuration.
+ * Returns a copy to prevent external mutations.
+ *
+ * @returns Current global configuration object
+ */
+function getSlugifyConfig() {
+    return { ...globalSlugifyConfig };
+}
+/**
+ * Resets the global slugify configuration to default values.
+ */
+function resetSlugifyConfig() {
+    globalSlugifyConfig = { ...exports.defaultSlugifyConfig };
+}

package/dist/utils/slugify.utils.d.ts

@@ -0,0 +1,10 @@
+import { SlugifyConfig } from './slugify.config';
+/**
+ * Applies slugify transformations to a string based on the provided configuration.
+ * This is the core logic for converting strings to URL-friendly slugs.
+ *
+ * @param str - The input string to slugify
+ * @param config - Configuration object (uses global config if not provided)
+ * @returns The slugified string
+ */
+export declare function slugifyString(str: string, config?: SlugifyConfig): string;

package/dist/utils/slugify.utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugifyString = slugifyString;
+const slugify_config_1 = require("./slugify.config");
+/**
+ * Applies slugify transformations to a string based on the provided configuration.
+ * This is the core logic for converting strings to URL-friendly slugs.
+ *
+ * @param str - The input string to slugify
+ * @param config - Configuration object (uses global config if not provided)
+ * @returns The slugified string
+ */
+function slugifyString(str, config) {
+    // Merge provided config with global config
+    const finalConfig = { ...(0, slugify_config_1.getSlugifyConfig)(), ...config };
+    let result = str;
+    // 1. Apply custom replacements first
+    if (finalConfig.customReplacements && Object.keys(finalConfig.customReplacements).length > 0) {
+        for (const [pattern, replacement] of Object.entries(finalConfig.customReplacements)) {
+            // Escape special regex characters in the pattern
+            const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            result = result.replace(new RegExp(escapedPattern, 'g'), replacement);
+        }
+    }
+    // 2. Apply custom transformers
+    if (finalConfig.transformers && finalConfig.transformers.length > 0) {
+        for (const transformer of finalConfig.transformers) {
+            result = transformer(result);
+        }
+    }
+    // 3. Remove accents if configured
+    if (finalConfig.removeAccents) {
+        result = result.normalize('NFD').replace(/[̀-ͯ]/g, '');
+    }
+    // 4. Replace non-allowed characters with separator
+    const separator = finalConfig.separator || '-';
+    // Determine allowed characters based on removeAccents setting
+    const defaultAllowedChars = finalConfig.removeAccents ? /[a-zA-Z0-9]/ : /[a-zA-Z0-9\u00C0-\u017F]/; // Include accented Latin characters if accents are preserved
+    const allowedRegex = finalConfig.allowedChars || defaultAllowedChars;
+    const allowedPattern = allowedRegex.source;
+    // Extract the character class content (remove surrounding brackets if present)
+    const charClass = allowedPattern.startsWith('[') && allowedPattern.endsWith(']') ? allowedPattern.slice(1, -1) : allowedPattern;
+    result = result.replace(new RegExp(`[^${charClass}]+`, 'g'), separator);
+    // 5. Remove leading/trailing separators
+    result = result.replace(new RegExp(`^${separator}+|${separator}+$`, 'g'), '');
+    // 6. Convert to lowercase if configured
+    if (finalConfig.lowercase) {
+        result = result.toLowerCase();
+    }
+    // 7. Apply max length if configured
+    if (finalConfig.maxLength && finalConfig.maxLength > 0) {
+        result = result.slice(0, finalConfig.maxLength);
+        // Remove trailing separator after truncation
+        result = result.replace(new RegExp(`${separator}$`), '');
+    }
+    // 8. Collapse multiple consecutive separators
+    result = result.replace(new RegExp(`${separator}+`, 'g'), separator);
+    return result;
+}

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "utilitish",
-  "version": "0.0.7",
+  "version": "0.0.9",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FDonovan12/utilitish.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",