@cube-dev/ui-kit 0.8.8 → 0.9.2

package/dist/cjs/utils/interactions.js

@@ -0,0 +1,29 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFocus = void 0;
+const react_1 = require("react");
+const interactions_1 = require("@react-aria/interactions");
+function useFocus({ isDisabled }, onlyVisible = false) {
+    (0, react_1.useEffect)(() => {
+        setIsFocused(false);
+    }, [isDisabled]);
+    let [isFocused, setIsFocused] = (0, react_1.useState)(false);
+    let { isFocusVisible } = (0, interactions_1.useFocusVisible)({});
+    let { focusProps } = (0, interactions_1.useFocus)({
+        onFocusChange: setIsFocused,
+    });
+    return {
+        focusProps,
+        isFocused: isFocused && (onlyVisible ? isFocusVisible : true),
+    };
+}
+exports.useFocus = useFocus;
+
+        

package/dist/cjs/utils/mergeStyles.js

@@ -0,0 +1,36 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeStyles = void 0;
+const renderStyles_1 = require("./renderStyles");
+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 ((0, renderStyles_1.isSelector)(key)) {
+                resultStyles[key] = {
+                    ...((styles === null || styles === void 0 ? void 0 : styles[key]) ? styles[key] : null),
+                    ...((newStyles === null || newStyles === void 0 ? void 0 : newStyles[key])
+                        ? newStyles[key]
+                        : null),
+                };
+            }
+        }
+        styles = resultStyles;
+        pos++;
+    }
+    return styles;
+}
+exports.mergeStyles = mergeStyles;
+
+        

package/dist/cjs/utils/modules.js

@@ -0,0 +1,16 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractModule = void 0;
+function extractModule(promise) {
+    return promise.then((module) => module.default || module);
+}
+exports.extractModule = extractModule;
+
+        

package/dist/cjs/utils/promise.js

@@ -0,0 +1,18 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeout = void 0;
+function timeout(ms = 30) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+exports.timeout = timeout;
+
+        

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

@@ -0,0 +1,48 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClearSlots = exports.SlotProvider = exports.useSlotProps = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const mergeProps_1 = require("../../utils/react/mergeProps");
+const react_1 = require("react");
+let SlotContext = (0, react_1.createContext)({});
+function useSlotProps(props, defaultSlot) {
+    let slot = props.slot || defaultSlot;
+    let allSlots = (0, react_1.useContext)(SlotContext) || {};
+    let slotProps = allSlots[slot];
+    return (0, mergeProps_1.mergeProps)(slotProps, props);
+}
+exports.useSlotProps = useSlotProps;
+function SlotProvider(props) {
+    let parentSlots = (0, react_1.useContext)(SlotContext) || {};
+    let { slots = {}, children } = props;
+    // Merge props for each slot from parent context and props
+    let value = (0, react_1.useMemo)(() => Object.keys(parentSlots)
+        .concat(Object.keys(slots))
+        .reduce((o, p) => ({
+        ...o,
+        [p]: (0, mergeProps_1.mergeProps)(parentSlots[p] || {}, slots[p] || {}),
+    }), {}), [parentSlots, slots]);
+    return (0, jsx_runtime_1.jsx)(SlotContext.Provider, { value: value, children: children }, void 0);
+}
+exports.SlotProvider = SlotProvider;
+function ClearSlots(props) {
+    let { children, ...otherProps } = props;
+    let content = children;
+    if (react_1.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 = (0, react_1.cloneElement)(react_1.Children.only(children), otherProps);
+        }
+    }
+    return (0, jsx_runtime_1.jsx)(SlotContext.Provider, { value: {}, children: content }, void 0);
+}
+exports.ClearSlots = ClearSlots;
+
+        

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

@@ -0,0 +1,25 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chain = void 0;
+/**
+ * Calls all functions in the order they were chained with the same arguments.
+ */
+function chain(...callbacks) {
+    return (...args) => {
+        for (let callback of callbacks) {
+            if (typeof callback === 'function') {
+                callback(...args);
+            }
+        }
+    };
+}
+exports.chain = chain;
+
+        

package/dist/cjs/utils/react/index.js

