utilitish 0.0.1 → 0.0.2

package/LICENSE.txt

@@ -1,25 +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/>.
+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

@@ -1,5 +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.
+## 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-prototype.d.ts

@@ -57,6 +57,26 @@ declare global {
          * @returns An array of [value, index] pairs.
          */
         enumerate(): [T, number][];
+        /**
+         * Returns a sorted copy of the array in ascending order.
+         * - If no callback is provided, all elements must be of type `number` or `string`.
+         * - If a callback is provided, it must return a `number` or `string` for each element.
+         * @param callback Optional function to extract the value to sort by.
+         * @throws {TypeError} If elements are not sortable or the callback returns an invalid type.
+         * @returns A new array sorted in ascending order.
+         */
+        sortAsc(this: number[] | string[]): T[];
+        sortAsc(this: T[], callback: (item: T) => number | string): T[];
+        /**
+         * Returns a sorted copy of the array in descending order.
+         * - If no callback is provided, all elements must be of type `number` or `string`.
+         * - If a callback is provided, it must return a `number` or `string` for each element.
+         * @param callback Optional function to extract the value to sort by.
+         * @throws {TypeError} If elements are not sortable or the callback returns an invalid type.
+         * @returns A new array sorted in descending order.
+         */
+        sortDesc(this: number[] | string[]): T[];
+        sortDesc(this: T[], callback: (item: T) => number | string): T[];
         /**
          * Swaps the values at two indices in the array.
          * @param i First index

package/dist/array/array-prototype.js

@@ -36,7 +36,7 @@ const utils_1 = require("../utils");
         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);
+        return this.reduce((acc, item) => acc + item, 0) / this.length;
     }
     throw new Error('Array.prototype.average() requires a callback unless array is number[]');
 });
@@ -62,11 +62,57 @@ const utils_1 = require("../utils");
 (0, utils_1.defineIfNotExists)(Array.prototype, 'enumerate', function () {
     return this.map((value, index) => [value, index]);
 });
+(0, utils_1.defineIfNotExists)(Array.prototype, 'sortAsc', function (callback) {
+    const arr = this.slice();
+    if (arr.length === 0)
+        return arr;
+    if (callback && typeof callback !== 'function') {
+        throw new TypeError('Callback must be a function');
+    }
+    // Si pas de callback, vérifier que tous les éléments sont number ou string
+    if (!callback && !arr.every((item) => typeof item === 'number' || typeof item === 'string')) {
+        throw new TypeError('Array elements must be number or string if no callback is provided');
+    }
+    return arr.sort((a, b) => {
+        const valA = callback ? callback(a) : a;
+        const valB = callback ? callback(b) : b;
+        if ((typeof valA !== 'number' && typeof valA !== 'string') ||
+            (typeof valB !== 'number' && typeof valB !== 'string')) {
+            throw new TypeError('Callback must return number or string');
+        }
+        if (valA < valB)
+            return -1;
+        if (valA > valB)
+            return 1;
+        return 0;
+    });
+});
+(0, utils_1.defineIfNotExists)(Array.prototype, 'sortDesc', function (callback) {
+    const arr = this.slice();
+    if (arr.length === 0)
+        return arr;
+    if (callback && typeof callback !== 'function') {
+        throw new TypeError('Callback must be a function');
+    }
+    if (!callback && !arr.every((item) => typeof item === 'number' || typeof item === 'string')) {
+        throw new TypeError('Array elements must be number or string if no callback is provided');
+    }
+    return arr.sort((a, b) => {
+        const valA = callback ? callback(a) : a;
+        const valB = callback ? callback(b) : b;
+        if ((typeof valA !== 'number' && typeof valA !== 'string') ||
+            (typeof valB !== 'number' && typeof valB !== 'string')) {
+            throw new TypeError('Callback must return number or string');
+        }
+        if (valA > valB)
+            return -1;
+        if (valA < valB)
+            return 1;
+        return 0;
+    });
+});
 (0, utils_1.defineIfNotExists)(Array.prototype, 'swap', function (i, j) {
-    if (typeof i !== 'number' ||
-        typeof j !== 'number' ||
-        !Number.isInteger(i) ||
-        !Number.isInteger(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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "utilitish",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "jest"
   },
   "keywords": [
     "typescript",
@@ -19,6 +20,8 @@
   "license": "GPL-3.0",
   "devDependencies": {
     "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.4",
     "typescript": "^5.8.3"
   }
 }

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

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

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

@@ -1,75 +0,0 @@
-"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.spec.d.ts

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

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

@@ -1,99 +0,0 @@
-"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/object/object-prototype.spec.d.ts

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

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

@@ -1,94 +0,0 @@
-"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.spec.d.ts

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

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

@@ -1,76 +0,0 @@
-"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');
-        });
-    });
-});