utilitish 0.0.14 → 0.0.16

package/dist/string/string-prototype.js

@@ -1,7 +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");
+const slugify_config_1 = require("../utils/slugify.config");
 /**
  * @see String.prototype.splitWords
  */
@@ -42,9 +42,12 @@ const slugify_utils_1 = require("../utils/slugify.utils");
  * @see String.prototype.truncate
  */
 (0, core_utils_1.defineIfNotExists)(String.prototype, 'truncate', function (n) {
-    if (typeof n !== 'number' || !Number.isInteger(n) || n < 0) {
-        throw new TypeError('Truncate length must be a non-negative integer');
-    }
+    if (typeof n !== 'number')
+        (0, core_utils_1.utilitishError)('String.prototype.truncate', 'n must be a number', n);
+    if (!Number.isInteger(n))
+        (0, core_utils_1.utilitishError)('String.prototype.truncate', 'n must be an integer', n);
+    if (n < 0)
+        (0, core_utils_1.utilitishError)('String.prototype.truncate', 'n must be non-negative', n);
     return this.length > n ? this.slice(0, n) + '...' : this.toString();
 });
 /**
@@ -63,7 +66,7 @@ const slugify_utils_1 = require("../utils/slugify.utils");
  * @see String.prototype.slugify
  */
 (0, core_utils_1.defineIfNotExists)(String.prototype, 'slugify', function (config) {
-    return (0, slugify_utils_1.slugifyString)(this, config);
+    return (0, slugify_config_1.slugifyString)(this, config);
 });
 /**
  * @see String.prototype.capitalize
@@ -73,19 +76,65 @@ const slugify_utils_1 = require("../utils/slugify.utils");
         return '';
     return this.charAt(0).toUpperCase() + this.slice(1);
 });
+/**
+ * @see String.prototype.slugifyEquals
+ */
+(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugifyEquals', function (other) {
+    if (typeof other !== 'string')
+        (0, core_utils_1.utilitishError)('String.prototype.slugifyEquals', 'other must be a string', other);
+    return this.slugify() === other.slugify();
+});
+/**
+ * @see String.prototype.slugifyIncludes
+ */
+(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugifyIncludes', function (other) {
+    if (typeof other !== 'string')
+        (0, core_utils_1.utilitishError)('String.prototype.slugifyIncludes', 'other must be a string', other);
+    return this.slugify().includes(other.slugify());
+});
+/**
+ * @see String.prototype.slugifyStartsWith
+ */
+(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugifyStartsWith', function (other) {
+    if (typeof other !== 'string')
+        (0, core_utils_1.utilitishError)('String.prototype.slugifyStartsWith', 'other must be a string', other);
+    return this.slugify().startsWith(other.slugify());
+});
+/**
+ * @see String.prototype.slugifyEndsWith
+ */
+(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugifyEndsWith', function (other) {
+    if (typeof other !== 'string')
+        (0, core_utils_1.utilitishError)('String.prototype.slugifyEndsWith', 'other must be a string', other);
+    return this.slugify().endsWith(other.slugify());
+});
+/**
+ * @see String.prototype.slugifyIn
+ */
+(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugifyIn', function (list) {
+    if (!Array.isArray(list))
+        (0, core_utils_1.utilitishError)('String.prototype.slugifyIn', 'list must be an array', list);
+    if (!list.every((item) => typeof item === 'string'))
+        (0, core_utils_1.utilitishError)('String.prototype.slugifyIn', 'list must be an array of strings', list);
+    const slugified = this.slugify();
+    return list.some((item) => item.slugify() === slugified);
+});
 /**
  * @see String.prototype.replaceRange
  */
 (0, core_utils_1.defineIfNotExists)(String.prototype, 'replaceRange', function (start, end, replaceString = '') {
-    if (!Number.isInteger(start) || !Number.isInteger(end)) {
-        throw new TypeError('start and end must be integers');
-    }
-    if (start < 0 || end < 0) {
-        throw new RangeError('start or end cannot be negative');
-    }
-    if (start > this.length || end > this.length) {
-        throw new RangeError('start or end is out of bounds');
-    }
+    if (!Number.isInteger(start))
+        (0, core_utils_1.utilitishError)('String.prototype.replaceRange', 'start must be an integer', start);
+    if (!Number.isInteger(end))
+        (0, core_utils_1.utilitishError)('String.prototype.replaceRange', 'end must be an integer', end);
+    if (start < 0)
+        (0, core_utils_1.utilitishError)('String.prototype.replaceRange', 'start cannot be negative', start, RangeError);
+    if (end < 0)
+        (0, core_utils_1.utilitishError)('String.prototype.replaceRange', 'end cannot be negative', end, RangeError);
+    if (start > this.length)
+        (0, core_utils_1.utilitishError)('String.prototype.replaceRange', 'start is out of bounds', start, RangeError);
+    if (end > this.length)
+        (0, core_utils_1.utilitishError)('String.prototype.replaceRange', 'end is out of bounds', end, RangeError);
     if (start > end)
         [start, end] = [end, start];
     return this.slice(0, start) + (replaceString ?? '') + this.slice(end);

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

@@ -161,6 +161,42 @@ describe('String.prototype', () => {
             });
         });
     });