@@ -0,0 +1,30 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapNodeIfPlain = exports.useCombinedRefs = exports.useLayoutEffect = exports.ClearSlots = exports.SlotProvider = exports.useSlotProps = exports.modAttrs = exports.mergeProps = exports.isTextOnly = exports.chain = void 0;
+var chain_1 = require("./chain");
+Object.defineProperty(exports, "chain", { enumerable: true, get: function () { return chain_1.chain; } });
+var isTextOnly_1 = require("./isTextOnly");
+Object.defineProperty(exports, "isTextOnly", { enumerable: true, get: function () { return isTextOnly_1.isTextOnly; } });
+var mergeProps_1 = require("./mergeProps");
+Object.defineProperty(exports, "mergeProps", { enumerable: true, get: function () { return mergeProps_1.mergeProps; } });
+var modAttrs_1 = require("./modAttrs");
+Object.defineProperty(exports, "modAttrs", { enumerable: true, get: function () { return modAttrs_1.modAttrs; } });
+var Slots_1 = require("./Slots");
+Object.defineProperty(exports, "useSlotProps", { enumerable: true, get: function () { return Slots_1.useSlotProps; } });
+Object.defineProperty(exports, "SlotProvider", { enumerable: true, get: function () { return Slots_1.SlotProvider; } });
+Object.defineProperty(exports, "ClearSlots", { enumerable: true, get: function () { return Slots_1.ClearSlots; } });
+var useLayoutEffect_1 = require("./useLayoutEffect");
+Object.defineProperty(exports, "useLayoutEffect", { enumerable: true, get: function () { return useLayoutEffect_1.useLayoutEffect; } });
+var useCombinedRefs_1 = require("./useCombinedRefs");
+Object.defineProperty(exports, "useCombinedRefs", { enumerable: true, get: function () { return useCombinedRefs_1.useCombinedRefs; } });
+var wrapNodeIfPlain_1 = require("./wrapNodeIfPlain");
+Object.defineProperty(exports, "wrapNodeIfPlain", { enumerable: true, get: function () { return wrapNodeIfPlain_1.wrapNodeIfPlain; } });
+
+        

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

@@ -0,0 +1,17 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTextOnly = void 0;
+const react_1 = require("react");
+function isTextOnly(children) {
+    return react_1.Children.toArray(children).every((c) => !(0, react_1.isValidElement)(c));
+}
+exports.isTextOnly = isTextOnly;
+
+        

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

@@ -0,0 +1,30 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cubeToAriaButtonProps = exports.ariaToCubeButtonProps = void 0;
+/** Converts AriaButtonProps to CubeButtonProps */
+function ariaToCubeButtonProps(props) {
+    const { type, ...filteredProps } = props;
+    return {
+        ...filteredProps,
+        htmlType: type,
+    };
+}
+exports.ariaToCubeButtonProps = ariaToCubeButtonProps;
+/** Converts CubeButtonProps to AriaButtonProps */
+function cubeToAriaButtonProps(props) {
+    const { htmlType, ...filteredProps } = props;
+    return {
+        ...filteredProps,
+        type: htmlType,
+    };
+}
+exports.cubeToAriaButtonProps = cubeToAriaButtonProps;
+
+        

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

@@ -0,0 +1,67 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeProps = void 0;
+const clsx_1 = __importDefault(require("clsx"));
+const utils_1 = require("@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.
+ */
+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] = (0, utils_1.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] = (0, clsx_1.default)(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 === null || props === void 0 ? void 0 : props.id)) {
+                result.id = (0, utils_1.mergeIds)(result.id, props === null || props === void 0 ? void 0 : 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;
+}
+exports.mergeProps = mergeProps;
+
+        

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

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

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

@@ -0,0 +1,46 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castNullableField = exports.castNullableSelectedKey = exports.castNullableIsSelected = exports.castNullableArrayValue = exports.castNullableNumberValue = exports.castNullableStringValue = void 0;
+function castNullableStringValue(props) {
+    return castNullableField(props, ['value', 'defaultValue'], 'string', (v) => String(v));
+}
+exports.castNullableStringValue = castNullableStringValue;
+function castNullableNumberValue(props) {
+    return castNullableField(props, ['value', 'defaultValue'], 'number', (v) => Number(v));
+}
+exports.castNullableNumberValue = castNullableNumberValue;
+function castNullableArrayValue(props) {
+    return castNullableField(props, ['value', 'defaultValue'], 'object', (v) => Array.isArray(v) ? v : []);
+}
+exports.castNullableArrayValue = castNullableArrayValue;
+function castNullableIsSelected(props) {
+    return castNullableField(props, ['isSelected', 'defaultSelected'], 'boolean', (v) => !!v);
+}
+exports.castNullableIsSelected = castNullableIsSelected;
+function castNullableSelectedKey(props) {
+    return castNullableField(props, ['selectedKey', 'defaultSelectedKey']);
+}
+exports.castNullableSelectedKey = castNullableSelectedKey;
+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;
+}
+exports.castNullableField = castNullableField;
+
+        

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

