@webalternatif/js-core 1.0.0 → 1.1.1

package/tests/is.test.js

@@ -1,354 +0,0 @@
-import {each} from "../src/traversal.js";
-import {
-    isObject,
-    isPlainObject,
-    isFunction,
-    isDate,
-    isBoolean,
-    isBool,
-    isEvent,
-    isFloat, isScalar, isEventSupported, isTouchDevice
-} from "../src/is.js";
-
-describe('is methods', () => {
-    describe('isObject()', () => {
-        it('should return true for a plain object', () => {
-            const obj = {key: 'value'};
-            expect(isObject(obj)).toBe(true);
-        })
-
-        it('should return false for an array', () => {
-            const arr = [1, 2, 3];
-            expect(isObject(arr)).toBe(false);
-        })
-
-        it('should return true for an object created with Object.create', () => {
-            const obj = Object.create(null);
-            expect(isObject(obj)).toBe(true);
-        })
-    })
-
-    describe('isArray()', () => {
-        it('should return true for an empty array', () => {
-            const arr = [];
-            expect(isArray(arr)).toBe(true);
-        })
-
-        it('should return true for an array with elements', () => {
-            const arr = [1, 2, 3];
-            expect(isArray(arr)).toBe(true);
-        })
-
-        it('should return false for a plain object', () => {
-            const obj = {key: 'value'};
-            expect(isArray(obj)).toBe(false);
-        })
-
-        const isArray = Array.isArray;
-        Array.isArray = undefined;
-
-        it('should return true id Array.isArray is undefined', () => {
-            const arr = [1, 2, 3];
-            expect(isArray(arr)).toBe(true);
-        })
-
-        Array.isArray = isArray;
-    })
-
-    describe('isPlainObject()', () => {
-        it('should return true for a plain object', () => {
-            const obj = { key: 'value' };
-            expect(isPlainObject(obj)).toBe(true);
-        })
-
-        it('should return false for null, undefined, array', () => {
-            expect(isPlainObject(null)).toBe(false);
-            expect(isPlainObject(undefined)).toBe(false);
-            expect(isPlainObject([1, 2, 3])).toBe(false);
-            expect(isPlainObject(() => {})).toBe(false);
-        })
-
-        it('should return true for an object created with Object.create(null)', () => {
-            const obj = Object.create(null);
-            expect(isPlainObject(obj)).toBe(true);
-        })
-
-        it('should return false for an object with a custom constructor', () => {
-            function CustomConstructor() {}
-            const obj = new CustomConstructor();
-            expect(isPlainObject(obj)).toBe(false);
-        })
-
-        it('should return false for non-object values', () => {
-            each([2, 'string', true, Symbol('sym')], (i, value) => {
-                expect(isPlainObject(value)).toBe(false);
-            })
-        })
-
-        it('should return false if isObject returns false for o.constructor.prototype', () => {
-            const obj = {};
-            obj.constructor = function CustomConstructor() {};
-            expect(isPlainObject(obj)).toBe(false);
-        })
-
-        it('should return false if isFunction returns true', () => {
-            const obj = function () {};
-            expect(isPlainObject(obj)).toBe(false);
-        })
-
-        it('should return false if o.constructor.prototype is not an object', () => {
-            const nonObjectPrototype = Object.create(null);
-            nonObjectPrototype.constructor = {
-                prototype: null,
-            };
-
-            const result = isPlainObject(nonObjectPrototype);
-
-            expect(result).toBe(false);
-        })
-    })
-
-    describe('isFunction()', () => {
-        it('should return true for a regular and arrow functions', () => {
-            expect(isFunction(function () {})).toBe(true);
-            expect(isFunction(() => {})).toBe(true);
-        })
-
-        it('should return false for null, undefined, string, number, boolean, object, array, symbol', () => {
-            expect(isFunction(null)).toBe(false);
-            expect(isFunction(undefined)).toBe(false);
-            expect(isFunction('Hello world')).toBe(false);
-            expect(isFunction(2)).toBe(false);
-            expect(isFunction(true)).toBe(false);
-            expect(isFunction(false)).toBe(false);
-            expect(isFunction({ key: 'value' })).toBe(false);
-            expect(isFunction([1, 2, 3])).toBe(false);
-            expect(isFunction(Symbol('f'))).toBe(false);
-            expect(isFunction(class MyClass {})).toBe(true); // Les classes sont des fonctions
-        })
-
-        it('should return false for a function-like object', () => {
-            const funcLike = { call: () => {} };
-            expect(isFunction(funcLike)).toBe(false);
-        })
-    })
-
-    describe('isDate()', () => {
-        it('should return true for a valid Date object', () => {
-            const date = new Date();
-            expect(isDate(date)).toBe(true);
-        })
-
-        it('should return false for a string that looks like a date', () => {
-            const dateString = '2023-01-01';
-            expect(isDate(dateString)).toBe(false);
-        })
-
-        it('should return false for a number representing a timestamp', () => {
-            const timestamp = Date.now();
-            expect(isDate(timestamp)).toBe(false);
-        })
-
-        it('should return false for invalid Date objects', () => {
-            const invalidDate = new Date('invalid-date');
-            expect(isDate(invalidDate)).toBe(true);
-        })
-    })
-
-    describe('isBoolean(), isBool()', () => {
-        it('should return true for true and false', () => {
-            expect(isBoolean(true)).toBe(true);
-            expect(isBoolean(false)).toBe(true);
-        })
-
-        it('should return false for a string, a number, null and undefined', () => {
-            expect(isBoolean('true')).toBe(false);
-            expect(isBoolean('false')).toBe(false);
-            expect(isBoolean(1)).toBe(false);
-            expect(isBoolean(0)).toBe(false);
-            expect(isBoolean(null)).toBe(false);
-            expect(isBoolean(undefined)).toBe(false);
-        })
-
-        it('should be an alias of isBoolean', () => {
-            expect(isBool === isBoolean).toBe(true);
-        })
-    })
-
-    describe('isEvent()', () => {
-        it('should return true for a valid DOM Event object', () => {
-            const mockEvent = new Event('click');
-            expect(isEvent(mockEvent)).toBe(true);
-        })
-
-        it('should return true for an object with a preventDefault method', () => {
-            const mockEvent = {
-                preventDefault: () => {},
-            };
-
-            expect(isEvent(mockEvent)).toBe(true);
-        })
-
-        it('should return true if constructor matches [object Event]', () => {
-            const mockEvent = {
-                constructor: { toString: () => '[object Event]' },
-            };
-
-            expect(isEvent(mockEvent)).toBe(true);
-        })
-
-        it('should return false for non-object inputs', () => {
-            expect(isEvent(null)).toBe(false);
-            expect(isEvent(undefined)).toBe(false);
-            expect(isEvent(42)).toBe(false);
-            expect(isEvent('string')).toBe(false);
-        })
-    })
-
-    describe('isFloat() function()', () => {
-        it('should return true for valid float strings', () => {
-            expect(isFloat('3.14')).toBe(true);
-            expect(isFloat('-3.14')).toBe(true);
-            expect(isFloat('0.123')).toBe(true);
-            expect(isFloat('-0.123')).toBe(true);
-        })
-
-        it('should return true for valid integers (as they are also floats)', () => {
-            expect(isFloat('42')).toBe(true);
-            expect(isFloat('-42')).toBe(true);
-            expect(isFloat('0')).toBe(true);
-        })
-
-        it('should return true for valid float numbers', () => {
-            expect(isFloat(3.14)).toBe(true);
-            expect(isFloat(-3.14)).toBe(true);
-            expect(isFloat(0.123)).toBe(true);
-            expect(isFloat(-0.123)).toBe(true);
-        })
-
-        it('should return true for valid integer numbers', () => {
-            expect(isFloat(42)).toBe(true);
-            expect(isFloat(-42)).toBe(true);
-            expect(isFloat(0)).toBe(true);
-        })
-
-        it('should return false for invalid float strings', () => {
-            expect(isFloat('3.14.15')).toBe(false);
-            expect(isFloat('abc')).toBe(false);
-            expect(isFloat('-3.')).toBe(false);
-            expect(isFloat('-.')).toBe(false);
-            expect(isFloat('3-3')).toBe(false);
-        })
-
-        it('should return false for non-numeric values', () => {
-            expect(isFloat(null)).toBe(false);
-            expect(isFloat(undefined)).toBe(false);
-            expect(isFloat({})).toBe(false);
-            expect(isFloat([])).toBe(false);
-            expect(isFloat(() => {})).toBe(false);
-        })
-
-        it('should return true for floats in exponential notation', () => {
-            expect(isFloat('1e3')).toBe(false);
-            expect(isFloat('1.23e3')).toBe(false);
-        })
-
-        it('should return true for numbers passed as strings', () => {
-            expect(isFloat('123')).toBe(true);
-            expect(isFloat('123.456')).toBe(true);
-            expect(isFloat('-123.456')).toBe(true);
-        })
-    })
-
-    describe('isScalar', () => {
-        it('should return true for null', () => {
-            expect(isScalar(null)).toBe(true);
-        })
-
-        it('should return true for strings', () => {
-            expect(isScalar('hello')).toBe(true);
-            expect(isScalar('')).toBe(true);
-        })
-
-        it('should return true for numbers', () => {
-            expect(isScalar(42)).toBe(true);
-            expect(isScalar(0)).toBe(true);
-            expect(isScalar(-123.45)).toBe(true);
-        })
-
-        it('should return true for bigints', () => {
-            expect(isScalar(10n)).toBe(true);
-        })
-
-        it('should return true for booleans', () => {
-            expect(isScalar(true)).toBe(true);
-            expect(isScalar(false)).toBe(true);
-        })
-
-        it('should return true for symbols', () => {
-            expect(isScalar(Symbol('test'))).toBe(true);
-        })
-
-        it('should return false for objects', () => {
-            expect(isScalar({})).toBe(false);
-            expect(isScalar([])).toBe(false);
-            expect(isScalar(() => {})).toBe(false);
-        })
-
-        it('should return false for undefined', () => {
-            expect(isScalar(undefined)).toBe(false);
-        })
-    })
-
-    describe('isEventSupported', () => {
-        it('should return true for supported events on specific elements', () => {
-            expect(isEventSupported('select')).toBe(true);
-            expect(isEventSupported('change')).toBe(true);
-            expect(isEventSupported('submit')).toBe(true);
-            expect(isEventSupported('reset')).toBe(true);
-            expect(isEventSupported('error')).toBe(true);
-            expect(isEventSupported('load')).toBe(true);
-            expect(isEventSupported('abort')).toBe(true);
-        })
-
-        it('should return true for generic events on a div', () => {
-            expect(isEventSupported('click')).toBe(true);
-            expect(isEventSupported('mouseover')).toBe(true);
-            expect(isEventSupported('keydown')).toBe(true);
-        })
-
-        it('should return false for unsupported events', () => {
-            expect(isEventSupported('unsupportedEvent')).toBe(false);
-            expect(isEventSupported('customEvent')).toBe(false);
-        })
-
-        it('should handle empty event names gracefully', () => {
-            expect(isEventSupported('')).toBe(false);
-        })
-
-        it('should handle null and undefined inputs gracefully', () => {
-            expect(isEventSupported(null)).toBe(false);
-            expect(isEventSupported(undefined)).toBe(false);
-        })
-    })
-
-    describe('isTouchDevice()', () => {
-        it('should return true if the device supports touchstart events', () => {
-            jest.spyOn(document, 'createElement').mockImplementation(() => {
-                return { ontouchstart: jest.fn() };
-            })
-
-            expect(isTouchDevice()).toBe(true);
-            jest.restoreAllMocks();
-        })
-
-        it('should return false if the device does not support touchstart events', () => {
-            jest.spyOn(document, 'createElement').mockImplementation(() => {
-                return {};
-            })
-
-            expect(isTouchDevice()).toBe(false);
-            jest.restoreAllMocks();
-        })
-    })
-})

