@webalternatif/js-core 1.0.0

package/tests/dom.test.js

@@ -0,0 +1,239 @@
+import dom, {isWindow, isDomElement, getStyle} from "../src/dom.js";
+
+describe('dom methods', () => {
+    describe('isWindow()', () => {
+        it('should returns true for window object', () => {
+            expect(isWindow(window)).toBe(true);
+        });
+
+        it('should return false for a DOM element', () => {
+            const div = document.createElement('div');
+            expect(isWindow(div)).toBe(false);
+        });
+
+        it('should return false for primitives', () => {
+            expect(isWindow(123)).toBe(false);
+            expect(isWindow(null)).toBe(false);
+            expect(isWindow('string')).toBe(false);
+        });
+    });
+
+    describe('isDomElement()', () => {
+        it('should return true for a DOM element', () => {
+            const div = document.createElement('div');
+            expect(isDomElement(div)).toBe(true);
+        });
+
+        it('should return false for non-DOM objects', () => {
+            expect(isDomElement({})).toBe(false);
+            expect(isDomElement(null)).toBe(false);
+            expect(isDomElement(undefined)).toBe(false);
+            expect(isDomElement(42)).toBe(false);
+            expect(isDomElement('string')).toBe(false);
+            expect(isDomElement({ nodeType: 1 })).toBe(false);
+        });
+    })
+
+    describe('getStyle', () => {
+        const mockElement = (styles = {}) => {
+            const element = document.createElement('div');
+            Object.assign(element.style, styles);
+            return element;
+        };
+
+        const mockNonDomElement = () => ({});
+
+        it('should return empty string for non-DOM elements', () => {
+            const nonDomElement = mockNonDomElement();
+            expect(getStyle(nonDomElement, 'color')).toBe('');
+        });
+
+        it('should return the computed style for a valid DOM element', () => {
+            const elem = mockElement({color: 'red'});
+            document.body.appendChild(elem);
+
+            expect(getStyle(elem, 'color')).toBe('red');
+            document.body.removeChild(elem);
+        });
+
+        it('should return inline style when no computed style is available', () => {
+            const elem = mockElement({ backgroundColor: 'blue' });
+            expect(getStyle(elem, 'background-color')).toBe('blue');
+        });
+
+        it('should return camelCase style for kebab-case properties', () => {
+            const elem = mockElement({ backgroundColor: 'green' });
+            expect(getStyle(elem, 'background-color')).toBe('green');
+        });
+
+        it('should return empty string for undefined styles', () => {
+            const elem = mockElement();
+            expect(getStyle(elem, 'color')).toBe('');
+        });
+
+        it('should return empty string for invalid cssRule', () => {
+            const elem = mockElement({ color: 'red' });
+            expect(getStyle(elem, 'invalid-rule')).toBe('');
+        });
+
+        it('should handle cases where getComputedStyle is unavailable', () => {
+            const originalGetComputedStyle = window.getComputedStyle;
+            delete window.getComputedStyle;
+
+            const elem = mockElement({ color: 'blue' });
+            expect(getStyle(elem, 'color')).toBe('blue');
+            expect(getStyle(elem, 'notexists')).toBe('');
+
+            window.getComputedStyle = originalGetComputedStyle;
+        });
+    });
+});
+
+describe('dom manipulation', () => {
+    /** @type {HTMLDivElement} */
+    let el;
+
+    beforeEach(() => {
+        el = document.createElement('div');
+        el.id = 'root';
+
+        for (let i = 0; i < 3; i++) {
+            const child = document.createElement('div');
+            child.classList.add('child');
+            child.classList.add(`child${i}`);
+            el.append(child);
+
+            for (let j = 0; j < 3; j++) {
+                const grandchild = document.createElement('div');
+                grandchild.classList.add('grandchild');
+                grandchild.classList.add(`grandchild${j}`);
+                child.append(grandchild);
+            }
+        }
+
+        document.body.append(el);
+    })
+
+    afterEach(() => document.body.innerHTML = '');
+
+    describe('children()', () => {
+        it('should return children of element', () => {
+            expect(dom.children(el).length).toBe(3);
+            expect(dom.children(el, '.child1').length).toBe(1);
+            expect(dom.children(el, '.notexists').length).toBe(0);
+        });
+    })
+
+    describe('child()', () => {
+        it('should return one child of element', () => {
+            const firstChild = el.children[0];
+            const secondChild = el.children[1];
+
+            expect(dom.child(el)).toBe(firstChild);
+            expect(dom.child(el, '.child1')).toBe(secondChild);
+            expect(dom.child(el, '.notexists')).toBe(null);
+        })
+    })
+
+    describe('find()', () => {
+        it('should return descendants of element', () => {
+            expect(dom.find(el).length).toBe(12);
+            expect(dom.find(el, '.grandchild').length).toBe(9);
+            expect(dom.find('.grandchild').length).toBe(9);
+        })
+
+        it('should return an empty list on invalid selector', () => {
+            expect(dom.find(el, '!!!').length).toBe(0);
+        })
+    })
+
+    describe('findOne()', () => {
+        it('should return one descendant of element', () => {
+            const child = el.children[0];
+            const grandChild = child.children[0];
+
+            expect(dom.findOne(el)).toBe(child);
+            expect(dom.findOne(el, '.grandchild')).toBe(grandChild);
+            expect(dom.findOne('.grandchild')).toBe(grandChild);
+        })
+
+        it('should return null on invalid selector', () => {
+            expect(dom.findOne(el, '!!!')).toBe(null);
+        })
+    })
+
+    describe('addClass()', () => {
+        it('should add classes to element', () => {
+            dom.addClass(el, 'perceval karadoc');
+
+            expect(el.classList.contains('perceval')).toBe(true);
+            expect(el.classList.contains('karadoc')).toBe(true);
+        })
+
+        it('should handle empty string', () => {
+            const before = [...el.classList];
+            dom.addClass(el, '');
+            expect([...el.classList]).toEqual(before);
+        })
+    })
+
+    describe('removeClass()', () => {
+        it('should remove classes to element', () => {
+            const child = el.children[0];
+            dom.removeClass(child, 'child child1');
+
+            expect(el.classList.contains('child')).toBe(false);
+            expect(el.classList.contains('child1')).toBe(false);
+        })
+
+        it('should handle empty string', () => {
+            el.classList.add('root');
+
+            const before = [...el.classList];
+            dom.removeClass(el, '');
+            expect([...el.classList]).toEqual(before);
+        })
+    })
+
+    describe('toggleClass()', () => {
+        it('should toggle classes to element', () => {
+            const child = el.children[0];
+
+            dom.toggleClass(child, 'foo');
+            expect(child.classList.contains('foo')).toBe(true);
+
+            dom.toggleClass(child, 'foo child1');
+            expect(child.classList.contains('foo')).toBe(false);
+            expect(child.classList.contains('child1')).toBe(false);
+        })
+
+        it('should handle empty string', () => {
+            el.classList.add('root');
+
+            const before = [...el.classList];
+            dom.toggleClass(el, '');
+            expect([...el.classList]).toEqual(before);
+        })
+    })
+})
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/tests/eventdispatcher.test.js

