utilitish 0.0.11 → 0.0.15

package/dist/object/object-prototype.js

@@ -11,9 +11,10 @@ const core_utils_1 = require("../utils/core.utils");
  * @see Object.prototype.deepMerge
  */
 (0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepMerge', function (source) {
-    if (typeof source !== 'object' || source === null) {
-        throw new TypeError('Source must be a non-null object');
-    }
+    if (typeof source !== 'object')
+        (0, core_utils_1.utilitishError)('Object.prototype.deepMerge', 'source must be an object', source);
+    if (source === null)
+        (0, core_utils_1.utilitishError)('Object.prototype.deepMerge', 'source cannot be null', source);
     const isObject = (val) => val !== null && typeof val === 'object' && !Array.isArray(val);
     const merge = (target, source) => {
         for (const key of Object.keys(source)) {

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

@@ -15,7 +15,7 @@ declare global {
          * - Returns a new array instance each time; modifying it does not affect the Set
          * - Empty sets return an empty array
          */
-        toList<T>(): T[];
+        toList(): T[];
         /**
          * Returns true if at least one of the given items is present in the Set.
          *

package/dist/set/set-prototype.js

@@ -13,7 +13,7 @@ const core_utils_1 = require("../utils/core.utils");
  */
 (0, core_utils_1.defineIfNotExists)(Set.prototype, 'hasAny', function (...items) {
     if (!Array.isArray(items))
-        throw new TypeError('Arguments must be an array');
+        (0, core_utils_1.utilitishError)('Set.prototype.hasAny', 'arguments must be an array', items);
     if (items.length === 0)
         return false;
     return items.some((item) => this.has(item));
@@ -32,7 +32,7 @@ const core_utils_1 = require("../utils/core.utils");
         values = args;
     }
     if (!Array.isArray(values))
-        throw new TypeError('Arguments must be an array or a Set');
+        (0, core_utils_1.utilitishError)('Set.prototype.includes', 'arguments must be an array or a Set', args);
     return values.every((item) => this.has(item));
 });
 /**
@@ -42,7 +42,7 @@ const core_utils_1 = require("../utils/core.utils");
     const result = new Set(this);
     for (const other of others) {
         if (!(other instanceof Set))
-            throw new TypeError('Arguments must be Sets');
+            (0, core_utils_1.utilitishError)('Set.prototype.union', 'arguments must be Sets', other);
         for (const item of other) {
             result.add(item);
         }
@@ -54,7 +54,7 @@ const core_utils_1 = require("../utils/core.utils");
  */
 (0, core_utils_1.defineIfNotExists)(Set.prototype, 'intersection', function (...others) {
     if (others.some((s) => !(s instanceof Set)))
-        throw new TypeError('Arguments must be Sets');
+        (0, core_utils_1.utilitishError)('Set.prototype.intersection', 'arguments must be Sets', others);
     const result = new Set();
     for (const item of this) {
         if (others.every((set) => set.has(item))) {

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

@@ -198,22 +198,99 @@ declare global {
          * 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
+         * @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 `other` 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
+         * 'Hello World'.slugifyEquals('hello-world');   // true
+         * 'Héllo World'.slugifyEquals('hello-world');   // true
+         * 'Hello World'.slugifyEquals('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
+         * - Both strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified string works as expected.
+         * - Useful for comparing user-provided strings with stored slugs.
          */
-        compareSlugify(other: string): boolean;
+        slugifyEquals(other: string): boolean;
+        /**
+         * Checks if the slugified version of this string includes the slugified version of another.
+         * Useful for case-insensitive and accent-insensitive substring search.
+         *
+         * @this {string} The string to search in.
+         * @param {string} other - The string to search for.
+         * @returns {boolean} `true` if the slugified string contains the slugified `other`, `false` otherwise.
+         * @throws {TypeError} If `other` is not a string.
+         *
+         * @example
+         * 'Hello World'.slugifyIncludes('hello');      // true
+         * 'Héllo World'.slugifyIncludes('hello');      // true
+         * 'Hello World'.slugifyIncludes('goodbye');    // false
+         *
+         * @remarks
+         * - Both strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified string works as expected.
+         */
+        slugifyIncludes(other: string): boolean;
+        /**
+         * Checks if the slugified version of this string starts with the slugified version of another.
+         * Useful for case-insensitive and accent-insensitive prefix matching.
+         *
+         * @this {string} The string to check.
+         * @param {string} other - The prefix to check against.
+         * @returns {boolean} `true` if the slugified string starts with the slugified `other`, `false` otherwise.
+         * @throws {TypeError} If `other` is not a string.
+         *
+         * @example
+         * 'Hello World'.slugifyStartsWith('hello');    // true
+         * 'Héllo World'.slugifyStartsWith('hello');    // true
+         * 'Hello World'.slugifyStartsWith('world');    // false
+         *
+         * @remarks
+         * - Both strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified string works as expected.
+         */
+        slugifyStartsWith(other: string): boolean;
+        /**
+         * Checks if the slugified version of this string ends with the slugified version of another.
+         * Useful for case-insensitive and accent-insensitive suffix matching.
+         *
+         * @this {string} The string to check.
+         * @param {string} other - The suffix to check against.
+         * @returns {boolean} `true` if the slugified string ends with the slugified `other`, `false` otherwise.
+         * @throws {TypeError} If `other` is not a string.
+         *
+         * @example
+         * 'Hello World'.slugifyEndsWith('world');      // true
+         * 'Héllo World'.slugifyEndsWith('world');      // true
+         * 'Hello World'.slugifyEndsWith('hello');      // false
+         *
+         * @remarks
+         * - Both strings are slugified before comparison.
+         * - Since `slugify` is idempotent, passing an already-slugified string works as expected.
+         */
+        slugifyEndsWith(other: string): boolean;
+        /**
+         * Checks if the slugified version of this string matches any slugified string in a list.
+         * Useful for case-insensitive and accent-insensitive list lookup.
+         *
+         * @this {string} The string to search for.
+         * @param {string[]} list - The array of strings to search in.
+         * @returns {boolean} `true` if any slugified item in the list equals the slugified string, `false` otherwise.
+         * @throws {TypeError} If `list` is not an array.
+         * @throws {TypeError} If `list` contains non-string items.
+         *
+         * @example
+         * 'Hello World'.slugifyIn(['hello-world', 'foo']); // true
+         * 'Héllo World'.slugifyIn(['hello-world', 'foo']); // true
+         * 'Hello World'.slugifyIn(['foo', 'bar']);          // false
+         *
+         * @remarks
+         * - All strings are slugified before comparison.
+         * - Since `slugify` is idempotent, mixing raw and already-slugified strings in the list works as expected.
+         */
+        slugifyIn(list: 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

@@ -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
@@ -74,27 +77,64 @@ const slugify_utils_1 = require("../utils/slugify.utils");
     return this.charAt(0).toUpperCase() + this.slice(1);
 });
 /**
- * @see String.prototype.compareSlugify
+ * @see String.prototype.slugifyEquals
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'compareSlugify', function (other) {
-    if (typeof other !== 'string') {
-        throw new TypeError('Parameter must be a string');
-    }
+(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,40 +161,40 @@ describe('String.prototype', () => {
             });
         });
     });
-    describe('compareSlugify()', () => {
+    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'.compareSlugify('hello-world')).toBe(true);
-            expect('hello world'.compareSlugify('hello-world')).toBe(true);
-            expect('HELLO WORLD'.compareSlugify('hello-world')).toBe(true);
+            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é'.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);
+            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'.compareSlugify('goodbye-world')).toBe(false);
-            expect('test string'.compareSlugify('different-string')).toBe(false);
+            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  '.compareSlugify('hello-world')).toBe(true);
-            expect('Hello!!!World???'.compareSlugify('hello-world')).toBe(true);
+            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'.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);
+            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(''.compareSlugify('')).toBe(true);
-            expect('   '.compareSlugify('')).toBe(true);
-            expect('hello'.compareSlugify('')).toBe(false);
+            expect(''.slugifyEquals('')).toBe(true);
+            expect('   '.slugifyEquals('')).toBe(true);
+            expect('hello'.slugifyEquals('')).toBe(false);
         });
     });
     describe('replaceRange()', () => {

package/dist/test.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta
+            name="viewport"
+            content="width=device-width, initial-scale=1.0"
+        />
+        <script src="index.js"></script>
+        <title>Document</title>
+    </head>
+    <body></body>
+</html>

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

@@ -96,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;