+    describe('slugifyEquals()', () => {
+        beforeEach(() => {
+            (0, slugify_config_1.resetSlugifyConfig)(); // Reset to defaults before each test
+        });
+        it('should return true when slugified strings are equal', () => {
+            expect('Hello World'.slugifyEquals('hello-world')).toBe(true);
+            expect('hello world'.slugifyEquals('hello-world')).toBe(true);
+            expect('HELLO WORLD'.slugifyEquals('hello-world')).toBe(true);
+        });
+        it('should handle accents and special characters', () => {
+            expect('Café'.slugifyEquals('cafe')).toBe(true);
+            expect('Éléphant'.slugifyEquals('elephant')).toBe(true);
+            expect('naïve café'.slugifyEquals('naive-cafe')).toBe(true);
+            expect('résumé'.slugifyEquals('resume')).toBe(true);
+        });
+        it('should return false when slugified strings are different', () => {
+            expect('Hello World'.slugifyEquals('goodbye-world')).toBe(false);
+            expect('test string'.slugifyEquals('different-string')).toBe(false);
+        });
+        it('should handle extra spaces and special characters', () => {
+            expect('  Hello  ---  World  '.slugifyEquals('hello-world')).toBe(true);
+            expect('Hello!!!World???'.slugifyEquals('hello-world')).toBe(true);
+        });
+        it('should throw TypeError if parameter is not a string', () => {
+            expect(() => 'hello'.slugifyEquals(123)).toThrowError(TypeError);
+            expect(() => 'hello'.slugifyEquals(null)).toThrowError(TypeError);
+            expect(() => 'hello'.slugifyEquals(undefined)).toThrowError(TypeError);
+            expect(() => 'hello'.slugifyEquals({})).toThrowError(TypeError);
+            expect(() => 'hello'.slugifyEquals([])).toThrowError(TypeError);
+        });
+        it('should work with empty strings', () => {
+            expect(''.slugifyEquals('')).toBe(true);
+            expect('   '.slugifyEquals('')).toBe(true);
+            expect('hello'.slugifyEquals('')).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/core.utils.d.ts

@@ -101,3 +101,4 @@ export declare function isNumberOrString(value: unknown): value is string | numb
  * Type for a selector: either a key of T or a function from T to K.
  */
 export type Selector<T, K> = keyof T | ((item: T) => K);
+export declare const utilitishError: (method: string, message: string, received?: unknown, ErrorClass?: TypeErrorConstructor) => never;

package/dist/utils/core.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineStaticIfNotExists = exports.defineIfNotExists = void 0;
+exports.utilitishError = exports.defineStaticIfNotExists = exports.defineIfNotExists = void 0;
 exports.resolveSelector = resolveSelector;
 exports.assertValidSelector = assertValidSelector;
 exports.isNumberOrString = isNumberOrString;
@@ -150,3 +150,8 @@ function assertValidSelector(selector, name = 'selector') {
 function isNumberOrString(value) {
     return typeof value === 'string' || typeof value === 'number';
 }
+const utilitishError = (method, message, received, ErrorClass = TypeError) => {
+    const receivedInfo = received !== undefined ? `, received ${ErrorClass === RangeError ? received : typeof received}` : '';
+    throw new ErrorClass(`[Utilitish] ${method}: ${message}${receivedInfo}`);
+};
+exports.utilitishError = utilitishError;

package/dist/utils/core.utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/core.utils.spec.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_utils_1 = require("./core.utils");
+describe('core.utils', () => {
+    describe('defineIfNotExists()', () => {
+        it('should define a new method on a prototype', () => {
+            const proto = {};
+            (0, core_utils_1.defineIfNotExists)(proto, 'hello', () => 'world');
+            expect(proto.hello()).toBe('world');
+        });
+        it('should not overwrite a non-configurable non-writable property', () => {
+            const proto = {};
+            Object.defineProperty(proto, 'locked', {
+                value: () => 'original',
+                writable: false,
+                configurable: false,
+            });
+            (0, core_utils_1.defineIfNotExists)(proto, 'locked', () => 'overwritten');
+            expect(proto.locked()).toBe('original');
+        });
+        it('should overwrite a writable property', () => {
+            const proto = {};
+            Object.defineProperty(proto, 'flexible', {
+                value: () => 'original',
+                writable: true,
+                configurable: false,
+            });
+            (0, core_utils_1.defineIfNotExists)(proto, 'flexible', () => 'overwritten');
+            expect(proto.flexible()).toBe('overwritten');
+        });
+        it('should overwrite a configurable property', () => {
+            const proto = {};
+            Object.defineProperty(proto, 'flexible', {
+                value: () => 'original',
+                writable: false,
+                configurable: true,
+            });
+            (0, core_utils_1.defineIfNotExists)(proto, 'flexible', () => 'overwritten');
+            expect(proto.flexible()).toBe('overwritten');
+        });
+        it('should define the property as non-enumerable', () => {
+            const proto = {};
+            (0, core_utils_1.defineIfNotExists)(proto, 'hidden', () => 'value');
+            expect(Object.keys(proto)).not.toContain('hidden');
+        });
+    });
+    describe('defineStaticIfNotExists()', () => {
+        it('should define a new static method on a constructor', () => {
+            const ctor = {};
+            (0, core_utils_1.defineStaticIfNotExists)(ctor, 'create', () => 'created');
+            expect(ctor.create()).toBe('created');
+        });
+        it('should not overwrite a non-configurable non-writable static property', () => {
+            const ctor = {};
+            Object.defineProperty(ctor, 'locked', {
+                value: () => 'original',
+                writable: false,
+                configurable: false,
+            });
+            (0, core_utils_1.defineStaticIfNotExists)(ctor, 'locked', () => 'overwritten');
+            expect(ctor.locked()).toBe('original');
+        });
+        it('should define the property as non-enumerable', () => {
+            const ctor = {};
+            (0, core_utils_1.defineStaticIfNotExists)(ctor, 'hidden', () => 'value');
+            expect(Object.keys(ctor)).not.toContain('hidden');
+        });
+    });
+    describe('resolveSelector()', () => {
+        describe('with function selector', () => {
+            it('should return a function that applies the selector', () => {
+                const sel = (0, core_utils_1.resolveSelector)((item) => item.x);
+                expect(sel({ x: 42 })).toBe(42);
+            });
+        });
+        describe('with string key selector', () => {
+            it('should return a function that extracts the property', () => {
+                const sel = (0, core_utils_1.resolveSelector)('name');
+                expect(sel({ name: 'Alice' })).toBe('Alice');
+            });
+        });
+        describe('with fallback', () => {
+            it('should return the fallback function when no selector is provided', () => {
+                const sel = (0, core_utils_1.resolveSelector)(undefined, (item) => item.toString());
+                expect(sel(42)).toBe('42');
+            });
+        });
+        describe('error handling', () => {
+            it('should throw TypeError when selector is invalid', () => {
+                expect(() => (0, core_utils_1.resolveSelector)(123)).toThrow(TypeError);
+            });
+            it('should throw TypeError when no selector and no fallback', () => {
+                expect(() => (0, core_utils_1.resolveSelector)(undefined, undefined)).toThrow(TypeError);
+            });
+        });
+    });
+    describe('assertValidSelector()', () => {
+        it('should not throw when selector is a function', () => {
+            expect(() => (0, core_utils_1.assertValidSelector)(() => { })).not.toThrow();
+        });
+        it('should not throw when selector is a string', () => {
+            expect(() => (0, core_utils_1.assertValidSelector)('name')).not.toThrow();
+        });
+        it('should not throw when selector is undefined', () => {
+            expect(() => (0, core_utils_1.assertValidSelector)(undefined)).not.toThrow();
+        });
+        describe('error handling', () => {
+            it('should throw TypeError when selector is a number', () => {
+                expect(() => (0, core_utils_1.assertValidSelector)(123)).toThrow(TypeError);
+            });
+            it('should throw TypeError when selector is an object', () => {
+                expect(() => (0, core_utils_1.assertValidSelector)({})).toThrow(TypeError);
+            });
+        });
+    });
+    describe('isNumberOrString()', () => {
+        it('should return true for a string', () => {
+            expect((0, core_utils_1.isNumberOrString)('hello')).toBe(true);
+        });
+        it('should return true for a number', () => {
+            expect((0, core_utils_1.isNumberOrString)(42)).toBe(true);
+        });
+        it('should return false for a boolean', () => {
+            expect((0, core_utils_1.isNumberOrString)(true)).toBe(false);
+        });
+        it('should return false for null', () => {
+            expect((0, core_utils_1.isNumberOrString)(null)).toBe(false);
+        });
+        it('should return false for an object', () => {
+            expect((0, core_utils_1.isNumberOrString)({})).toBe(false);
+        });
+    });
+    describe('utilitishError()', () => {
+        it('should throw a TypeError by default', () => {
+            expect(() => (0, core_utils_1.utilitishError)('method', 'message')).toThrow(TypeError);
+        });
+        it('should throw a RangeError when specified', () => {
+            expect(() => (0, core_utils_1.utilitishError)('method', 'message', undefined, RangeError)).toThrow(RangeError);
+        });
+        it('should include method and message in the error message', () => {
+            expect(() => (0, core_utils_1.utilitishError)('String.prototype.test', 'value must be a string')).toThrow('[Utilitish] String.prototype.test: value must be a string');
+        });
+        it('should include received type in the error message when provided', () => {
+            expect(() => (0, core_utils_1.utilitishError)('String.prototype.test', 'value must be a string', 42)).toThrow('[Utilitish] String.prototype.test: value must be a string, received number');
+        });
+        it('should not include received info when received is undefined', () => {
+            expect(() => (0, core_utils_1.utilitishError)('String.prototype.test', 'value must be a string', undefined)).toThrow('[Utilitish] String.prototype.test: value must be a string');
+        });
+    });
+});

package/dist/utils/logic.utils.js

@@ -6,6 +6,10 @@ function sortBy(arr, direction, selector) {
     if (arr.length === 0)
         return arr.slice();
     const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
+    const sample = getValue(arr[0]);
+    if (!(0, core_utils_1.isNumberOrString)(sample)) {
+        throw new TypeError('Selector must return number or string');
+    }
     if (!selector && !arr.every((item) => (0, core_utils_1.isNumberOrString)(item))) {
         throw new TypeError('Array elements must be number or string if no selector is provided');
     }

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

@@ -0,0 +1 @@
+export {};

package/dist/utils/logic.utils.spec.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logic_utils_1 = require("./logic.utils");
+describe('logic.utils', () => {
+    describe('sortBy()', () => {
+        describe('with primitive arrays', () => {
+            it('should sort numbers in ascending order', () => {
+                expect((0, logic_utils_1.sortBy)([3, 1, 2], 'asc')).toEqual([1, 2, 3]);
+            });
+            it('should sort numbers in descending order', () => {
+                expect((0, logic_utils_1.sortBy)([1, 3, 2], 'desc')).toEqual([3, 2, 1]);
+            });
+            it('should sort strings in ascending order', () => {
+                expect((0, logic_utils_1.sortBy)(['b', 'a', 'c'], 'asc')).toEqual(['a', 'b', 'c']);
+            });
+            it('should sort strings in descending order', () => {
+                expect((0, logic_utils_1.sortBy)(['b', 'a', 'c'], 'desc')).toEqual(['c', 'b', 'a']);
+            });
+            it('should return empty array when input is empty', () => {
+                expect((0, logic_utils_1.sortBy)([], 'asc')).toEqual([]);
+            });
+            it('should not mutate the original array', () => {
+                const arr = [3, 1, 2];
+                (0, logic_utils_1.sortBy)(arr, 'asc');
+                expect(arr).toEqual([3, 1, 2]);
+            });
+        });
+        describe('with selector function', () => {
+            it('should sort in ascending order using selector', () => {
+                const arr = [{ v: 3 }, { v: 1 }, { v: 2 }];
+                expect((0, logic_utils_1.sortBy)(arr, 'asc', (x) => x.v)).toEqual([{ v: 1 }, { v: 2 }, { v: 3 }]);
+            });
+            it('should sort in descending order using selector', () => {
+                const arr = [{ v: 1 }, { v: 3 }, { v: 2 }];
+                expect((0, logic_utils_1.sortBy)(arr, 'desc', (x) => x.v)).toEqual([{ v: 3 }, { v: 2 }, { v: 1 }]);
+            });
+        });
+        describe('with selector string key', () => {
+            it('should sort in ascending order using property key', () => {
+                const arr = [{ v: 3 }, { v: 1 }, { v: 2 }];
+                expect((0, logic_utils_1.sortBy)(arr, 'asc', 'v')).toEqual([{ v: 1 }, { v: 2 }, { v: 3 }]);
+            });
+            it('should sort in descending order using property key', () => {
+                const arr = [{ v: 1 }, { v: 3 }, { v: 2 }];
+                expect((0, logic_utils_1.sortBy)(arr, 'desc', 'v')).toEqual([{ v: 3 }, { v: 2 }, { v: 1 }]);
+            });
+        });
+        describe('error handling', () => {
+            it('should throw TypeError when elements are not sortable without selector', () => {
+                expect(() => (0, logic_utils_1.sortBy)([{ v: 1 }], 'asc')).toThrow(TypeError);
+            });
+            it('should throw TypeError when selector returns non-sortable value', () => {
+                expect(() => (0, logic_utils_1.sortBy)([{ v: {} }], 'asc', (x) => x.v)).toThrow(TypeError);
+            });
+        });
+    });
+});

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

@@ -10,7 +10,6 @@ export declare class SlugifyConfig {
     private readonly _allowedChars?;
     private readonly _maxLength?;
     private readonly _transformers;
-    private readonly _isValidated;
     private constructor();
     static builder(): SlugifyConfigBuilder;
     static default(): SlugifyConfig;
@@ -84,7 +83,7 @@ export declare function getDefaultSlugifyConfig(): SlugifyConfig;
  * );
  */
 export declare function assertCharClass(regex: RegExp): void;
-export declare function validateSlugifyConfig(builderOrConfig: SlugifyConfigBuilder | SlugifyConfig): void;
+export declare function assertSlugifyConfig(builderOrConfig: SlugifyConfigBuilder | SlugifyConfig): void;
 export declare function setSlugifyConfig(config: SlugifyConfig): void;
 /**
  * Gets the current global slugify configuration.
@@ -97,3 +96,12 @@ export declare function getSlugifyConfig(): SlugifyConfig;
  * Resets the global slugify configuration to default values.
  */
 export declare function resetSlugifyConfig(): void;
+/**
+ * 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.config.js

@@ -3,16 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SlugifyConfigBuilder = exports.SlugifyConfig = void 0;
 exports.getDefaultSlugifyConfig = getDefaultSlugifyConfig;
 exports.assertCharClass = assertCharClass;
-exports.validateSlugifyConfig = validateSlugifyConfig;
+exports.assertSlugifyConfig = assertSlugifyConfig;
 exports.setSlugifyConfig = setSlugifyConfig;
 exports.getSlugifyConfig = getSlugifyConfig;
 exports.resetSlugifyConfig = resetSlugifyConfig;
+exports.slugifyString = slugifyString;
 /**
  * Configuration class for the slugify functionality.
  * Provides comprehensive customization options for URL slug generation.
  */
 class SlugifyConfig {
-    constructor(builder, isValidated = false) {
+    constructor(builder) {
         this._customReplacements = builder.customReplacements;
         this._separator = builder.separator;
         this._case = builder.case;
@@ -20,7 +21,6 @@ class SlugifyConfig {
         this._allowedChars = builder.allowedChars;
         this._maxLength = builder.maxLength;
         this._transformers = builder.transformers;
-        this._isValidated = isValidated;
     }
     static builder() {
         return new SlugifyConfigBuilder();
@@ -29,8 +29,8 @@ class SlugifyConfig {
         return SlugifyConfig.builder().build();
     }
     static create(builder) {
-        validateSlugifyConfig(builder);
-        const config = new SlugifyConfig(builder, true);
+        assertSlugifyConfig(builder);
+        const config = new SlugifyConfig(builder);
         return Object.freeze(config);
     }
     get customReplacements() {
@@ -217,7 +217,7 @@ function assertCharClass(regex) {
         throw new Error(`Invalid allowedChars: must be a character class like /[a-z]/, received ${regex}`);
     }
 }
-function validateSlugifyConfig(builderOrConfig) {
+function assertSlugifyConfig(builderOrConfig) {
     const allowedChars = builderOrConfig.allowedChars;
     const separator = builderOrConfig.separator;
     const caseValue = builderOrConfig.case;
@@ -270,3 +270,17 @@ function getSlugifyConfig() {
 function resetSlugifyConfig() {
     globalSlugifyConfig = getDefaultSlugifyConfig();
 }
+/**
+ * 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 = getSlugifyConfig();
+    const finalConfig = config ? globalConfig.merge(config) : globalConfig;
+    return finalConfig.slugify(str);
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/utils/slugify.config.spec.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const slugify_config_1 = require("./slugify.config");
+describe('slugify.config', () => {
+    afterEach(() => {
+        (0, slugify_config_1.resetSlugifyConfig)();
+    });
+    describe('SlugifyConfig.default()', () => {
+        it('should return a config with default separator', () => {
+            expect((0, slugify_config_1.getDefaultSlugifyConfig)().separator).toBe('-');
+        });
+        it('should return a config with lowercase case', () => {
+            expect((0, slugify_config_1.getDefaultSlugifyConfig)().case).toBe('lower');
+        });
+        it('should return a config with removeAccents enabled', () => {
+            expect((0, slugify_config_1.getDefaultSlugifyConfig)().removeAccents).toBe(true);
+        });
+    });
+    describe('SlugifyConfig.slugify()', () => {
+        describe('with default config', () => {
+            it('should convert to lowercase', () => {
+                expect(slugify_config_1.SlugifyConfig.default().slugify('Hello World')).toBe('hello-world');
+            });
+            it('should replace spaces with separator', () => {
+                expect(slugify_config_1.SlugifyConfig.default().slugify('foo bar')).toBe('foo-bar');
+            });
+            it('should remove accents', () => {
+                expect(slugify_config_1.SlugifyConfig.default().slugify('Héllo')).toBe('hello');
+            });
+            it('should collapse multiple separators', () => {
+                expect(slugify_config_1.SlugifyConfig.default().slugify('foo  bar')).toBe('foo-bar');
+            });
+            it('should trim leading and trailing separators', () => {
+                expect(slugify_config_1.SlugifyConfig.default().slugify(' foo ')).toBe('foo');
+            });
+        });
+        describe('with custom separator', () => {
+            it('should use custom separator', () => {
+                const config = slugify_config_1.SlugifyConfig.builder().withSeparator('_').build();
+                expect(config.slugify('hello world')).toBe('hello_world');
+            });
+        });
+        describe('with maxLength', () => {
+            it('should truncate to maxLength', () => {
+                const config = slugify_config_1.SlugifyConfig.builder().withMaxLength(5).build();
+                expect(config.slugify('hello world').length).toBeLessThanOrEqual(5);
+            });
+        });
+        describe('with custom replacements', () => {
+            it('should apply custom replacements before slugifying', () => {
+                const config = slugify_config_1.SlugifyConfig.builder().withCustomReplacements({ '&': 'and' }).build();
+                expect(config.slugify('cats & dogs')).toBe('cats-and-dogs');
+            });
+        });
+        describe('with transformers', () => {
+            it('should apply transformers before slugifying', () => {
+                const config = slugify_config_1.SlugifyConfig.builder()
+                    .withTransformers([(s) => s.replace('foo', 'bar')])
+                    .build();
+                expect(config.slugify('foo baz')).toBe('bar-baz');
+            });
+        });
+    });
+    describe('SlugifyConfig.slugifyWith()', () => {
+        it('should slugify with a temporary configuration', () => {
+            const result = slugify_config_1.SlugifyConfig.slugifyWith('hello world', (b) => b.withSeparator('_'));
+            expect(result).toBe('hello_world');
+        });
+    });
+    describe('SlugifyConfig.merge()', () => {
+        it('should merge two configs with the other taking precedence', () => {
+            const base = slugify_config_1.SlugifyConfig.builder().withSeparator('-').build();
+            const other = slugify_config_1.SlugifyConfig.builder().withSeparator('_').build();
+            expect(base.merge(other).separator).toBe('_');
+        });
+    });
+    describe('assertCharClass()', () => {
+        it('should not throw for a valid character class', () => {
+            expect(() => (0, slugify_config_1.assertCharClass)(/[a-z]/)).not.toThrow();
+        });
+        describe('error handling', () => {
+            it('should throw Error for a regex that is not a character class', () => {
+                expect(() => (0, slugify_config_1.assertCharClass)(/a-z/)).toThrow(Error);
+            });
+        });
+    });
+    describe('assertSlugifyConfig()', () => {
+        it('should not throw for a valid builder', () => {
+            expect(() => (0, slugify_config_1.assertSlugifyConfig)(slugify_config_1.SlugifyConfig.builder())).not.toThrow();
+        });
+        describe('error handling', () => {
+            it('should throw TypeError for invalid separator', () => {
+                const builder = slugify_config_1.SlugifyConfig.builder();
+                builder.separator = 123;
+                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+            });
+            it('should throw TypeError for invalid case value', () => {
+                const builder = slugify_config_1.SlugifyConfig.builder();
+                builder.case = 'invalid';
+                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+            });
+            it('should throw TypeError for invalid removeAccents', () => {
+                const builder = slugify_config_1.SlugifyConfig.builder();
+                builder.removeAccents = 'yes';
+                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+            });
+            it('should throw TypeError for invalid maxLength', () => {
+                const builder = slugify_config_1.SlugifyConfig.builder();
+                builder.maxLength = -1;
+                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+            });
+            it('should throw TypeError for invalid allowedChars', () => {
+                const builder = slugify_config_1.SlugifyConfig.builder();
+                builder.allowedChars = 'not-a-regex';
+                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+            });
+            it('should throw TypeError for invalid transformers', () => {
+                const builder = slugify_config_1.SlugifyConfig.builder();
+                builder.transformers = ['not-a-function'];
+                expect(() => (0, slugify_config_1.assertSlugifyConfig)(builder)).toThrow(TypeError);
+            });
+        });
+    });
+    describe('getSlugifyConfig()', () => {
+        it('should return the default config initially', () => {
+            expect((0, slugify_config_1.getSlugifyConfig)().separator).toBe('-');
+        });
+    });
+    describe('setSlugifyConfig()', () => {
+        it('should update the global config', () => {
+            const config = slugify_config_1.SlugifyConfig.builder().withSeparator('_').build();
+            (0, slugify_config_1.setSlugifyConfig)(config);
+            expect((0, slugify_config_1.getSlugifyConfig)().separator).toBe('_');
+        });
+    });
+    describe('resetSlugifyConfig()', () => {
+        it('should restore the default config', () => {
+            const config = slugify_config_1.SlugifyConfig.builder().withSeparator('_').build();
+            (0, slugify_config_1.setSlugifyConfig)(config);
+            (0, slugify_config_1.resetSlugifyConfig)();
+            expect((0, slugify_config_1.getSlugifyConfig)().separator).toBe('-');
+        });
+    });
+});