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

package/js/utils/className/getBasicClass.test.js

@@ -1,22 +1,57 @@
-'use strict';
+import { getBasicClass } from './getBasicClass.js';
+import '../string/kebabCase.js';
 
-var js_utils_className_getBasicClass = require('./getBasicClass.js');
-require('lodash/isBoolean');
-require('lodash/kebabCase');
+describe(getBasicClass, () => {
+  it('should return correct basic CSS class for different types and values', () => {
+    // Test cases with different inputs
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'color',
+      value: 'primary'
+    })).toBe('test--color-primary');
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'variant',
+      value: 'button'
+    })).toBe('test--variant-button');
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'isDark',
+      value: true
+    })).toBe('test--is-dark');
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'dark',
+      value: true
+    })).toBe('test--is-dark');
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'hasDark',
+      value: true
+    })).toBe('test--has-dark');
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'isActive',
+      value: false
+    })).toBe('');
 
-describe(js_utils_className_getBasicClass.getBasicClass, () => {
-    it('should return correct basic CSS class for different types and values', () => {
-        // Test cases with different inputs
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'color', value: 'primary' })).toBe('test--color-primary');
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'variant', value: 'button' })).toBe('test--variant-button');
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'isDark', value: true })).toBe('test--is-dark');
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'dark', value: true })).toBe('test--is-dark');
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'hasDark', value: true })).toBe('test--has-dark');
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'isActive', value: false })).toBe('');
-        // Additional tests for boolean types
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'hasBorder', value: true })).toBe('test--has-border');
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'isVisible', value: false })).toBe('');
-        // Tests for undefined
-        expect(js_utils_className_getBasicClass.getBasicClass({ prefix: 'test', type: 'variant', value: undefined })).toBe('test--variant-undefined');
-    });
+    // Additional tests for boolean types
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'hasBorder',
+      value: true
+    })).toBe('test--has-border');
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'isVisible',
+      value: false
+    })).toBe('');
+
+    // Tests for undefined
+    expect(getBasicClass({
+      prefix: 'test',
+      type: 'variant',
+      value: undefined
+    })).toBe('test--variant-undefined');
+  });
 });

package/js/utils/className/getBasicClass.ts

@@ -1,5 +1,4 @@
-import isBoolean from 'lodash/isBoolean';
-import kebabCase from 'lodash/kebabCase';
+import { kebabCase } from '../string/kebabCase';
 
 /**
  * Get the basic CSS class for the given type.
@@ -18,7 +17,7 @@ export function getBasicClass({
     type: string;
     value: string | number | boolean | undefined;
 }): string {
-    if (isBoolean(value)) {
+    if (typeof value === 'boolean') {
         if (!value) {
             // False value should not return a class.
             return '';

package/js/utils/className/getRootClassName.js

@@ -1,17 +1,10 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var kebabCase = require('lodash/kebabCase');
-var js_constants_index = require('../../constants/index.js');
-require('../../constants/keycodes.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var kebabCase__default = /*#__PURE__*/_interopDefaultLegacy(kebabCase);
+import { CSS_PREFIX } from '../../constants/index.js';
+import { kebabCase } from '../string/kebabCase.js';
+import '../../constants/keycodes.js';
 
 // See https://regex101.com/r/YjS1uI/3
 const LAST_PART_CLASSNAME = /^(.*)-(.+)$/gi;
+
 /**
  * Get the name of the root CSS class of a component based on its name.
  *
@@ -23,11 +16,11 @@ const LAST_PART_CLASSNAME = /^(.*)-(.+)$/gi;
  *         lower-snake-case.
  */
 function getRootClassName(componentName, subComponent) {
-    const formattedClassName = `${js_constants_index.CSS_PREFIX}-${kebabCase__default["default"](componentName)}`;
-    if (subComponent) {
-        return formattedClassName.replace(LAST_PART_CLASSNAME, '$1__$2');
-    }
-    return formattedClassName;
+  const formattedClassName = `${CSS_PREFIX}-${kebabCase(componentName)}`;
+  if (subComponent) {
+    return formattedClassName.replace(LAST_PART_CLASSNAME, '$1__$2');
+  }
+  return formattedClassName;
 }
 
-exports.getRootClassName = getRootClassName;
+export { getRootClassName };

package/js/utils/className/getRootClassName.test.js

@@ -1,15 +1,13 @@
-'use strict';
+import { getRootClassName } from './getRootClassName.js';
+import '../../constants/index.js';
+import '../../constants/keycodes.js';
+import '../string/kebabCase.js';
 
