@lumx/core 3.20.1-alpha.38 → 3.20.1-alpha.39

package/js/utils/className/handleBasicClasses.test.js

@@ -1,34 +0,0 @@
-'use strict';
-
-var js_utils_className_handleBasicClasses = require('./handleBasicClasses.js');
-require('classnames');
-require('../collection/isEmpty.js');
-require('./getBasicClass.js');
-require('../string/kebabCase.js');
-
-describe(js_utils_className_handleBasicClasses.handleBasicClasses, () => {
-    it('should return correct combined CSS classes based on props', () => {
-        const className = js_utils_className_handleBasicClasses.handleBasicClasses({
-            prefix: 'test',
-            // Undefined
-            undefined,
-            // Null
-            null: null,
-            // Empty string
-            emptyString: '',
-            // Empty array
-            emptyArray: [],
-            // Empty object
-            emptyObject: {},
-            // String
-            color: 'red',
-            // False property
-            isDisabled: false,
-            // Boolean without a prefix (is or has)
-            visible: true,
-            // Has prefix
-            hasButton: true,
-        });
-        expect(className).toBe('test test--color-red test--is-visible test--has-button');
-    });
-});

package/js/utils/className/handleBasicClasses.test.min.js

@@ -1 +0,0 @@
-"use strict";var e=require("./handleBasicClasses.min.js");require("classnames"),require("../collection/isEmpty.min.js"),require("./getBasicClass.min.js"),require("../string/kebabCase.min.js"),describe(e.handleBasicClasses,()=>{it("should return correct combined CSS classes based on props",()=>{const s=e.handleBasicClasses({prefix:"test",undefined:void 0,null:null,emptyString:"",emptyArray:[],emptyObject:{},color:"red",isDisabled:!1,visible:!0,hasButton:!0});expect(s).toBe("test test--color-red test--is-visible test--has-button")})});

package/js/utils/className/handleBasicClasses.test.ts

@@ -1,28 +0,0 @@
-import { handleBasicClasses } from './handleBasicClasses';
-
-describe(handleBasicClasses, () => {
-    it('should return correct combined CSS classes based on props', () => {
-        const className = handleBasicClasses({
-            prefix: 'test',
-            // Undefined
-            undefined,
-            // Null
-            null: null,
-            // Empty string
-            emptyString: '',
-            // Empty array
-            emptyArray: [],
-            // Empty object
-            emptyObject: {},
-            // String
-            color: 'red',
-            // False property
-            isDisabled: false,
-            // Boolean without a prefix (is or has)
-            visible: true,
-            // Has prefix
-            hasButton: true,
-        });
-        expect(className).toBe('test test--color-red test--is-visible test--has-button');
-    });
-});

package/js/utils/className/handleBasicClasses.ts

@@ -1,42 +0,0 @@
-import classNames from 'classnames';
-
-import { isEmpty } from '@lumx/core/js/utils/collection/isEmpty';
-
-import { getBasicClass } from './getBasicClass';
-
-/**
- * Enhance isEmpty method to also works with numbers.
- *
- * @param  value The value to check.
- * @return Whether the input value is empty or != 0.
- */
-const _isEmpty = (value: any) => {
-    if (typeof value === 'number') {
-        return value === 0;
-    }
-
-    return isEmpty(value);
-};
-
-/**
- * Return all basic LumX CSS classes which are available for every components.
- *
- * @see {@link /src/components/index.d.ts} for the possible values of each parameter.
- *
- * @param  prefix The class name prefix for the generated CSS class.
- * @param  props  All the other props you want to generate a class.
- *                The rule of thumb: the key is the name of the prop in the class, the value a string that will
- *                be used in the classname to represent the value of the given prop.
- * @return All LumX basic CSS classes.
- */
-export function handleBasicClasses({ prefix, ...props }: { prefix: string; [prop: string]: any }): string {
-    const otherClasses: any = {};
-    if (!isEmpty(props)) {
-        Object.keys(props).forEach((prop) => {
-            otherClasses[getBasicClass({ prefix, type: prop, value: props[prop] })] =
-                typeof props[prop] === 'boolean' ? props[prop] : !_isEmpty(props[prop]);
-        });
-    }
-
-    return classNames(prefix, otherClasses);
-}

package/js/utils/className/index.min.js

