@cube-dev/ui-kit 0.0.0-canary-f1f3d22 → 0.0.0-canary-22594b2

package/es/_internal/hooks/index.js

@@ -0,0 +1,18 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+export * from './use-deprecation-warning.js';
+export * from './use-event.js';
+export * from './use-sync-ref.js';
+export * from './use-chained-callback.js';
+export * from './use-timer/index.js';
+export * from './use-effect-once.js';
+export * from './use-warn.js';
+export * from './use-is-first-render.js';
+export * from './use-debounced-value.js';
+
+        

package/es/_internal/hooks/use-chained-callback.js

@@ -0,0 +1,19 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useEvent } from './use-event.js';
+export function useChainedCallback(...callbacks) {
+    return useEvent((...args) => {
+        callbacks.forEach((callback) => {
+            if (typeof callback === 'function') {
+                callback(...args);
+            }
+        });
+    });
+}
+
+        

package/es/_internal/hooks/use-debounced-value.js

@@ -0,0 +1,53 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useEffect, useRef, useState } from 'react';
+export function useDebouncedValue(value, delay = 300, maxWait) {
+    const [debouncedValue, setDebouncedValue] = useState(value);
+    const lastValueRef = useRef(value);
+    const timeoutRef = useRef(null);
+    const maxWaitTimeoutRef = useRef(null);
+    useEffect(() => {
+        // If value returns to the original while waiting, clear timeouts
+        if (value === lastValueRef.current) {
+            if (timeoutRef.current)
+                clearTimeout(timeoutRef.current);
+            if (maxWaitTimeoutRef.current)
+                clearTimeout(maxWaitTimeoutRef.current);
+            return;
+        }
+        // Handle delay
+        timeoutRef.current = setTimeout(() => {
+            setDebouncedValue(value);
+            lastValueRef.current = value;
+            if (maxWaitTimeoutRef.current) {
+                clearTimeout(maxWaitTimeoutRef.current);
+                maxWaitTimeoutRef.current = null;
+            }
+        }, delay);
+        // Handle maxWait if provided
+        if (maxWait && !maxWaitTimeoutRef.current) {
+            maxWaitTimeoutRef.current = setTimeout(() => {
+                setDebouncedValue(value);
+                lastValueRef.current = value;
+                if (timeoutRef.current) {
+                    clearTimeout(timeoutRef.current);
+                    timeoutRef.current = null;
+                }
+            }, maxWait);
+        }
+        return () => {
+            if (timeoutRef.current)
+                clearTimeout(timeoutRef.current);
+            if (maxWaitTimeoutRef.current)
+                clearTimeout(maxWaitTimeoutRef.current);
+        };
+    }, [value, delay, maxWait]);
+    return debouncedValue;
+}
+
+        

package/es/_internal/hooks/use-deprecation-warning.js

@@ -0,0 +1,20 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import React, { useEffect } from 'react';
+import { deprecationWarning } from '../../utils/warnings.js';
+export function useDeprecationWarning(...args) {
+    const didWarn = React.useRef(false);
+    useEffect(() => {
+        if (didWarn.current)
+            return;
+        didWarn.current = true;
+        deprecationWarning(...args);
+    }, [args[0]]);
+}
+
+        

package/es/_internal/hooks/use-effect-once.js

@@ -0,0 +1,13 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useEffect } from 'react';
+export function useEffectOnce(effect) {
+    useEffect(effect, []);
+}
+
+        

package/es/_internal/hooks/use-event.js

@@ -0,0 +1,21 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useCallback } from 'react';
+import { useSyncRef } from './use-sync-ref.js';
+/**
+ * useEvent shim from the latest React RFC.
+ *
+ * @see https://github.com/reactjs/rfcs/pull/220
+ * @see https://github.com/reactjs/rfcs/blob/useevent/text/0000-useevent.md#internal-implementation
+ */
+export function useEvent(callback) {
+    const callbackRef = useSyncRef(callback);
+    return useCallback((...args) => callbackRef.current(...args), []);
+}
+
+        

package/es/_internal/hooks/use-is-first-render.js

@@ -0,0 +1,18 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useRef } from 'react';
+export function useIsFirstRender() {
+    const isFirst = useRef(true);
+    if (isFirst.current) {
+        isFirst.current = false;
+        return true;
+    }
+    return isFirst.current;
+}
+
+        

package/es/_internal/hooks/use-sync-ref.js

@@ -0,0 +1,18 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useRef } from 'react';
+import { useLayoutEffect } from '../../utils/react/index.js';
+export function useSyncRef(value) {
+    const ref = useRef(value);
+    useLayoutEffect(() => {
+        ref.current = value;
+    });
+    return ref;
+}
+
+        

package/es/_internal/hooks/use-timer/index.js

@@ -0,0 +1,11 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+export * from './timer.js';
+export * from './use-timer.js';
+
+        

package/es/_internal/hooks/use-timer/timer.js

@@ -0,0 +1,60 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+export class Timer {
+    callback;
+    delay;
+    remaining;
+    timerId = null;
+    startTime = null;
+    _status = 'stopped';
+    get status() {
+        return this._status;
+    }
+    set status(status) {
+        this._status = status;
+    }
+    constructor(callback, delay) {
+        this.callback = callback;
+        this.delay = delay;
+        this.remaining = delay;
+        this.resume();
+    }
+    reset() {
+        this.clear();
+        this.remaining = this.delay;
+        this.status = 'stopped';
+    }
+    pause() {
+        if (this.timerId === null || this.startTime === null) {
+            return;
+        }
+        this.clear();
+        this.remaining -= Date.now() - this.startTime;
+        this.status = 'paused';
+    }
+    resume() {
+        if (this.timerId !== null)
+            return;
+        this.startTime = Date.now();
+        this.clear();
+        this.timerId = setTimeout(() => {
+            this.reset();
+            this.callback();
+        }, this.remaining);
+        this.status = 'running';
+    }
+    clear() {
+        if (this.timerId === null) {
+            return;
+        }
+        clearTimeout(this.timerId);
+        this.timerId = null;
+    }
+}
+
+        

