entangle-ui 0.8.2 → 0.10.0

package/dist/esm/hooks/useMediaQuery/useMediaQuery.js

@@ -0,0 +1,60 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function getInitialMatch(query, fallback) {
+    if (typeof window === 'undefined' ||
+        typeof window.matchMedia !== 'function') {
+        return fallback;
+    }
+    return window.matchMedia(query).matches;
+}
+/**
+ * Reactive media query matching.
+ *
+ * Returns `true` when the current viewport matches the query and updates as
+ * the viewport changes. SSR-safe — returns `defaultMatches` when `matchMedia`
+ * is unavailable. Uses the modern `addEventListener('change')` API with a
+ * fallback to the legacy `addListener` for older browsers.
+ *
+ * @example
+ * ```tsx
+ * const isWide = useMediaQuery('(min-width: 768px)');
+ * return isWide ? <DesktopLayout /> : <MobileLayout />;
+ * ```
+ */
+function useMediaQuery(query, options = {}) {
+    const { defaultMatches = false } = options;
+    const [matches, setMatches] = useState(() => getInitialMatch(query, defaultMatches));
+    useEffect(() => {
+        if (typeof window === 'undefined' ||
+            typeof window.matchMedia !== 'function') {
+            return;
+        }
+        const mql = window.matchMedia(query);
+        // External-system sync: seed state from matchMedia on mount/query change.
+        // eslint-disable-next-line react-hooks/set-state-in-effect
+        setMatches(mql.matches);
+        const handler = (event) => {
+            setMatches(event.matches);
+        };
+        if (typeof mql.addEventListener === 'function') {
+            mql.addEventListener('change', handler);
+            return () => {
+                mql.removeEventListener('change', handler);
+            };
+        }
+        // Legacy Safari fallback, reached only when the modern addEventListener
+        // API above is unavailable. addListener/removeListener are deprecated but
+        // remain the only option on those older engines.
+        // eslint-disable-next-line @typescript-eslint/no-deprecated
+        mql.addListener(handler);
+        return () => {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            mql.removeListener(handler);
+        };
+    }, [query]);
+    return matches;
+}
+
+export { useMediaQuery };
+//# sourceMappingURL=useMediaQuery.js.map

package/dist/esm/hooks/useMediaQuery/useMediaQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaQuery.js","sources":["../../../../../src/hooks/useMediaQuery/useMediaQuery.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;AAGI;AAEA;;;AAGJ;AAEA;;;;;;;;;;;;;AAaG;;AAKD;AAEA;;;AAOI;;;;;;AAQF;AAEA;AACE;AACF;AAEA;AACE;AACA;AACE;AACF;;;;;;AAOF;AACA;;AAEE;AACF;AACF;AAEA;AACF;;"}

package/dist/esm/hooks/useMergedRef/useMergedRef.js

@@ -20,7 +20,8 @@ import { useCallback } from 'react';
  */
 function useMergedRef(...refs) {
     // The spread of refs is intentional — the merged callback must pick up the
-    // latest set of refs the consumer is passing in.
+    // latest set of refs the consumer is passing in, so the dependency list is
+    // dynamic by design (use-memo / exhaustive-deps cannot model that).
     return useCallback((node) => {
         for (const ref of refs) {
             if (!ref)
@@ -29,9 +30,13 @@ function useMergedRef(...refs) {
                 ref(node);
             }
             else {
+                // Assigning a node into an object ref's `.current` is the entire point
+                // of a callback ref; it is not a forbidden mutation of hook arguments.
+                // eslint-disable-next-line react-hooks/immutability
                 ref.current = node;
             }
         }
+        // eslint-disable-next-line react-hooks/exhaustive-deps, react-hooks/use-memo
     }, refs);
 }
 