@@ -0,0 +1,177 @@
+import eventDispatcher from '../src/eventDispatcher';
+import {sizeOf} from "../src/utils.js";
+
+describe('eventDispatcher', () => {
+    beforeEach(() => {
+        eventDispatcher.reset();
+    })
+
+    it('should add a listener and trigger the event', () => {
+        const callback = jest.fn();
+        eventDispatcher.addListener('testEvent', callback);
+
+        eventDispatcher.dispatch('testEvent', 'arg1', 'arg2');
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith('testEvent', 'arg1', 'arg2');
+    })
+
+    it('should handle multiple listeners for the same event', () => {
+        const callback1 = jest.fn();
+        const callback2 = jest.fn();
+
+        eventDispatcher.addListener('testEvent', callback1);
+        eventDispatcher.addListener('testEvent', callback2);
+
+        eventDispatcher.dispatch('testEvent', 'arg1');
+
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(1);
+    })
+
+    it('should add a listener that triggers only once', () => {
+        const callback = jest.fn();
+
+        eventDispatcher.addListenerOnce('testEvent', callback);
+
+        eventDispatcher.dispatch('testEvent', 'arg1');
+        eventDispatcher.dispatch('testEvent', 'arg2');
+
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback).toHaveBeenCalledWith('testEvent', 'arg1');
+    })
+
+    it('should remove a specific listener', () => {
+        const callback = jest.fn();
+
+        eventDispatcher.addListener('testEvent', callback);
+        eventDispatcher.removeListener('testEvent', callback);
+
+        eventDispatcher.dispatch('testEvent', 'arg1');
+
+        expect(callback).not.toHaveBeenCalled();
+    })
+
+    it('should remove all listeners for an event', () => {
+        const callback1 = jest.fn();
+        const callback2 = jest.fn();
+
+        eventDispatcher.addListener('testEvent', callback1);
+        eventDispatcher.addListener('testEvent', callback2);
+
+        eventDispatcher.removeListener('testEvent');
+
+        eventDispatcher.dispatch('testEvent', 'arg1');
+
+        expect(callback1).not.toHaveBeenCalled();
+        expect(callback2).not.toHaveBeenCalled();
+    })
+
+    it('should check if a listener exists', () => {
+        const callback = jest.fn();
+
+        eventDispatcher.addListener('testEvent', callback);
+
+        expect(eventDispatcher.hasListener('testEvent')).toBe(true);
+        expect(eventDispatcher.hasListener('nonExistentEvent')).toBe(false);
+    })
+
+    it('should handle events with multiple names', () => {
+        const callback1 = jest.fn();
+        const callback2 = jest.fn();
+
+        eventDispatcher.addListener('event1, event2', callback1);
+        eventDispatcher.addListener('event2, event3', callback2);
+
+        eventDispatcher.dispatch('event2', 'arg');
+
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(1);
+    })
+
+    it('should handle an empty event name gracefully', () => {
+        const callback = jest.fn();
+
+        eventDispatcher.addListener('', callback);
+        eventDispatcher.dispatch('');
+
+        expect(callback).not.toHaveBeenCalled();
+    })
+
+    it('should handle undefined or null event names', () => {
+        expect(() => eventDispatcher.addListener(undefined, jest.fn())).toThrow();
+        expect(() => eventDispatcher.addListener(null, jest.fn())).toThrow();
+    })
+
+    it('should not fail if dispatching an event with no listeners', () => {
+        expect(() => eventDispatcher.dispatch('nonExistentEvent')).not.toThrow();
+    })
+
+    it('should maintain listener context when specified', () => {
+        const context = { value: 42 };
+        const callback = jest.fn(function () {
+            expect(this).toBe(context);
+        })
+
+        eventDispatcher.addListener('testEvent', callback, context);
+        eventDispatcher.dispatch('testEvent');
+        expect(callback).toHaveBeenCalledTimes(1);
+    })
+
+    it('should throw an error if callback is not a function', () => {
+        expect(() => eventDispatcher.addListener('testEvent', 'not a function')).toThrow();
+    })
+
+    it('should throw an error if events name are not a string', () => {
+        expect(() => eventDispatcher.dispatch(null)).toThrow();
+    })
+
+    it('should do nothing if an empty event name is provided', () => {
+        const mockCallback = jest.fn();
+        eventDispatcher.addListenerOnce('', mockCallback);
+
+        eventDispatcher.dispatch('someEvent');
+        expect(mockCallback).not.toHaveBeenCalled();
+    })
+
+    it('should return false if callback and context do not match any listener', () => {
+        const callback = jest.fn();
+        const context = { some: 'context' };
+        eventDispatcher.addListener('testEvent', callback, { other: 'context' })
+
+        const result = eventDispatcher.hasListener('testEvent', callback, context);
+
+        expect(result).toBe(false);
+    })
+
+    it('should do nothing if listener does not exists', () => {
+        const callback = jest.fn();
+        const result = eventDispatcher.removeListener('nonExistentEvent', callback);
+
+        expect(result).toBe(eventDispatcher);
+        expect(eventDispatcher.hasListener('nonExistentEvent')).toBe(false);
+    })
+
+    it('should not remove a listener if callback or context does not match', () => {
+        const callback1 = jest.fn();
+        const callback2 = jest.fn();
+        const context1 = { some: 'context1' };
+        const context2 = { some: 'context2' };
+
+        eventDispatcher.addListener('testEvent', callback1, context1);
+        eventDispatcher.addListener('testEvent', callback2, context2);
+
+        eventDispatcher.removeListener('testEvent', callback1, context2);
+
+        const allListeners = eventDispatcher.getListeners();
+        const listeners = eventDispatcher.getListeners('testEvent');
+
+        expect(sizeOf(allListeners)).toBe(1);
+        expect(eventDispatcher.getListeners('notExists')).toHaveLength(0);
+        expect(listeners).toHaveLength(2);
+        expect(listeners[0].callback).toBe(callback1);
+        expect(listeners[0].context).toBe(context1);
+        expect(listeners[1].callback).toBe(callback2);
+        expect(listeners[1].context).toBe(context2);
+    });
+})