package/tests/math.test.js

@@ -1,221 +0,0 @@
-import {
-    min,
-    max,
-    round,
-    hex2dec,
-    dec2hex,
-    floorTo,
-    plancher
-} from "../src/math.js";
-
-describe('math functions', () => {
-    describe('round()', () => {
-        it('should round to the nearest integer when no precision is given', () => {
-            expect(round(1.4)).toBe(1);
-            expect(round(1.6)).toBe(2);
-        });
-
-        it('should round to the specified precision', () => {
-            expect(round(1.234, 1)).toBe(1.2);
-            expect(round(1.234, 2)).toBe(1.23);
-            expect(round(1.235, 2)).toBe(1.24);
-        });
-
-        it('should handle negative precision', () => {
-            expect(round(1234.56, -1)).toBe(1230);
-            expect(round(1234.56, -2)).toBe(1200);
-            expect(round(1234.56, -3)).toBe(1000);
-        });
-
-        it('should handle edge cases with 0 precision', () => {
-            expect(round(0.5)).toBe(1);
-            expect(round(-0.5)).toBe(-0);
-            expect(round(0)).toBe(0);
-        });
-
-        it('should handle very large numbers', () => {
-            expect(round(123456789.98765, 3)).toBe(123456789.988);
-            expect(round(123456789.98765, -3)).toBe(123457000);
-        });
-
-        it('should handle negative numbers', () => {
-            expect(round(-1.234, 1)).toBe(-1.2);
-            expect(round(-1.234, 2)).toBe(-1.23);
-            expect(round(-1.235, 2)).toBe(-1.24);
-        });
-
-        it('should handle edge cases with precision 0', () => {
-            expect(round(1.5, 0)).toBe(2);
-            expect(round(-1.5, 0)).toBe(-1);
-        });
-
-        it('should return the same value for integers', () => {
-            expect(round(5)).toBe(5);
-            expect(round(-5)).toBe(-5);
-        });
-    });
-
-    describe('floorTo()', () => {
-        it('should round down to the nearest multiple of the precision', () => {
-            expect(floorTo(123, 10)).toBe(120);
-            expect(floorTo(456, 100)).toBe(400);
-            expect(floorTo(789.25, 0.1)).toBe(789.2);
-        });
-
-        it('should handle negative numbers correctly', () => {
-            expect(floorTo(-123, 10)).toBe(-130);
-            expect(floorTo(-456, 100)).toBe(-500);
-            expect(floorTo(-789.25, 0.1)).toBe(-789.3);
-        });
-
-        it('should handle precision larger than the number', () => {
-            expect(floorTo(50, 100)).toBe(0);
-            expect(floorTo(-50, 100)).toBe(-100);
-        });
-
-        it('should return the number itself when precision is 1', () => {
-            expect(floorTo(123, 1)).toBe(123);
-            expect(floorTo(-456, 1)).toBe(-456);
-        });
-
-        it('should return 0 when the number is 0', () => {
-            expect(floorTo(0, 10)).toBe(0);
-            expect(floorTo(0, 100)).toBe(0);
-        });
-
-        it('should handle edge cases with very small precision', () => {
-            expect(floorTo(123.456, 0.01)).toBe(123.45);
-            expect(floorTo(-123.456, 0.01)).toBe(-123.46);
-        });
-
-        it('should throw an error if precision is 0', () => {
-            expect(() => floorTo(123, 0)).toThrow();
-        });
-
-        it('should throw an error if precision is negative', () => {
-            expect(() => floorTo(123, -10)).toThrow();
-        });
-    });
-
-    describe('min()', () => {
-        it('should return the minimum value from an array', () => {
-            const list = [5, 2, 9, 1, 7];
-            const result = min(list);
-            expect(result).toBe(1);
-        });
-
-        it('should handle an empty array and return Infinity', () => {
-            const list = [];
-            const result = min(list);
-            expect(result).toBe(Infinity);
-        });
-
-        it('should handle an object with a custom comparison function', () => {
-            const list = { a: 5, b: 2, c: 9, d: 1, e: 7 };
-            const cmp_func = (a, b) => a - b;
-            const result = min(list, cmp_func);
-            expect(result).toBe(1);
-        });
-
-        it('should handle an object without a custom comparison function', () => {
-            const list = { a: 'z', b: 'b', c: 'm' };
-            const result = min(list);
-            expect(result).toBe('b');
-        });
-
-        it('should return undefined for an empty object', () => {
-            const list = {};
-            const result = min(list);
-            expect(result).toBeUndefined();
-        });
-
-        it('should return undefined if neither array nor object is passed', () => {
-            const list = null;
-            const result = min(list);
-            expect(result).toBeUndefined();
-        });
-    });
-
-    describe('max()', () => {
-        it('should return the maximum value from an array', () => {
-            const list = [0, 1, 5, 2, 4, 9, 1, 7, 2];
-            const result = max(list);
-            expect(result).toBe(9);
-        });
-
-        it('should handle an empty array and return -Infinity', () => {
-            const list = [];
-            const result = max(list);
-            expect(result).toBe(-Infinity);
-        });
-
-        it('should handle an object with a custom comparison function', () => {
-            const list = { a: 5, b: 2, c: 9, d: 1, e: 7 };
-            const cmp_func = (a, b) => b - a;
-            const result = max(list, cmp_func);
-            expect(result).toBe(9);
-        });
-
-        it('should handle an object without a custom comparison function', () => {
-            const list = { a: 'z', b: 'b', c: 'm' };
-            const result = max(list);
-            expect(result).toBe('z');
-        });
-
-        it('should return undefined for an empty object', () => {
-            const list = {};
-            const result = max(list);
-            expect(result).toBeUndefined();
-        });
-
-        it('should return undefined if neither array nor object is passed', () => {
-            const list = null;
-            const result = max(list);
-            expect(result).toBeUndefined();
-        });
-    });
-
-    describe('hex2dec function', () => {
-        it('should convert a single-digit hexadecimal to decimal', () => {
-            expect(hex2dec('A')).toBe(10);
-            expect(hex2dec('F')).toBe(15);
-            expect(hex2dec('0')).toBe(0);
-        });
-
-        it('should convert a multi-digit hexadecimal to decimal', () => {
-            expect(hex2dec('1A')).toBe(26);
-            expect(hex2dec('FF')).toBe(255);
-            expect(hex2dec('100')).toBe(256);
-            expect(hex2dec('ABC')).toBe(2748);
-        });
-
-        it('should handle lowercase hexadecimal inputs', () => {
-            expect(hex2dec('a')).toBe(10);
-            expect(hex2dec('ff')).toBe(255);
-            expect(hex2dec('abc')).toBe(2748);
-        });
-
-        it('should handle mixed-case hexadecimal inputs', () => {
-            expect(hex2dec('aBc')).toBe(2748);
-            expect(hex2dec('Ff')).toBe(255);
-        });
-
-        it('should handle numeric strings as input', () => {
-            expect(hex2dec('123')).toBe(291);
-        });
-
-        it('should return 0 for an empty string', () => {
-            expect(hex2dec('')).toBe(0);
-        });
-
-        it('should handle non-string inputs by converting them to strings', () => {
-            expect(hex2dec(123)).toBe(291);
-            expect(hex2dec(0)).toBe(0);
-        });
-
-        it('should return 0 for invalid hexadecimal characters', () => {
-            expect(hex2dec('G')).toBe(0);
-            expect(hex2dec('123G')).toBe(0);
-        });
-    });
-});

