@cube-dev/ui-kit 0.8.5 → 0.9.0

package/dist/es/utils/dotize.js

@@ -0,0 +1,191 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+/* eslint-disable */
+// @ts-nocheck
+// Convert complex js object to dot notation js object
+// url: https://github.com/vardars/dotize
+// author: vardars
+export const dotize = {
+    valTypes: {
+        none: 'NONE',
+        primitive: 'PRIM',
+        object: 'OBJECT',
+        array: 'ARRAY',
+    },
+    getValType: function (val) {
+        if (!val || typeof val != 'object' || Array.isArray(val))
+            return dotize.valTypes.primitive;
+        if (typeof val == 'object')
+            return dotize.valTypes.object;
+    },
+    getPathType: function (arrPath) {
+        let arrPathTypes = [];
+        for (let path in arrPath) {
+            let pathVal = arrPath[path];
+            if (!pathVal)
+                arrPathTypes.push(dotize.valTypes.none);
+            else if (dotize.isNumber(pathVal))
+                arrPathTypes.push(dotize.valTypes.array);
+            else
+                arrPathTypes.push(dotize.valTypes.object);
+        }
+        return arrPathTypes;
+    },
+    isUndefined: function (obj) {
+        return typeof obj == 'undefined';
+    },
+    isNumber: function (f) {
+        return !isNaN(parseInt(f));
+    },
+    isEmptyObj: function (obj) {
+        for (let prop in obj) {
+            if (Object.hasOwnProperty.call(obj, prop))
+                return false;
+        }
+        return JSON.stringify(obj) === JSON.stringify({});
+    },
+    isNotObject: function (obj) {
+        return !obj || typeof obj != 'object';
+    },
+    isEmptyArray: function (arr) {
+        return Array.isArray(arr) && arr.length == 0;
+    },
+    isNotArray: function (arr) {
+        return Array.isArray(arr) == false;
+    },
+    removeEmptyArrayItem: function (arr) {
+        return arr.filter(function (el) {
+            return el != null && el != '';
+        });
+    },
+    getFieldName: function (field, prefix, isRoot, isArrayItem, isArray) {
+        if (isArray)
+            return ((prefix ? prefix : '') +
+                (dotize.isNumber(field)
+                    ? '[' + field + ']'
+                    : (isRoot && !prefix ? '' : '.') + field));
+        else if (isArrayItem)
+            return (prefix ? prefix : '') + '[' + field + ']';
+        else
+            return (prefix ? prefix + '.' : '') + field;
+    },
+    startsWith: function (val, valToSearch) {
+        return val.indexOf(valToSearch) == 0;
+    },
+    convert: function (obj, prefix = '') {
+        let newObj = {};
+        // primitives
+        if (dotize.isNotObject(obj)) {
+            if (prefix) {
+                newObj[prefix] = obj;
+                return newObj;
+            }
+            else {
+                return obj;
+            }
+        }
+        return (function recurse(o, p, isRoot) {
+            let isArrayItem = Array.isArray(o);
+            for (let f in o) {
+                let currentProp = o[f];
+                if (currentProp &&
+                    typeof currentProp === 'object' &&
+                    !Array.isArray(currentProp)) {
+                    if (isArrayItem && dotize.isEmptyObj(currentProp) == false) {
+                        newObj = recurse(currentProp, dotize.getFieldName(f, p, isRoot, true)); // array item object
+                    }
+                    else if (dotize.isEmptyObj(currentProp) == false) {
+                        newObj = recurse(currentProp, dotize.getFieldName(f, p, isRoot)); // object
+                    }
+                    else if (dotize.isEmptyObj(currentProp)) {
+                        newObj[dotize.getFieldName(f, p, isRoot, isArrayItem)] =
+                            currentProp;
+                    }
+                }
+                else {
+                    if (isArrayItem || dotize.isNumber(f)) {
+                        newObj[dotize.getFieldName(f, p, isRoot, true)] = currentProp; // array item primitive
+                    }
+                    else {
+                        newObj[dotize.getFieldName(f, p, isRoot)] = currentProp; // primitive
+                    }
+                }
+            }
+            return newObj;
+        })(obj, prefix, true);
+    },
+    backward: function (obj, prefix) {
+        let newObj = {};
+        let arStartRegex = /\[(\d+)\]/g;
+        // primitives
+        if (dotize.isNotObject(obj) && dotize.isNotArray(obj)) {
+            if (prefix) {
+                return obj[prefix];
+            }
+            else {
+                return obj;
+            }
+        }
+        for (let tProp in obj) {
+            let tPropVal = obj[tProp];
+            if (prefix) {
+                let prefixRegex = new RegExp('^' + prefix);
+                tProp = tProp.replace(prefixRegex, '');
+            }
+            tProp = tProp.replace(arStartRegex, '.$1');
+            if (dotize.startsWith(tProp, '.'))
+                tProp = tProp.replace(/^\./, '');
+            var arrPath = tProp.split('.');
+            var arrPathTypes = dotize.getPathType(arrPath);
+            // has array on root
+            if (!dotize.isUndefined(arrPathTypes) &&
+                arrPathTypes[0] == dotize.valTypes.array &&
+                Array.isArray(newObj) == false) {
+                newObj = [];
+            }
+            (function recurse(rPropVal, rObj, rPropValPrev, rObjPrev) {
+                let currentPath = arrPath.shift();
+                let currentPathType = arrPathTypes.shift();
+                if (typeof currentPath == 'undefined' || currentPath == '') {
+                    newObj = rPropVal;
+                    return;
+                }
+                let isArray = currentPathType == dotize.valTypes.array;
+                if (dotize.isNumber(currentPath))
+                    currentPath = parseInt(currentPath);
+                // has multiple levels
+                if (arrPath.length > 0) {
+                    // is not assigned before
+                    if (typeof rObj[currentPath] == 'undefined') {
+                        if (isArray) {
+                            rObj[currentPath] = [];
+                        }
+                        else {
+                            rObj[currentPath] = {};
+                        }
+                    }
+                    recurse(rPropVal, rObj[currentPath], currentPath, rObj);
+                    return;
+                }
+                if (currentPathType == dotize.valTypes.array &&
+                    rPropValPrev &&
+                    rObjPrev) {
+                    if (Array.isArray(rObjPrev[rPropValPrev]) == false)
+                        rObjPrev[rPropValPrev] = [];
+                    rObjPrev[rPropValPrev].push(rPropVal);
+                }
+                else {
+                    rObj[currentPath] = rPropVal;
+                }
+            })(tPropVal, newObj);
+        }
+        return newObj;
+    },
+};
+
+        

