utilitish 0.0.9 → 0.0.11

package/README.md

@@ -16,16 +16,19 @@ Vous pouvez définir une configuration globale qui s'appliquera à tous les appe
 import { setSlugifyConfig } from 'utilitish';
 
 // Configuration pour remplacer les symboles de genre
-setSlugifyConfig({
-    customReplacements: {
-        '♀': 'feminin',
-        '♂': 'masculin',
-    },
-    separator: '_',
-});
+setSlugifyConfig(
+    SlugifyConfig.builder()
+        .withSeparator('_')
+        .withCustomReplacements({
+            '♀': 'feminin',
+            '♂': 'masculin',
+            '@': 'at',
+        })
+        .build(),
+);
 
 'Test ♀'.slugify(); // "test_feminin"
-'User♂@domain.com'.slugify(); // "user_masculin_at_domain_com"
+'User♂@domain.com'.slugify(); // "usermasculinatdomain_com"
 ```
 
 ### Configuration par appel
@@ -37,7 +40,7 @@ Vous pouvez aussi passer une configuration spécifique à chaque appel :
 'Hello World'.slugify(); // "hello-world"
 
 // Override la config pour cet appel
-'Hello World'.slugify({ separator: '_' }); // "hello_world"
+'Hello World'.slugify(SlugifyConfig.builder().withSeparator('_').build()); // "hello_world"
 ```
 
 ### Options de configuration

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