package/tests/random.test.js

@@ -1,72 +0,0 @@
-import * as r from '../src/random.js';
-
-describe('Random String Generation Functions', () => {
-    const isAlpha = /^[a-z]+$/;
-    const isAlphaCs = /^[a-zA-Z]+$/;
-    const isAlphaNum = /^[a-z0-9]+$/;
-    const isAlphaNumCs = /^[a-zA-Z0-9]+$/;
-    const isNum = /^[0-9]+$/;
-
-    it('should generate a unique ID of length 10 with uniqid', () => {
-        const id = r.uniqid();
-        expect(id).toHaveLength(10);
-        expect(isAlpha.test(id)).toBe(true);
-    });
-
-    it('should generate a random lowercase alphabetic string with randAlpha', () => {
-        const str = r.randAlpha(15);
-        expect(str).toHaveLength(15);
-        expect(isAlpha.test(str)).toBe(true);
-    });
-
-    it('should generate a random alphabetic string with uppercase and lowercase with randAlphaCs', () => {
-        const str = r.randAlphaCs(12);
-        expect(str).toHaveLength(12);
-        expect(isAlphaCs.test(str)).toBe(true);
-    });
-
-    it('should generate a random alphanumeric string with lowercase letters and numbers with randAlphaNum', () => {
-        const str = r.randAlphaNum(20);
-        expect(str).toHaveLength(20);
-        expect(isAlphaNum.test(str)).toBe(true);
-    });
-
-    it('should generate a random alphanumeric string with uppercase, lowercase letters, and numbers with randAlphaNumCs', () => {
-        const str = r.randAlphaNumCs(25);
-        expect(str).toHaveLength(25);
-        expect(isAlphaNumCs.test(str)).toBe(true);
-    });
-
-    it('should generate a random numeric string with randNum', () => {
-        const str = r.randNum(8);
-        expect(str).toHaveLength(8);
-        expect(isNum.test(str)).toBe(true);
-    });
-
-    it('should generate a random string from a custom range with rand', () => {
-        const range = ['A', 'B', 'C', '1', '2', '3'];
-        const str = r.rand(range, 6);
-        expect(str).toHaveLength(6);
-        [...str].forEach((char) => {
-            expect(range).toContain(char);
-        });
-    });
-
-    it('should handle zero length input for all functions', () => {
-        expect(r.randAlpha(0)).toHaveLength(0);
-        expect(r.randAlphaCs(0)).toHaveLength(0);
-        expect(r.randAlphaNum(0)).toHaveLength(0);
-        expect(r.randAlphaNumCs(0)).toHaveLength(0);
-        expect(r.randNum(0)).toHaveLength(0);
-        expect(r.rand(['X', 'Y', 'Z'], 0)).toHaveLength(0);
-    });
-
-    it('should return an empty string if n is negative for all functions', () => {
-        expect(r.randAlpha(-5)).toHaveLength(0);
-        expect(r.randAlphaCs(-5)).toHaveLength(0);
-        expect(r.randAlphaNum(-5)).toHaveLength(0);
-        expect(r.randAlphaNumCs(-5)).toHaveLength(0);
-        expect(r.randNum(-5)).toHaveLength(0);
-        expect(r.rand(['A', 'B', 'C'], -5)).toHaveLength(0);
-    });
-});