@@ -1 +0,0 @@
-"use strict";var s=require("./handleBasicClasses.min.js"),e=require("./getBasicClass.min.js"),a=require("./getRootClassName.min.js"),r=require("./getTypographyClassName.min.js"),i=require("./fontColorClass.min.js"),o=require("./resolveColorWithVariants.min.js");require("classnames"),require("../collection/isEmpty.min.js"),require("../string/kebabCase.min.js"),require("../../constants/index.min.js"),require("../../constants/keycodes.min.js"),exports.handleBasicClasses=s.handleBasicClasses,exports.getBasicClass=e.getBasicClass,exports.getRootClassName=a.getRootClassName,exports.getTypographyClassName=r.getTypographyClassName,exports.fontColorClass=i.fontColorClass,exports.resolveColorWithVariants=o.resolveColorWithVariants;

package/js/utils/className/resolveColorWithVariants.min.js

@@ -1 +0,0 @@
-"use strict";exports.resolveColorWithVariants=function(t,r){if(!t)return[void 0,r];const[i,o]=t.split("-");return[i,r||o]};

package/js/utils/className/resolveColorWithVariants.test.js

@@ -1,30 +0,0 @@
-'use strict';
-
-var js_utils_className_resolveColorWithVariants = require('./resolveColorWithVariants.js');
-
-describe(js_utils_className_resolveColorWithVariants.resolveColorWithVariants, () => {
-    it('should handle undefined color', () => {
-        const result = js_utils_className_resolveColorWithVariants.resolveColorWithVariants(undefined);
-        expect(result).toEqual([undefined, undefined]);
-    });
-    it('should handle undefined color with variant', () => {
-        const result = js_utils_className_resolveColorWithVariants.resolveColorWithVariants(undefined, 'L2');
-        expect(result).toEqual([undefined, 'L2']);
-    });
-    it('should handle color with undefined variant', () => {
-        const result = js_utils_className_resolveColorWithVariants.resolveColorWithVariants('primary');
-        expect(result).toEqual(['primary', undefined]);
-    });
-    it('should handle color & variant separated', () => {
-        const result = js_utils_className_resolveColorWithVariants.resolveColorWithVariants('primary', 'L2');
-        expect(result).toEqual(['primary', 'L2']);
-    });
-    it('should handle color with variant all in one', () => {
-        const result = js_utils_className_resolveColorWithVariants.resolveColorWithVariants('primary-L2');
-        expect(result).toEqual(['primary', 'L2']);
-    });
-    it('should override color variant with the given color variant', () => {
-        const result = js_utils_className_resolveColorWithVariants.resolveColorWithVariants('primary-L2', 'D2');
-        expect(result).toEqual(['primary', 'D2']);
-    });
-});

package/js/utils/className/resolveColorWithVariants.test.min.js

@@ -1 +0,0 @@
-"use strict";var o=require("./resolveColorWithVariants.min.js");describe(o.resolveColorWithVariants,()=>{it("should handle undefined color",()=>{const r=o.resolveColorWithVariants(void 0);expect(r).toEqual([void 0,void 0])}),it("should handle undefined color with variant",()=>{const r=o.resolveColorWithVariants(void 0,"L2");expect(r).toEqual([void 0,"L2"])}),it("should handle color with undefined variant",()=>{const r=o.resolveColorWithVariants("primary");expect(r).toEqual(["primary",void 0])}),it("should handle color & variant separated",()=>{const r=o.resolveColorWithVariants("primary","L2");expect(r).toEqual(["primary","L2"])}),it("should handle color with variant all in one",()=>{const r=o.resolveColorWithVariants("primary-L2");expect(r).toEqual(["primary","L2"])}),it("should override color variant with the given color variant",()=>{const r=o.resolveColorWithVariants("primary-L2","D2");expect(r).toEqual(["primary","D2"])})});

package/js/utils/className/resolveColorWithVariants.test.ts

@@ -1,33 +0,0 @@
-import { resolveColorWithVariants } from './resolveColorWithVariants';
-
-describe(resolveColorWithVariants, () => {
-    it('should handle undefined color', () => {
-        const result = resolveColorWithVariants(undefined);
-        expect(result).toEqual([undefined, undefined]);
-    });
-
-    it('should handle undefined color with variant', () => {
-        const result = resolveColorWithVariants(undefined, 'L2');
-        expect(result).toEqual([undefined, 'L2']);
-    });
-
-    it('should handle color with undefined variant', () => {
-        const result = resolveColorWithVariants('primary');
-        expect(result).toEqual(['primary', undefined]);
-    });
-
-    it('should handle color & variant separated', () => {
-        const result = resolveColorWithVariants('primary', 'L2');
-        expect(result).toEqual(['primary', 'L2']);
-    });
-
-    it('should handle color with variant all in one', () => {
-        const result = resolveColorWithVariants('primary-L2');
-        expect(result).toEqual(['primary', 'L2']);
-    });
-
-    it('should override color variant with the given color variant', () => {
-        const result = resolveColorWithVariants('primary-L2', 'D2');
-        expect(result).toEqual(['primary', 'D2']);
-    });
-});