@@ -24,13 +24,11 @@ describe('Object.prototype', () => {
             const source = { b: { d: 3 }, e: 4 };
             const merged = obj.deepMerge(source);
             expect(merged).toEqual({ a: 1, b: { c: 2, d: 3 }, e: 4 });
-            console.log(merged);
         });
         it('should overwrite primitive values', () => {
             const obj = { a: 1, b: 2 };
             const merged = obj.deepMerge({ b: 3 });
             expect(merged).toEqual({ a: 1, b: 3 });
-            console.log(merged);
         });
         describe('error handling', () => {
             it('should throw if source is not an object', () => {

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

@@ -152,31 +152,31 @@ declare global {
          *
          * @example
          * // Custom replacements
-         * 'Test ♀'.slugify({ customReplacements: { "♀": "feminin" } }); // 'test-feminin'
-         * 'User♂@domain.com'.slugify({ customReplacements: { "♂": "masculin", "@": "at" } }); // 'usermasculinatdomain-com'
+         * '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({ separator: "_" }); // 'hello_world'
-         * 'Hello World'.slugify({ separator: "--" }); // 'hello--world'
+         * 'Hello World'.slugify(SlugifyConfig.builder().withSeparator("_").build()); // 'hello_world'
+         * 'Hello World'.slugify(SlugifyConfig.builder().withSeparator("--").build()); // 'hello--world'
          *
          * @example
          * // Preserve accents
-         * 'Éléphant'.slugify({ removeAccents: false }); // 'éléphant'
+         * 'Éléphant'.slugify(SlugifyConfig.builder().withRemoveAccents(false).build()); // 'éléphant'
          *
          * @example
          * // Disable lowercasing
-         * 'Hello World'.slugify({ lowercase: false }); // 'Hello-World'
+         * 'Hello World'.slugify(SlugifyConfig.builder().withCase('default').build()); // 'Hello-World'
          *
          * @example
          * // Max length
-         * 'Very long string'.slugify({ maxLength: 8 }); // 'very-lon'
+         * 'Very long string'.slugify(SlugifyConfig.builder().withMaxLength(8).build()); // 'very-lon'
          *
          * @example
          * // Custom transformers
-         * 'hello world'.slugify({
-         *   transformers: [(str) => str.replace(/world/g, 'universe')]
-         * }); // 'hello-universe'
+         * 'hello world'.slugify(SlugifyConfig.builder()
+         *   .withTransformers([(str) => str.replace(/world/g, 'universe')])
+         *   .build()); // 'hello-universe'
          *
          * @remarks
          * - Uses global configuration by default (see setSlugifyConfig)
@@ -187,12 +187,33 @@ declare global {
          * - Removes leading/trailing separators
          * - Collapses multiple consecutive separators into one
          *
+         * @see SlugifyConfig
          * @see setSlugifyConfig
          * @see getSlugifyConfig
          * @see resetSlugifyConfig
          */
         slugify(): string;
         slugify(config: SlugifyConfig): string;
+        /**
+         * Compares two strings by slugifying both and checking if they are equal.
+         * Useful for case-insensitive and accent-insensitive string comparison.
+         *
+         * @this {string} The first string to compare
+         * @param {string} other - The second string to compare
+         * @returns {boolean} True if both slugified strings are equal, false otherwise
+         * @throws {TypeError} If the parameter is not a string
+         *
+         * @example
+         * 'Hello World'.compareSlugify('hello-world'); // true
+         * 'Héllo Wørld'.compareSlugify('hello-world'); // true
+         * 'Hello World'.compareSlugify('goodbye-world'); // false
+         *
+         * @remarks
+         * - Both strings are slugified using the default or global configuration
+         * - Useful for comparing user-provided strings with stored slugs
+         * - Guard ensures the parameter is a valid string type
+         */
+        compareSlugify(other: string): boolean;
         /**
          * 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

@@ -73,6 +73,15 @@ const slugify_utils_1 = require("../utils/slugify.utils");
         return '';
     return this.charAt(0).toUpperCase() + this.slice(1);
 });
+/**
+ * @see String.prototype.compareSlugify
+ */
+(0, core_utils_1.defineIfNotExists)(String.prototype, 'compareSlugify', function (other) {
+    if (typeof other !== 'string') {
+        throw new TypeError('Parameter must be a string');
+    }
+    return this.slugify() === other.slugify();
+});
 /**
  * @see String.prototype.replaceRange
  */

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

@@ -78,71 +78,125 @@ describe('String.prototype', () => {
         });
         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');
+                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({ customReplacements: { '[': 'left', ']': 'right' } })).toBe('test-leftbracketright');
+                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)({ separator: '_' });
+                (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({ separator: '_' })).toBe('hello_world');
-                expect('Test String'.slugify({ separator: '__' })).toBe('test__string');
+                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)({ lowercase: false });
+                (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({ lowercase: false })).toBe('Hello-World');
+                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({ removeAccents: false })).toBe('éléphant');
+                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({ allowedChars: /[a-zA-Z0-9_]/ })).toBe('hello123');
+                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({ maxLength: 10 })).toBe('very-long');
-                expect('short'.slugify({ maxLength: 10 })).toBe('short');
+                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({ maxLength: 8 })).toBe('hello-wo');
+                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 = {
-                    transformers: [
-                        (str) => str.replace(/test/g, 'example'),
-                        (str) => str.toUpperCase(),
-                    ],
-                    lowercase: false,
-                };
+                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({ separator: '_', customReplacements: { '♀': 'female' } })).toBe('test_female');
+                expect('Test ♀'.slugify(slugify_config_1.SlugifyConfig.builder().withSeparator('_').withCustomReplacements({ '♀': 'female' }).build())).toBe('test_female');
             });
         });
     });
