@webalternatif/js-core 1.0.0

package/tests/utils.test.js

@@ -0,0 +1,371 @@
+import {
+    equals,
+    sizeOf,
+    flatten, noop,
+    strParseFloat, throttle, debounce
+} from "../src/utils";
+
+describe('utils methods', () => {
+    describe('equals()', () => {
+        it('should return true for strictly equal primitive values', () => {
+            expect(equals(42, 42)).toBe(true);
+            expect(equals('hello', 'hello')).toBe(true);
+            expect(equals(true, true)).toBe(true);
+        })
+
+        it('should return false for different primitive values', () => {
+            expect(equals(42, 24)).toBe(false);
+            expect(equals('hello', 'world')).toBe(false);
+            expect(equals(true, false)).toBe(false);
+        })
+
+        it('should return false if types are different', () => {
+            expect(equals(42, '42')).toBe(false);
+            expect(equals(true, 'true')).toBe(false);
+        })
+
+        it('should return false if one value is null or undefined', () => {
+            expect(equals(null, {})).toBe(false);
+            expect(equals({}, null)).toBe(false);
+            expect(equals(undefined, {})).toBe(false);
+        })
+
+        it('should return true for deeply equal objects', () => {
+            const obj1 = { a: 1, b: { c: 2 } };
+            const obj2 = { a: 1, b: { c: 2 } };
+
+            expect(equals(obj1, obj2)).toBe(true);
+        })
+
+        it('should return false for objects with different structures', () => {
+            const obj1 = { a: 1, b: { c: 2 } };
+            const obj2 = { a: 1, b: { d: 3 } };
+
+            expect(equals(obj1, obj2)).toBe(false);
+        })
+
+        it('should return false for objects with different keys', () => {
+            const obj1 = { a: 1, b: 2 };
+            const obj2 = { a: 1, c: 3 };
+
+            expect(equals(obj1, obj2)).toBe(false);
+        })
+
+        it('should return true for deeply nested empty objects', () => {
+            const obj1 = {};
+            const obj2 = {};
+
+            expect(equals(obj1, obj2)).toBe(true);
+        })
+
+        it('should handle circular references gracefully', () => {
+            const obj1 = {};
+            const obj2 = {};
+            obj1.self = obj1;
+            obj2.self = obj2;
+
+            expect(equals(obj1, obj2)).toBe(true);
+        })
+
+        it('should return true for empty objects', () => {
+            const obj1 = {};
+            const obj2 = {};
+
+            expect(equals(obj1, obj2)).toBe(true);
+        })
+
+        it('should return false for objects with different lengths', () => {
+            const obj1 = { a: 1 };
+            const obj2 = { a: 1, b: 2 };
+
+            expect(equals(obj1, obj2)).toBe(false);
+        })
+    })
+
+    describe('sizeOf()', () => {
+        it('should return the length of an array, object', () => {
+            expect(sizeOf([1, 2, 3])).toBe(3);
+            expect(sizeOf({ a: 1, b: 2, c: 3 })).toBe(3);
+        })
+
+        it('should return 0 for an empty array, empty object, null, undefined', () => {
+            expect(sizeOf([])).toBe(0);
+            expect(sizeOf({})).toBe(0);
+            expect(sizeOf(null)).toBe(0);
+            expect(sizeOf(undefined)).toBe(0);
+        })
+    })
+
+    describe('flatten()', () => {
+        it('should flatten a nested array', () => {
+            const input = [1, [2, [3, [4, 5]]], 6];
+            const result = flatten(input);
+            expect(result).toEqual([1, 2, 3, 4, 5, 6]);
+        })
+
+        it('should flatten an object into an array', () => {
+            const input = { a: 1, b: [2, { c: 3 }], d: 4 };
+            const result = flatten(input);
+            expect(result).toEqual([1, 2, 3, 4]);
+        })
+
+        it('should return a flat array when input is already flat', () => {
+            const input = [1, 2, 3, 4, 5];
+            const result = flatten(input);
+            expect(result).toEqual([1, 2, 3, 4, 5]);
+        })
+
+        it('should return the input unchanged if it is not an object or array', () => {
+            const input = 42;
+            const result = flatten(input);
+            expect(result).toBe(42);
+
+            const inputString = 'hello';
+            const resultString = flatten(inputString);
+            expect(resultString).toBe('hello');
+        })
+
+        it('should handle null or undefined inputs', () => {
+            expect(flatten(null)).toBe(null);
+            expect(flatten(undefined)).toBe(undefined);
+        })
+
+        it('should handle an empty array', () => {
+            const input = [];
+            const result = flatten(input);
+            expect(result).toEqual([]);
+        })
+
+        it('should handle an empty object', () => {
+            const input = {};
+            const result = flatten(input);
+            expect(result).toEqual([]);
+        })
+    })
+
+    describe('noop()', () => {
+        it('should not perform any operation', () => {
+            const spy = jest.fn(noop);
+            spy();
+            expect(spy).toHaveBeenCalledTimes(1);
+        })
+    })
+
+    describe('strParseFloat()', () => {
+        it('should parse a valid float string', () => {
+            expect(strParseFloat('123.45')).toBe(123.45);
+        })
+
+        it('should parse a string with commas as decimal separator', () => {
+            expect(strParseFloat('123,45')).toBe(123.45);
+        })
+
+        it('should parse a string with spaces', () => {
+            expect(strParseFloat('  123.45  ')).toBe(123.45);
+        })
+
+        it('should handle a string with mixed spaces and commas', () => {
+            expect(strParseFloat('  1 234,56  ')).toBe(1234.56);
+        })
+
+        it('should handle null input and return 0', () => {
+            expect(strParseFloat(null)).toBe(0);
+        })
+
+        it('should handle undefined input and return 0', () => {
+            expect(strParseFloat(undefined)).toBe(0);
+        })
+
+        it('should handle an empty string and return 0', () => {
+            expect(strParseFloat('')).toBe(0);
+        })
+
+        it('should handle input that is already a number', () => {
+            expect(strParseFloat(123.45)).toBe(123.45);
+        })
+
+        it('should handle input with extra characters gracefully', () => {
+            expect(strParseFloat('123.45abc')).toBe(123.45);
+        })
+
+        it('should handle strings with no numeric values and return NaN', () => {
+            expect(strParseFloat('abc')).toBeNaN();
+        })
+    })
+
+    describe('throttle', () => {
+        jest.useFakeTimers();
+
+        it('should call the function immediately if leading is true', () => {
+            const mockfunc = jest.fn();
+            const throttled = throttle(mockfunc, 1000, true, false);
+
+            throttled();
+            expect(mockfunc).toHaveBeenCalledTimes(1);
+
+            throttled();
+            expect(mockfunc).toHaveBeenCalledTimes(1);
+
+            jest.advanceTimersByTime(1000);
+            throttled();
+            expect(mockfunc).toHaveBeenCalledTimes(2);
+        })
+
+        it('should not call the function immediately if leading is false', () => {
+            const mockfunc = jest.fn();
+            const throttled = throttle(mockfunc, 1000, false, true);
+
+            throttled();
+            expect(mockfunc).toHaveBeenCalledTimes(0);
+
+            jest.advanceTimersByTime(1000);
+            expect(mockfunc).toHaveBeenCalledTimes(1);
+        })
+
+        it('should call the function at the end if trailing is true', () => {
+            const mockfunc = jest.fn();
+            const throttled = throttle(mockfunc, 1000, false, true);
+
+            throttled();
+            jest.advanceTimersByTime(500);
+            throttled();
+            jest.advanceTimersByTime(500);
+            expect(mockfunc).toHaveBeenCalledTimes(1);
+        })
+
+        it('should not call the function at the end if trailing is false', () => {
+            const func = jest.fn();
+            const throttled = throttle(func, 1000, true, false);
+
+            throttled();
+            jest.advanceTimersByTime(500);
+            throttled();
+            jest.advanceTimersByTime(500);
+            expect(func).toHaveBeenCalledTimes(1);
+        })
+
+        it('should respect the wait time between calls', () => {
+            const func = jest.fn();
+            const throttled = throttle(func, 1000);
+
+            throttled();
+            expect(func).toHaveBeenCalledTimes(1);
+
+            jest.advanceTimersByTime(500);
+            throttled();
+            expect(func).toHaveBeenCalledTimes(1);
+
+            jest.advanceTimersByTime(500);
+            throttled();
+            expect(func).toHaveBeenCalledTimes(2);
+        })
+
+        it('should use the provided context', () => {
+            const context = { value: 42 };
+            const func = jest.fn(function() {
+                expect(this.value).toBe(42);
+            })
+
+            const throttled = throttle(func, 1000, true, true, context);
+            throttled();
+        })
+
+        it('should handle multiple calls within the wait period', () => {
+            const func = jest.fn();
+            const throttled = throttle(func, 1000);
+
+            throttled();
+            throttled();
+            throttled();
+            expect(func).toHaveBeenCalledTimes(1);
+
+            jest.advanceTimersByTime(1000);
+            expect(func).toHaveBeenCalledTimes(2);
+        })
+    })
+
+    describe('debounce', () => {
+        jest.useFakeTimers();
+
+        it('should call the function after the wait time', () => {
+            const func = jest.fn();
+            const debounced = debounce(func, 1000);
+
+            debounced();
+            expect(func).not.toHaveBeenCalled();
+
+            jest.advanceTimersByTime(1000);
+            expect(func).toHaveBeenCalledTimes(1);
+        })
+
+        it('should reset the timer if called again within the wait time', () => {
+            const func = jest.fn();
+            const debounced = debounce(func, 1000);
+
+            debounced();
+            jest.advanceTimersByTime(500);
+            debounced();
+            jest.advanceTimersByTime(500);
+
+            expect(func).not.toHaveBeenCalled();
+
+            jest.advanceTimersByTime(500);
+            expect(func).toHaveBeenCalledTimes(1);
+        })
+
+        it('should call the function immediately if immediate is true', () => {
+            const func = jest.fn();
+            const debounced = debounce(func, 1000, true);
+
+            debounced();
+            expect(func).toHaveBeenCalledTimes(1);
+
+            debounced();
+            expect(func).toHaveBeenCalledTimes(1);
+
+            jest.advanceTimersByTime(1000);
+            debounced();
+            expect(func).toHaveBeenCalledTimes(2);
+        })
+
+        it('should use the provided context', () => {
+            const context = { value: 42 };
+            const func = jest.fn(function () {
+                expect(this.value).toBe(42);
+            })
+
+            const debounced = debounce(func, 1000, false, context);
+            debounced();
+
+            jest.advanceTimersByTime(1000);
+            expect(func).toHaveBeenCalledTimes(1);
+        })
+
+        it('should use the provided context', () => {
+            const context = { value: 42 };
+            const func = jest.fn(function () {
+                expect(this.value).toBe(42);
+            })
+            const debounced = debounce(func, 1000, true, context);
+
+            debounced();
+            expect(func).toHaveBeenCalledTimes(1);
+
+            debounced();
+            expect(func).toHaveBeenCalledTimes(1);
+
+            jest.advanceTimersByTime(1000);
+            debounced();
+            expect(func).toHaveBeenCalledTimes(2);
+        })
+
+        it('should not call the function if never invoked after the delay', () => {
+            const func = jest.fn();
+            const debounced = debounce(func, 1000);
+
+            debounced();
+            jest.advanceTimersByTime(500);
+            expect(func).not.toHaveBeenCalled();
+        })
+    })
+})

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "lib": ["esnext", "dom"],
+        "declaration": true,
+        "emitDeclarationOnly": true,
+        "outDir": "types",
+        "allowJs": true,
+        "checkJs": false,
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "baseUrl": "./",
+    },
+    "include": ["src/**/*.js"],
+    "exclude": ["i18n", "index.js"]
+}

