utilitish 0.0.1

package/LICENSE.txt

@@ -0,0 +1,25 @@
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2025 Donovan Ferreira
+
+Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
+
+                            Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+[... contenu tronqué pour l’aperçu ...]
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.

package/README.md

@@ -0,0 +1,5 @@
+## Licence
+
+Ce projet est distribué sous licence [GPL v3](https://www.gnu.org/licenses/gpl-3.0.html) © 2025 Donovan Ferreira.
+
+Ceci est une petite librairie qui ajoute plusieurs méthodes au prototype JavaScript.

package/dist/array/array-constructor.d.ts

@@ -0,0 +1,26 @@
+export {};
+declare global {
+    interface ArrayConstructor {
+        /**
+         * Combines multiple arrays element-wise, like Python's itertools.zip_longest .
+         * @param arrays Arrays to zip together
+         * @returns An array of arrays, each containing the i-th elements of the input arrays, undefined for the shortest arrays
+         */
+        zip(...arrays: any[][]): any[][];
+        /**
+         * Generates a sequence of numbers, similar to Python's range.
+         * @param start First number, or length if end is not defined
+         * @param end Last number (excluded)
+         * @param step Step of the sequence (positive or negative)
+         * @returns An array of numbers
+         */
+        range(start: number, end?: number, step?: number): number[];
+        /**
+         * Creates an array filled with the same value or a generated value.
+         * @param length Length of the array
+         * @param value Value or function generating a value
+         * @returns Filled array
+         */
+        repeat<T>(length: number, value: T | (() => T)): T[];
+    }
+}

package/dist/array/array-constructor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+Array.zip = function (...arrays) {
+    if (arrays.length === 0)
+        return [];
+    const maxLen = Math.max(...arrays.map((arr) => arr.length));
+    const result = [];
+    for (let i = 0; i < maxLen; i++) {
+        result.push(arrays.map((arr) => arr[i]));
+    }
+    return result;
+};
+Array.range = function (start, end, step = 1) {
+    if (end === undefined) {
+        end = start;
+        start = 0;
+    }
+    const result = [];
+    if (step === 0)
+        throw new Error('step must not be 0');
+    const condition = step > 0 ? (i) => i < end : (i) => i > end;
+    for (let i = start; condition(i); i += step) {
+        result.push(i);
+    }
+    return result;
+};
+Array.repeat = function (length, value) {
+    if (typeof length !== 'number' || !Number.isInteger(length) || length < 0) {
+        throw new TypeError('Indices must be integers');
+    }
+    const result = [];
+    for (let i = 0; i < length; i++) {
+        result.push(typeof value === 'function' ? value() : value);
+    }
+    return result;
+};

package/dist/array/array-constructor.spec.d.ts

@@ -0,0 +1 @@
+import './array-constructor';

package/dist/array/array-constructor.spec.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./array-constructor");
+describe('Array Constructor extensions', () => {
+    describe('range', () => {
+        it('should generate a range from 0 to n-1 if only start is given', () => {
+            expect(Array.range(5)).toEqual([0, 1, 2, 3, 4]);
+        });
+        it('should generate a range from start to end-1', () => {
+            expect(Array.range(2, 6)).toEqual([2, 3, 4, 5]);
+        });
+        it('should support negative steps', () => {
+            expect(Array.range(5, 1, -1)).toEqual([5, 4, 3, 2]);
+        });
+        it('should throw if step is 0', () => {
+            expect(() => Array.range(0, 5, 0)).toThrowError('step must not be 0');
+        });
+        it('should return an empty array if start equals end', () => {
+            expect(Array.range(3, 3)).toEqual([]);
+        });
+        it('should return an empty array if step does not reach end', () => {
+            expect(Array.range(0, 5, -1)).toEqual([]);
+            expect(Array.range(5, 0, 1)).toEqual([]);
+        });
+    });
+    describe('repeat', () => {
+        it('should fill an array with the same value', () => {
+            expect(Array.repeat(3, 'a')).toEqual(['a', 'a', 'a']);
+        });
+        it('should fill an array with values from a function', () => {
+            let n = 0;
+            expect(Array.repeat(4, () => ++n)).toEqual([1, 2, 3, 4]);
+        });
+        it('should return an empty array if length is 0', () => {
+            expect(Array.repeat(0, 'x')).toEqual([]);
+        });
+        it('should throw if length is negative or not an integer', () => {
+            expect(() => Array.repeat(-1, 'a')).toThrowError();
+            expect(() => Array.repeat(1.5, 'a')).toThrowError();
+            expect(() => Array.repeat('a', 'a')).toThrowError();
+        });
+    });
+    describe('zip', () => {
+        it('should zip two arrays of equal length', () => {
+            expect(Array.zip([1, 2, 3], ['a', 'b', 'c'])).toEqual([
+                [1, 'a'],
+                [2, 'b'],
+                [3, 'c'],
+            ]);
+        });
+        it('should zip arrays of different lengths (fill with undefined)', () => {
+            expect(Array.zip([1, 2], ['a', 'b', 'c'], [true, false, true])).toEqual([
+                [1, 'a', true],
+                [2, 'b', false],
+                [undefined, 'c', true],
+            ]);
+        });
+        it('should return an empty array if no arrays are given', () => {
+            expect(Array.zip()).toEqual([]);
+        });
+        it('should return an array of undefineds if all arrays are empty', () => {
+            expect(Array.zip([], [])).toEqual([]);
+        });
+        it('should work with a single array', () => {
+            expect(Array.zip([1, 2, 3])).toEqual([[1], [2], [3]]);
+        });
+        it('should fill with undefined for missing elements', () => {
+            expect(Array.zip([1], [2, 3, 4])).toEqual([
+                [1, 2],
+                [undefined, 3],
+                [undefined, 4],
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,68 @@
+export {};
+declare global {
+    interface Array<T> {
+        /**
+         * Returns the first element of the array, or `undefined` if the array is empty.
+         */
+        first(): T | undefined;
+        /**
+         * Returns the last element of the array, or `undefined` if the array is empty.
+         */
+        last(): T | undefined;
+        /**
+         * Calculates the sum of the array values.
+         * - If the array is of type `number[]`, no callback is required.
+         * - Otherwise, a callback must be provided to extract a numeric value.
+         *
+         * @param callback - Optional function that returns a `number` from an item.
+         * @throws {Error} If no callback is provided for a non-number array.
+         * @returns The sum of the values.
+         */
+        sum(this: number[]): number;
+        sum(this: T[], callback: (item: T) => number): number;
+        /**
+         * Returns a new array with only unique elements (based on strict equality).
+         */
+        unique(): T[];
+        /**
+         * Splits the array into chunks of the given size.
+         * @param size - Maximum size of each chunk.
+         */
+        chunk(size: number): T[][];
+        /**
+         * Calculates the average of the array values.
+         * - If the array is of type `number[]`, no callback is required.
+         * - Otherwise, a callback must be provided to extract a numeric value.
+         *
+         * @param callback - Optional function that returns a `number` from an item.
+         * @throws {Error} If no callback is provided for a non-number array.
+         * @returns The average of the values.
+         */
+        average(this: number[]): number;
+        average(this: T[], callback: (item: T) => number): number;
+        /**
+         * Groups the array elements based on a key returned by the callback function.
+         * @param callback - Function that returns a key to group by.
+         * @returns An object where keys are the group names and values are arrays of grouped items.
+         */
+        groupBy(callback: (item: T) => string | number): Record<string | number, T[]>;
+        /**
+         * Removes all falsy values (`false`, `null`, `0`, `""`, `undefined`, and `NaN`) from the array.
+         * @returns A new array with all falsy values removed.
+         */
+        compact(): T[];
+        /**
+         * Enumerates the array into tuples [value, index].
+         * Similar to Python's enumerate but returns value first.
+         * @returns An array of [value, index] pairs.
+         */
+        enumerate(): [T, number][];
+        /**
+         * Swaps the values at two indices in the array.
+         * @param i First index
+         * @param j Second index
+         * @returns The array itself after swapping
+         */
+        swap(i: number, j: number): this;
+    }
+}

package/dist/array/array-prototype.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+(0, utils_1.defineIfNotExists)(Array.prototype, 'first', function () {
+    return this[0];
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'last', function () {
+    return this[this.length - 1];
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'sum', function (callback) {
+    if (typeof callback === 'function') {
+        return this.reduce((acc, item) => acc + callback(item), 0);
+    }
+    if (this.every((item) => typeof item === 'number')) {
+        return this.reduce((acc, item) => acc + item, 0);
+    }
+    throw new Error('Array.prototype.sum() requires a callback unless array is number[]');
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'unique', function () {
+    return [...new Set(this)];
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'chunk', function (size) {
+    if (typeof size !== 'number' || !Number.isInteger(size) || size <= 0) {
+        throw new TypeError('Chunk size must be a positive integer');
+    }
+    const result = [];
+    for (let i = 0; i < this.length; i += size) {
+        result.push(this.slice(i, i + size));
+    }
+    return result;
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'average', function (callback) {
+    if (this.length === 0)
+        return 0;
+    if (typeof callback === 'function') {
+        return this.reduce((acc, item) => acc + callback(item), 0) / this.length;
+    }
+    if (this.every((item) => typeof item === 'number')) {
+        return (this.reduce((acc, item) => acc + item, 0) / this.length);
+    }
+    throw new Error('Array.prototype.average() requires a callback unless array is number[]');
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'groupBy', function (callback) {
+    if (typeof callback !== 'function') {
+        throw new TypeError('Callback must be a function');
+    }
+    const result = {};
+    this.forEach((item) => {
+        const key = callback(item);
+        if (typeof key !== 'string' && typeof key !== 'number') {
+            throw new TypeError('groupBy callback must return a string or number');
+        }
+        if (!result[key])
+            result[key] = [];
+        result[key].push(item);
+    });
+    return result;
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'compact', function () {
+    return this.filter(Boolean);
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'enumerate', function () {
+    return this.map((value, index) => [value, index]);
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'swap', function (i, j) {
+    if (typeof i !== 'number' ||
+        typeof j !== 'number' ||
+        !Number.isInteger(i) ||
+        !Number.isInteger(j)) {
+        throw new TypeError('Indices must be integers');
+    }
+    if (i < 0 || i >= this.length || j < 0 || j >= this.length) {
+        throw new RangeError('Index out of bounds');
+    }
+    if (i !== j) {
+        const temp = this[i];
+        this[i] = this[j];
+        this[j] = temp;
+    }
+    return this;
+});

package/dist/array/array-prototype.spec.d.ts

@@ -0,0 +1 @@
+import './array-prototype';

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./array-prototype");
+describe('Array prototype extensions', () => {
+    describe('first', () => {
+        it('should return the first element or undefined', () => {
+            expect([1, 2, 3].first()).toBe(1);
+            expect([].first()).toBeUndefined();
+        });
+    });
+    describe('last', () => {
+        it('should return the last element or undefined', () => {
+            expect([1, 2, 3].last()).toBe(3);
+            expect([].last()).toBeUndefined();
+        });
+    });
+    describe('sum', () => {
+        it('should work for number[] without callback', () => {
+            expect([1, 2, 3].sum()).toBe(6);
+        });
+        it('should work with callback', () => {
+            const items = [{ x: 1 }, { x: 2 }];
+            expect(items.sum((item) => item.x)).toBe(3);
+        });
+        // Ajoute ici les tests d’erreur si besoin
+    });
+    describe('average', () => {
+        it('should work for number[] without callback', () => {
+            expect([2, 4, 6].average()).toBe(4);
+        });
+        it('should work with callback', () => {
+            const items = [{ x: 2 }, { x: 4 }];
+            expect(items.average((item) => item.x)).toBe(3);
+        });
+        it('should return 0 for empty array', () => {
+            expect([].average()).toBe(0);
+        });
+    });
+    describe('unique', () => {
+        it('should return array with unique values', () => {
+            expect([1, 1, 2, 2, 3].unique()).toEqual([1, 2, 3]);
+        });
+    });
+    describe('chunk', () => {
+        it('should split array into chunks', () => {
+            expect([1, 2, 3, 4].chunk(2)).toEqual([
+                [1, 2],
+                [3, 4],
+            ]);
+            expect([1, 2, 3].chunk(2)).toEqual([[1, 2], [3]]);
+        });
+        it('should throw if size is not a positive integer', () => {
+            expect(() => [1, 2, 3].chunk(0)).toThrowError(TypeError);
+            expect(() => [1, 2, 3].chunk(-1)).toThrowError(TypeError);
+            expect(() => [1, 2, 3].chunk(1.5)).toThrowError(TypeError);
+            expect(() => [1, 2, 3].chunk('a')).toThrowError(TypeError);
+        });
+    });
+    describe('groupBy', () => {
+        it('should group items by callback result', () => {
+            const items = ['a', 'ab', 'abc'];
+            const result = items.groupBy((item) => item.length);
+            expect(result).toEqual({ 1: ['a'], 2: ['ab'], 3: ['abc'] });
+        });
+        it('should throw if callback is not a function', () => {
+            expect(() => [1, 2, 3].groupBy(null)).toThrowError(TypeError);
+        });
+        it('should throw if callback does not return string or number', () => {
+            expect(() => [1, 2, 3].groupBy(() => ({}))).toThrowError(TypeError);
+        });
+    });
+    describe('compact', () => {
+        it('should remove falsy values', () => {
+            expect([0, 1, false, 2, '', 3, null].compact()).toEqual([1, 2, 3]);
+        });
+    });
+    describe('swap', () => {
+        it('should swap two elements in the array', () => {
+            const arr = [1, 2, 3];
+            arr.swap(0, 2);
+            expect(arr).toEqual([3, 2, 1]);
+        });
+        it('should do nothing if indices are the same', () => {
+            const arr = [1, 2, 3];
+            arr.swap(1, 1);
+            expect(arr).toEqual([1, 2, 3]);
+        });
+        it('should throw if an index is out of bounds', () => {
+            const arr = [1, 2, 3];
+            expect(() => arr.swap(-1, 2)).toThrowError(RangeError);
+            expect(() => arr.swap(0, 3)).toThrowError(RangeError);
+        });
+        it('should throw if indices are not integers', () => {
+            const arr = [1, 2, 3];
+            expect(() => arr.swap(0.5, 2)).toThrowError(TypeError);
+            expect(() => arr.swap(0, 'a')).toThrowError(TypeError);
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import './array/array-constructor';
+import './array/array-prototype';
+import './object/object-prototype';
+import './string/string-prototype';

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./array/array-constructor");
+require("./array/array-prototype");
+require("./object/object-prototype");
+require("./string/string-prototype");

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

@@ -0,0 +1,22 @@
+export {};
+declare global {
+    interface Object {
+        /**
+         * Creates a deep clone of the object.
+         * @returns A deep copy of the original object.
+         */
+        deepClone<T>(): T;
+        /**
+         * Deeply merges another object into the current object.
+         * @param source - The object to merge from.
+         * @returns The merged object (this).
+         */
+        deepMerge<T>(source: any): T | typeof source;
+        /**
+         * Checks for deep equality with another object.
+         * @param other - The object to compare with.
+         * @returns True if deeply equal, false otherwise.
+         */
+        deepEquals(other: unknown): boolean;
+    }
+}

package/dist/object/object-prototype.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const defineIfNotExists = (name, fn) => {
+    const descriptor = Object.getOwnPropertyDescriptor(Object.prototype, name);
+    if (!descriptor || descriptor.writable || descriptor.configurable) {
+        Object.defineProperty(Object.prototype, name, {
+            value: fn,
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+    }
+};
+defineIfNotExists('deepClone', function () {
+    return structuredClone(this);
+});
+defineIfNotExists('deepMerge', function (source) {
+    if (typeof source !== 'object' || source === null) {
+        throw new TypeError('Source must be a non-null object');
+    }
+    const isObject = (val) => val !== null && typeof val === 'object' && !Array.isArray(val);
+    const merge = (target, source) => {
+        for (const key of Object.keys(source)) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, { [key]: {} });
+                merge(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+        return target;
+    };
+    return merge(this.deepClone(), source);
+});
+defineIfNotExists('deepEquals', function (other) {
+    function eq(a, b) {
+        // Functions: always false (even if code is the same)
+        if (typeof a === 'function' || typeof b === 'function') {
+            return false;
+        }
+        // Type check
+        if (typeof a !== typeof b)
+            return false;
+        if (a === b) {
+            // +0 !== -0
+            return a !== 0 || 1 / a === 1 / b;
+        }
+        // NaN === NaN
+        if (Number.isNaN(a) && Number.isNaN(b)) {
+            return true;
+        }
+        // Null check
+        if (a === null || b === null)
+            return a === b;
+        // Array and object check
+        if (Array.isArray(a) !== Array.isArray(b))
+            return false;
+        // Array check
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (!eq(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        // Object check
+        if (typeof a === 'object' && typeof b === 'object') {
+            const aKeys = Object.keys(a);
+            const bKeys = Object.keys(b);
+            if (aKeys.length !== bKeys.length)
+                return false;
+            // Check for undefined vs missing keys
+            for (const key of aKeys) {
+                if (!b.hasOwnProperty(key))
+                    return false;
+                if (!eq(a[key], b[key]))
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    return eq(this, other);
+});

package/dist/object/object-prototype.spec.d.ts

@@ -0,0 +1 @@
+import './object-prototype';

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./object-prototype");
+describe('Object.prototype extensions', () => {
+    describe('deepClone', () => {
+        it('should deeply clone a plain object', () => {
+            const obj = { a: 1, b: { c: 2 } };
+            const clone = structuredClone(obj);
+            expect(clone).toEqual(obj);
+            expect(clone).not.toBe(obj);
+            expect(clone.b).not.toBe(obj.b);
+        });
+        it('should deeply clone an array', () => {
+            const arr = [{ a: 1 }, { b: 2 }];
+            const clone = arr.deepClone();
+            expect(clone).toEqual(arr);
+            expect(clone).not.toBe(arr);
+            expect(clone[0]).not.toBe(arr[0]);
+        });
+    });
+    describe('deepMerge', () => {
+        it('should deeply merge two objects', () => {
+            const obj = { a: 1, b: { c: 2 } };
+            const source = { b: { d: 3 }, e: 4 };
+            const merged = obj.deepMerge(source);
+            expect(merged).toEqual({ a: 1, b: { c: 2, d: 3 }, e: 4 });
+            console.log(merged);
+        });
+        it('should overwrite primitive values', () => {
+            const obj = { a: 1, b: 2 };
+            const merged = obj.deepMerge({ b: 3 });
+            expect(merged).toEqual({ a: 1, b: 3 });
+            console.log(merged);
+        });
+        it('should throw if source is not an object', () => {
+            expect(() => ({}).deepMerge(null)).toThrowError(TypeError);
+            expect(() => ({}).deepMerge(42)).toThrowError(TypeError);
+        });
+    });
+    describe('Object.prototype polyfills - deepEquals', () => {
+        it('should return true for objects with same keys and values, regardless of key order', () => {
+            expect({ a: 2, b: 3 }.deepEquals({ b: 3, a: 2 })).toBe(true);
+            expect({ a: 2, b: { c: 4 } }.deepEquals({ b: { c: 4 }, a: 2 })).toBe(true);
+        });
+        it('should return false for objects with different values', () => {
+            expect({ a: 2, b: 3 }.deepEquals({ a: 2, b: 4 })).toBe(false);
+            expect({ a: 2, b: { c: 4 } }.deepEquals({ a: 2, b: { c: 5 } })).toBe(false);
+        });
+        it('should return true for arrays with same elements in same order', () => {
+            expect([1, 2, 3].deepEquals([1, 2, 3])).toBe(true);
+            expect([1, [2, 3]].deepEquals([1, [2, 3]])).toBe(true);
+        });
+        it('should return false for arrays with different elements or order', () => {
+            expect([1, 2, 3].deepEquals([1, 3, 2])).toBe(false);
+            expect([1, [2, 3]].deepEquals([1, [3, 2]])).toBe(false);
+        });
+        it('should return false for objects with different keys', () => {
+            expect({ a: 2 }.deepEquals({ b: 2 })).toBe(false);
+        });
+        it('should return true for empty arrays and objects', () => {
+            expect([].deepEquals([])).toBe(true);
+            expect({}.deepEquals({})).toBe(true);
+        });
+        it('should return false for array vs object', () => {
+            expect([].deepEquals({})).toBe(false);
+            expect({}.deepEquals([])).toBe(false);
+        });
+        it('should return false for different lengths', () => {
+            expect([1].deepEquals([1, 2])).toBe(false);
+            expect({ a: 1 }.deepEquals({ a: 1, b: 2 })).toBe(false);
+        });
+        it('should return true for NaN deepEquals NaN', () => {
+            expect({ a: NaN }.deepEquals({ a: NaN })).toBe(true);
+            expect([NaN].deepEquals([NaN])).toBe(true);
+        });
+        it('should return false for +0 and -0', () => {
+            expect({ a: +0 }.deepEquals({ a: -0 })).toBe(false);
+            expect([+0].deepEquals([-0])).toBe(false);
+        });
+        it('should return false for objects with undefined vs missing keys', () => {
+            expect({ a: undefined }.deepEquals({})).toBe(false);
+            expect({}.deepEquals({ a: undefined })).toBe(false);
+        });
+        it('should return false for objects with functions, even if functions are equal', () => {
+            expect({ a: () => 1 }.deepEquals({ a: () => 1 })).toBe(false);
+        });
+        it('should return true for nested structures deeply equal', () => {
+            expect({ a: [1, { b: 2 }] }.deepEquals({ a: [1, { b: 2 }] })).toBe(true);
+        });
+        it('should return false for nested structures not deeply equal', () => {
+            expect({ a: [1, { b: 2 }] }.deepEquals({ a: [1, { b: 3 }] })).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,51 @@
+export {};
+declare global {
+    interface String {
+        /**
+         * Capitalizes the first character of the string.
+         * @returns A new string with the first character in uppercase.
+         */
+        capitalize(): string;
+        /**
+         * Splits the string into an array of words, detecting camelCase, kebab-case, snake_case, and spaces.
+         * @returns An array of words extracted from the string.
+         */
+        splitWords(): string[];
+        /**
+         * Converts the string to camelCase.
+         * @returns A camelCased version of the string.
+         */
+        camelCase(): string;
+        /**
+         * Converts the string to kebab-case.
+         * @returns A kebab-cased version of the string.
+         */
+        kebabCase(): string;
+        /**
+         * Converts the string to snake_case.
+         * @returns A snake_cased version of the string.
+         */
+        snakeCase(): string;
+        /**
+         * Truncates the string to a maximum number of characters, appending '...' if truncated.
+         * @param n - Maximum length of the string.
+         * @returns A truncated string.
+         */
+        truncate(n: number): string;
+        /**
+         * Reverses the characters in the string.
+         * @returns The reversed string.
+         */
+        reverse(): string;
+        /**
+         * Checks if the string is empty or contains only whitespace.
+         * @returns `true` if the string is empty or whitespace only, `false` otherwise.
+         */
+        isEmpty(): boolean;
+        /**
+         * Converts the string into a slug usable in URLs.
+         * @returns A slugified version of the string.
+         */
+        slugify(): string;
+    }
+}

package/dist/string/string-prototype.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+(0, utils_1.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(/[^a-zA-Z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean);
+});
+(0, utils_1.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))
+        .join('');
+});
+(0, utils_1.defineIfNotExists)(String.prototype, 'kebabCase', function () {
+    return this.splitWords()
+        .map((w) => w.toLowerCase())
+        .join('-');
+});
+(0, utils_1.defineIfNotExists)(String.prototype, 'snakeCase', function () {
+    return this.splitWords()
+        .map((w) => w.toLowerCase())
+        .join('_');
+});
+(0, 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');
+    }
+    return this.length > n ? this.slice(0, n) + '...' : this.toString();
+});
+(0, utils_1.defineIfNotExists)(String.prototype, 'reverse', function () {
+    return [...this].reverse().join('');
+});
+(0, utils_1.defineIfNotExists)(String.prototype, 'isEmpty', function () {
+    return this.trim().length === 0;
+});
+(0, utils_1.defineIfNotExists)(String.prototype, 'slugify', function () {
+    return this.normalize('NFD')
+        .replace(/[̀-ͯ]/g, '')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+});
+(0, utils_1.defineIfNotExists)(String.prototype, 'capitalize', function () {
+    if (this.length === 0)
+        return '';
+    return this.charAt(0).toUpperCase() + this.slice(1);
+});

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

@@ -0,0 +1 @@
+import './string-prototype';

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./string-prototype");
+describe('String prototype extensions', () => {
+    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');
+        });
+    });
+});

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare const defineIfNotExists: <T extends object>(prototype: T, name: string, fn: Function) => void;

package/dist/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineIfNotExists = void 0;
+const defineIfNotExists = (prototype, name, fn) => {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+    if (!descriptor || descriptor.writable || descriptor.configurable) {
+        Object.defineProperty(prototype, name, {
+            value: fn,
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+    }
+};
+exports.defineIfNotExists = defineIfNotExists;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "utilitish",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "typescript",
+    "prototype",
+    "utils"
+  ],
+  "author": "Donovan Ferreira <donovanferreira12@gmail.com> (https://github.com/FDonovan12)",
+  "license": "GPL-3.0",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "typescript": "^5.8.3"
+  }
+}