+    describe('compareSlugify()', () => {
+        beforeEach(() => {
+            (0, slugify_config_1.resetSlugifyConfig)(); // Reset to defaults before each test
+        });
+        it('should return true when slugified strings are equal', () => {
+            expect('Hello World'.compareSlugify('hello-world')).toBe(true);
+            expect('hello world'.compareSlugify('hello-world')).toBe(true);
+            expect('HELLO WORLD'.compareSlugify('hello-world')).toBe(true);
+        });
+        it('should handle accents and special characters', () => {
+            expect('Café'.compareSlugify('cafe')).toBe(true);
+            expect('Éléphant'.compareSlugify('elephant')).toBe(true);
+            expect('naïve café'.compareSlugify('naive-cafe')).toBe(true);
+            expect('résumé'.compareSlugify('resume')).toBe(true);
+        });
+        it('should return false when slugified strings are different', () => {
+            expect('Hello World'.compareSlugify('goodbye-world')).toBe(false);
+            expect('test string'.compareSlugify('different-string')).toBe(false);
+        });
+        it('should handle extra spaces and special characters', () => {
+            expect('  Hello  ---  World  '.compareSlugify('hello-world')).toBe(true);
+            expect('Hello!!!World???'.compareSlugify('hello-world')).toBe(true);
+        });
+        it('should throw TypeError if parameter is not a string', () => {
+            expect(() => 'hello'.compareSlugify(123)).toThrowError(TypeError);
+            expect(() => 'hello'.compareSlugify(null)).toThrowError(TypeError);
+            expect(() => 'hello'.compareSlugify(undefined)).toThrowError(TypeError);
+            expect(() => 'hello'.compareSlugify({})).toThrowError(TypeError);
+            expect(() => 'hello'.compareSlugify([])).toThrowError(TypeError);
+        });
+        it('should work with empty strings', () => {
+            expect(''.compareSlugify('')).toBe(true);
+            expect('   '.compareSlugify('')).toBe(true);
+            expect('hello'.compareSlugify('')).toBe(false);
+        });
+    });
     describe('replaceRange()', () => {
         it('should replace a single character at the given index', () => {
             expect('hello'.replaceRange(1, 2, 'a')).toBe('hallo');

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

@@ -1,73 +1,93 @@
 /**
- * Configuration types and interfaces for the slugify functionality.
+ * Configuration class for the slugify functionality.
  * Provides comprehensive customization options for URL slug generation.
  */
-export interface SlugifyConfig {
+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;
     /**
-     * Custom character replacements applied before other transformations.
-     * Useful for replacing special symbols with words or other characters.
-     *
-     * @example
-     * { "♀": "feminin", "♂": "masculin", "@": "at" }
+     * Applies the slugify transformations to the given string using this configuration.
+     * @param str - The input string to slugify
+     * @returns The slugified string
      */
-    customReplacements?: Record<string, string>;
+    slugify(str: 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]/"
+     * 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;
-    /**
-     * 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>;
+    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 const defaultSlugifyConfig: SlugifyConfig;
+export declare function getDefaultSlugifyConfig(): SlugifyConfig;
 /**
  * Sets the global slugify configuration that will be used by default.
- * Merges the provided config with the existing global config.
+ * Replaces the current global config with the provided config.
  *
- * @param config - Partial configuration object to merge with current global config
+ * @param config - Configuration object to set as global config
  *
  * @example
- * setSlugifyConfig({
- *   customReplacements: { "♀": "feminin", "♂": "masculin" },
- *   separator: "_"
- * });
+ * 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 a copy to prevent external mutations.
+ * Returns the current global config instance.
  *
  * @returns Current global configuration object
  */

package/dist/utils/slugify.config.js

@@ -1,58 +1,271 @@
 "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.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.
  */
-exports.defaultSlugifyConfig = {
-    customReplacements: {},
-    separator: '-',
-    lowercase: true,
-    removeAccents: true,
-    allowedChars: undefined, // Will be determined dynamically based on removeAccents
-    maxLength: undefined,
-    transformers: [],
-};
+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 = { ...exports.defaultSlugifyConfig };
+let globalSlugifyConfig = getDefaultSlugifyConfig();
 /**
  * Sets the global slugify configuration that will be used by default.
- * Merges the provided config with the existing global config.
+ * Replaces the current global config with the provided config.
  *
- * @param config - Partial configuration object to merge with current global config
+ * @param config - Configuration object to set as global config
  *
  * @example
- * setSlugifyConfig({
- *   customReplacements: { "♀": "feminin", "♂": "masculin" },
- *   separator: "_"
- * });
+ * 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 = { ...globalSlugifyConfig, ...config };
+    globalSlugifyConfig = config;
 }
 /**
  * Gets the current global slugify configuration.
- * Returns a copy to prevent external mutations.
+ * Returns the current global config instance.
  *
  * @returns Current global configuration object
  */
 function getSlugifyConfig() {
-    return { ...globalSlugifyConfig };
+    return globalSlugifyConfig;
 }
 /**
  * Resets the global slugify configuration to default values.
  */
 function resetSlugifyConfig() {
-    globalSlugifyConfig = { ...exports.defaultSlugifyConfig };
+    globalSlugifyConfig = getDefaultSlugifyConfig();
 }

package/dist/utils/slugify.utils.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utilitish",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/FDonovan12/utilitish.git"