package/es/_internal/hooks/use-timer/use-timer.js

@@ -0,0 +1,45 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useEffect, useState } from 'react';
+import { useEvent } from '../use-event.js';
+import { Timer } from './timer.js';
+export function useTimer(props = {}) {
+    const { callback, delay, isDisabled, timer: propsTimer = null } = props;
+    const callbackEvent = useEvent(() => callback?.());
+    const [timer, setTimer] = useState(() => {
+        if (propsTimer) {
+            return propsTimer;
+        }
+        if (typeof delay === 'number') {
+            return new Timer(callbackEvent, delay);
+        }
+        return null;
+    });
+    if (isDisabled) {
+        timer?.reset();
+    }
+    else {
+        timer?.resume();
+    }
+    useEffect(() => {
+        setTimer(propsTimer);
+        return () => timer?.reset();
+    }, [propsTimer]);
+    useEffect(() => {
+        if (propsTimer)
+            return;
+        if (typeof delay === 'number') {
+            setTimer(new Timer(callbackEvent, delay));
+        }
+        return () => timer?.reset();
+    }, [delay, propsTimer]);
+    useEffect(() => () => timer?.reset(), [timer]);
+    return { timer };
+}
+
+        

package/es/_internal/hooks/use-update-effect.js

@@ -0,0 +1,19 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useEffect } from 'react';
+import { useIsFirstRender } from './use-is-first-render.js';
+export function useUpdateEffect(effect, deps) {
+    const isFirst = useIsFirstRender();
+    useEffect(() => {
+        if (!isFirst) {
+            return effect();
+        }
+    }, deps);
+}
+
+        

package/es/_internal/hooks/use-warn.js

@@ -0,0 +1,39 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { useRef } from 'react';
+import { warn } from '../../utils/warnings.js';
+import { useEvent } from './use-event.js';
+const GLOBAL_WARNED = new Set();
+export function useWarn(condition, params) {
+    const { once = true, key, args } = params;
+    const hasWarnedRef = useRef(false);
+    const execute = useEvent((condition, args) => {
+        if (condition) {
+            warn(...args);
+            return true;
+        }
+        return false;
+    });
+    if (once) {
+        const keyString = JSON.stringify(key);
+        if (GLOBAL_WARNED.has(keyString))
+            return;
+        if (execute(condition, args)) {
+            GLOBAL_WARNED.add(keyString);
+            return;
+        }
+    }
+    if (hasWarnedRef.current)
+        return;
+    if (execute(condition, args)) {
+        hasWarnedRef.current = true;
+        return;
+    }
+}
+
+        

package/es/_internal/index.js

@@ -0,0 +1,10 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+export * from './hooks/index.js';
+
+        

package/es/components/Block.js

@@ -0,0 +1,21 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { CONTAINER_STYLES, extractStyles, filterBaseProps, tasty, } from '../tasty/index.js';
+const BlockElement = tasty({
+    styles: {
+        display: 'block',
+    },
+});
+export const Block = forwardRef(function Block(props, ref) {
+    const styles = extractStyles(props, CONTAINER_STYLES);
+    return (_jsx(BlockElement, { ...filterBaseProps(props, { eventProps: true }), ref: ref, styles: styles }));
+});
+
+        

package/es/components/CollectionItem.js

@@ -0,0 +1,62 @@
+/**
+ * @license MIT
+ * author: Cube Dev Team
+ * @cube-dev/ui-kit v0.0.0-canary-22594b2
+ * Released under the MIT license.
+ */
+
+import { Item } from 'react-stately';
+import { ItemAction } from './actions/ItemAction/index.js';
+import { ItemBadge } from './content/ItemBadge/index.js';
+/**
+ * Service props that are used by react-stately or parent components
+ * and should not be passed to the Item component.
+ */
+const SERVICE_PROPS = new Set([
+    // React Stately props
+    'textValue',
+    'hasChildItems',
+    'childItems',
+    'title',
+    // Custom service props
+    'onAction',
+    'wrapper',
+    'keywords', // CommandMenu-specific
+    'forceMount', // CommandMenu-specific
+]);
+/**
+ * Filters out service props from collection item props, returning only
+ * props that should be passed to the Item component.
+ *
+ * This eliminates the need to manually extract and pass Item props
+ * in components like MenuItem, ListBox Option, and Select Option.
+ *
+ * @param itemProps - The props from a collection item (node.props)
+ * @returns Filtered props safe to spread onto Item component
+ *
+ * @example
+ * ```tsx
+ * const itemProps = filterCollectionItemProps(item.props);
+ * return <Item {...itemProps} />;
+ * ```
+ */
+export function filterCollectionItemProps(itemProps) {
+    if (!itemProps) {
+        return {};
+    }
+    const filtered = {};
+    for (const key in itemProps) {
+        if (Object.prototype.hasOwnProperty.call(itemProps, key) &&
+            !SERVICE_PROPS.has(key)) {
+            filtered[key] = itemProps[key];
+        }
+    }
+    return filtered;
+}
+const _CollectionItem = Object.assign(Item, {
+    Action: ItemAction,
+    Badge: ItemBadge,
+});
+export { _CollectionItem as CollectionItem };
+
+