package/types/array.d.ts

@@ -0,0 +1,8 @@
+export function inArray(value: any, arr: Object | any[], index?: number, strict?: boolean): boolean;
+export function indexOf(arr: any, elt: any, from?: number): number;
+export function compareArray(a1: any, a2: any): any;
+export function arrayUnique(arr: any): any;
+export function array_unique(arr: any): any;
+export function arrayDiff(array1: any, array2: any, strict?: boolean): any;
+export function array_diff(arr: any): any;
+export function range(size: any, startAt?: number, step?: number): any[];

package/types/dom.d.ts

@@ -0,0 +1,241 @@
+export function isWindow(o: any): boolean;
+export function isDomElement(o: any): boolean;
+export function getStyle(elem: any, cssRule: any): any;
+declare namespace _default {
+    /**
+     * @param {Element} el
+     * @param {string} [selector]
+     * @returns {NodeList}
+     */
+    function children(el: Element, selector?: string): NodeList;
+    /**
+     * @param {Element} el
+     * @param {string} [selector]
+     * @returns {Element|null}
+     */
+    function child(el: Element, selector?: string): Element | null;
+    /**
+     * @param {Element|Document|string} refEl
+     * @param {string} [selector='*']
+     * @returns {NodeList}
+     */
+    function find(refEl: Element | Document | string, selector?: string): NodeList;
+    /**
+     * @param {Element|Document|string} refEl
+     * @param {string} [selector='*']
+     * @returns {Element|null}
+     */
+    function findOne(refEl: Element | Document | string, selector?: string): Element | null;
+    /**
+     * @param {Element} el
+     * @param {string} className
+     * @returns {Element}
+     */
+    function addClass(el: Element, className: string): Element;
+    /**
+     * @param {Element} el
+     * @param {string} classNames
+     * @returns {Element}
+     */
+    function removeClass(el: Element, classNames: string): Element;
+    /**
+     * @param {Element} el
+     * @param {string} classNames
+     * @param {boolean} [force]
+     * @returns {Element}
+     */
+    function toggleClass(el: Element, classNames: string, force?: boolean): Element;
+    /**
+     * @param {Element} el
+     * @param {string} classNames
+     * @returns {boolean}
+     */
+    function hasClass(el: Element, classNames: string): boolean;
+    /**
+     * @param {Element} el
+     * @param {Element} child
+     * @returns {Element}
+     */
+    function append(el: Element, child: Element): Element;
+    /**
+     * @param {Element} el
+     * @param {Element} child
+     * @returns {Element}
+     */
+    function prepend(el: Element, child: Element): Element;
+    /**
+     * @param {Element} el
+     * @returns {void}
+     */
+    function remove(el: Element): void;
+    /**
+     * @param {Element} el
+     * @param {string} [selector]
+     * @returns {Element|null}
+     */
+    function closest(el: Element, selector?: string): Element | null;
+    /**
+     * @param {Element} el
+     * @param {string} [selector]
+     * @returns {Element|null}
+     */
+    function next(el: Element, selector?: string): Element | null;
+    /**
+     * @param {Element} el
+     * @param {string|null} [selector]
+     * @returns {Element|null}
+     */
+    function prev(el: Element, selector?: string | null): Element | null;
+    /**
+     * @param {Element} el
+     * @param {string} [selector]
+     * @returns {Element[]}
+     */
+    function nextAll(el: Element, selector?: string): Element[];
+    /**
+     * @param {Element} el
+     * @param {string} [selector]
+     * @returns {Element[]}
+     */
+    function prevAll(el: Element, selector?: string): Element[];
+    /**
+     * @param {Element} el
+     * @param {Element} wrappingElement
+     * @returns {Element}
+     */
+    function wrap(el: Element, wrappingElement: Element): Element;
+    /**
+     * @param {Element} el
+     * @param {string} name
+     * @param {*} [value]
+     * @returns {Element|*}
+     */
+    function attr(el: Element, name: string, value?: any): Element | any;
+    /**
+     * @param {Element} el
+     * @param {string} name
+     * @param {*} [value]
+     * @returns {*|Element}
+     */
+    function prop(el: Element, name: string, value?: any): any | Element;
+    /**
+     * @param {Element} el
+     * @param {string} [html]
+     * @returns {Element|*}
+     */
+    function html(el: Element, html?: string): Element | any;
+    /**
+     * @param {Element} el
+     * @param {string} [text]
+     * @returns {Element|*}
+     */
+    function text(el: Element, text?: string): Element | any;
+    /**
+     * @param {Element} el
+     * @returns {Element}
+     */
+    function hide(el: Element): Element;
+    /**
+     * @param {Element} el
+     * @returns {Element}
+     */
+    function show(el: Element): Element;
+    /**
+     * @param {Element} el
+     * @returns {Element}
+     */
+    function toggle(el: Element): Element;
+    /**
+     * @param {Element} el
+     * @param {Object<string, string>|string} name
+     * @param {string} [value]
+     * @returns {Element}
+     */
+    function data(el: Element, name: {
+        [x: string]: string;
+    } | string, value?: string): Element;
+    /**
+     * @param {Element} el
+     * @param {string} name
+     * @returns {Element|*}
+     */
+    function removeData(el: Element, name: string): Element | any;
+    /**
+     * @param {Element|Document|Window} el
+     * @param {string} event
+     * @param {function} handler
+     * @param {AddEventListenerOptions|false} options
+     * @returns {Element}
+     */
+    function on(el: Element | Document | Window, event: string, handler: Function, options?: AddEventListenerOptions | false): Element;
+    /**
+     * @param {Element|Document|Window} el
+     * @param {string} event
+     * @param {function} handler
+     * @param {Object} options
+     * @returns {Element}
+     */
+    function off(el: Element | Document | Window, event: string, handler: Function, options: Object): Element;
+    /**
+     * @param {HTMLElement} el
+     * @param {Object<string, string>|string} styles
+     * @param {string} [value]
+     * @returns {Element}
+     */
+    function css(el: HTMLElement, styles: {
+        [x: string]: string;
+    } | string, value?: string): Element;
+    /**
+     * @param {Element} el
+     * @param {string} selectorClosest
+     * @param {string} selectorFind
+     * @returns {NodeList|null}
+     */
+    function closestFind(el: Element, selectorClosest: string, selectorFind: string): NodeList | null;
+    /**
+     * @param {Element} el
+     * @param {string} selectorClosest
+     * @param {string} selectorFindOne
+     * @returns {Element|null}
+     */
+    function closestFindOne(el: Element, selectorClosest: string, selectorFindOne: string): Element | null;
+    /**
+     * @param {NodeList} nodeList
+     * @returns {Element|null}
+     */
+    function first(nodeList: NodeList): Element | null;
+    /**
+     * @param {NodeList} nodeList
+     * @returns {Element|null}
+     */
+    function last(nodeList: NodeList): Element | null;
+    /**
+     * @param {string} html
+     * @returns {Element}
+     */
+    function create(html: string): Element;
+    /**
+     * @param {NodeList} nodeList
+     * @param {number} [index=0]
+     * @returns {Element|null}
+     */
+    function eq(nodeList: NodeList, index?: number): Element | null;
+    /**
+     * @param {Element} el
+     * @param {Element} newEl
+     * @returns {Element}
+     */
+    function after(el: Element, newEl: Element): Element;
+    /**
+     * @param {Element} el
+     * @param {Element} newEl
+     * @returns {Element}
+     */
+    function before(el: Element, newEl: Element): Element;
+    /**
+     * @param {Element} el
+     * @returns {Element}
+     */
+    function empty(el: Element): Element;
+}
+export default _default;

package/types/eventDispatcher.d.ts

@@ -0,0 +1,12 @@
+export default eventDispatcher;
+declare const eventDispatcher: EventDispatcher;
+declare class EventDispatcher {
+    addListener(eventsName: any, callback: any, context: any, ...args: any[]): this;
+    addListenerOnce(eventsName: any, callback: any, context: any, ...listenerArgs: any[]): this;
+    dispatch(eventsName: any, ...args: any[]): this;
+    hasListener(eventName: any, callback: any, context: any): boolean;
+    removeListener(eventName: any, callback: any, context: any): this;
+    getListeners(eventName: any): any;
+    reset(): void;
+    #private;
+}

package/types/i18n.d.ts

@@ -0,0 +1,4 @@
+export function translate(lang: any, ns: any, label: any): any;
+export function _(lang: any, ns: any, label: any): any;
+export function getLang(): any;
+export function setLang(lang: any): void;