package/tests/i18n.test.js

@@ -0,0 +1,132 @@
+import {translate, _, setLang, getLang} from '../src/i18n.js';
+
+jest.mock('../i18n/index', () => {
+    return {
+        core: {
+            en: { hello: 'Hello', goodbye: 'Goodbye' },
+            fr: { hello: 'Bonjour' }
+        },
+        date: {
+            en: { today: 'Today', tomorrow: () => 'Tomorrow' },
+            fr: { today: 'Aujourd\'hui', tomorrow: () => 'Demain' }
+        }
+    };
+})
+
+describe('Translation system', () => {
+    beforeEach(() => {
+        Object.defineProperty(global, 'navigator', {
+            value: { language: 'fr-FR' },
+            configurable: true
+        })
+        process.env.LANG = 'fr-FR.UTF-8';
+        process.env.LC_ALL = 'fr-FR.UTF-8';
+        process.env.LC_MESSAGES = 'fr-FR.UTF-8';
+    })
+
+    it('should check process.env and navigator.language', () => {
+        expect(process.env.LANG).toBe('fr-FR.UTF-8');
+        expect(navigator.language).toBe('fr-FR');
+    })
+
+    it('should return the correct translation for a given language and namespace', () => {
+        expect(translate('fr', 'core', 'hello')).toBe('Bonjour');
+        expect(translate('en', 'date', 'today')).toBe('Today');
+        expect(translate('fr', 'date', 'tomorrow')).toBe('Demain');
+        expect(translate('en', 'date', 'tomorrow')).toBe('Tomorrow');
+    })
+
+    it('should fallback to English if translation is missing in the given language', () => {
+        expect(translate('fr', 'core', 'goodbye')).toBe('Goodbye');
+    })
+
+    it('should fallback to the label if the translation is missing in all languages', () => {
+        expect(translate('fr', 'core', 'unknown')).toBe('unknown');
+    })
+
+    it('should default to the current language when no language is specified', () => {
+        expect(getLang()).toBe('fr');
+        expect(translate('core', 'hello')).toBe('Bonjour');
+    })
+
+    it('should fallback to namespace "core" if no namespace is specified', () => {
+        expect(translate('hello')).toBe('Bonjour');
+    })
+
+    it('should return the same result for translate and _', () => {
+        expect(translate('en', 'core', 'hello')).toBe(_('en', 'core', 'hello'));
+    })
+})
+
+describe('Language detection and setting', () => {
+    let originalNavigator, originalProcess;
+
+    beforeEach(() => {
+        originalProcess = process;
+        process.env.LANG = 'fr-FR.UTF-8';
+
+        originalNavigator = { ...global.navigator };
+        Object.defineProperty(global.navigator, 'language', {
+            value: 'fr-FR',
+            configurable: true
+        })
+    })
+
+    afterEach(() => {
+        process = originalProcess;
+        Object.defineProperty(global.navigator, 'language', {
+            value: originalNavigator.language,
+            configurable: true
+        })
+    })
+
+    it('should return the explicitly set language', () => {
+        setLang('fr');
+        expect(getLang()).toBe('fr');
+    })
+
+    it('should detect language from navigator.language', () => {
+        Object.defineProperty(global.navigator, 'language', {
+            value: 'es-ES',
+            configurable: true
+        })
+        setLang();
+        expect(getLang()).toBe('es');
+    })
+
+    it('should detect language from process.env if navigator.language is undefined', () => {
+        Object.defineProperty(global.navigator, 'language', {
+            value: null,
+            configurable: true
+        })
+        setLang();
+        expect(getLang()).toBe('fr');
+    })
+
+    it('should fallback to "en" if no language is detected', () => {
+        Object.defineProperty(global.navigator, 'language', {
+            value: null,
+            configurable: true
+        })
+        process = undefined;
+
+        setLang(); expect(getLang()).toBe('en');
+
+        process = originalProcess;
+        process.env.LANG = '';
+        process.env.LC_ALL = 'en-US.UTF-8';
+
+        setLang(); expect(getLang()).toBe('en');
+
+        process.env.LANG = '';
+        process.env.LC_ALL = '';
+        process.env.LC_MESSAGES = 'en-US.UTF-8';
+
+        setLang(); expect(getLang()).toBe('en');
+    })
+
+    it('should trim and normalize the language code', () => {
+        setLang('  FR-fr  ');
+        expect(getLang()).toBe('fr');
+    })
+})

package/tests/index.test.js

@@ -0,0 +1,29 @@
+import '../src/index.js';
+import {isFunction} from "../src/is.js";
+import {trim, numberFormat} from "../src/string.js";
+
+describe('index', () => {
+    const origTrim = String.prototype.trim;
+
+    describe('String.prototype extensions', () => {
+        it('should add custom methods to String.prototype', () => {
+            expect(isFunction(String.prototype.numberFormat)).toBe(true);
+        });
+
+        it('should call the original method if available and arguments match', () => {
+            const origTrim = String.prototype.trim;
+
+            String.prototype.trim = jest.fn(origTrim);
+
+            const result = ' hello '.trim();
+            expect(result).toBe('hello');
+            expect(String.prototype.trim).toHaveBeenCalled();
+
+            String.prototype.trim = origTrim;
+        });
+
+        it('should call the custom method if arguments do not match the original', () => {
+            expect('!hello!'.trim('!')).toBe('hello');
+        });
+    });
+})