@lumx/core 3.20.1-alpha.30 → 3.20.1-alpha.32

package/package.json

@@ -19,7 +19,6 @@
         "LumX"
     ],
     "license": "MIT",
-    "type": "module",
     "name": "@lumx/core",
     "publishConfig": {
         "directory": "dist"
@@ -35,12 +34,11 @@
         "update-version-changelog": "yarn version-changelog ../../CHANGELOG.md"
     },
     "sideEffects": false,
-    "version": "3.20.1-alpha.30",
+    "version": "3.20.1-alpha.32",
     "devDependencies": {
-        "@babel/preset-typescript": "^7.26.0",
-        "@rollup/plugin-babel": "^6.0.4",
         "@rollup/plugin-commonjs": "^29.0.0",
-        "@rollup/plugin-node-resolve": "16.0.0",
+        "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^12.1.4",
         "@types/react": "^17.0.2",
         "autoprefixer": "^9.7.4",
         "glob": "^7.1.6",

package/js/utils/collection/castArray.js

@@ -1,4 +0,0 @@
-/** Cast a value into an array if needed */
-const castArray = arrayOrElement => Array.isArray(arrayOrElement) ? arrayOrElement : [arrayOrElement];
-
-export { castArray };

package/js/utils/collection/castArray.test.js

@@ -1,15 +0,0 @@
-import { castArray } from '@lumx/core/js/utils/collection/castArray';
-
-describe(castArray, () => {
-  it('should keep existing array', () => {
-    const input = [1, 2];
-    const output = castArray(input);
-    expect(output).toEqual([1, 2]);
-    expect(output).toBe(input);
-  });
-  it('should cast item to array', () => {
-    const input = 1;
-    const output = castArray(input);
-    expect(output).toEqual([1]);
-  });
-});

package/js/utils/collection/castArray.test.ts

@@ -1,15 +0,0 @@
-import { castArray } from '@lumx/core/js/utils/collection/castArray';
-
-describe(castArray, () => {
-    it('should keep existing array', () => {
-        const input = [1, 2];
-        const output = castArray(input);
-        expect(output).toEqual([1, 2]);
-        expect(output).toBe(input);
-    });
-    it('should cast item to array', () => {
-        const input = 1;
-        const output = castArray(input);
-        expect(output).toEqual([1]);
-    });
-});

package/js/utils/collection/castArray.ts

@@ -1,3 +0,0 @@
-/** Cast a value into an array if needed */
-export const castArray = <T>(arrayOrElement: T[] | T) =>
-    Array.isArray(arrayOrElement) ? arrayOrElement : [arrayOrElement];

package/js/utils/collection/chunk.js

@@ -1,13 +0,0 @@
-/** Chunk array in slices of given size */
-function chunk(input, size) {
-  if (size <= 0) {
-    throw new Error('Size must be greater than 0');
-  }
-  const result = [];
-  for (let i = 0; i < input.length; i += size) {
-    result.push(input.slice(i, i + size));
-  }
-  return result;
-}
-
-export { chunk };

package/js/utils/collection/chunk.test.js

@@ -1,28 +0,0 @@
-import { chunk } from '@lumx/core/js/utils/collection/chunk';
-
-describe(chunk, () => {
-  it('should do nothing on empty array', () => {
-    expect(chunk([], 2)).toEqual([]);
-  });
-  it('should work with size larger than input array', () => {
-    expect(chunk([1, 2], 4)).toEqual([[1, 2]]);
-  });
-  it('should chunk array with size not perfectly dividing the array length', () => {
-    expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
-  });
-  it('should chunk array with size perfectly dividing the array length', () => {
-    expect(chunk([1, 2, 3, 4], 2)).toEqual([[1, 2], [3, 4]]);
-  });
-  it('should work with size of 1', () => {
-    expect(chunk([1, 2, 3], 1)).toEqual([[1], [2], [3]]);
-  });
-  it('should work with size equal to array length', () => {
-    expect(chunk([1, 2, 3], 3)).toEqual([[1, 2, 3]]);
-  });
-  it('should throw error when size is 0', () => {
-    expect(() => chunk([1, 2, 3], 0)).toThrow('Size must be greater than 0');
-  });
-  it('should throw error when size is negative', () => {
-    expect(() => chunk([1, 2, 3], -1)).toThrow('Size must be greater than 0');
-  });
-});

package/js/utils/collection/chunk.test.ts

@@ -1,38 +0,0 @@
-import { chunk } from '@lumx/core/js/utils/collection/chunk';
-
-describe(chunk, () => {
-    it('should do nothing on empty array', () => {
-        expect(chunk([], 2)).toEqual([]);
-    });
-
-    it('should work with size larger than input array', () => {
-        expect(chunk([1, 2], 4)).toEqual([[1, 2]]);
-    });
-
-    it('should chunk array with size not perfectly dividing the array length', () => {
-        expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
-    });
-
-    it('should chunk array with size perfectly dividing the array length', () => {
-        expect(chunk([1, 2, 3, 4], 2)).toEqual([
-            [1, 2],
-            [3, 4],
-        ]);
-    });
-
-    it('should work with size of 1', () => {
-        expect(chunk([1, 2, 3], 1)).toEqual([[1], [2], [3]]);
-    });
-
-    it('should work with size equal to array length', () => {
-        expect(chunk([1, 2, 3], 3)).toEqual([[1, 2, 3]]);
-    });
-
-    it('should throw error when size is 0', () => {
-        expect(() => chunk([1, 2, 3], 0)).toThrow('Size must be greater than 0');
-    });
-
-    it('should throw error when size is negative', () => {
-        expect(() => chunk([1, 2, 3], -1)).toThrow('Size must be greater than 0');
-    });
-});

package/js/utils/collection/chunk.ts

@@ -1,11 +0,0 @@
-/** Chunk array in slices of given size */
-export function chunk<T>(input: Array<T>, size: number): T[][] {
-    if (size <= 0) {
-        throw new Error('Size must be greater than 0');
-    }
-    const result: T[][] = [];
-    for (let i = 0; i < input.length; i += size) {
-        result.push(input.slice(i, i + size));
-    }
-    return result;
-}

package/js/utils/collection/isEmpty.js

@@ -1,4 +0,0 @@
-/** Check if object or array is empty (true on falsy values) */
-const isEmpty = obj => !obj || Object.entries(obj).length === 0;
-
-export { isEmpty };

package/js/utils/collection/isEmpty.test.js

@@ -1,21 +0,0 @@
-import { isEmpty } from './isEmpty.js';
-
-describe(isEmpty, () => {
-  it('should return true for falsy values', () => {
-    expect(isEmpty(undefined)).toBe(true);
-    expect(isEmpty(null)).toBe(true);
-    expect(isEmpty(0)).toBe(true);
-    expect(isEmpty('')).toBe(true);
-    expect(isEmpty(false)).toBe(true);
-  });
-  it('should return true for empty object or array', () => {
-    expect(isEmpty([])).toBe(true);
-    expect(isEmpty({})).toBe(true);
-  });
-  it('should return false for non empty object or array', () => {
-    expect(isEmpty([''])).toBe(false);
-    expect(isEmpty({
-      foo: false
-    })).toBe(false);
-  });
-});

package/js/utils/collection/isEmpty.test.ts

@@ -1,21 +0,0 @@
-import { isEmpty } from './isEmpty';
-
-describe(isEmpty, () => {
-    it('should return true for falsy values', () => {
-        expect(isEmpty(undefined)).toBe(true);
-        expect(isEmpty(null)).toBe(true);
-        expect(isEmpty(0)).toBe(true);
-        expect(isEmpty('')).toBe(true);
-        expect(isEmpty(false)).toBe(true);
-    });
-
-    it('should return true for empty object or array', () => {
-        expect(isEmpty([])).toBe(true);
-        expect(isEmpty({})).toBe(true);
-    });
-
-    it('should return false for non empty object or array', () => {
-        expect(isEmpty([''])).toBe(false);
-        expect(isEmpty({ foo: false })).toBe(false);
-    });
-});

package/js/utils/collection/isEmpty.ts

@@ -1,4 +0,0 @@
-import type { Falsy } from '../../types';
-
-/** Check if object or array is empty (true on falsy values) */
-export const isEmpty = (obj: NonNullable<unknown> | Falsy) => !obj || Object.entries(obj).length === 0;

package/js/utils/collection/last.js

@@ -1,4 +0,0 @@
-/** Get last item from array */
-const last = array => array[array.length - 1];
-
-export { last };

package/js/utils/collection/last.test.js

@@ -1,19 +0,0 @@
-import { last } from '@lumx/core/js/utils/collection/last';
-
-describe(last, () => {
-  it('should return undefined for empty array', () => {
-    const input = [];
-    const output = last(input);
-    expect(output).toBeUndefined();
-  });
-  it('should return last element from array with single element', () => {
-    const input = [42];
-    const output = last(input);
-    expect(output).toBe(42);
-  });
-  it('should return last element from array with multiple elements', () => {
-    const input = [1, 2, 3, 4, 5];
-    const output = last(input);
-    expect(output).toBe(5);
-  });
-});

package/js/utils/collection/last.test.ts

@@ -1,21 +0,0 @@
-import { last } from '@lumx/core/js/utils/collection/last';
-
-describe(last, () => {
-    it('should return undefined for empty array', () => {
-        const input: number[] = [];
-        const output = last(input);
-        expect(output).toBeUndefined();
-    });
-
-    it('should return last element from array with single element', () => {
-        const input = [42];
-        const output = last(input);
-        expect(output).toBe(42);
-    });
-
-    it('should return last element from array with multiple elements', () => {
-        const input = [1, 2, 3, 4, 5];
-        const output = last(input);
-        expect(output).toBe(5);
-    });
-});

package/js/utils/collection/last.ts

@@ -1,2 +0,0 @@
-/** Get last item from array */
-export const last = <T>(array: Array<T>): T | undefined => array[array.length - 1];

package/js/utils/collection/partitionMulti.js

@@ -1,28 +0,0 @@
-/**
- * Similar to lodash `partition` function but working with multiple predicates.
- *
- * @example
- * const isString = (s) => typeof s === 'string'
- * const isNumber = (s) => typeof s === 'number'
- * const [strings, numbers, others] = partitionMulti(['a', 1, 'b', false], [isString, isNumber])
- * //=> [['a', 'b'], [1], [false]]
- *
- * @param  elements array of elements
- * @param  predicates array of predicates to apply on elements
- * @return partitioned elements by the given predicates
- */
-function partitionMulti(elements, predicates) {
-  const others = [];
-  const groups = predicates.map(() => []);
-  for (const element of elements) {
-    const index = predicates.findIndex(predicate => predicate(element));
-    if (index !== -1) {
-      groups[index].push(element);
-    } else {
-      others.push(element);
-    }
-  }
-  return [...groups, others];
-}
-
-export { partitionMulti };

package/js/utils/collection/partitionMulti.test.js

@@ -1,26 +0,0 @@
-import { partitionMulti } from './partitionMulti.js';
-
-describe('partitionMulti', () => {
-  it('should partition with single predicate', () => {
-    const data = [0, 1, 2, 3, 4, 5];
-    const isEven = n => n % 2 === 0;
-    const actual = partitionMulti(data, [isEven]);
-    expect(actual).toEqual([[0, 2, 4], [1, 3, 5]]);
-  });
-  it('should partition on multiple predicates', () => {
-    const data = ['a', 1, 'b', false, true];
-    const isString = s => typeof s === 'string';
-    const isNumber = s => typeof s === 'number';
-    const isNull = s => s === null;
-    const partitions = partitionMulti(data, [isString, isNumber, isNull]);
-    expect(partitions).toEqual([
-    // strings
-    ['a', 'b'],
-    // numbers
-    [1],
-    // nulls
-    [],
-    // others
-    [false, true]]);
-  });
-});

package/js/utils/collection/partitionMulti.test.ts

@@ -1,35 +0,0 @@
-import { partitionMulti } from './partitionMulti';
-
-describe('partitionMulti', () => {
-    it('should partition with single predicate', () => {
-        const data = [0, 1, 2, 3, 4, 5];
-        const isEven = (n: number): boolean => n % 2 === 0;
-
-        const actual = partitionMulti(data, [isEven]);
-
-        expect(actual).toEqual([
-            [0, 2, 4],
-            [1, 3, 5],
-        ]);
-    });
-
-    it('should partition on multiple predicates', () => {
-        type T = string | number | boolean;
-        const data: T[] = ['a', 1, 'b', false, true];
-        const isString = (s: T): boolean => typeof s === 'string';
-        const isNumber = (s: T): boolean => typeof s === 'number';
-        const isNull = (s: T): boolean => s === null;
-
-        const partitions = partitionMulti(data, [isString, isNumber, isNull]);
-        expect(partitions).toEqual([
-            // strings
-            ['a', 'b'],
-            // numbers
-            [1],
-            // nulls
-            [],
-            // others
-            [false, true],
-        ]);
-    });
-});

package/js/utils/collection/partitionMulti.ts

@@ -1,29 +0,0 @@
-import type { Predicate } from '@lumx/core/js/types';
-
-/**
- * Similar to lodash `partition` function but working with multiple predicates.
- *
- * @example
- * const isString = (s) => typeof s === 'string'
- * const isNumber = (s) => typeof s === 'number'
- * const [strings, numbers, others] = partitionMulti(['a', 1, 'b', false], [isString, isNumber])
- * //=> [['a', 'b'], [1], [false]]
- *
- * @param  elements array of elements
- * @param  predicates array of predicates to apply on elements
- * @return partitioned elements by the given predicates
- */
-export function partitionMulti<T>(elements: T[], predicates: Array<Predicate<T>>): T[][] {
-    const others = [] as T[];
-    const groups = predicates.map(() => []) as T[][];
-
-    for (const element of elements) {
-        const index = predicates.findIndex((predicate) => predicate(element));
-        if (index !== -1) {
-            groups[index].push(element);
-        } else {
-            others.push(element);
-        }
-    }
-    return [...groups, others];
-}

package/js/utils/collection/range.js

@@ -1,6 +0,0 @@
-/** Generate a range of number starting at 0 and ending before the given number */
-const range = end => Array.from({
-  length: end
-}, (_, i) => i);
-
-export { range };

package/js/utils/collection/range.test.js

@@ -1,10 +0,0 @@
-import { range } from './range.js';
-
-describe(range, () => {
-  it('should generate a number range', () => {
-    expect(range(-2)).toEqual([]);
-    expect(range(0)).toEqual([]);
-    expect(range(1)).toEqual([0]);
-    expect(range(5)).toEqual([0, 1, 2, 3, 4]);
-  });
-});

package/js/utils/collection/range.test.ts

@@ -1,10 +0,0 @@
-import { range } from './range';
-
-describe(range, () => {
-    it('should generate a number range', () => {
-        expect(range(-2)).toEqual([]);
-        expect(range(0)).toEqual([]);
-        expect(range(1)).toEqual([0]);
-        expect(range(5)).toEqual([0, 1, 2, 3, 4]);
-    });
-});

package/js/utils/collection/range.ts

@@ -1,2 +0,0 @@
-/** Generate a range of number starting at 0 and ending before the given number */
-export const range = (end: number) => Array.from({ length: end }, (_, i) => i);

package/js/utils/string/kebabCase.js

@@ -1,28 +0,0 @@
-/**
- * Converts a string to kebab-case.
- *
- * @param str The string to convert
- * @returns The kebab-cased string
- *
- * @example
- * kebabCase('fooBar') // 'foo-bar'
- * kebabCase('FooBar') // 'foo-bar'
- * kebabCase('foo_bar') // 'foo-bar'
- * kebabCase('foo bar') // 'foo-bar'
- * kebabCase('FOO_BAR') // 'foo-bar'
- */
-function kebabCase(str) {
-  return str
-  // Insert a hyphen before any uppercase letter that follows a lowercase letter or number
-  .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-  // Insert a hyphen before any uppercase letter that is followed by a lowercase letter and preceded by an uppercase letter
-  .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-  // Replace spaces and underscores with hyphens
-  .replace(/[\s_]+/g, '-')
-  // Convert to lowercase
-  .toLowerCase()
-  // Remove leading/trailing hyphens
-  .replace(/^-+|-+$/g, '');
-}
-
-export { kebabCase };

package/js/utils/string/kebabCase.test.js

@@ -1,41 +0,0 @@
-import { kebabCase } from '@lumx/core/js/utils/string/kebabCase';
-
-describe(kebabCase, () => {
-  it('should convert camelCase to kebab-case', () => {
-    expect(kebabCase('fooBar')).toBe('foo-bar');
-    expect(kebabCase('fooBarBaz')).toBe('foo-bar-baz');
-  });
-  it('should convert PascalCase to kebab-case', () => {
-    expect(kebabCase('FooBar')).toBe('foo-bar');
-    expect(kebabCase('FooBarBaz')).toBe('foo-bar-baz');
-  });
-  it('should convert snake_case to kebab-case', () => {
-    expect(kebabCase('foo_bar')).toBe('foo-bar');
-    expect(kebabCase('foo_bar_baz')).toBe('foo-bar-baz');
-  });
-  it('should convert spaces to hyphens', () => {
-    expect(kebabCase('foo bar')).toBe('foo-bar');
-    expect(kebabCase('foo bar baz')).toBe('foo-bar-baz');
-  });
-  it('should handle UPPERCASE strings', () => {
-    expect(kebabCase('FOO_BAR')).toBe('foo-bar');
-    expect(kebabCase('FOOBAR')).toBe('foobar');
-  });
-  it('should handle mixed formats', () => {
-    expect(kebabCase('fooBar_baz qux')).toBe('foo-bar-baz-qux');
-  });
-  it('should handle strings that are already kebab-case', () => {
-    expect(kebabCase('foo-bar')).toBe('foo-bar');
-  });
-  it('should handle empty strings', () => {
-    expect(kebabCase('')).toBe('');
-  });
-  it('should handle single words', () => {
-    expect(kebabCase('foo')).toBe('foo');
-    expect(kebabCase('Foo')).toBe('foo');
-  });
-  it('should remove leading and trailing hyphens', () => {
-    expect(kebabCase('_foo_bar_')).toBe('foo-bar');
-    expect(kebabCase(' foo bar ')).toBe('foo-bar');
-  });
-});

package/js/utils/string/kebabCase.test.ts

@@ -1,50 +0,0 @@
-import { kebabCase } from '@lumx/core/js/utils/string/kebabCase';
-
-describe(kebabCase, () => {
-    it('should convert camelCase to kebab-case', () => {
-        expect(kebabCase('fooBar')).toBe('foo-bar');
-        expect(kebabCase('fooBarBaz')).toBe('foo-bar-baz');
-    });
-
-    it('should convert PascalCase to kebab-case', () => {
-        expect(kebabCase('FooBar')).toBe('foo-bar');
-        expect(kebabCase('FooBarBaz')).toBe('foo-bar-baz');
-    });
-
-    it('should convert snake_case to kebab-case', () => {
-        expect(kebabCase('foo_bar')).toBe('foo-bar');
-        expect(kebabCase('foo_bar_baz')).toBe('foo-bar-baz');
-    });
-
-    it('should convert spaces to hyphens', () => {
-        expect(kebabCase('foo bar')).toBe('foo-bar');
-        expect(kebabCase('foo bar baz')).toBe('foo-bar-baz');
-    });
-
-    it('should handle UPPERCASE strings', () => {
-        expect(kebabCase('FOO_BAR')).toBe('foo-bar');
-        expect(kebabCase('FOOBAR')).toBe('foobar');
-    });
-
-    it('should handle mixed formats', () => {
-        expect(kebabCase('fooBar_baz qux')).toBe('foo-bar-baz-qux');
-    });
-
-    it('should handle strings that are already kebab-case', () => {
-        expect(kebabCase('foo-bar')).toBe('foo-bar');
-    });
-
-    it('should handle empty strings', () => {
-        expect(kebabCase('')).toBe('');
-    });
-
-    it('should handle single words', () => {
-        expect(kebabCase('foo')).toBe('foo');
-        expect(kebabCase('Foo')).toBe('foo');
-    });
-
-    it('should remove leading and trailing hyphens', () => {
-        expect(kebabCase('_foo_bar_')).toBe('foo-bar');
-        expect(kebabCase(' foo bar ')).toBe('foo-bar');
-    });
-});

package/js/utils/string/kebabCase.ts

@@ -1,28 +0,0 @@
-/**
- * Converts a string to kebab-case.
- *
- * @param str The string to convert
- * @returns The kebab-cased string
- *
- * @example
- * kebabCase('fooBar') // 'foo-bar'
- * kebabCase('FooBar') // 'foo-bar'
- * kebabCase('foo_bar') // 'foo-bar'
- * kebabCase('foo bar') // 'foo-bar'
- * kebabCase('FOO_BAR') // 'foo-bar'
- */
-export function kebabCase(str: string): string {
-    return (
-        str
-            // Insert a hyphen before any uppercase letter that follows a lowercase letter or number
-            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-            // Insert a hyphen before any uppercase letter that is followed by a lowercase letter and preceded by an uppercase letter
-            .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-            // Replace spaces and underscores with hyphens
-            .replace(/[\s_]+/g, '-')
-            // Convert to lowercase
-            .toLowerCase()
-            // Remove leading/trailing hyphens
-            .replace(/^-+|-+$/g, '')
-    );
-}