package/js/utils/className/resolveColorWithVariants.ts

@@ -1,11 +0,0 @@
-import { ColorPalette, ColorVariant, ColorWithVariants } from '../../constants';
-
-/** Resolve color & color variant from a `ColorWithVariants` and optionally a `ColorVariant`. */
-export function resolveColorWithVariants(
-    colorWithVariants?: ColorWithVariants,
-    colorVariant?: ColorVariant,
-): [color?: ColorPalette, colorVariant?: ColorVariant] {
-    if (!colorWithVariants) return [undefined, colorVariant];
-    const [color, baseColorVariant] = colorWithVariants.split('-');
-    return [color as ColorPalette, (colorVariant || baseColorVariant) as ColorVariant];
-}

package/js/utils/collection/castArray.js

@@ -1,6 +0,0 @@
-'use strict';
-
-/** Cast a value into an array if needed */
-const castArray = (arrayOrElement) => Array.isArray(arrayOrElement) ? arrayOrElement : [arrayOrElement];
-
-exports.castArray = castArray;

package/js/utils/collection/castArray.min.js

@@ -1 +0,0 @@
-"use strict";exports.castArray=r=>Array.isArray(r)?r:[r];

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

@@ -1,17 +0,0 @@
-'use strict';
-
-var js_utils_collection_castArray = require('./castArray.js');
-
-describe(js_utils_collection_castArray.castArray, () => {
-    it('should keep existing array', () => {
-        const input = [1, 2];
-        const output = js_utils_collection_castArray.castArray(input);
-        expect(output).toEqual([1, 2]);
-        expect(output).toBe(input);
-    });
-    it('should cast item to array', () => {
-        const input = 1;
-        const output = js_utils_collection_castArray.castArray(input);
-        expect(output).toEqual([1]);
-    });
-});

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