package/dist/es/utils/escape-string.js

@@ -0,0 +1,18 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+// https://github.com/sindresorhus/escape-string-regexp/blob/main/index.js
+export default function escapeStringRegexp(string) {
+    if (typeof string !== 'string') {
+        throw new TypeError('Expected a string');
+    }
+    // Escape characters with special meaning either inside or outside character sets.
+    // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
+    return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+}
+
+        

package/dist/es/utils/filterBaseProps.js

@@ -0,0 +1,65 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+const DOMPropNames = new Set(['id']);
+const labelablePropNames = new Set([
+    'aria-label',
+    'aria-labelledby',
+    'aria-describedby',
+    'aria-details',
+]);
+const BasePropNames = new Set([
+    'role',
+    'as',
+    'css',
+    'qa',
+    'mods',
+    'qaVal',
+    'hidden',
+    'isHidden',
+    'disabled',
+    'isDisabled',
+    'children',
+    'style',
+    'className',
+    'href',
+    'target',
+]);
+const ignoreEventPropsNames = new Set([
+    'onPress',
+    'onHoverStart',
+    'onHoverEnd',
+    'onPressStart',
+    'onPressEnd',
+]);
+const propRe = /^((data-).*)$/;
+const eventRe = /^on[A-Z].+$/;
+/**
+ * Filters out all props that aren't valid DOM props or defined via override prop obj.
+ * @param props - The component props to be filtered.
+ * @param opts - Props to override.
+ */
+export function filterBaseProps(props, opts = {}) {
+    let { labelable, propNames, eventProps } = opts;
+    let filteredProps = {};
+    for (const prop in props) {
+        if (Object.prototype.hasOwnProperty.call(props, prop)
+            && (DOMPropNames.has(prop)
+                || BasePropNames.has(prop)
+                || (labelable && labelablePropNames.has(prop))
+                || (eventProps
+                    && eventRe.test(prop)
+                    && !ignoreEventPropsNames.has(prop))
+                || propNames?.has(prop)
+                || propRe.test(prop))) {
+            filteredProps[prop] = props[prop];
+        }
+    }
+    return filteredProps;
+}
+
+        

package/dist/es/utils/index.js

@@ -0,0 +1,42 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+function filterCombinations(combinations) {
+    return combinations.filter((combination) => {
+        const list = [];
+        return !combination.find((mod) => {
+            const match = mod.match(/\[(.+?)[=\]]/);
+            if (match) {
+                if (list.includes(match[1])) {
+                    return true;
+                }
+                list.push(match[1]);
+                return false;
+            }
+            return false;
+        });
+    });
+}
+export function getModCombinations(array, allowEmpty) {
+    const result = allowEmpty ? [[]] : [];
+    if (array.length === 0) {
+        return [array];
+    }
+    if (array.length < 2) {
+        return result.concat([array]);
+    }
+    const f = function (prefix = [], array) {
+        for (let i = 0; i < array.length; i++) {
+            result.push([...prefix, array[i]]);
+            f([...prefix, array[i]], array.slice(i + 1));
+        }
+    };
+    f([], array);
+    return filterCombinations(result);
+}
+
+        

