utilitish 0.0.8 → 0.0.10

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-prototype.d.ts

@@ -47,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.
@@ -187,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.
@@ -210,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.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/string/string-prototype.d.ts

@@ -1,3 +1,4 @@
+import { SlugifyConfig } from '../utils/slugify.config';
 declare global {
     interface String {
         /**
@@ -137,24 +138,62 @@ 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(SlugifyConfig.builder().withCustomReplacements({ "♀": "feminin" }).build()); // 'test-feminin'
+         * 'User♂@domain.com'.slugify(SlugifyConfig.builder().withCustomReplacements({ "♂": "masculin", "@": "at" }).build()); // 'usermasculinatdomain-com'
+         *
+         * @example
+         * // Custom separator
+         * 'Hello World'.slugify(SlugifyConfig.builder().withSeparator("_").build()); // 'hello_world'
+         * 'Hello World'.slugify(SlugifyConfig.builder().withSeparator("--").build()); // 'hello--world'
+         *
+         * @example
+         * // Preserve accents
+         * 'Éléphant'.slugify(SlugifyConfig.builder().withRemoveAccents(false).build()); // 'éléphant'
+         *
+         * @example
+         * // Disable lowercasing
+         * 'Hello World'.slugify(SlugifyConfig.builder().withCase('default').build()); // 'Hello-World'
+         *
+         * @example
+         * // Max length
+         * 'Very long string'.slugify(SlugifyConfig.builder().withMaxLength(8).build()); // 'very-lon'
+         *
+         * @example
+         * // Custom transformers
+         * 'hello world'.slugify(SlugifyConfig.builder()
+         *   .withTransformers([(str) => str.replace(/world/g, 'universe')])
+         *   .build()); // '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 SlugifyConfig
+         * @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.
@@ -178,4 +217,3 @@ declare global {
         replaceRange(start: number, end: number, replaceString?: string): string;
     }
 }
-export {};

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,98 @@ 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(slugify_config_1.SlugifyConfig.builder().withCustomReplacements({ '♀': 'feminin' }).build())).toBe('test-feminin');
+                expect('User♂@domain.com'.slugify(slugify_config_1.SlugifyConfig.builder().withCustomReplacements({ '♂': 'masculin', '@': 'at' }).build())).toBe('usermasculinatdomain-com');
+            });
+            it('should handle special regex characters in replacements', () => {
+                expect('Test [bracket]'.slugify(slugify_config_1.SlugifyConfig.builder().withCustomReplacements({ '[': 'left', ']': 'right' }).build())).toBe('test-leftbracketright');
+            });
+        });
+        describe('separator customization', () => {
+            it('should use custom separator globally', () => {
+                (0, slugify_config_1.setSlugifyConfig)(slugify_config_1.SlugifyConfig.builder().withSeparator('_').build());
+                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(slugify_config_1.SlugifyConfig.builder().withSeparator('_').build())).toBe('hello_world');
+                expect('Test String'.slugify(slugify_config_1.SlugifyConfig.builder().withSeparator('__').build())).toBe('test__string');
+            });
+        });
+        describe('case transformation', () => {
+            it('should respect lowercase setting globally', () => {
+                (0, slugify_config_1.setSlugifyConfig)(slugify_config_1.SlugifyConfig.builder().withCase('default').build());
+                expect('Hello World'.slugify()).toBe('Hello-World');
+            });
+            it('should respect lowercase setting per call', () => {
+                expect('Hello World'.slugify(slugify_config_1.SlugifyConfig.builder().withCase('default').build())).toBe('Hello-World');
+            });
+        });
+        describe('accent removal', () => {
+            it('should respect removeAccents setting per call', () => {
+                expect('Éléphant'.slugify(slugify_config_1.SlugifyConfig.builder().withRemoveAccents(false).build())).toBe('éléphant');
+            });
+        });
+        describe('allowed characters', () => {
+            it('should use custom allowed characters', () => {
+                expect('Hello123!@#'.slugify(slugify_config_1.SlugifyConfig.builder()
+                    .withAllowedChars(/[a-zA-Z0-9_]/)
+                    .build())).toBe('hello123');
+            });
+            it('should throw for invalid allowedChars regex in call', () => {
+                expect(() => slugify_config_1.SlugifyConfig.builder()
+                    .withAllowedChars(/foo|bar/)
+                    .build()).toThrowError(/Invalid allowedChars:/);
+            });
+            it('should throw for invalid allowedChars regex in global config', () => {
+                expect(() => (0, slugify_config_1.setSlugifyConfig)(slugify_config_1.SlugifyConfig.builder()
+                    .withAllowedChars(/foo|bar/)
+                    .build())).toThrowError(/Invalid allowedChars:/);
+            });
+        });
+        describe('separator special characters', () => {
+            it('should handle regex-special separators without breaking', () => {
+                expect('a b+c'.slugify(slugify_config_1.SlugifyConfig.builder().withSeparator('.').build())).toBe('a.b.c');
+                expect('a.b.c'.slugify(slugify_config_1.SlugifyConfig.builder().withSeparator('*').build())).toBe('a*b*c');
+            });
+        });
+        describe('max length', () => {
+            it('should truncate to max length', () => {
+                expect('very-long-string-here'.slugify(slugify_config_1.SlugifyConfig.builder().withMaxLength(10).build())).toBe('very-long');
+                expect('short'.slugify(slugify_config_1.SlugifyConfig.builder().withMaxLength(10).build())).toBe('short');
+            });
+            it('should remove trailing separator after truncation', () => {
+                expect('hello-world-test'.slugify(slugify_config_1.SlugifyConfig.builder().withMaxLength(8).build())).toBe('hello-wo');
+            });
+        });
+        describe('custom transformers', () => {
+            it('should apply custom transformers', () => {
+                const config = slugify_config_1.SlugifyConfig.builder()
+                    .withTransformers([
+                    (str) => str.replace(/test/g, 'example'),
+                    (str) => str.toUpperCase(),
+                ])
+                    .withCase('upper')
+                    .build();
+                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(slugify_config_1.SlugifyConfig.builder().withSeparator('_').withCustomReplacements({ '♀': 'female' }).build())).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,98 @@
+/**
+ * Configuration class for the slugify functionality.
+ * Provides comprehensive customization options for URL slug generation.
+ */
+export declare class SlugifyConfig {
+    private readonly _customReplacements;
+    private readonly _separator;
+    private readonly _case;
+    private readonly _removeAccents;
+    private readonly _allowedChars?;
+    private readonly _maxLength?;
+    private readonly _transformers;
+    private constructor();
+    static builder(): SlugifyConfigBuilder;
+    static default(): SlugifyConfig;
+    static create(builder: SlugifyConfigBuilder): SlugifyConfig;
+    get customReplacements(): Record<string, string>;
+    get separator(): string;
+    get case(): 'lower' | 'upper' | 'default';
+    get removeAccents(): boolean;
+    get allowedChars(): RegExp | undefined;
+    get maxLength(): number | undefined;
+    get transformers(): Array<(str: string) => string>;
+    merge(other: SlugifyConfig): SlugifyConfig;
+    private escapeRegex;
+    getCharClass(): RegExp;
+    applyCustomReplacements(str: string): string;
+    applyTransformers(str: string): string;
+    applyRemoveAccents(str: string): string;
+    replaceNonAllowedChars(str: string): string;
+    trimSeparators(str: string): string;
+    applyCase(str: string): string;
+    applyMaxLength(str: string): string;
+    collapseSeparators(str: string): string;
+    /**
+     * Applies the slugify transformations to the given string using this configuration.
+     * @param str - The input string to slugify
+     * @returns The slugified string
+     */
+    slugify(str: string): string;
+    /**
+     * Static method to slugify a string with a temporary configuration built from the builder.
+     * @param str - The input string to slugify
+     * @param builderFn - A function that configures the builder
+     * @returns The slugified string
+     */
+    static slugifyWith(str: string, builderFn: (builder: SlugifyConfigBuilder) => SlugifyConfigBuilder): string;
+}
+export declare class SlugifyConfigBuilder {
+    customReplacements: Record<string, string>;
+    separator: string;
+    case: 'lower' | 'upper' | 'default';
+    removeAccents: boolean;
+    allowedChars?: RegExp;
+    maxLength?: number;
+    transformers: Array<(str: string) => string>;
+    withCustomReplacements(replacements: Record<string, string>): this;
+    withSeparator(separator: string): this;
+    withCase(caseValue: 'lower' | 'upper' | 'default'): this;
+    withRemoveAccents(remove: boolean): this;
+    withAllowedChars(regex?: RegExp): this;
+    withMaxLength(length?: number): this;
+    withTransformers(transformers: Array<(str: string) => string>): this;
+    build(): SlugifyConfig;
+}
+/**
+ * Default configuration for slugify operations.
+ * Provides sensible defaults that can be overridden by users.
+ */
+export declare function getDefaultSlugifyConfig(): SlugifyConfig;
+/**
+ * Sets the global slugify configuration that will be used by default.
+ * Replaces the current global config with the provided config.
+ *
+ * @param config - Configuration object to set as global config
+ *
+ * @example
+ * setSlugifyConfig(
+ *   SlugifyConfig.builder()
+ *     .withCustomReplacements({ "♀": "feminin", "♂": "masculin" })
+ *     .withSeparator("_")
+ *     .build()
+ * );
+ */
+export declare function assertCharClass(regex: RegExp): void;
+export declare function assertSlugifyConfig(builderOrConfig: SlugifyConfigBuilder | SlugifyConfig): void;
+export declare function setSlugifyConfig(config: SlugifyConfig): void;
+/**
+ * Gets the current global slugify configuration.
+ * Returns the current global config instance.
+ *
+ * @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,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlugifyConfigBuilder = exports.SlugifyConfig = void 0;
+exports.getDefaultSlugifyConfig = getDefaultSlugifyConfig;
+exports.assertCharClass = assertCharClass;
+exports.assertSlugifyConfig = assertSlugifyConfig;
+exports.setSlugifyConfig = setSlugifyConfig;
+exports.getSlugifyConfig = getSlugifyConfig;
+exports.resetSlugifyConfig = resetSlugifyConfig;
+/**
+ * Configuration class for the slugify functionality.
+ * Provides comprehensive customization options for URL slug generation.
+ */
+class SlugifyConfig {
+    constructor(builder) {
+        this._customReplacements = builder.customReplacements;
+        this._separator = builder.separator;
+        this._case = builder.case;
+        this._removeAccents = builder.removeAccents;
+        this._allowedChars = builder.allowedChars;
+        this._maxLength = builder.maxLength;
+        this._transformers = builder.transformers;
+    }
+    static builder() {
+        return new SlugifyConfigBuilder();
+    }
+    static default() {
+        return SlugifyConfig.builder().build();
+    }
+    static create(builder) {
+        assertSlugifyConfig(builder);
+        const config = new SlugifyConfig(builder);
+        return Object.freeze(config);
+    }
+    get customReplacements() {
+        return { ...this._customReplacements };
+    }
+    get separator() {
+        return this._separator;
+    }
+    get case() {
+        return this._case;
+    }
+    get removeAccents() {
+        return this._removeAccents;
+    }
+    get allowedChars() {
+        return this._allowedChars;
+    }
+    get maxLength() {
+        return this._maxLength;
+    }
+    get transformers() {
+        return [...this._transformers];
+    }
+    merge(other) {
+        return SlugifyConfig.builder()
+            .withCustomReplacements({ ...this.customReplacements, ...other.customReplacements })
+            .withSeparator(other.separator || this.separator)
+            .withCase(other.case || this.case)
+            .withRemoveAccents(other.removeAccents !== undefined ? other.removeAccents : this.removeAccents)
+            .withAllowedChars(other.allowedChars || this.allowedChars)
+            .withMaxLength(other.maxLength || this.maxLength)
+            .withTransformers([...this.transformers, ...other.transformers])
+            .build();
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    getCharClass() {
+        return this._allowedChars || (this._removeAccents ? /[a-zA-Z0-9]/ : /[a-zA-Z0-9\u00C0-\u017F]/);
+    }
+    applyCustomReplacements(str) {
+        let result = str;
+        for (const [pattern, replacement] of Object.entries(this._customReplacements)) {
+            const escapedPattern = this.escapeRegex(pattern);
+            result = result.replace(new RegExp(escapedPattern, 'g'), replacement);
+        }
+        return result;
+    }
+    applyTransformers(str) {
+        return this._transformers.reduce((result, transformer) => transformer(result), str);
+    }
+    applyRemoveAccents(str) {
+        if (!this._removeAccents)
+            return str;
+        return str.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+    }
+    replaceNonAllowedChars(str) {
+        const charClass = this.getCharClass().source;
+        const safeCharClass = charClass.startsWith('[') && charClass.endsWith(']') ? charClass.slice(1, -1) : charClass;
+        return str.replace(new RegExp(`[^${safeCharClass}]+`, 'g'), this._separator);
+    }
+    trimSeparators(str) {
+        const safeSeparator = this.escapeRegex(this._separator);
+        return str.replace(new RegExp(`^${safeSeparator}+|${safeSeparator}+$`, 'g'), '');
+    }
+    applyCase(str) {
+        if (this._case === 'lower')
+            return str.toLowerCase();
+        if (this._case === 'upper')
+            return str.toUpperCase();
+        return str;
+    }
+    applyMaxLength(str) {
+        if (!this._maxLength || this._maxLength <= 0)
+            return str;
+        let result = str.slice(0, this._maxLength);
+        const safeSeparator = this.escapeRegex(this._separator);
+        return result.replace(new RegExp(`${safeSeparator}$`), '');
+    }
+    collapseSeparators(str) {
+        const safeSeparator = this.escapeRegex(this._separator);
+        return str.replace(new RegExp(`${safeSeparator}+`, 'g'), this._separator);
+    }
+    /**
+     * Applies the slugify transformations to the given string using this configuration.
+     * @param str - The input string to slugify
+     * @returns The slugified string
+     */
+    slugify(str) {
+        let result = str;
+        result = this.applyCustomReplacements(result);
+        result = this.applyTransformers(result);
+        result = this.applyRemoveAccents(result);
+        result = this.replaceNonAllowedChars(result);
+        result = this.trimSeparators(result);
+        result = this.applyCase(result);
+        result = this.applyMaxLength(result);
+        result = this.collapseSeparators(result);
+        return result;
+    }
+    /**
+     * Static method to slugify a string with a temporary configuration built from the builder.
+     * @param str - The input string to slugify
+     * @param builderFn - A function that configures the builder
+     * @returns The slugified string
+     */
+    static slugifyWith(str, builderFn) {
+        const config = builderFn(SlugifyConfig.builder()).build();
+        return config.slugify(str);
+    }
+}
+exports.SlugifyConfig = SlugifyConfig;
+class SlugifyConfigBuilder {
+    constructor() {
+        this.customReplacements = {};
+        this.separator = '-';
+        this.case = 'lower';
+        this.removeAccents = true;
+        this.transformers = [];
+    }
+    withCustomReplacements(replacements) {
+        this.customReplacements = { ...replacements };
+        return this;
+    }
+    withSeparator(separator) {
+        this.separator = separator;
+        return this;
+    }
+    withCase(caseValue) {
+        this.case = caseValue;
+        return this;
+    }
+    withRemoveAccents(remove) {
+        this.removeAccents = remove;
+        return this;
+    }
+    withAllowedChars(regex) {
+        this.allowedChars = regex;
+        return this;
+    }
+    withMaxLength(length) {
+        this.maxLength = length;
+        return this;
+    }
+    withTransformers(transformers) {
+        this.transformers = [...transformers];
+        return this;
+    }
+    build() {
+        const config = SlugifyConfig.create(this);
+        return config;
+    }
+}
+exports.SlugifyConfigBuilder = SlugifyConfigBuilder;
+/**
+ * Default configuration for slugify operations.
+ * Provides sensible defaults that can be overridden by users.
+ */
+function getDefaultSlugifyConfig() {
+    return SlugifyConfig.default();
+}
+/**
+ * Global configuration instance that can be modified by users.
+ * Starts with default values but can be updated via setSlugifyConfig().
+ */
+let globalSlugifyConfig = getDefaultSlugifyConfig();
+/**
+ * Sets the global slugify configuration that will be used by default.
+ * Replaces the current global config with the provided config.
+ *
+ * @param config - Configuration object to set as global config
+ *
+ * @example
+ * setSlugifyConfig(
+ *   SlugifyConfig.builder()
+ *     .withCustomReplacements({ "♀": "feminin", "♂": "masculin" })
+ *     .withSeparator("_")
+ *     .build()
+ * );
+ */
+function assertCharClass(regex) {
+    const src = regex.source;
+    if (!src.startsWith('[') || !src.endsWith(']')) {
+        throw new Error(`Invalid allowedChars: must be a character class like /[a-z]/, received ${regex}`);
+    }
+}
+function assertSlugifyConfig(builderOrConfig) {
+    const allowedChars = builderOrConfig.allowedChars;
+    const separator = builderOrConfig.separator;
+    const caseValue = builderOrConfig.case;
+    const removeAccents = builderOrConfig.removeAccents;
+    const maxLength = builderOrConfig.maxLength;
+    const customReplacements = builderOrConfig.customReplacements;
+    const transformers = builderOrConfig.transformers;
+    if (allowedChars !== undefined) {
+        if (!(allowedChars instanceof RegExp)) {
+            throw new TypeError(`Invalid allowedChars: expected a RegExp, received ${typeof allowedChars}`);
+        }
+        assertCharClass(allowedChars);
+    }
+    if (typeof separator !== 'string') {
+        throw new TypeError(`Invalid separator: expected a string, received ${typeof separator}`);
+    }
+    if (caseValue !== 'lower' && caseValue !== 'upper' && caseValue !== 'default') {
+        throw new TypeError(`Invalid case value: expected 'lower' | 'upper' | 'default', received ${caseValue}`);
+    }
+    if (typeof removeAccents !== 'boolean') {
+        throw new TypeError(`Invalid removeAccents: expected a boolean, received ${typeof removeAccents}`);
+    }
+    if (maxLength !== undefined) {
+        if (typeof maxLength !== 'number' || !Number.isInteger(maxLength) || maxLength < 0) {
+            throw new TypeError(`Invalid maxLength: expected a non-negative integer, received ${maxLength}`);
+        }
+    }
+    if (typeof customReplacements !== 'object' || customReplacements === null) {
+        throw new TypeError(`Invalid customReplacements: expected an object, received ${typeof customReplacements}`);
+    }
+    if (!Array.isArray(transformers) || !transformers.every((fn) => typeof fn === 'function')) {
+        throw new TypeError(`Invalid transformers: expected an array of functions`);
+    }
+}
+function setSlugifyConfig(config) {
+    globalSlugifyConfig = config;
+}
+/**
+ * Gets the current global slugify configuration.
+ * Returns the current global config instance.
+ *
+ * @returns Current global configuration object
+ */
+function getSlugifyConfig() {
+    return globalSlugifyConfig;
+}
+/**
+ * Resets the global slugify configuration to default values.
+ */
+function resetSlugifyConfig() {
+    globalSlugifyConfig = getDefaultSlugifyConfig();
+}

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,18 @@
+"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 globalConfig = (0, slugify_config_1.getSlugifyConfig)();
+    const finalConfig = config ? globalConfig.merge(config) : globalConfig;
+    return finalConfig.slugify(str);
+}

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "utilitish",
-  "version": "0.0.8",
+  "version": "0.0.10",
+  "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",