@@ -1 +0,0 @@
-"use strict";var t=require("./castArray.min.js");describe(t.castArray,()=>{it("should keep existing array",()=>{const r=[1,2],a=t.castArray(r);expect(a).toEqual([1,2]),expect(a).toBe(r)}),it("should cast item to array",()=>{const r=t.castArray(1);expect(r).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,15 +0,0 @@
-'use strict';
-
-/** 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;
-}
-
-exports.chunk = chunk;

package/js/utils/collection/chunk.min.js

@@ -1 +0,0 @@
-"use strict";exports.chunk=function(t,e){if(e<=0)throw new Error("Size must be greater than 0");const r=[];for(let n=0;n<t.length;n+=e)r.push(t.slice(n,n+e));return r};

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

@@ -1,33 +0,0 @@
-'use strict';
-
-var js_utils_collection_chunk = require('./chunk.js');
-
-describe(js_utils_collection_chunk.chunk, () => {
-    it('should do nothing on empty array', () => {
-        expect(js_utils_collection_chunk.chunk([], 2)).toEqual([]);
-    });
-    it('should work with size larger than input array', () => {
-        expect(js_utils_collection_chunk.chunk([1, 2], 4)).toEqual([[1, 2]]);
-    });
-    it('should chunk array with size not perfectly dividing the array length', () => {
-        expect(js_utils_collection_chunk.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(js_utils_collection_chunk.chunk([1, 2, 3, 4], 2)).toEqual([
-            [1, 2],
-            [3, 4],
-        ]);
-    });
-    it('should work with size of 1', () => {
-        expect(js_utils_collection_chunk.chunk([1, 2, 3], 1)).toEqual([[1], [2], [3]]);
-    });
-    it('should work with size equal to array length', () => {
-        expect(js_utils_collection_chunk.chunk([1, 2, 3], 3)).toEqual([[1, 2, 3]]);
-    });
-    it('should throw error when size is 0', () => {
-        expect(() => js_utils_collection_chunk.chunk([1, 2, 3], 0)).toThrow('Size must be greater than 0');
-    });
-    it('should throw error when size is negative', () => {
-        expect(() => js_utils_collection_chunk.chunk([1, 2, 3], -1)).toThrow('Size must be greater than 0');
-    });
-});

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

@@ -1 +0,0 @@
-"use strict";var e=require("./chunk.min.js");describe(e.chunk,()=>{it("should do nothing on empty array",()=>{expect(e.chunk([],2)).toEqual([])}),it("should work with size larger than input array",()=>{expect(e.chunk([1,2],4)).toEqual([[1,2]])}),it("should chunk array with size not perfectly dividing the array length",()=>{expect(e.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(e.chunk([1,2,3,4],2)).toEqual([[1,2],[3,4]])}),it("should work with size of 1",()=>{expect(e.chunk([1,2,3],1)).toEqual([[1],[2],[3]])}),it("should work with size equal to array length",()=>{expect(e.chunk([1,2,3],3)).toEqual([[1,2,3]])}),it("should throw error when size is 0",()=>{expect(()=>e.chunk([1,2,3],0)).toThrow("Size must be greater than 0")}),it("should throw error when size is negative",()=>{expect(()=>e.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,6 +0,0 @@
-'use strict';
-
-/** Check if object or array is empty (true on falsy values) */
-const isEmpty = (obj) => !obj || Object.entries(obj).length === 0;
-
-exports.isEmpty = isEmpty;

package/js/utils/collection/isEmpty.min.js

@@ -1 +0,0 @@
-"use strict";exports.isEmpty=t=>!t||0===Object.entries(t).length;

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

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

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

@@ -1 +0,0 @@
-"use strict";var e=require("./isEmpty.min.js");describe(e.isEmpty,()=>{it("should return true for falsy values",()=>{expect(e.isEmpty(void 0)).toBe(!0),expect(e.isEmpty(null)).toBe(!0),expect(e.isEmpty(0)).toBe(!0),expect(e.isEmpty("")).toBe(!0),expect(e.isEmpty(!1)).toBe(!0)}),it("should return true for empty object or array",()=>{expect(e.isEmpty([])).toBe(!0),expect(e.isEmpty({})).toBe(!0)}),it("should return false for non empty object or array",()=>{expect(e.isEmpty([""])).toBe(!1),expect(e.isEmpty({foo:!1})).toBe(!1)})});

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,6 +0,0 @@
-'use strict';
-
-/** Get last item from array */
-const last = (array) => array[array.length - 1];
-
-exports.last = last;

package/js/utils/collection/last.min.js

@@ -1 +0,0 @@
-"use strict";exports.last=t=>t[t.length-1];

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

@@ -1,21 +0,0 @@
-'use strict';
-
-var js_utils_collection_last = require('./last.js');
-
-describe(js_utils_collection_last.last, () => {
-    it('should return undefined for empty array', () => {
-        const input = [];
-        const output = js_utils_collection_last.last(input);
-        expect(output).toBeUndefined();
-    });
-    it('should return last element from array with single element', () => {
-        const input = [42];
-        const output = js_utils_collection_last.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 = js_utils_collection_last.last(input);
-        expect(output).toBe(5);
-    });
-});

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

@@ -1 +0,0 @@
-"use strict";var e=require("./last.min.js");describe(e.last,()=>{it("should return undefined for empty array",()=>{const t=e.last([]);expect(t).toBeUndefined()}),it("should return last element from array with single element",()=>{const t=e.last([42]);expect(t).toBe(42)}),it("should return last element from array with multiple elements",()=>{const t=e.last([1,2,3,4,5]);expect(t).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,31 +0,0 @@
-'use strict';
-
-/**
- * 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];
-}
-
-exports.partitionMulti = partitionMulti;

package/js/utils/collection/partitionMulti.min.js

@@ -1 +0,0 @@
-"use strict";exports.partitionMulti=function(t,n){const o=[],s=n.map(()=>[]);for(const i of t){const t=n.findIndex(t=>t(i));-1!==t?s[t].push(i):o.push(i)}return[...s,o]};

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

@@ -1,32 +0,0 @@
-'use strict';
-
-var js_utils_collection_partitionMulti = require('./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 = js_utils_collection_partitionMulti.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 = js_utils_collection_partitionMulti.partitionMulti(data, [isString, isNumber, isNull]);
-        expect(partitions).toEqual([
-            // strings
-            ['a', 'b'],
-            // numbers
-            [1],
-            // nulls
-            [],
-            // others
-            [false, true],
-        ]);
-    });
-});

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

@@ -1 +0,0 @@
-"use strict";var t=require("./partitionMulti.min.js");describe("partitionMulti",()=>{it("should partition with single predicate",()=>{const i=t.partitionMulti([0,1,2,3,4,5],[t=>t%2==0]);expect(i).toEqual([[0,2,4],[1,3,5]])}),it("should partition on multiple predicates",()=>{const i=t.partitionMulti(["a",1,"b",!1,!0],[t=>"string"==typeof t,t=>"number"==typeof t,t=>null===t]);expect(i).toEqual([["a","b"],[1],[],[!1,!0]])})});

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 @@
-'use strict';
-
-/** Generate a range of number starting at 0 and ending before the given number */
-const range = (end) => Array.from({ length: end }, (_, i) => i);
-
-exports.range = range;