@webalternatif/js-core 1.0.0 → 1.1.1

package/src/traversal.js

@@ -1,134 +0,0 @@
-import {isArray, isBoolean, isObject, isPlainObject, isString, isUndefined} from "./is.js";
-import {isWindow} from "./dom.js";
-import {sizeOf} from "./utils.js";
-
-export const each = function(o, callback, context) {
-    const oToString = Object.prototype.toString.call(o);
-
-    if (oToString === '[object Set]') {
-        o = [...o];
-    } else if (oToString === '[object Map]') {
-        o = Object.fromEntries(o);
-    }
-
-    if (isArray(o)) {
-        for (let i = 0; i < o.length; i++)
-            if (false === callback.call(context || o[i], i, o[i], o, i))
-                return;
-    } else if (isObject(o)) {
-        let index = -1;
-
-        for (let i in o)
-            if (o.hasOwnProperty(i) && false === callback.call(context || o[i], i, o[i], o, ++index))
-                return;
-    } else if (isString(o)) {
-        const arr = o.split('');
-
-        for (let i = 0; i < arr.length; i++)
-            if (false === callback.call(context || arr[i], i, arr[i], o, i))
-                return;
-    }
-
-    return o;
-}
-
-export const foreach = function(o, callback, context) {
-    return each(o, (key, value, o, index) => callback.apply(context || value, [value, key, o, index]), context)
-}
-
-export const map = function(o, callback, context) {
-    let results = [];
-
-    each(o, function(index, value, o, i) {
-        const response = callback.call(context, index, value, o, i);
-
-        if (response !== null) {
-            results.push(response);
-        }
-    });
-
-    return results;
-}
-
-export const reduce = function(o, callback, initialValue) {
-    const isInitialValueDefined = !isUndefined(initialValue);
-
-    if (!sizeOf(o) && !isInitialValueDefined) {
-        throw new Error('Nothing to reduce and no initial value');
-    }
-
-    let accumulator = !isInitialValueDefined ? map(o, (i, v) => i === 0 ? v : null)[0] : initialValue;
-
-    each(o, (i, v) => {
-        if (i === 0 && !isInitialValueDefined) {
-            return true;
-        }
-
-        accumulator = callback(accumulator, v, i, o);
-    })
-
-    return accumulator;
-}
-
-export const extend = function(...args) {
-    let deep = false;
-    if (isBoolean(args[0])) {
-        deep = args.shift();
-    }
-
-    if (args.length < 2 || isUndefined(args[0]) || null === args[0]) {
-        return args[0];
-    }
-
-    let dest = args[0];
-    if (!isObject(dest)) {
-        args[0] = dest = {};
-    }
-
-    each(args.slice(1), (i, src) => {
-        if (isObject(src)) {
-            for (let name in src) {
-                if (deep && isPlainObject(src[name])) {
-                    dest[name] = extend(true, {}, dest[name], src[name]);
-                } else {
-                    dest[name] = src[name];
-                }
-            }
-        }
-    })
-
-    return dest;
-}
-
-export const clone = function(o) {
-    if ((!isObject(o) && !isArray(o)) || isWindow(o)) {
-        return o;
-    }
-
-    const c = isObject(o) ? {} : [];
-
-    each(o, (i, value) => {
-        if (isObject(value)) {
-            c[i] = clone(value);
-        } else {
-            c[i] = value;
-        }
-    })
-
-    return c;
-}
-
-export const merge = function(first, second = [], ...args)
-{
-    const result = map(first, (i, elem) => elem);
-
-    each(second, function(i, elem) {
-        result.push(elem);
-    });
-
-    if (args.length) {
-        return merge(result, ...args);
-    }
-
-    return result;
-}

package/src/utils.js