-var js_utils_className_getRootClassName = require('./getRootClassName.js');
-require('lodash/kebabCase');
-require('../../constants/index.js');
-require('../../constants/keycodes.js');
-
-describe(js_utils_className_getRootClassName.getRootClassName, () => {
-    it('should transform the component name into a lumx class', () => {
-        expect(js_utils_className_getRootClassName.getRootClassName('Table')).toBe('lumx-table');
-    });
-    it('should transform the sub component name into a lumx class', () => {
-        expect(js_utils_className_getRootClassName.getRootClassName('TableBody', true)).toBe('lumx-table__body');
-    });
+describe(getRootClassName, () => {
+  it('should transform the component name into a lumx class', () => {
+    expect(getRootClassName('Table')).toBe('lumx-table');
+  });
+  it('should transform the sub component name into a lumx class', () => {
+    expect(getRootClassName('TableBody', true)).toBe('lumx-table__body');
+  });
 });

package/js/utils/className/getRootClassName.ts

@@ -1,6 +1,5 @@
-import kebabCase from 'lodash/kebabCase';
-
 import { CSS_PREFIX } from '../../constants';
+import { kebabCase } from '../string/kebabCase';
 
 // See https://regex101.com/r/YjS1uI/3
 const LAST_PART_CLASSNAME = /^(.*)-(.+)$/gi;

package/js/utils/className/getTypographyClassName.js

@@ -1,13 +1,9 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
 /**
  * Returns the classname associated to the given typography.
  * For example, for `Typography.title` it returns `lumx-typography-title`
  */
-const getTypographyClassName = (typography) => {
-    return `lumx-typography-${typography}`;
+const getTypographyClassName = typography => {
+  return `lumx-typography-${typography}`;
 };
 
-exports.getTypographyClassName = getTypographyClassName;
+export { getTypographyClassName };

package/js/utils/className/getTypographyClassName.test.js

@@ -1,9 +1,7 @@
-'use strict';
+import { getTypographyClassName } from './getTypographyClassName.js';
 
-var js_utils_className_getTypographyClassName = require('./getTypographyClassName.js');
-
-describe(js_utils_className_getTypographyClassName.getTypographyClassName, () => {
-    it('should generate lumx typography class', () => {
-        expect(js_utils_className_getTypographyClassName.getTypographyClassName('title')).toBe('lumx-typography-title');
-    });
+describe(getTypographyClassName, () => {
+  it('should generate lumx typography class', () => {
+    expect(getTypographyClassName('title')).toBe('lumx-typography-title');
+  });
 });

package/js/utils/className/handleBasicClasses.js

@@ -1,18 +1,7 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var classNames = require('classnames');
-var isBoolean = require('lodash/isBoolean');
-var isEmpty = require('lodash/isEmpty');
-var js_utils_className_getBasicClass = require('./getBasicClass.js');
-require('lodash/kebabCase');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var classNames__default = /*#__PURE__*/_interopDefaultLegacy(classNames);
-var isBoolean__default = /*#__PURE__*/_interopDefaultLegacy(isBoolean);
-var isEmpty__default = /*#__PURE__*/_interopDefaultLegacy(isEmpty);
+import classNames from 'classnames';
+import { isEmpty } from '@lumx/core/js/utils/collection/isEmpty';
+import { getBasicClass } from './getBasicClass.js';
+import '../string/kebabCase.js';
 
 /**
  * Enhance isEmpty method to also works with numbers.
@@ -20,12 +9,13 @@ var isEmpty__default = /*#__PURE__*/_interopDefaultLegacy(isEmpty);
  * @param  value The value to check.
  * @return Whether the input value is empty or != 0.
  */
-const _isEmpty = (value) => {
-    if (typeof value === 'number') {
-        return value === 0;
-    }
-    return isEmpty__default["default"](value);
+const _isEmpty = value => {
+  if (typeof value === 'number') {
+    return value === 0;
+  }
+  return isEmpty(value);
 };
+
 /**
  * Return all basic LumX CSS classes which are available for every components.
  *
@@ -37,16 +27,21 @@ const _isEmpty = (value) => {
  *                be used in the classname to represent the value of the given prop.
  * @return All LumX basic CSS classes.
  */
-function handleBasicClasses({ prefix, ...props }) {
-    const otherClasses = {};
-    if (!isEmpty__default["default"](props)) {
-        Object.keys(props).forEach((prop) => {
-            otherClasses[js_utils_className_getBasicClass.getBasicClass({ prefix, type: prop, value: props[prop] })] = isBoolean__default["default"](props[prop])
-                ? props[prop]
-                : !_isEmpty(props[prop]);
-        });
-    }
-    return classNames__default["default"](prefix, otherClasses);
+function handleBasicClasses({
+  prefix,
+  ...props
+}) {
+  const otherClasses = {};
+  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);
 }
 
-exports.handleBasicClasses = handleBasicClasses;
+export { handleBasicClasses };

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

@@ -1,35 +1,32 @@
-'use strict';
+import { handleBasicClasses } from './handleBasicClasses.js';
+import 'classnames';
+import '@lumx/core/js/utils/collection/isEmpty';
+import './getBasicClass.js';
+import '../string/kebabCase.js';
 
-var js_utils_className_handleBasicClasses = require('./handleBasicClasses.js');
-require('classnames');
-require('lodash/isBoolean');
-require('lodash/isEmpty');
-require('./getBasicClass.js');
-require('lodash/kebabCase');
-
-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');
+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,7 +1,6 @@
 import classNames from 'classnames';
 
-import isBoolean from 'lodash/isBoolean';
-import isEmpty from 'lodash/isEmpty';
+import { isEmpty } from '@lumx/core/js/utils/collection/isEmpty';
 
 import { getBasicClass } from './getBasicClass';
 
@@ -34,9 +33,8 @@ export function handleBasicClasses({ prefix, ...props }: { prefix: string; [prop
     const otherClasses: any = {};
     if (!isEmpty(props)) {
         Object.keys(props).forEach((prop) => {
-            otherClasses[getBasicClass({ prefix, type: prop, value: props[prop] })] = isBoolean(props[prop])
-                ? props[prop]
-                : !_isEmpty(props[prop]);
+            otherClasses[getBasicClass({ prefix, type: prop, value: props[prop] })] =
+                typeof props[prop] === 'boolean' ? props[prop] : !_isEmpty(props[prop]);
         });
     }
 

package/js/utils/className/index.js

@@ -1,25 +1,11 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var js_utils_className_handleBasicClasses = require('./handleBasicClasses.js');
-var js_utils_className_getBasicClass = require('./getBasicClass.js');
-var js_utils_className_getRootClassName = require('./getRootClassName.js');
-var js_utils_className_getTypographyClassName = require('./getTypographyClassName.js');
-var js_utils_className_fontColorClass = require('./fontColorClass.js');
-var js_utils_className_resolveColorWithVariants = require('./resolveColorWithVariants.js');
-require('classnames');
-require('lodash/isBoolean');
-require('lodash/isEmpty');
-require('lodash/kebabCase');
-require('../../constants/index.js');
-require('../../constants/keycodes.js');
-
-
-
-exports.handleBasicClasses = js_utils_className_handleBasicClasses.handleBasicClasses;
-exports.getBasicClass = js_utils_className_getBasicClass.getBasicClass;
-exports.getRootClassName = js_utils_className_getRootClassName.getRootClassName;
-exports.getTypographyClassName = js_utils_className_getTypographyClassName.getTypographyClassName;
-exports.fontColorClass = js_utils_className_fontColorClass.fontColorClass;
-exports.resolveColorWithVariants = js_utils_className_resolveColorWithVariants.resolveColorWithVariants;
+export { handleBasicClasses } from './handleBasicClasses.js';
+export { getBasicClass } from './getBasicClass.js';
+export { getRootClassName } from './getRootClassName.js';
+export { getTypographyClassName } from './getTypographyClassName.js';
+export { fontColorClass } from './fontColorClass.js';
+export { resolveColorWithVariants } from './resolveColorWithVariants.js';
+import 'classnames';
+import '@lumx/core/js/utils/collection/isEmpty';
+import '../string/kebabCase.js';
+import '../../constants/index.js';
+import '../../constants/keycodes.js';

package/js/utils/className/resolveColorWithVariants.js

@@ -1,13 +1,8 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
 /** Resolve color & color variant from a `ColorWithVariants` and optionally a `ColorVariant`. */
 function resolveColorWithVariants(colorWithVariants, colorVariant) {
-    if (!colorWithVariants)
-        return [undefined, colorVariant];
-    const [color, baseColorVariant] = colorWithVariants.split('-');
-    return [color, (colorVariant || baseColorVariant)];
+  if (!colorWithVariants) return [undefined, colorVariant];
+  const [color, baseColorVariant] = colorWithVariants.split('-');
+  return [color, colorVariant || baseColorVariant];
 }
 
-exports.resolveColorWithVariants = resolveColorWithVariants;
+export { resolveColorWithVariants };

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

@@ -1,30 +1,28 @@
-'use strict';
+import { resolveColorWithVariants } from './resolveColorWithVariants.js';
 
-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']);
-    });
+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/collection/castArray.js

@@ -0,0 +1,4 @@
+/** 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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,3 @@
+/** 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

@@ -0,0 +1,13 @@
+/** 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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,11 @@
+/** 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

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