utilitish 0.0.19 → 0.0.20

package/dist/string/string-prototype.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_utils_1 = require("../utils/core.utils");
-const slugify_config_1 = require("../utils/slugify.config");
+import { defineIfNotExists, utilitishError } from '../utils/core.utils';
+import { slugifyString } from '../utils/slugify.config';
 /**
  * @see String.prototype.splitWords
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'splitWords', function () {
+defineIfNotExists(String.prototype, 'splitWords', function () {
     return this.replace(/([a-z0-9])([A-Z])/g, '$1 $2') // helloWorld → hello World
         .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2') // HTMLParser → HTML Parser
         .replace(/[^\p{L}\p{N}]+/gu, ' ')
@@ -16,7 +14,7 @@ const slugify_config_1 = require("../utils/slugify.config");
 /**
  * @see String.prototype.camelCase
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'camelCase', function () {
+defineIfNotExists(String.prototype, 'camelCase', function () {
     const words = this.splitWords().map((w) => w.toLowerCase());
     return words
         .map((word, i) => (i === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))
@@ -25,7 +23,7 @@ const slugify_config_1 = require("../utils/slugify.config");
 /**
  * @see String.prototype.kebabCase
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'kebabCase', function () {
+defineIfNotExists(String.prototype, 'kebabCase', function () {
     return this.splitWords()
         .map((w) => w.toLowerCase())
         .join('-');
@@ -33,7 +31,7 @@ const slugify_config_1 = require("../utils/slugify.config");
 /**
  * @see String.prototype.snakeCase
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'snakeCase', function () {
+defineIfNotExists(String.prototype, 'snakeCase', function () {
     return this.splitWords()
         .map((w) => w.toLowerCase())
         .join('_');
@@ -41,7 +39,7 @@ const slugify_config_1 = require("../utils/slugify.config");
 /**
  * @see String.prototype.sentenceCase
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'sentenceCase', function () {
+defineIfNotExists(String.prototype, 'sentenceCase', function () {
     return this.splitWords()
         .map((w) => w.toLowerCase())
         .join(' ');
@@ -49,7 +47,7 @@ const slugify_config_1 = require("../utils/slugify.config");
 /**
  * @see String.prototype.titleCase
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'titleCase', function () {
+defineIfNotExists(String.prototype, 'titleCase', function () {
     return this.splitWords()
         .map((w) => w.toLowerCase().capitalize())
         .join(' ');
@@ -57,37 +55,37 @@ const slugify_config_1 = require("../utils/slugify.config");
 /**
  * @see String.prototype.truncate
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'truncate', function (n) {
+defineIfNotExists(String.prototype, 'truncate', function (n) {
     if (typeof n !== 'number')
-        (0, core_utils_1.utilitishError)('String.prototype.truncate', 'n must be a number', n);
+        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);
+        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);
+        utilitishError('String.prototype.truncate', 'n must be non-negative', n);
     return this.length > n ? this.slice(0, n) + '...' : this.toString();
 });
 /**
  * @see String.prototype.reverse
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'reverse', function () {
+defineIfNotExists(String.prototype, 'reverse', function () {
     return [...this].reverse().join('');
 });
 /**
  * @see String.prototype.isEmpty
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'isEmpty', function () {
+defineIfNotExists(String.prototype, 'isEmpty', function () {
     return this.trim().length === 0;
 });
 /**
  * @see String.prototype.slugify
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugify', function (config) {
-    return (0, slugify_config_1.slugifyString)(this, config);
+defineIfNotExists(String.prototype, 'slugify', function (config) {
+    return slugifyString(this, config);
 });
 /**
  * @see String.prototype.capitalize
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'capitalize', function () {
+defineIfNotExists(String.prototype, 'capitalize', function () {
     if (this.length === 0)
         return '';
     return this.charAt(0).toUpperCase() + this.slice(1);
@@ -95,62 +93,62 @@ const slugify_config_1 = require("../utils/slugify.config");
 /**
  * @see String.prototype.slugifyEquals
  */