@@ -1,130 +0,0 @@
-import {each, map} from "./traversal.js";
-import {isArray, isFunction, isObject, isUndefined} from "./is.js";
-
-export const equals = function(o1, o2, seen = new WeakMap()) {
-    if (o1 === o2) return true;
-
-    if (typeof o1 !== typeof o2 || o1 == null || o2 == null) {
-        return false;
-    }
-
-    if (isObject(o1)) {
-        if (seen.has(o1)) {
-            return seen.get(o1) === o2;
-        }
-
-        seen.set(o1, o2);
-
-        const keys1 = Object.keys(o1),
-            keys2 = Object.keys(o2);
-
-        if (keys1.length !== keys2.length) {
-            return false;
-        }
-
-        return keys1.every((key) => equals(o1[key], o2[key], seen));
-    }
-
-    return false;
-}
-
-export const noop = function() {}
-
-export const sizeOf = function(o) {
-    return map(o, noop).length;
-}
-
-/**
- * Recursively flattens an object or array into a single-level array.
- *
- * @param {Object|Array} o - The object or array to flatten.
- * @returns {Array} A flattened array containing all the values from the input object or array.
- *
- * @example <caption>Flatten an array of arrays</caption>
- * const result = flatten([1, [2, [3, 4]], 5]);
- * console.log(result);
- * // Output: [1, 2, 3, 4, 5]
- *
- * @example <caption>Flatten an object</caption>
- * const result = flatten({ a: 1, b: [2, { c: 3 }], d: 4 });
- * console.log(result);
- * // Output: [1, 2, 3, 4]
- */
-export const flatten = function(o)
-{
-    if (isObject(o) || isArray(o)) {
-        return [].concat.apply([], map(o, (i, val) => flatten(val)))
-    }
-
-    return o;
-}
-
-export const strParseFloat = function(val) {
-    if (!val) return 0;
-
-    return parseFloat((val + '')
-        .replace(/\s/g, '')
-        .replace(',', '.'));
-}
-
-export const throttle = function(func, wait, leading = true, trailing = true, context = null) {
-    let timeout = null;
-    let lastCall = 0;
-
-    return function (...args) {
-        const now = Date.now();
-
-        if (!lastCall && !leading) {
-            lastCall = now;
-        }
-
-        const remaining = wait - (now - lastCall);
-
-        if (remaining <= 0 || remaining > wait) {
-            lastCall = now;
-            func.apply(context || this, args);
-        } else if (!timeout && trailing) {
-            timeout = setTimeout(() => {
-                timeout = null;
-                lastCall = leading ? Date.now() : 0;
-                func.apply(context || this, args);
-            }, remaining);
-        }
-    }
-}
-
-/**
- * Creates a debounced function that delays the invocation of `func` until after `wait` milliseconds
- * have elapsed since the last time the debounced function was invoked.
- *
- * @param {Function} func - The function to debounce.
- * @param {number} wait - The number of milliseconds to delay.
- * @param {boolean} [immediate=false] - If true, execute `func` on the leading edge instead of the trailing.
- * @param {Object} [context=null] - The context to bind to `func`.
- * @returns {Function} The debounced function.
- */
-export const debounce = function(func, wait, immediate = false, context = null) {
-    let timeout = null;
-    let lastCall = 0;
-
-    return function (...args) {
-        const now = Date.now();
-
-        if (immediate) {
-            if (!lastCall) {
-                lastCall = now;
-                func.apply(context || this, args);
-            }
-        }
-
-        clearTimeout(timeout);
-        timeout = null;
-
-        timeout = setTimeout(() => {
-            lastCall = now;
-            clearTimeout(timeout);
-            timeout = null;
-            func.apply(context || this, args);
-        }, wait);
-    }
-}

package/tests/array.test.js