@@ -0,0 +1,30 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCombinedRefs = void 0;
+const react_1 = require("react");
+function useCombinedRefs(...refs) {
+    const targetRef = (0, react_1.useRef)();
+    (0, react_1.useEffect)(() => {
+        refs.forEach((ref) => {
+            if (!ref)
+                return;
+            if (typeof ref === 'function') {
+                ref(targetRef.current);
+            }
+            else {
+                ref.current = targetRef.current;
+            }
+        });
+    }, [refs]);
+    return targetRef;
+}
+exports.useCombinedRefs = useCombinedRefs;
+
+        

package/dist/cjs/utils/react/useId.js

@@ -0,0 +1,87 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSlotId = exports.mergeIds = exports.useId = void 0;
+const react_1 = require("react");
+const useLayoutEffect_1 = require("./useLayoutEffect");
+const ssr_1 = require("@react-aria/ssr");
+let idsUpdaterMap = new Map();
+/**
+ * If a default is not provided, generate an id.
+ * @param defaultId - Default component id.
+ */
+function useId(defaultId) {
+    let isRendering = (0, react_1.useRef)(true);
+    isRendering.current = true;
+    let [value, setValue] = (0, react_1.useState)(defaultId);
+    let nextId = (0, react_1.useRef)(null);
+    // don't memo this, we want it new each render so that the Effects always run
+    let updateValue = (val) => {
+        if (!isRendering.current) {
+            setValue(val);
+        }
+        else {
+            nextId.current = val;
+        }
+    };
+    (0, useLayoutEffect_1.useLayoutEffect)(() => {
+        isRendering.current = false;
+    }, [updateValue]);
+    (0, react_1.useEffect)(() => {
+        let newId = nextId.current;
+        if (newId) {
+            setValue(newId);
+            nextId.current = null;
+        }
+    }, [setValue, updateValue]);
+    let res = (0, ssr_1.useSSRSafeId)(value);
+    idsUpdaterMap.set(res, updateValue);
+    return res;
+}
+exports.useId = useId;
+/**
+ * Merges two ids.
+ * Different ids will trigger a side-effect and re-render components hooked up with `useId`.
+ */
+function mergeIds(idA, idB) {
+    if (idA === idB) {
+        return idA;
+    }
+    let setIdA = idsUpdaterMap.get(idA);
+    if (setIdA) {
+        setIdA(idB);
+        return idB;
+    }
+    let setIdB = idsUpdaterMap.get(idB);
+    if (setIdB) {
+        setIdB(idA);
+        return idA;
+    }
+    return idB;
+}
+exports.mergeIds = mergeIds;
+/**
+ * Used to generate an id, and after render, check if that id is rendered so we know
+ * if we can use it in places such as labelledby.
+ */
+function useSlotId() {
+    let [id, setId] = (0, react_1.useState)(useId());
+    (0, useLayoutEffect_1.useLayoutEffect)(() => {
+        if (id) {
+            let setCurr = idsUpdaterMap.get(id);
+            if (setCurr && !document.getElementById(id)) {
+                setId(null);
+            }
+        }
+    }, [id]);
+    return id;
+}
+exports.useSlotId = useSlotId;
+
+        

package/dist/cjs/utils/react/useLayoutEffect.js

@@ -0,0 +1,36 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLayoutEffect = void 0;
+const React = __importStar(require("react"));
+// During SSR, React emits a warning when calling useLayoutEffect.
+// Since neither useLayoutEffect nor useEffect run on the server,
+// we can suppress this by replace it with a noop on the server.
+exports.useLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : () => { };
+
+        

package/dist/cjs/utils/react/wrapNodeIfPlain.js

@@ -0,0 +1,22 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.9.2
+ * Released under the MIT license.
+ */
+
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapNodeIfPlain = void 0;
+const react_1 = require("react");
+const react_is_1 = require("react-is");
+function wrapNodeIfPlain(children, render) {
+    const childrenIsFragment = children && (Array.isArray(children) || (0, react_is_1.isFragment)(children));
+    if (!children || (!childrenIsFragment && (0, react_1.isValidElement)(children))) {
+        return children;
+    }
+    return render();
+}
+exports.wrapNodeIfPlain = wrapNodeIfPlain;
+
+