-(0, core_utils_1.defineIfNotExists)(String.prototype, 'slugifyEquals', function (other) {
+defineIfNotExists(String.prototype, 'slugifyEquals', function (other) {
     if (typeof other !== 'string')
-        (0, core_utils_1.utilitishError)('String.prototype.slugifyEquals', 'other must be a string', other);
+        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) {
+defineIfNotExists(String.prototype, 'slugifyIncludes', function (other) {
     if (typeof other !== 'string')
-        (0, core_utils_1.utilitishError)('String.prototype.slugifyIncludes', 'other must be a string', other);
+        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) {
+defineIfNotExists(String.prototype, 'slugifyStartsWith', function (other) {
     if (typeof other !== 'string')
-        (0, core_utils_1.utilitishError)('String.prototype.slugifyStartsWith', 'other must be a string', other);
+        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) {
+defineIfNotExists(String.prototype, 'slugifyEndsWith', function (other) {
     if (typeof other !== 'string')
-        (0, core_utils_1.utilitishError)('String.prototype.slugifyEndsWith', 'other must be a string', other);
+        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) {
+defineIfNotExists(String.prototype, 'slugifyIn', function (list) {
     if (!Array.isArray(list))
-        (0, core_utils_1.utilitishError)('String.prototype.slugifyIn', 'list must be an array', list);
+        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);
+        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 = '') {
+defineIfNotExists(String.prototype, 'replaceRange', function (start, end, replaceString = '') {
     if (!Number.isInteger(start))
-        (0, core_utils_1.utilitishError)('String.prototype.replaceRange', 'start must be an integer', start);
+        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);
+        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);
+        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);
+        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);
+        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);
+        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

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("../string/string-prototype");
-const slugify_config_1 = require("../utils/slugify.config");
+import '../string/string-prototype';
+import { resetSlugifyConfig, setSlugifyConfig, SlugifyConfig } from '../utils/slugify.config';
 describe('String.prototype', () => {
     describe('capitalize()', () => {
         it('should capitalize the first character', () => {
@@ -94,7 +92,7 @@ describe('String.prototype', () => {
     });
     describe('slugify()', () => {
         beforeEach(() => {
-            (0, slugify_config_1.resetSlugifyConfig)(); // Reset to defaults before each test
+            resetSlugifyConfig(); // Reset to defaults before each test
         });
         it('should slugify a string with default config', () => {
             expect('Hello World!'.slugify()).toBe('hello-world');
@@ -103,73 +101,73 @@ describe('String.prototype', () => {
         });
         describe('custom replacements', () => {
             it('should apply custom replacements per call', () => {
-                expect('Test ♀'.slugify(slugify_config_1.SlugifyConfig.builder().withCustomReplacements({ '♀': 'feminin' }).build())).toBe('test-feminin');
-                expect('User♂@domain.com'.slugify(slugify_config_1.SlugifyConfig.builder().withCustomReplacements({ '♂': 'masculin', '@': 'at' }).build())).toBe('usermasculinatdomain-com');
+                expect('Test ♀'.slugify(SlugifyConfig.builder().withCustomReplacements({ '♀': 'feminin' }).build())).toBe('test-feminin');
+                expect('User♂@domain.com'.slugify(SlugifyConfig.builder().withCustomReplacements({ '♂': 'masculin', '@': 'at' }).build())).toBe('usermasculinatdomain-com');
             });
             it('should handle special regex characters in replacements', () => {
-                expect('Test [bracket]'.slugify(slugify_config_1.SlugifyConfig.builder().withCustomReplacements({ '[': 'left', ']': 'right' }).build())).toBe('test-leftbracketright');
+                expect('Test [bracket]'.slugify(SlugifyConfig.builder().withCustomReplacements({ '[': 'left', ']': 'right' }).build())).toBe('test-leftbracketright');
             });
         });
         describe('separator customization', () => {
             it('should use custom separator globally', () => {
-                (0, slugify_config_1.setSlugifyConfig)(slugify_config_1.SlugifyConfig.builder().withSeparator('_').build());
+                setSlugifyConfig(SlugifyConfig.builder().withSeparator('_').build());
                 expect('Hello World'.slugify()).toBe('hello_world');
                 expect('Test String'.slugify()).toBe('test_string');
             });
             it('should use custom separator per call', () => {
-                expect('Hello World'.slugify(slugify_config_1.SlugifyConfig.builder().withSeparator('_').build())).toBe('hello_world');
-                expect('Test String'.slugify(slugify_config_1.SlugifyConfig.builder().withSeparator('__').build())).toBe('test__string');
+                expect('Hello World'.slugify(SlugifyConfig.builder().withSeparator('_').build())).toBe('hello_world');
+                expect('Test String'.slugify(SlugifyConfig.builder().withSeparator('__').build())).toBe('test__string');
             });
         });
         describe('case transformation', () => {
             it('should respect lowercase setting globally', () => {
-                (0, slugify_config_1.setSlugifyConfig)(slugify_config_1.SlugifyConfig.builder().withCase('default').build());
+                setSlugifyConfig(SlugifyConfig.builder().withCase('default').build());
                 expect('Hello World'.slugify()).toBe('Hello-World');
             });
             it('should respect lowercase setting per call', () => {
-                expect('Hello World'.slugify(slugify_config_1.SlugifyConfig.builder().withCase('default').build())).toBe('Hello-World');
+                expect('Hello World'.slugify(SlugifyConfig.builder().withCase('default').build())).toBe('Hello-World');
             });
         });
         describe('accent removal', () => {
             it('should respect removeAccents setting per call', () => {
-                expect('Éléphant'.slugify(slugify_config_1.SlugifyConfig.builder().withRemoveAccents(false).build())).toBe('éléphant');
+                expect('Éléphant'.slugify(SlugifyConfig.builder().withRemoveAccents(false).build())).toBe('éléphant');
             });
         });
         describe('allowed characters', () => {
             it('should use custom allowed characters', () => {
-                expect('Hello123!@#'.slugify(slugify_config_1.SlugifyConfig.builder()
+                expect('Hello123!@#'.slugify(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()
+                expect(() => 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()
+                expect(() => setSlugifyConfig(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');
+                expect('a b+c'.slugify(SlugifyConfig.builder().withSeparator('.').build())).toBe('a.b.c');
+                expect('a.b.c'.slugify(SlugifyConfig.builder().withSeparator('*').build())).toBe('a*b*c');
             });
         });
         describe('max length', () => {
             it('should truncate to max length', () => {
-                expect('very-long-string-here'.slugify(slugify_config_1.SlugifyConfig.builder().withMaxLength(10).build())).toBe('very-long');
-                expect('short'.slugify(slugify_config_1.SlugifyConfig.builder().withMaxLength(10).build())).toBe('short');
+                expect('very-long-string-here'.slugify(SlugifyConfig.builder().withMaxLength(10).build())).toBe('very-long');
+                expect('short'.slugify(SlugifyConfig.builder().withMaxLength(10).build())).toBe('short');
             });
             it('should remove trailing separator after truncation', () => {
-                expect('hello-world-test'.slugify(slugify_config_1.SlugifyConfig.builder().withMaxLength(8).build())).toBe('hello-wo');
+                expect('hello-world-test'.slugify(SlugifyConfig.builder().withMaxLength(8).build())).toBe('hello-wo');
             });
         });
         describe('custom transformers', () => {
             it('should apply custom transformers', () => {
-                const config = slugify_config_1.SlugifyConfig.builder()
+                const config = SlugifyConfig.builder()
                     .withTransformers([
                     (str) => str.replace(/test/g, 'example'),
                     (str) => str.toUpperCase(),
@@ -182,13 +180,13 @@ describe('String.prototype', () => {
         describe('configuration merging', () => {
             it('should merge global and local config correctly', () => {
                 // Local config should override global defaults
-                expect('Test ♀'.slugify(slugify_config_1.SlugifyConfig.builder().withSeparator('_').withCustomReplacements({ '♀': 'female' }).build())).toBe('test_female');
+                expect('Test ♀'.slugify(SlugifyConfig.builder().withSeparator('_').withCustomReplacements({ '♀': 'female' }).build())).toBe('test_female');
             });
         });
     });
     describe('slugifyEquals()', () => {
         beforeEach(() => {
-            (0, slugify_config_1.resetSlugifyConfig)(); // Reset to defaults before each test
+            resetSlugifyConfig(); // Reset to defaults before each test
         });
         it('should return true when slugified strings are equal', () => {
             expect('Hello World'.slugifyEquals('hello-world')).toBe(true);

package/dist/utils/core.utils.js

@@ -1,9 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.utilitishError = exports.defineStaticIfNotExists = exports.defineIfNotExists = void 0;
-exports.resolveSelector = resolveSelector;
-exports.assertValidSelector = assertValidSelector;
-exports.isNumberOrString = isNumberOrString;
 /**
  * Defines a **non-enumerable, non-writable, non-configurable** property on a prototype
  * if it does not already exist, or if the existing property is writable or configurable.
@@ -25,7 +19,7 @@ exports.isNumberOrString = isNumberOrString;
  * @remarks
  * Use this function to safely add prototype methods without overwriting stable or built-in ones.
  */
-const defineIfNotExists = (prototype, name, fn) => {
+export const defineIfNotExists = (prototype, name, fn) => {
     const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
     if (!descriptor || descriptor.writable || descriptor.configurable) {
         Object.defineProperty(prototype, name, {
@@ -36,7 +30,6 @@ const defineIfNotExists = (prototype, name, fn) => {
         });
     }
 };
-exports.defineIfNotExists = defineIfNotExists;
 /**
  * Defines a **static** property on a constructor if it does not already exist,
  * or if the existing property is writable or configurable.
@@ -58,7 +51,7 @@ exports.defineIfNotExists = defineIfNotExists;
  * @remarks
  * To forcefully replace an existing property, delete it first or use `Object.defineProperty` directly.
  */
-const defineStaticIfNotExists = (constructor, name, fn) => {
+export const defineStaticIfNotExists = (constructor, name, fn) => {
     const descriptor = Object.getOwnPropertyDescriptor(constructor, name);
     if (!descriptor || descriptor.writable || descriptor.configurable) {
         Object.defineProperty(constructor, name, {
@@ -69,7 +62,6 @@ const defineStaticIfNotExists = (constructor, name, fn) => {
         });
     }
 };
-exports.defineStaticIfNotExists = defineStaticIfNotExists;
 /**
  * Resolves a selector parameter into a function that extracts a value from an item.
  *
@@ -98,7 +90,7 @@ exports.defineStaticIfNotExists = defineStaticIfNotExists;
  * @throws {TypeError} If the selector is not a function or string key.
  * @throws {TypeError} If no selector is provided and no fallback is given.
  */
-function resolveSelector(selector, fallback, name = 'selector') {
+export function resolveSelector(selector, fallback, name = 'selector') {
     assertValidSelector(selector);
     if (typeof selector === 'function') {
         return selector;
@@ -134,7 +126,7 @@ function resolveSelector(selector, fallback, name = 'selector') {
  * @remarks
  * Used internally by `resolveSelector` to provide clearer type safety and errors.
  */
-function assertValidSelector(selector, name = 'selector') {
+export function assertValidSelector(selector, name = 'selector') {
     const isValid = typeof selector === 'function' || typeof selector === 'string';
     if (selector !== undefined && !isValid) {
         throw new TypeError(`${name} must be a function or a string key`);
@@ -151,11 +143,10 @@ function assertValidSelector(selector, name = 'selector') {
  * @param {unknown} value The value to test.
  * @returns {value is string | number} True if the value is a string or number, else false.
  */
-function isNumberOrString(value) {
+export function isNumberOrString(value) {
     return typeof value === 'string' || typeof value === 'number';
 }
-const utilitishError = (method, message, received, ErrorClass = TypeError) => {
+export 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.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_utils_1 = require("./core.utils");
+import { assertValidSelector, defineIfNotExists, defineStaticIfNotExists, isNumberOrString, resolveSelector, utilitishError, } from './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');
+            defineIfNotExists(proto, 'hello', () => 'world');
             expect(proto.hello()).toBe('world');
         });
         it('should not overwrite a non-configurable non-writable property', () => {
@@ -15,7 +13,7 @@ describe('core.utils', () => {
                 writable: false,
                 configurable: false,
             });
-            (0, core_utils_1.defineIfNotExists)(proto, 'locked', () => 'overwritten');
+            defineIfNotExists(proto, 'locked', () => 'overwritten');
             expect(proto.locked()).toBe('original');
         });
         it('should overwrite a writable property', () => {
@@ -25,7 +23,7 @@ describe('core.utils', () => {
                 writable: true,
                 configurable: false,
             });
-            (0, core_utils_1.defineIfNotExists)(proto, 'flexible', () => 'overwritten');
+            defineIfNotExists(proto, 'flexible', () => 'overwritten');
             expect(proto.flexible()).toBe('overwritten');
         });
         it('should overwrite a configurable property', () => {
@@ -35,19 +33,19 @@ describe('core.utils', () => {
                 writable: false,
                 configurable: true,
             });
-            (0, core_utils_1.defineIfNotExists)(proto, 'flexible', () => 'overwritten');
+            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');
+            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');
+            defineStaticIfNotExists(ctor, 'create', () => 'created');
             expect(ctor.create()).toBe('created');
         });
         it('should not overwrite a non-configurable non-writable static property', () => {
@@ -57,94 +55,94 @@ describe('core.utils', () => {
                 writable: false,
                 configurable: false,
             });
-            (0, core_utils_1.defineStaticIfNotExists)(ctor, 'locked', () => 'overwritten');
+            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');
+            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);
+                const sel = 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');
+                const sel = 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());
+                const sel = 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);
+                expect(() => resolveSelector(123)).toThrow(TypeError);
             });
             it('should throw TypeError when no selector and no fallback', () => {
-                expect(() => (0, core_utils_1.resolveSelector)(undefined, undefined)).toThrow(TypeError);
+                expect(() => resolveSelector(undefined, undefined)).toThrow(TypeError);
             });
         });
     });
     describe('assertValidSelector()', () => {
         it('should not throw when selector is a function', () => {
-            expect(() => (0, core_utils_1.assertValidSelector)(() => { })).not.toThrow();
+            expect(() => assertValidSelector(() => { })).not.toThrow();
         });
         it('should not throw when selector is a string', () => {
-            expect(() => (0, core_utils_1.assertValidSelector)('name')).not.toThrow();
+            expect(() => assertValidSelector('name')).not.toThrow();
         });
         it('should not throw when selector is undefined', () => {
-            expect(() => (0, core_utils_1.assertValidSelector)(undefined)).not.toThrow();
+            expect(() => 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);
+                expect(() => assertValidSelector(123)).toThrow(TypeError);
             });
             it('should throw TypeError when selector is an object', () => {
-                expect(() => (0, core_utils_1.assertValidSelector)({})).toThrow(TypeError);
+                expect(() => assertValidSelector({})).toThrow(TypeError);
             });
         });
     });
     describe('isNumberOrString()', () => {
         it('should return true for a string', () => {
-            expect((0, core_utils_1.isNumberOrString)('hello')).toBe(true);
+            expect(isNumberOrString('hello')).toBe(true);
         });
         it('should return true for a number', () => {
-            expect((0, core_utils_1.isNumberOrString)(42)).toBe(true);
+            expect(isNumberOrString(42)).toBe(true);
         });
         it('should return false for a boolean', () => {
-            expect((0, core_utils_1.isNumberOrString)(true)).toBe(false);
+            expect(isNumberOrString(true)).toBe(false);
         });
         it('should return false for null', () => {
-            expect((0, core_utils_1.isNumberOrString)(null)).toBe(false);
+            expect(isNumberOrString(null)).toBe(false);
         });
         it('should return false for an object', () => {
-            expect((0, core_utils_1.isNumberOrString)({})).toBe(false);
+            expect(isNumberOrString({})).toBe(false);
         });
     });
     describe('utilitishError()', () => {
         it('should throw a TypeError by default', () => {
-            expect(() => (0, core_utils_1.utilitishError)('method', 'message')).toThrow(TypeError);
+            expect(() => utilitishError('method', 'message')).toThrow(TypeError);
         });
         it('should throw a RangeError when specified', () => {
-            expect(() => (0, core_utils_1.utilitishError)('method', 'message', undefined, RangeError)).toThrow(RangeError);
+            expect(() => 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');
+            expect(() => 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');
+            expect(() => 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');
+            expect(() => 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

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortBy = sortBy;
-const core_utils_1 = require("./core.utils");
-function sortBy(arr, direction, selector) {
+import { isNumberOrString, resolveSelector } from './core.utils';
+export function sortBy(arr, direction, selector) {
     if (arr.length === 0)
         return arr.slice();
-    const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
+    const getValue = resolveSelector(selector, (item) => item);
     const sample = getValue(arr[0]);
-    if (!(0, core_utils_1.isNumberOrString)(sample)) {
+    if (!isNumberOrString(sample)) {
         throw new TypeError('Selector must return number or string');
     }
-    if (!selector && !arr.every((item) => (0, core_utils_1.isNumberOrString)(item))) {
+    if (!selector && !arr.every((item) => isNumberOrString(item))) {
         throw new TypeError('Array elements must be number or string if no selector is provided');
     }
     return arr.slice().sort((a, b) => {
         const valA = getValue(a);
         const valB = getValue(b);
-        if (!(0, core_utils_1.isNumberOrString)(valA) || !(0, core_utils_1.isNumberOrString)(valB)) {
+        if (!isNumberOrString(valA) || !isNumberOrString(valB)) {
             throw new TypeError('Selector must return number or string');
         }
         if (valA > valB)