package/dist/es/utils/interactions.js

@@ -0,0 +1,25 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+import { useEffect, useState } from 'react';
+import { useFocus as reactAriaUseFocus, useFocusVisible, } from '@react-aria/interactions';
+export function useFocus({ isDisabled }, onlyVisible = false) {
+    useEffect(() => {
+        setIsFocused(false);
+    }, [isDisabled]);
+    let [isFocused, setIsFocused] = useState(false);
+    let { isFocusVisible } = useFocusVisible({});
+    let { focusProps } = reactAriaUseFocus({
+        onFocusChange: setIsFocused,
+    });
+    return {
+        focusProps,
+        isFocused: isFocused && (onlyVisible ? isFocusVisible : true),
+    };
+}
+
+        

package/dist/es/utils/mergeStyles.js

@@ -0,0 +1,32 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+import { isSelector } from './renderStyles';
+export function mergeStyles(...objects) {
+    let styles = objects[0] || {};
+    let pos = 1;
+    while (pos in objects) {
+        const keys = styles ? Object.keys(styles) : [];
+        const newStyles = objects[pos];
+        const resultStyles = { ...styles, ...newStyles };
+        for (let key of keys) {
+            if (isSelector(key)) {
+                resultStyles[key] = {
+                    ...(styles?.[key] ? styles[key] : null),
+                    ...(newStyles?.[key]
+                        ? newStyles[key]
+                        : null),
+                };
+            }
+        }
+        styles = resultStyles;
+        pos++;
+    }
+    return styles;
+}
+
+        

package/dist/es/utils/modules.js

@@ -0,0 +1,12 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+export function extractModule(promise) {
+    return promise.then((module) => module.default || module);
+}
+
+        

package/dist/es/utils/promise.js

@@ -0,0 +1,14 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+export function timeout(ms = 30) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+
+        

package/dist/es/utils/react/Slots.js

@@ -0,0 +1,42 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+import { jsx as _jsx } from "react/jsx-runtime";
+import { mergeProps } from '../../utils/react/mergeProps';
+import { createContext, Children, cloneElement, useContext, useMemo, } from 'react';
+let SlotContext = createContext({});
+export function useSlotProps(props, defaultSlot) {
+    let slot = props.slot || defaultSlot;
+    let allSlots = useContext(SlotContext) || {};
+    let slotProps = allSlots[slot];
+    return mergeProps(slotProps, props);
+}
+export function SlotProvider(props) {
+    let parentSlots = useContext(SlotContext) || {};
+    let { slots = {}, children } = props;
+    // Merge props for each slot from parent context and props
+    let value = useMemo(() => Object.keys(parentSlots)
+        .concat(Object.keys(slots))
+        .reduce((o, p) => ({
+        ...o,
+        [p]: mergeProps(parentSlots[p] || {}, slots[p] || {}),
+    }), {}), [parentSlots, slots]);
+    return _jsx(SlotContext.Provider, { value: value, children: children }, void 0);
+}
+export function ClearSlots(props) {
+    let { children, ...otherProps } = props;
+    let content = children;
+    if (Children.toArray(children).length <= 1) {
+        if (typeof children === 'function') {
+            // need to know if the node is a string or something else that react can render that doesn't get props
+            content = cloneElement(Children.only(children), otherProps);
+        }
+    }
+    return _jsx(SlotContext.Provider, { value: {}, children: content }, void 0);
+}
+
+        

package/dist/es/utils/react/chain.js

@@ -0,0 +1,21 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+/**
+ * Calls all functions in the order they were chained with the same arguments.
+ */
+export function chain(...callbacks) {
+    return (...args) => {
+        for (let callback of callbacks) {
+            if (typeof callback === 'function') {
+                callback(...args);
+            }
+        }
+    };
+}
+
+        

package/dist/{mjs/utils/react/index.d.ts → es/utils/react/index.js}

@@ -1,3 +1,10 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
 export { chain } from './chain';
 export { isTextOnly } from './isTextOnly';
 export { mergeProps } from './mergeProps';
@@ -6,3 +13,5 @@ export { useSlotProps, SlotProvider, ClearSlots } from './Slots';
 export { useLayoutEffect } from './useLayoutEffect';
 export { useCombinedRefs } from './useCombinedRefs';
 export { wrapNodeIfPlain } from './wrapNodeIfPlain';
+
+        

package/dist/es/utils/react/isTextOnly.js

@@ -0,0 +1,13 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+import { Children, isValidElement } from 'react';
+export function isTextOnly(children) {
+    return Children.toArray(children).every((c) => !isValidElement(c));
+}
+
+        