package/dist/esm/hooks/useMergedRef/useMergedRef.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMergedRef.js","sources":["../../../../../src/hooks/useMergedRef/useMergedRef.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACG;;;AAKJ;AACE;AACE;;AACA;;;;AAGG;;;;AAIT;;"}
+{"version":3,"file":"useMergedRef.js","sources":["../../../../../src/hooks/useMergedRef/useMergedRef.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;AAgBG;AACG;;;;AAMJ;AACE;AACE;;AACA;;;;;;;AAMG;;;;;AAKT;;"}

package/dist/esm/hooks/useNavigationHistory/useNavigationHistory.js

@@ -0,0 +1,146 @@
+"use client";
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../node_modules/tslib/tslib.es6.js';
+import { useState, useSyncExternalStore, useCallback, useMemo } from 'react';
+
+var _NavigationHistoryStore_instances, _NavigationHistoryStore_stack, _NavigationHistoryStore_index, _NavigationHistoryStore_listeners, _NavigationHistoryStore_notify;
+/**
+ * Per-instance back/forward stack. Lives outside React so reads are stable
+ * across concurrent renders and so non-React handlers can mutate without
+ * scheduling extra renders for unrelated consumers.
+ */
+class NavigationHistoryStore {
+    constructor(initial) {
+        _NavigationHistoryStore_instances.add(this);
+        _NavigationHistoryStore_stack.set(this, void 0);
+        _NavigationHistoryStore_index.set(this, void 0);
+        _NavigationHistoryStore_listeners.set(this, new Set());
+        this.subscribe = (listener) => {
+            __classPrivateFieldGet(this, _NavigationHistoryStore_listeners, "f").add(listener);
+            return () => {
+                __classPrivateFieldGet(this, _NavigationHistoryStore_listeners, "f").delete(listener);
+            };
+        };
+        this.getCurrent = () => __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f")];
+        this.getCanGoBack = () => __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") > 0;
+        this.getCanGoForward = () => __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") < __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").length - 1;
+        if (initial !== undefined) {
+            __classPrivateFieldSet(this, _NavigationHistoryStore_stack, [initial], "f");
+            __classPrivateFieldSet(this, _NavigationHistoryStore_index, 0, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _NavigationHistoryStore_stack, [], "f");
+            __classPrivateFieldSet(this, _NavigationHistoryStore_index, -1, "f");
+        }
+    }
+    push(entry) {
+        if (__classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f")] === entry)
+            return;
+        const next = __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").slice(0, __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") + 1);
+        next.push(entry);
+        __classPrivateFieldSet(this, _NavigationHistoryStore_stack, next, "f");
+        __classPrivateFieldSet(this, _NavigationHistoryStore_index, next.length - 1, "f");
+        __classPrivateFieldGet(this, _NavigationHistoryStore_instances, "m", _NavigationHistoryStore_notify).call(this);
+    }
+    goBack() {
+        if (__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") <= 0)
+            return undefined;
+        __classPrivateFieldSet(this, _NavigationHistoryStore_index, __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") - 1, "f");
+        __classPrivateFieldGet(this, _NavigationHistoryStore_instances, "m", _NavigationHistoryStore_notify).call(this);
+        return __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f")];
+    }
+    goForward() {
+        if (__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") >= __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").length - 1)
+            return undefined;
+        __classPrivateFieldSet(this, _NavigationHistoryStore_index, __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") + 1, "f");
+        __classPrivateFieldGet(this, _NavigationHistoryStore_instances, "m", _NavigationHistoryStore_notify).call(this);
+        return __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[__classPrivateFieldGet(this, _NavigationHistoryStore_index, "f")];
+    }
+    reset(entry) {
+        if (entry !== undefined) {
+            if (__classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").length === 1 &&
+                __classPrivateFieldGet(this, _NavigationHistoryStore_index, "f") === 0 &&
+                __classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f")[0] === entry) {
+                return;
+            }
+            __classPrivateFieldSet(this, _NavigationHistoryStore_stack, [entry], "f");
+            __classPrivateFieldSet(this, _NavigationHistoryStore_index, 0, "f");
+        }
+        else {
+            if (__classPrivateFieldGet(this, _NavigationHistoryStore_stack, "f").length === 0)
+                return;
+            __classPrivateFieldSet(this, _NavigationHistoryStore_stack, [], "f");
+            __classPrivateFieldSet(this, _NavigationHistoryStore_index, -1, "f");
+        }
+        __classPrivateFieldGet(this, _NavigationHistoryStore_instances, "m", _NavigationHistoryStore_notify).call(this);
+    }
+}
+_NavigationHistoryStore_stack = new WeakMap(), _NavigationHistoryStore_index = new WeakMap(), _NavigationHistoryStore_listeners = new WeakMap(), _NavigationHistoryStore_instances = new WeakSet(), _NavigationHistoryStore_notify = function _NavigationHistoryStore_notify() {
+    __classPrivateFieldGet(this, _NavigationHistoryStore_listeners, "f").forEach(l => {
+        l();
+    });
+};
+/**
+ * Back/forward history primitive. Tracks a stack of entries (`T`) with a
+ * cursor, mirrors browser semantics (pushing truncates the forward branch),
+ * and exposes the current entry plus `canGoBack` / `canGoForward` flags via
+ * `useSyncExternalStore`.
+ *
+ * Useful any time a UI needs Back/Forward controls over a finite navigation
+ * — folder browsers, wizard steps, drill-down inspectors. Generic over the
+ * entry type, so it works with ids, paths, route objects, anything stable.
+ *
+ * @example
+ * ```tsx
+ * const nav = useNavigationHistory<string>({ initial: 'root' });
+ *
+ * <Toolbar>
+ *   <IconButton aria-label="Back" disabled={!nav.canGoBack} onClick={nav.goBack}>
+ *     <ChevronLeftIcon />
+ *   </IconButton>
+ *   <IconButton aria-label="Forward" disabled={!nav.canGoForward} onClick={nav.goForward}>
+ *     <ChevronRightIcon />
+ *   </IconButton>
+ * </Toolbar>
+ * ```
+ */
+function useNavigationHistory(options = {}) {
+    const { initial, enabled = true } = options;
+    // Lazy init via useState — the initial value is captured once on mount.
+    // Subsequent changes to `initial` are ignored (use `reset()` to re-seed).
+    const [store] = useState(() => new NavigationHistoryStore(initial));
+    const current = useSyncExternalStore(store.subscribe, store.getCurrent);
+    const canGoBackRaw = useSyncExternalStore(store.subscribe, store.getCanGoBack);
+    const canGoForwardRaw = useSyncExternalStore(store.subscribe, store.getCanGoForward);
+    const canGoBack = enabled && canGoBackRaw;
+    const canGoForward = enabled && canGoForwardRaw;
+    const push = useCallback((entry) => {
+        if (!enabled)
+            return;
+        store.push(entry);
+    }, [store, enabled]);
+    const goBack = useCallback(() => {
+        if (!enabled)
+            return undefined;
+        return store.goBack();
+    }, [store, enabled]);
+    const goForward = useCallback(() => {
+        if (!enabled)
+            return undefined;
+        return store.goForward();
+    }, [store, enabled]);
+    const reset = useCallback((entry) => {
+        store.reset(entry);
+    }, [store]);
+    return useMemo(() => ({
+        current,
+        canGoBack,
+        canGoForward,
+        push,
+        goBack,
+        goForward,
+        reset,
+    }), [current, canGoBack, canGoForward, push, goBack, goForward, reset]);
+}
+
+export { useNavigationHistory };
+//# sourceMappingURL=useNavigationHistory.js.map

package/dist/esm/hooks/useNavigationHistory/useNavigationHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNavigationHistory.js","sources":["../../../../../src/hooks/useNavigationHistory/useNavigationHistory.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AASA;;;;AAIG;AACH;AAKE;;;;;AAUA;AACE;AACA;AACE;AACF;AACF;AAEA;;AAEA;AAlBE;AACE;AACA;;;AAEA;AACA;;;AAqBJ;;;AAEE;AACA;AACA;;AAEA;;;AAIA;AAAsB;;AAEtB;;;;;AAK2C;;AAE3C;;;AAIF;AACE;AACE;;;;;AAOA;AACA;;;AAEA;;AACA;AACA;;AAEF;;AAEH;;AA9CG;AACE;AACF;AACF;AA6CF;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG;;;;AAOJ;AAEA;AACA;AAIA;AAKA;AACA;AAEA;AAEI;;AACA;AACF;AAIF;AACE;AAAc;AACd;AACF;AAEA;AACE;AAAc;AACd;AACF;AAEA;AAEI;AACF;AAIF;;;;;;;;AASG;AAGL;;"}

package/dist/esm/hooks/useResizeObserver/useResizeObserver.js

@@ -1,12 +1,13 @@
 "use client";
 import { useRef, useEffect } from 'react';
+import { useEventCallback } from '../useEventCallback/useEventCallback.js';
 
 /**
  * Observe size changes on an element. SSR-safe; cleans up on unmount.
  *
- * The callback is wrapped in a ref so consumers do not have to memoize it —
- * the underlying observer never re-subscribes when the callback identity
- * changes.
+ * The callback is wrapped with `useEventCallback` so consumers do not have
+ * to memoize it — the underlying observer never re-subscribes when the
+ * callback identity changes.
  *
  * The hook re-checks `ref.current` on every render so it picks up nodes that
  * mount later (e.g. through conditional rendering). When the observed node
@@ -24,12 +25,9 @@ import { useRef, useEffect } from 'react';
  */
 function useResizeObserver(ref, callback, options) {
     const { enabled = true } = options ?? {};
-    const callbackRef = useRef(callback);
+    const handleEntry = useEventCallback(callback);
     const observerRef = useRef(null);
     const observedNodeRef = useRef(null);
-    useEffect(() => {
-        callbackRef.current = callback;
-    }, [callback]);
     // Runs on every render so a node that mounts after the first render
     // (conditional rendering, lazy children, suspense fallback flips, ...) is
     // picked up automatically. Short-circuits on the common case where the
@@ -57,7 +55,7 @@ function useResizeObserver(ref, callback, options) {
             return;
         const observer = new ResizeObserver(entries => {
             for (const entry of entries) {
-                callbackRef.current(entry);
+                handleEntry(entry);
             }
         });
         observer.observe(node);

package/dist/esm/hooks/useResizeObserver/useResizeObserver.js.map

@@ -1 +1 @@
-{"version":3,"file":"useResizeObserver.js","sources":["../../../../../src/hooks/useResizeObserver/useResizeObserver.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;;;;;;;;AAoBG;;;AAQD;AACA;AACA;;AAGE;AACF;;;;;;;;;AAUI;AACE;AACA;AACA;;;;AAKJ;AACA;;AAEA;AACE;AACA;;AAEF;AACA;;AAEA;AACE;AACE;;AAEJ;AACA;AACA;AACF;;AAGA;AAEI;AACA;AACA;;AAIN;;"}
+{"version":3,"file":"useResizeObserver.js","sources":["../../../../../src/hooks/useResizeObserver/useResizeObserver.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;AAoBG;;;AAQD;AACA;AACA;;;;;;;;;AAUI;AACE;AACA;AACA;;;;AAKJ;AACA;;AAEA;AACE;AACA;;AAEF;AACA;;AAEA;AACE;;;AAGF;AACA;AACA;AACF;;AAGA;AAEI;AACA;AACA;;AAIN;;"}

package/dist/esm/hooks/useTheme/useTheme.js

@@ -4,10 +4,10 @@ import { vars } from '../../theme/contract.css.js';
 import { darkThemeValues } from '../../theme/darkThemeValues.js';
 import { lightThemeClass } from '../../theme/lightTheme.css.js';
 import '../../node_modules/@vanilla-extract/css/dist/vanilla-extract-css.esm.js';
-import './../../assets/src/theme/darkTheme.css.ts.vanilla-ab1WD4dr.css';
+import './../../assets/src/theme/darkTheme.css.ts.vanilla-BHZ3ecRn.css';
 import 'react/jsx-runtime';
-import './../../assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
 import '../../utils/devWarn.js';
+import './../../assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
 
 const VAR_REF_PATTERN = /^var\((--[^,)]+)/;
 /**
@@ -162,6 +162,9 @@ function useTheme() {
             values: resolveValues(darkThemeValues, root, vars),
         };
         tokenCacheRef.current.clear();
+        // External-system sync: read resolved CSS custom properties from the DOM
+        // into state once mounted (they are unavailable during SSR/first render).
+        // eslint-disable-next-line react-hooks/set-state-in-effect
         setSnapshot(next);
     }, []);
     const getToken = useCallback((path) => {

package/dist/esm/hooks/useTheme/useTheme.js.map

@@ -1 +1 @@
-{"version":3,"file":"useTheme.js","sources":["../../../../../src/hooks/useTheme/useTheme.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;AAUA;AAEA;;;;;;;;;;AAUG;AACH;;;AAGE;;;;AAMI;;;AAEA;;;;AAG0B;;AAE9B;AACF;AAEA;AACE;;AAEF;AAEA;;;;;AAKG;AACH;AACE;AACE;;AAEE;;AAEE;AACA;;;AAGJ;;;;;AAKE;AACA;AAGA;;AAEF;;AAEF;AACF;AAEA;;;AAGE;;;;AAMI;;;AAEA;;;AAGJ;AACF;AAEA;;;;;;;AAOG;AACH;;AACuC;;AAGnC;;AAEF;AACF;AAOA;AACE;AACA;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;;;;;;;AAOC;AACA;;;;AAIA;;;AAIF;AACE;;;AAE0B;AAE1B;;AAEE;AACA;;AAGF;;AAEE;AACA;;AAGF;;AAEG;;AAEH;AACA;;AAGF;AAEA;;;;;;AASF;;"}
+{"version":3,"file":"useTheme.js","sources":["../../../../../src/hooks/useTheme/useTheme.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;AAYA;AAEA;;;;;;;;;;AAUG;AACH;;;AAGE;;;;AAMI;;;AAEA;;;;AAG0B;;AAE9B;AACF;AAEA;AACE;;AAEF;AAEA;;;;;AAKG;AACH;AACE;AACE;;AAEE;;AAEE;AACA;;;AAGJ;;;;;AAKE;AACA;AAGA;;AAEF;;AAEF;AACF;AAEA;;;AAGE;;;;AAMI;;;AAEA;;;AAGJ;AACF;AAEA;;;;;;;AAOG;AACH;;AACuC;;AAGnC;;AAEF;AACF;AAOA;AACE;AACA;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;;;;;;;AAOC;AACA;;;;AAIA;;;;;;AAOF;AACE;;;AAE0B;AAE1B;;AAEE;AACA;;AAGF;;AAEE;AACA;;AAGF;;AAEG;;AAEH;AACA;;AAGF;AAEA;;;;;;AASF;;"}

package/dist/esm/hooks/useThrottledCallback/useThrottledCallback.js

@@ -0,0 +1,83 @@
+"use client";
+import { useRef, useMemo, useEffect } from 'react';
+import { useEventCallback } from '../useEventCallback/useEventCallback.js';
+
+/**
+ * Wrap a function so it fires at most once per `delay` ms. With both
+ * `leading` and `trailing` enabled (the default), the first call fires
+ * immediately and the most recent call inside the window fires at its
+ * end. Set `leading: false` to defer the first call; set
+ * `trailing: false` to drop calls inside the window.
+ *
+ * Typical use: drag handlers, scroll listeners, resize observers — places
+ * where the input rate exceeds the work rate and you want to bound the
+ * latter.
+ *
+ * The wrapper identity is stable across renders.
+ *
+ * @example
+ * ```tsx
+ * const onPointerMove = useThrottledCallback(updateGuide, 16);
+ * ```
+ */
+function useThrottledCallback(fn, delay, options = {}) {
+    const { leading = true, trailing = true } = options;
+    // Stable wrapper that always invokes the current callback, refreshed via
+    // useInsertionEffect so the throttled wrapper never goes stale.
+    const stableFn = useEventCallback(fn);
+    const lastCallRef = useRef(0);
+    const timerRef = useRef(null);
+    const lastArgsRef = useRef(null);
+    const throttled = useMemo(() => {
+        const invoke = (now) => {
+            lastCallRef.current = now;
+            const args = lastArgsRef.current;
+            lastArgsRef.current = null;
+            if (args)
+                stableFn(...args);
+        };
+        const wrapper = (...args) => {
+            // Date.now() runs only when the wrapper is invoked from an event/timer,
+            // never during render, so it is not a render-purity concern here.
+            // eslint-disable-next-line react-hooks/purity
+            const now = Date.now();
+            if (lastCallRef.current === 0 && !leading) {
+                // Skip the leading fire by anchoring the window to "now".
+                lastCallRef.current = now;
+            }
+            const elapsed = now - lastCallRef.current;
+            lastArgsRef.current = args;
+            if (elapsed >= delay) {
+                if (timerRef.current !== null) {
+                    clearTimeout(timerRef.current);
+                    timerRef.current = null;
+                }
+                invoke(now);
+                return;
+            }
+            if (trailing && timerRef.current === null) {
+                timerRef.current = setTimeout(() => {
+                    timerRef.current = null;
+                    invoke(Date.now());
+                }, delay - elapsed);
+            }
+        };
+        wrapper.cancel = () => {
+            if (timerRef.current !== null) {
+                clearTimeout(timerRef.current);
+                timerRef.current = null;
+            }
+            lastArgsRef.current = null;
+            lastCallRef.current = 0;
+        };
+        return wrapper;
+    }, [delay, leading, trailing, stableFn]);
+    useEffect(() => () => {
+        if (timerRef.current !== null)
+            clearTimeout(timerRef.current);
+    }, []);
+    return throttled;
+}
+
+export { useThrottledCallback };
+//# sourceMappingURL=useThrottledCallback.js.map

package/dist/esm/hooks/useThrottledCallback/useThrottledCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useThrottledCallback.js","sources":["../../../../../src/hooks/useThrottledCallback/useThrottledCallback.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;AASJ;AAEA;AACA;AACA;AAEA;AACE;AACE;AACA;AACA;AACA;AAAU;AACZ;AAEA;;;;AAIE;;;AAGE;;AAGF;AACA;AAEA;AACE;AACE;AACA;;;;;;AAOF;AACE;AACA;AACF;;AAEJ;AAEA;AACE;AACE;AACA;;AAEF;AACA;AACF;AAEA;;AAGF;AAEI;AAA+B;;AAKnC;AACF;;"}

package/dist/esm/index.js

@@ -7,10 +7,12 @@ export { createLightTheme } from './theme/createLightTheme.js';
 export { VanillaThemeProvider } from './theme/VanillaThemeProvider.js';
 export { ThemeProvider } from './theme/ThemeProvider.js';
 import './assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
+export { BREAKPOINT_ORDER, breakpoints } from './theme/breakpoints.js';
 export { Accordion } from './components/layout/Accordion/Accordion.js';
 export { AccordionItem } from './components/layout/Accordion/AccordionItem.js';
 export { AccordionTrigger } from './components/layout/Accordion/AccordionTrigger.js';
 export { AccordionContent } from './components/layout/Accordion/AccordionContent.js';
+export { Card } from './components/layout/Card/Card.js';
 export { Divider } from './components/layout/Divider/Divider.js';
 export { Flex } from './components/layout/Flex/Flex.js';
 export { Grid } from './components/layout/Grid/Grid.js';
@@ -30,6 +32,7 @@ export { Checkbox } from './components/primitives/Checkbox/Checkbox.js';
 export { CheckboxGroup } from './components/primitives/Checkbox/CheckboxGroup.js';
 export { Code } from './components/primitives/Code/Code.js';
 export { Collapsible } from './components/primitives/Collapsible/Collapsible.js';
+export { HoverCard } from './components/primitives/HoverCard/HoverCard.js';
 export { Icon } from './components/primitives/Icon/Icon.js';
 export { IconButton } from './components/primitives/IconButton/IconButton.js';
 export { Input } from './components/primitives/Input/Input.js';
@@ -49,6 +52,13 @@ export { Tooltip } from './components/primitives/Tooltip/Tooltip.js';
 export { VisuallyHidden } from './components/primitives/VisuallyHidden/VisuallyHidden.js';
 import 'react';
 import './components/primitives/canvas/CanvasContainer.js';
+export { Viewport } from './components/primitives/viewport/Viewport.js';
+export { ViewportLayer } from './components/primitives/viewport/ViewportLayer.js';
+export { ViewportWorld } from './components/primitives/viewport/ViewportWorld.js';
+export { ViewportOverlay } from './components/primitives/viewport/ViewportOverlay.js';
+export { useViewportContext } from './components/primitives/viewport/ViewportContext.js';
+export { getViewportPointerPosition, screenToWorld, worldToScreen } from './components/primitives/viewport/viewportCoords.js';
+export { computeCenterTransform, computeFitTransform, computeZoomTowardPivot, normalizeRect } from './components/primitives/viewport/viewportMath.js';
 export { ColorPicker } from './components/controls/ColorPicker/ColorPicker.js';
 export { ColorSwatch } from './components/controls/ColorPicker/ColorSwatch.js';
 export { EyeDropper } from './components/controls/ColorPicker/EyeDropper.js';
@@ -56,12 +66,19 @@ export { ColorPalette } from './components/controls/ColorPicker/ColorPalette.js'
 export { MATERIAL_PALETTE } from './components/controls/ColorPicker/palettes/material.js';
 export { TAILWIND_PALETTE } from './components/controls/ColorPicker/palettes/tailwind.js';
 export { EARTH_PALETTE, MONOCHROME_PALETTE, NEON_PALETTE, PASTEL_PALETTE, PROFESSIONAL_PALETTES, SKIN_TONES_PALETTE, VINTAGE_PALETTE } from './components/controls/ColorPicker/palettes/professional.js';
+export { Combobox } from './components/controls/Combobox/Combobox.js';
+export { FileTree } from './components/controls/FileTree/FileTree.js';
+export { classifyExtension, getFileExtension, getFileIconKind } from './components/controls/FileTree/fileTreeIcons.js';
+export { DEFAULT_FILE_TREE_LABELS } from './components/controls/FileTree/fileTreeLabels.js';
+export { FileUploader } from './components/controls/FileUploader/FileUploader.js';
+export { MultiSelect } from './components/controls/MultiSelect/MultiSelect.js';
 export { NumberInput } from './components/controls/NumberInput/NumberInput.js';
 export { KeyboardContextProvider, useEffectsOnKeyboard, useKeyboardContext } from './context/KeyboardContext.js';
-import './utils/mathExpression.js';
 import './utils/devWarn.js';
+import './utils/mathExpression.js';
 export { Select } from './components/controls/Select/Select.js';
 export { Slider } from './components/controls/Slider/Slider.js';
+export { TagInput } from './components/controls/TagInput/TagInput.js';
 export { VectorInput } from './components/controls/VectorInput/VectorInput.js';
 export { TreeView } from './components/controls/TreeView/TreeView.js';
 export { CurveEditor } from './components/controls/CurveEditor/CurveEditor.js';
@@ -73,15 +90,16 @@ export { BreadcrumbItem } from './components/navigation/Breadcrumbs/BreadcrumbIt
 export { BreadcrumbSeparator } from './components/navigation/Breadcrumbs/BreadcrumbSeparator.js';
 export { BreadcrumbEllipsis } from './components/navigation/Breadcrumbs/BreadcrumbEllipsis.js';
 export { ContextMenu } from './components/navigation/ContextMenu/ContextMenu.js';
-export { useContextMenuTarget } from './components/navigation/ContextMenu/useContextMenuTarget.js';
 export { Menu } from './components/navigation/Menu/Menu.js';
-export { useMenu } from './components/navigation/Menu/useMenu.js';
+export { Pagination } from './components/navigation/Pagination/Pagination.js';
+export { PathBar } from './components/navigation/PathBar/PathBar.js';
 export { SegmentedControl } from './components/navigation/SegmentedControl/SegmentedControl.js';
 export { SegmentedControlItem } from './components/navigation/SegmentedControl/SegmentedControlItem.js';
 export { Tabs } from './components/navigation/Tabs/Tabs.js';
 export { TabList } from './components/navigation/Tabs/TabList.js';
 export { Tab } from './components/navigation/Tabs/Tab.js';
 export { TabPanel } from './components/navigation/Tabs/TabPanel.js';
+export { DataTable } from './components/data/DataTable/DataTable.js';
 export { FormLabel } from './components/form/FormLabel.js';
 export { FormHelperText } from './components/form/FormHelperText.js';
 export { InputWrapper } from './components/form/InputWrapper.js';
@@ -94,14 +112,26 @@ export { DialogHeader } from './components/feedback/Dialog/DialogHeader.js';
 export { DialogBody } from './components/feedback/Dialog/DialogBody.js';
 export { DialogFooter } from './components/feedback/Dialog/DialogFooter.js';
 export { DialogClose } from './components/feedback/Dialog/DialogClose.js';
+export { CommandPalette } from './components/feedback/CommandPalette/CommandPalette.js';
+export { Drawer } from './components/feedback/Drawer/Drawer.js';
 export { EmptyState } from './components/feedback/EmptyState/EmptyState.js';
+export { LogView } from './components/feedback/LogView/LogView.js';
+export { LogViewBody } from './components/feedback/LogView/LogViewBody.js';
+export { LogViewClear, LogViewCopy, LogViewFooter, LogViewLevelFilter, LogViewSearch, LogViewToolbar } from './components/feedback/LogView/LogViewParts.js';
+export { useLogViewStats } from './components/feedback/LogView/LogViewContext.js';
+export { DEFAULT_LOG_VIEW_LABELS } from './components/feedback/LogView/logViewLabels.js';
+export { defaultFormatTimestamp, entriesToText, entryToText, getHighlightSegments } from './components/feedback/LogView/logViewUtils.js';
 export { ProgressBar } from './components/feedback/ProgressBar/ProgressBar.js';
 export { CircularProgress } from './components/feedback/ProgressBar/CircularProgress.js';
 export { Skeleton } from './components/feedback/Skeleton/Skeleton.js';
 export { SkeletonGroup } from './components/feedback/Skeleton/SkeletonGroup.js';
+export { SkeletonLayout } from './components/feedback/Skeleton/SkeletonLayout.js';
 export { Spinner } from './components/feedback/Spinner/Spinner.js';
+export { Stat } from './components/feedback/Stat/Stat.js';
 export { ToastProvider } from './components/feedback/Toast/ToastProvider.js';
 export { useToast } from './components/feedback/Toast/useToast.js';
+export { AssetBrowser } from './components/editor/AssetBrowser/AssetBrowser.js';
+export { DEFAULT_ASSET_BROWSER_LABELS } from './components/editor/AssetBrowser/assetBrowserLabels.js';
 export { PropertyPanel } from './components/editor/PropertyInspector/PropertyPanel.js';
 export { PropertySection } from './components/editor/PropertyInspector/PropertySection.js';
 export { PropertyRow } from './components/editor/PropertyInspector/PropertyRow.js';
@@ -110,6 +140,23 @@ export { usePropertyUndo } from './components/editor/PropertyInspector/useProper
 export { ViewportGizmo } from './components/editor/ViewportGizmo/ViewportGizmo.js';
 export { axisToPresetView, eulerToRotationMatrix, gizmoHitTest, presetViewToOrientation, projectAxes, projectToCanvas, quaternionToEuler } from './components/editor/ViewportGizmo/gizmoMath.js';
 export { TransformControl } from './components/editor/TransformControl/TransformControl.js';
+export { Minimap } from './components/editor/Minimap/index.js';
+export { NodeGraph } from './components/editor/NodeGraph/NodeGraph.js';
+import 'react/jsx-runtime';
+export { ViewportMinimap } from './components/editor/Minimap/ViewportMinimap.js';
+export { cx as cn, cx } from './utils/cx.js';
+import './components/editor/NodeGraph/NodeGraph.css.js';
+export { useNodeGraphData, useNodeGraphHover, useNodeGraphInteraction, useNodeGraphSelection, useNodeGraphStore } from './components/editor/NodeGraph/NodeGraphContext.js';
+export { NodeGraphBackground, NodeGraphMinimap } from './components/editor/NodeGraph/NodeGraphSlots.js';
+export { NodeGraphPort } from './components/editor/NodeGraph/NodeGraphPort.js';
+export { NodeGraphPortVisual } from './components/editor/NodeGraph/NodeGraphPortVisual.js';
+export { NodeGraphPin } from './components/editor/NodeGraph/NodeGraphPin.js';
+export { NodeGraphNodeSection } from './components/editor/NodeGraph/NodeGraphNodeSection.js';
+export { useNodeGraph } from './components/editor/NodeGraph/useNodeGraph.js';
+export { createTypeMatchValidator } from './components/editor/NodeGraph/createTypeMatchValidator.js';
+export { duplicateNodes, edgesConnectedToPort } from './components/editor/NodeGraph/nodeGraphActions.js';
+export { generateEdgeId, generateNodeId } from './components/editor/NodeGraph/nodeGraphIds.js';
+export { NODE_GRAPH_SLOT } from './components/editor/NodeGraph/NodeGraph.types.js';
 export { ChatPanel } from './components/editor/ChatPanel/ChatPanel.js';
 export { ChatMessageList } from './components/editor/ChatPanel/ChatMessageList.js';
 export { ChatMessage } from './components/editor/ChatPanel/ChatMessage.js';
@@ -127,6 +174,7 @@ export { ChatMarkdownRenderer } from './components/editor/ChatPanel/ChatMarkdown
 export { useChatMessages } from './components/editor/ChatPanel/useChatMessages.js';
 export { useChatInput } from './components/editor/ChatPanel/useChatInput.js';
 export { useChatScroll } from './components/editor/ChatPanel/useChatScroll.js';
+export { Timeline } from './components/editor/Timeline/index.js';
 export { AppShell, useAppShell } from './components/shell/AppShell/AppShell.js';
 export { FloatingManager, FloatingPanel } from './components/shell/FloatingPanel/FloatingPanel.js';
 export { MenuBar } from './components/shell/MenuBar/MenuBar.js';
@@ -145,22 +193,27 @@ export { ChevronDownIcon } from './components/Icons/ChevronDownIcon.js';
 export { ChevronUpIcon } from './components/Icons/ChevronUpIcon.js';
 export { ClockIcon } from './components/Icons/ClockIcon.js';
 export { CloseIcon } from './components/Icons/CloseIcon.js';
+export { CloudUploadIcon } from './components/Icons/CloudUploadIcon.js';
 export { CodeIcon } from './components/Icons/CodeIcon.js';
 export { CopyIcon } from './components/Icons/CopyIcon.js';
 export { CutIcon } from './components/Icons/CutIcon.js';
 export { DownloadIcon } from './components/Icons/DownloadIcon.js';
 export { EditIcon } from './components/Icons/EditIcon.js';
 export { ErrorIcon } from './components/Icons/ErrorIcon.js';
+export { ExternalLinkIcon } from './components/Icons/ExternalLinkIcon.js';
 export { EyeDropperIcon } from './components/Icons/EyeDropperIcon.js';
 export { EyeIcon } from './components/Icons/EyeIcon.js';
 export { FilterIcon } from './components/Icons/FilterIcon.js';
+export { FirstIcon } from './components/Icons/FirstIcon.js';
 export { FolderIcon } from './components/Icons/FolderIcon.js';
 export { FullscreenIcon } from './components/Icons/FullscreenIcon.js';
 export { GridIcon } from './components/Icons/GridIcon.js';
 export { HeartIcon } from './components/Icons/HeartIcon.js';
 export { HelpIcon } from './components/Icons/HelpIcon.js';
 export { HomeIcon } from './components/Icons/HomeIcon.js';
+export { ImageIcon } from './components/Icons/ImageIcon.js';
 export { InfoIcon } from './components/Icons/InfoIcon.js';
+export { LastIcon } from './components/Icons/LastIcon.js';
 export { LinkIcon } from './components/Icons/LinkIcon.js';
 export { ListIcon } from './components/Icons/ListIcon.js';
 export { LockIcon } from './components/Icons/LockIcon.js';
@@ -181,6 +234,7 @@ export { SuccessIcon } from './components/Icons/SuccessIcon.js';
 export { TagIcon } from './components/Icons/TagIcon.js';
 export { TrashIcon } from './components/Icons/TrashIcon.js';
 export { UndoIcon } from './components/Icons/UndoIcon.js';
+export { UnlinkIcon } from './components/Icons/UnlinkIcon.js';
 export { UnlockIcon } from './components/Icons/UnlockIcon.js';
 export { UploadIcon } from './components/Icons/UploadIcon.js';
 export { UserIcon } from './components/Icons/UserIcon.js';
@@ -217,14 +271,38 @@ export { useKeyboard } from './hooks/useKeyboard/useKeyboard.js';
 export { useControlledState } from './hooks/useControlledState/useControlledState.js';
 export { useFocusTrap } from './hooks/useFocusTrap/useFocusTrap.js';
 export { useMergedRef } from './hooks/useMergedRef/useMergedRef.js';
+export { useLatest } from './hooks/useLatest/useLatest.js';
+export { useEventCallback } from './hooks/useEventCallback/useEventCallback.js';
+export { useIsMounted } from './hooks/useIsMounted/useIsMounted.js';
 export { useResizeObserver } from './hooks/useResizeObserver/useResizeObserver.js';
 export { useDisclosure } from './hooks/useDisclosure/useDisclosure.js';
 export { useClipboard } from './hooks/useClipboard/useClipboard.js';
 export { useClickOutside } from './hooks/useClickOutside/useClickOutside.js';
 export { useHotkey } from './hooks/useHotkey/useHotkey.js';
+export { useMediaQuery } from './hooks/useMediaQuery/useMediaQuery.js';
+export { useBreakpoint } from './hooks/useBreakpoint/useBreakpoint.js';
+export { useDebouncedValue } from './hooks/useDebounced/useDebouncedValue.js';
+export { useDebouncedCallback } from './hooks/useDebounced/useDebouncedCallback.js';
+export { useThrottledCallback } from './hooks/useThrottledCallback/useThrottledCallback.js';
+export { useIntersectionObserver } from './hooks/useIntersectionObserver/useIntersectionObserver.js';
+export { useListboxNav } from './hooks/useListboxNav/useListboxNav.js';
 export { useTheme } from './hooks/useTheme/useTheme.js';
-export { cx as cn, cx } from './utils/cx.js';
+import './hooks/useNavigationHistory/useNavigationHistory.js';
 export { getKeyGlyph, getPlatform, parseShortcut } from './utils/platform.js';
 export { animBlink, animFadeIn, animPulse, animSpin, animWave, blinkKeyframe, fadeInKeyframe, pulseKeyframe, spinKeyframe, waveKeyframe } from './utils/animations.css.js';
+export { MINIMAP_SLOT } from './components/editor/Minimap/Minimap.types.js';
+export { MinimapCorner } from './components/editor/Minimap/MinimapCorner.js';
+export { MinimapFooter } from './components/editor/Minimap/MinimapFooter.js';
+export { MinimapTitle } from './components/editor/Minimap/MinimapTitle.js';
+export { TIMELINE_SLOT } from './components/editor/Timeline/Timeline.types.js';
+export { TimelineFooter } from './components/editor/Timeline/TimelineFooter.js';
+export { TimelineMinimap } from './components/editor/Timeline/TimelineMinimap.js';
+export { TimelineToolbar } from './components/editor/Timeline/TimelineToolbar.js';
+export { TimelineTrackScale } from './components/editor/Timeline/TimelineTrackScale.js';
+export { computeBoundsFromItems } from './components/editor/Minimap/computeBoundsFromItems.js';
+export { framesToTimecode } from './components/editor/Timeline/timelineCoords.js';
 export { isKeyPressed, isModifierKey } from './hooks/useKeyboard/utils.js';
+export { selectedTangentMode, setSelectedTangentMode } from './components/editor/Timeline/timelineEdits.js';
+export { useMinimapContext, useMinimapDragState, useMinimapGeometry, useMinimapHover } from './components/editor/Minimap/MinimapContext.js';
+export { useTimelineContext, useTimelineGeometry, useTimelinePlayhead, useTimelineSelectedTangentMode, useTimelineSelection } from './components/editor/Timeline/TimelineContext.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}