@@ -1,326 +0,0 @@
-import * as traversal from "../src/traversal.js";
-import {arrayDiff, arrayUnique, compareArray, inArray, indexOf, range} from "../src/array.js";
-import {each} from "../src/traversal.js";
-
-describe('array methods', () => {
-    beforeEach(() => {
-        jest.spyOn(traversal, 'each');
-    })
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    })
-
-    describe('inArray()', () => {
-        it('should return true if the value exists in the array (non-strict)', () => {
-            const arr = [1, '2', 3];
-            const result = inArray(2, arr);
-            expect(result).toBe(true);
-        })
-
-        it('should return false if the value does not exist in the array (non-strict)', () => {
-            const arr = [1, '3', 4];
-            const result = inArray(2, arr);
-            expect(result).toBe(false);
-        })
-
-        it('should return true if the value exists in the array (strict)', () => {
-            const arr = [1, 2, 3];
-            const result = inArray(2, arr, 0, true);
-            expect(result).toBe(true);
-        })
-
-        it('should return false if the value does not exist in the array (strict)', () => {
-            const arr = [1, '2', 3];
-            const result = inArray(2, arr, 0, true);
-            expect(result).toBe(false);
-        })
-
-        it('should start searching from the specified index', () => {
-            const arr = [1, 2, 3, 4];
-            const result = inArray(2, arr, 2);
-            expect(result).toBe(false);
-        })
-
-        it('should return false for an empty array', () => {
-            const arr = [];
-            const result = inArray(1, arr);
-            expect(result).toBe(false);
-        })
-
-        it('should stop iteration when the value is found', () => {
-            const arr = [1, 2, 3];
-            const mockEach = jest.fn((array, callback) => {
-                callback(0, 1);
-                callback(1, 2);
-            })
-            each.mockImplementation(mockEach);
-
-            const result = inArray(2, arr);
-
-            expect(result).toBe(true);
-            expect(mockEach).toHaveBeenCalledTimes(1);
-        })
-
-        it('should handle complex values (e.g., objects)', () => {
-            const obj = { id: 1 };
-            const arr = [{ id: 2 }, obj, { id: 3 }];
-            const result = inArray(obj, arr, 0, true);
-            expect(result).toBe(true);
-        })
-
-        it('should return false for objects with loose equality but different references', () => {
-            const obj = { id: 1 };
-            const arr = [{ id: 1 }, { id: 2 }];
-            const result = inArray(obj, arr, 0, true);
-            expect(result).toBe(false);
-        })
-    })
-
-    describe('indexOf()', () => {
-        it('should return the correct index of an element in the array', () => {
-            const arr = [10, 20, 30, 40, 50];
-            expect(indexOf(arr, 30)).toBe(2);
-        })
-
-        it('should return -1 if the element is not in the array', () => {
-            const arr = [10, 20, 30, 40, 50];
-            expect(indexOf(arr, 60)).toBe(-1);
-        })
-
-        it('should start searching from the given index', () => {
-            const arr = [10, 20, 30, 40, 50];
-            expect(indexOf(arr, 30, 3)).toBe(-1);
-            expect(indexOf(arr, 50, 3)).toBe(4);
-        })
-
-        it('should handle negative start indices', () => {
-            const arr = [10, 20, 30, 40, 50];
-            expect(indexOf(arr, 30, -3)).toBe(2);
-            expect(indexOf(arr, 10, -5)).toBe(0);
-        })
-
-        it('should return -1 for an empty array', () => {
-            const arr = [];
-            expect(indexOf(arr, 10)).toBe(-1);
-        })
-
-        it('should skip holes in sparse arrays', () => {
-            const arr = [10, , 30, , 50]; // Sparse array
-            expect(indexOf(arr, undefined)).toBe(-1); // undefined is not explicitly in the array
-            expect(indexOf(arr, 30)).toBe(2); // Finds 30 despite the holes
-        })
-
-        it('should return the first occurrence of the element', () => {
-            const arr = [10, 20, 30, 20, 10];
-            expect(indexOf(arr, 20)).toBe(1); // Returns the first occurrence
-        })
-
-        it('should work when from is larger than the array length', () => {
-            const arr = [10, 20, 30];
-            expect(indexOf(arr, 20, 10)).toBe(-1); // Starts beyond the array, no search
-        })
-
-        it('should work when from is exactly the array length', () => {
-            const arr = [10, 20, 30];
-            expect(indexOf(arr, 30, 3)).toBe(-1); // Starts at the end, no search
-        })
-    })
-
-    describe('compareArray()', () => {
-        it('should return true for identical arrays', () => {
-            const arr1 = [1, 2, 3];
-            const arr2 = [1, 2, 3];
-            expect(compareArray(arr1, arr2)).toBe(true);
-        })
-
-        it('should return false for arrays with different lengths', () => {
-            const arr1 = [1, 2, 3];
-            const arr2 = [1, 2];
-            expect(compareArray(arr1, arr2)).toBe(false);
-        })
-
-        it('should return true for nested identical arrays', () => {
-            const arr1 = [1, [2, 3], 4];
-            const arr2 = [1, [2, 3], 4];
-            expect(compareArray(arr1, arr2)).toBe(true);
-        })
-
-        it('should return false for nested arrays with different values', () => {
-            const arr1 = [1, [2, 3], 4];
-            const arr2 = [1, [2, 4], 4];
-            expect(compareArray(arr1, arr2)).toBe(false);
-        })
-
-        it('should return false if one array has nested arrays and the other does not', () => {
-            const arr1 = [1, [2, 3], 4, 5];
-            const arr2 = [1, 2, 3, 4];
-            expect(compareArray(arr1, arr2)).toBe(false);
-            expect(compareArray(arr2, arr1)).toBe(false);
-        })
-
-        it('should return true for empty arrays', () => {
-            const arr1 = [];
-            const arr2 = [];
-            expect(compareArray(arr1, arr2)).toBe(true);
-        })
-
-        it('should return false for arrays with different primitive values', () => {
-            const arr1 = [1, 2, 3];
-            const arr2 = [1, 2, 4];
-            expect(compareArray(arr1, arr2)).toBe(false);
-        })
-
-        it('should return false for deeply nested arrays with differences', () => {
-            const arr1 = [1, [2, [3, 4]], 5];
-            const arr2 = [1, [2, [3, 5]], 5];
-            expect(compareArray(arr1, arr2)).toBe(false);
-        })
-
-        it('should return true for deeply identical nested arrays', () => {
-            const arr1 = [1, [2, [3, 4]], 5];
-            const arr2 = [1, [2, [3, 4]], 5];
-            expect(compareArray(arr1, arr2)).toBe(true);
-        })
-
-        it('should handle arrays with mixed types correctly', () => {
-            const arr1 = [1, "hello", [true, null], { key: "value" }];
-            const arr2 = [1, "hello", [true, null], { key: "value" }];
-            expect(compareArray(arr1, arr2)).toBe(true);
-        })
-    })
-
-    describe('range()', () => {
-        it('should generate a range of numbers starting from 0', () => {
-            expect(range(5)).toEqual([0, 1, 2, 3, 4]);
-        })
-
-        it('should generate a range of numbers starting from a specific number', () => {
-            expect(range(5, 10)).toEqual([10, 11, 12, 13, 14]);
-        })
-
-        it('should generate a range of numbers with a specific step', () => {
-            expect(range(5, 0, 2)).toEqual([0, 2, 4, 6, 8]);
-        })
-
-        it('should generate a descending range of numbers with a negative step', () => {
-            expect(range(5, 10, -2)).toEqual([10, 8, 6, 4, 2]);
-        })
-
-        it('should generate a range of characters starting from a given character', () => {
-            expect(range(5, 'A')).toEqual(['A', 'B', 'C', 'D', 'E']);
-        })
-
-        it('should generate a range of characters with a specific step', () => {
-            expect(range(5, 'a', 2)).toEqual(['a', 'c', 'e', 'g', 'i']);
-        })
-
-        it('should generate a descending range of characters with a negative step', () => {
-            expect(range(5, 'E', -1)).toEqual(['E', 'D', 'C', 'B', 'A']);
-        })
-
-        it('should use the first character of a string when startAt is multiple characters', () => {
-            expect(range(5, 'hello')).toEqual(['h', 'i', 'j', 'k', 'l']);
-        })
-
-        it('should return an empty array if size is less than 1', () => {
-            expect(range(0)).toEqual([]);
-        })
-
-        it('should return an empty array if step is 0', () => {
-            expect(range(5, 0, 0)).toEqual([]);
-        })
-
-        it('should return an empty array if startAt is not a string or integer', () => {
-            expect(range(5, [])).toEqual([]);
-            expect(range(5, {})).toEqual([]);
-            expect(range(5, null)).toEqual([]);
-        })
-
-        it('should generate a single-element range if size is 1', () => {
-            expect(range(1, 5)).toEqual([5]);
-            expect(range(1, 'A')).toEqual(['A']);
-        })
-    })
-
-    describe('arrayUnique()', () => {
-        it('should return an array with unique values', () => {
-            const arr = [1, 2, 2, 3, 4, 4, 5];
-            expect(arrayUnique(arr)).toEqual([1, 2, 3, 4, 5]);
-        })
-
-        it('should handle an empty array', () => {
-            const arr = [];
-            expect(arrayUnique(arr)).toEqual([]);
-        })
-
-        it('should handle an array with all unique values', () => {
-            const arr = [1, 2, 3, 4, 5];
-            expect(arrayUnique(arr)).toEqual([1, 2, 3, 4, 5]);
-        })
-
-        it('should handle an array with all duplicate values', () => {
-            const arr = [1, 1, 1, 1];
-            expect(arrayUnique(arr)).toEqual([1]);
-        })
-
-        it('should handle an array with mixed types', () => {
-            const arr = [1, '1', 1, true, true, false, 'true'];
-            expect(arrayUnique(arr)).toEqual([1, '1', true, false, 'true']);
-        })
-
-        it('should handle an array with nested arrays or objects', () => {
-            const arr = [[1], [1], { a: 1 }, { a: 1 }];
-            expect(arrayUnique(arr)).toEqual([[1], [1], { a: 1 }, { a: 1 }]); // Objects and arrays are not strictly equal
-        })
-
-        it('should preserve the order of the first occurrence of elements', () => {
-            const arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
-            expect(arrayUnique(arr)).toEqual([3, 1, 4, 5, 9, 2, 6]);
-        })
-    })
-
-    describe('arrayDiff()', () => {
-        it('should return the difference of two arrays', () => {
-            const array1 = [1, 2, 3, 4];
-            const array2 = [2, 4];
-            expect(arrayDiff(array1, array2)).toEqual([1, 3]);
-        })
-
-        it('should return the original array if there is no overlap', () => {
-            const array1 = [1, 2, 3];
-            const array2 = [4, 5, 6];
-            expect(arrayDiff(array1, array2)).toEqual([1, 2, 3]);
-        })
-
-        it('should return an empty array if the first array is empty', () => {
-            const array1 = [];
-            const array2 = [1, 2, 3];
-            expect(arrayDiff(array1, array2)).toEqual([]);
-        })
-
-        it('should return the first array if the second array is empty', () => {
-            const array1 = [1, 2, 3];
-            const array2 = [];
-            expect(arrayDiff(array1, array2)).toEqual([1, 2, 3]);
-        })
-
-        it('should handle arrays with mixed types with strict mode', () => {
-            const array1 = [1, '1', true, null];
-            const array2 = [true, null];
-            expect(arrayDiff(array1, array2, true)).toEqual([1, '1']);
-        })
-
-        it('should handle arrays with nested arrays or objects', () => {
-            const array1 = [[1], { a: 1 }, 3];
-            const array2 = [{ a: 1 }];
-            expect(arrayDiff(array1, array2)).toEqual([[1], 3]);
-        })
-
-        it('should return an empty array if both arrays are empty', () => {
-            const array1 = [];
-            const array2 = [];
-            expect(arrayDiff(array1, array2)).toEqual([]);
-        })
-    })
-})