utilitish 0.0.6 → 0.0.8

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../string/string-prototype");
+describe('String.prototype', () => {
+    describe('capitalize()', () => {
+        it('should capitalize the first character', () => {
+            expect('hello'.capitalize()).toBe('Hello');
+            expect('Hello'.capitalize()).toBe('Hello');
+            expect(''.capitalize()).toBe('');
+        });
+    });
+    describe('splitWords()', () => {
+        it('should split camelCase, kebab-case, snake_case, and spaces', () => {
+            expect('helloWorld'.splitWords()).toEqual(['hello', 'World']);
+            expect('hello-world'.splitWords()).toEqual(['hello', 'world']);
+            expect('hello_world'.splitWords()).toEqual(['hello', 'world']);
+            expect('hello world'.splitWords()).toEqual(['hello', 'world']);
+            expect('HTMLParser'.splitWords()).toEqual(['HTML', 'Parser']);
+        });
+    });
+    describe('camelCase()', () => {
+        it('should convert to camelCase', () => {
+            expect('hello world'.camelCase()).toBe('helloWorld');
+            expect('Hello_world-test'.camelCase()).toBe('helloWorldTest');
+            expect('helloWorldTest'.camelCase()).toBe('helloWorldTest');
+        });
+    });
+    describe('kebabCase()', () => {
+        it('should convert to kebab-case', () => {
+            expect('hello world'.kebabCase()).toBe('hello-world');
+            expect('Hello_worldTest'.kebabCase()).toBe('hello-world-test');
+            expect('hello-world-test'.kebabCase()).toBe('hello-world-test');
+        });
+    });
+    describe('snakeCase()', () => {
+        it('should convert to snake_case', () => {
+            expect('hello world'.snakeCase()).toBe('hello_world');
+            expect('Hello-worldTest'.snakeCase()).toBe('hello_world_test');
+            expect('hello_world_test'.snakeCase()).toBe('hello_world_test');
+        });
+    });
+    describe('truncate()', () => {
+        it('should truncate and add ... if needed', () => {
+            expect('hello world'.truncate(5)).toBe('hello...');
+            expect('hello'.truncate(10)).toBe('hello');
+        });
+        it('should throw if n is not a non-negative integer', () => {
+            expect(() => 'abc'.truncate(-1)).toThrowError(TypeError);
+            expect(() => 'abc'.truncate(1.5)).toThrowError(TypeError);
+            expect(() => 'abc'.truncate('a')).toThrowError(TypeError);
+        });
+    });
+    describe('reverse()', () => {
+        it('should reverse the string', () => {
+            expect('abc'.reverse()).toBe('cba');
+            expect('été'.reverse()).toBe('été');
+        });
+    });
+    describe('isEmpty()', () => {
+        it('should return true for empty or whitespace strings', () => {
+            expect(''.isEmpty()).toBe(true);
+            expect('   '.isEmpty()).toBe(true);
+        });
+        it('should return false for non-empty strings', () => {
+            expect('abc'.isEmpty()).toBe(false);
+            expect(' a '.isEmpty()).toBe(false);
+        });
+    });
+    describe('slugify()', () => {
+        it('should slugify a string', () => {
+            expect('Hello World!'.slugify()).toBe('hello-world');
+            expect("Éléphant à l'été".slugify()).toBe('elephant-a-l-ete');
+            expect('  --Hello__World--  '.slugify()).toBe('hello-world');
+        });
+    });
+    describe('replaceRange()', () => {
+        it('should replace a single character at the given index', () => {
+            expect('hello'.replaceRange(1, 2, 'a')).toBe('hallo');
+        });
+        it('should replace a range of characters', () => {
+            expect('abcdef'.replaceRange(2, 5, 'Z')).toBe('abZf');
+        });
+        it('should remove a range if replaceString is omitted', () => {
+            expect('abcdef'.replaceRange(1, 4)).toBe('aef');
+        });
+        it('should work when start > end (swaps automatically)', () => {
+            expect('abcdef'.replaceRange(5, 2, 'X')).toBe('abXf');
+        });
+        it('should insert at the end if start and end are equal to length', () => {
+            expect('abc'.replaceRange(3, 3, 'Z')).toBe('abcZ');
+        });
+        describe('error handling', () => {
+            it('should throw if start or end is negative', () => {
+                expect(() => 'abc'.replaceRange(-1, 2)).toThrow(RangeError);
+                expect(() => 'abc'.replaceRange(1, -2)).toThrow(RangeError);
+            });
+            it('should throw if start or end is out of bounds', () => {
+                expect(() => 'abc'.replaceRange(0, 4)).toThrow(RangeError);
+                expect(() => 'abc'.replaceRange(5, 1)).toThrow(RangeError);
+            });
+            it('should throw if start or end is not an integer', () => {
+                expect(() => 'abc'.replaceRange(1.5, 2)).toThrow(TypeError);
+                expect(() => 'abc'.replaceRange(1, 2.2)).toThrow(TypeError);
+            });
+        });
+        describe('edge cases', () => {
+            it('should default replaceString to empty string', () => {
+                expect('hello'.replaceRange(1, 4)).toBe('ho');
+            });
+            it('should support empty string', () => {
+                expect(''.replaceRange(0, 0, 'x')).toBe('x');
+            });
+        });
+    });
+});

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

@@ -0,0 +1,3 @@
+import { Selector } from './core.utils';
+export declare function mapToObject<K extends PropertyKey, V>(map: Map<K, V>): Record<K, V>;
+export declare function sortBy<T>(arr: T[], direction: 'asc' | 'desc', selector?: Selector<T, number | string>): T[];

package/dist/utils/logic.utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapToObject = mapToObject;
+exports.sortBy = sortBy;
+const core_utils_1 = require("./core.utils");
+function mapToObject(map) {
+    const obj = {};
+    for (const [key, value] of map) {
+        // Validate that key is not null or undefined
+        if (key === null || key === undefined) {
+            throw new TypeError(`Invalid key: key cannot be null or undefined. Key received: ${String(key)}`);
+        }
+        const keyType = typeof key;
+        // Only allow string, number, or symbol
+        if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
+            throw new TypeError(`Invalid key type: keys must be string, number, or symbol, received ${keyType}. Key value: ${String(key)}`);
+        }
+        obj[key] = value;
+    }
+    return obj;
+}
+function sortBy(arr, direction, selector) {
+    if (arr.length === 0)
+        return arr.slice();
+    const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
+    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');
+    }
+    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)) {
+            throw new TypeError('Selector must return number or string');
+        }
+        if (valA > valB)
+            return direction === 'asc' ? 1 : -1;
+        if (valA < valB)
+            return direction === 'asc' ? -1 : 1;
+        return 0;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utilitish",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",