package/dist/es/utils/react/mapProps.js

@@ -0,0 +1,25 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+/** Converts AriaButtonProps to CubeButtonProps */
+export function ariaToCubeButtonProps(props) {
+    const { type, ...filteredProps } = props;
+    return {
+        ...filteredProps,
+        htmlType: type,
+    };
+}
+/** Converts CubeButtonProps to AriaButtonProps */
+export function cubeToAriaButtonProps(props) {
+    const { htmlType, ...filteredProps } = props;
+    return {
+        ...filteredProps,
+        type: htmlType,
+    };
+}
+
+        

package/dist/es/utils/react/mergeProps.js

@@ -0,0 +1,60 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+import clsx from 'clsx';
+import { chain, mergeIds } from '@react-aria/utils';
+/**
+ * Merges multiple props objects together. Event handlers are chained,
+ * classNames are combined, and ids are deduplicated - different ids
+ * will trigger a side-effect and re-render components hooked up with `useId`.
+ * For all other props, the last prop object overrides all previous ones.
+ * @param args - Multiple sets of props to merge together.
+ */
+export function mergeProps(...args) {
+    let result = {};
+    for (let props of args) {
+        for (let key in result) {
+            // Chain events
+            if (/^on[A-Z]/.test(key)
+                && typeof result[key] === 'function'
+                && props
+                && typeof props[key] === 'function') {
+                result[key] = chain(result[key], props[key]);
+                // Merge classnames, sometimes classNames are empty string which eval to false, so we just need to do a type check
+            }
+            else if (key === 'className'
+                && typeof result.className === 'string'
+                && props
+                && typeof props.className === 'string') {
+                result[key] = clsx(result.className, props.className);
+            }
+            else if (key === 'styles'
+                && typeof result.styles === 'object'
+                && props
+                && typeof props.styles === 'object') {
+                result[key] = { ...result.styles, ...props.styles };
+            }
+            else if (key === 'id' && result.id && props?.id) {
+                result.id = mergeIds(result.id, props?.id);
+                // Override others
+            }
+            else {
+                result[key]
+                    = props && props[key] !== undefined ? props[key] : result[key];
+            }
+        }
+        // Add props from b that are not in a
+        for (let key in props) {
+            if (result[key] === undefined) {
+                result[key] = props[key];
+            }
+        }
+    }
+    return result;
+}
+
+        

package/dist/es/utils/react/modAttrs.js

@@ -0,0 +1,22 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+/**
+ * Generate data DOM attributes from modifier map.
+ * @param {Object<string,boolean>} map
+ * @return {Object<string,string>}
+ */
+export function modAttrs(map) {
+    return Object.keys(map).reduce((attrs, key) => {
+        if (map[key]) {
+            attrs[`data-is-${key}`] = '';
+        }
+        return attrs;
+    }, {});
+}
+
+        

package/dist/es/utils/react/nullableValue.js

@@ -0,0 +1,37 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+export function castNullableStringValue(props) {
+    return castNullableField(props, ['value', 'defaultValue'], 'string', (v) => String(v));
+}
+export function castNullableNumberValue(props) {
+    return castNullableField(props, ['value', 'defaultValue'], 'number', (v) => Number(v));
+}
+export function castNullableArrayValue(props) {
+    return castNullableField(props, ['value', 'defaultValue'], 'object', (v) => Array.isArray(v) ? v : []);
+}
+export function castNullableIsSelected(props) {
+    return castNullableField(props, ['isSelected', 'defaultSelected'], 'boolean', (v) => !!v);
+}
+export function castNullableSelectedKey(props) {
+    return castNullableField(props, ['selectedKey', 'defaultSelectedKey']);
+}
+export function castNullableField(props, keys, type, cast) {
+    props = { ...props };
+    keys.forEach((key) => {
+        if (props[key] === null) {
+            props[key] = undefined;
+        }
+        if (type && cast && props[key] != null && typeof props[key] != type) {
+            props[key] = cast(props[key]);
+            console.warn('Wrong value type in', props, 'in keys', JSON.stringify(keys));
+        }
+    });
+    return props;
+}
+
+        

package/dist/es/utils/react/useCombinedRefs.js

@@ -0,0 +1,26 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.0
+ * Released under the MIT license.
+ */
+
+import { useRef, useEffect } from 'react';
+export function useCombinedRefs(...refs) {
+    const targetRef = useRef();
+    useEffect(() => {
+        refs.forEach((ref) => {
+            if (!ref)
+                return;
+            if (typeof ref === 'function') {
+                ref(targetRef.current);
+            }
+            else {
+                ref.current = targetRef.current;
+            }
+        });
+    }, [refs]);
+    return targetRef;
+}
+
+