entangle-ui 0.9.0 → 0.10.0

package/dist/esm/hooks/useListboxNav/useListboxNav.js

@@ -1,5 +1,6 @@
 "use client";
-import { useState, useRef, useEffect, useCallback } from 'react';
+import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
+import { useEventCallback } from '../useEventCallback/useEventCallback.js';
 
 /**
  * Shared keyboard navigation for listbox-like surfaces (Select, MultiSelect,
@@ -28,7 +29,6 @@ function useListboxNav(options) {
     const itemsRef = useRef(items);
     const isItemDisabledRef = useRef(isItemDisabled);
     const onSelectRef = useRef(onSelect);
-    const onEscapeRef = useRef(onEscape);
     const loopRef = useRef(loop);
     useEffect(() => {
         itemsRef.current = items;
@@ -39,9 +39,6 @@ function useListboxNav(options) {
     useEffect(() => {
         onSelectRef.current = onSelect;
     }, [onSelect]);
-    useEffect(() => {
-        onEscapeRef.current = onEscape;
-    }, [onEscape]);
     useEffect(() => {
         loopRef.current = loop;
     }, [loop]);
@@ -68,6 +65,20 @@ function useListboxNav(options) {
         }
         return out;
     }, []);
+    // Reactive navigable-index list for the returned value. Derived from the
+    // live props rather than the latest-refs above, which exist only for reads
+    // inside the event-time keyboard handlers.
+    const navigableIndices = useMemo(() => {
+        if (!isItemDisabled)
+            return items.map((_, i) => i);
+        const out = [];
+        for (let i = 0; i < items.length; i += 1) {
+            const item = items[i];
+            if (!isItemDisabled(item, i))
+                out.push(i);
+        }
+        return out;
+    }, [items, isItemDisabled]);
     const move = useCallback((direction) => {
         const navigable = getNavigableIndices();
         if (navigable.length === 0) {
@@ -131,6 +142,16 @@ function useListboxNav(options) {
             return current;
         });
     }, []);
+    // Escape handling via useEventCallback: stable identity (so handleKeyDown
+    // does not churn when callers pass an inline onEscape) while always seeing
+    // the latest onEscape and reporting whether it actually handled the key.
+    const handleEscape = useEventCallback((event) => {
+        if (!onEscape)
+            return false;
+        event.preventDefault();
+        onEscape();
+        return true;
+    });
     const handleKeyDown = useCallback((event) => {
         switch (event.key) {
             case 'ArrowDown':
@@ -154,16 +175,11 @@ function useListboxNav(options) {
                 selectActive();
                 return true;
             case 'Escape':
-                if (onEscapeRef.current) {
-                    event.preventDefault();
-                    onEscapeRef.current();
-                    return true;
-                }
-                return false;
+                return handleEscape(event);
             default:
                 return false;
         }
-    }, [next, prev, first, last, selectActive]);
+    }, [next, prev, first, last, selectActive, handleEscape]);
     return {
         activeIndex,
         setActiveIndex,
@@ -173,7 +189,7 @@ function useListboxNav(options) {
         last,
         selectActive,
         handleKeyDown,
-        navigableIndices: getNavigableIndices(),
+        navigableIndices,
     };
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"useListboxNav.js","sources":["../../../../../src/hooks/useListboxNav/useListboxNav.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AA8DA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;;;AAgBJ;AACA;AACA;AACA;AACA;;AAGE;AACF;;AAEE;AACF;;AAEE;AACF;;AAEE;AACF;;AAEE;AACF;;AAGA;;AAEE;;AACA;;AAEE;;;AAIJ;AACE;AACA;AACA;AAAe;;AAEf;AACE;AACA;AAAwB;;AAE1B;;AAGF;AAEI;AACA;AACE;;;;;;AAOE;AACE;AACF;;;;AAG4B;AAC1B;AACA;;;AAGI;;AAEJ;;;;;AAKA;AACA;;AAEI;;;AAGJ;;;AAGN;AACF;AAIF;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AAEA;AACE;AACA;;;AAE6C;AAC3C;AACA;AAA+B;;AAE/B;AACF;;AAGF;AAEI;AACE;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;AACE;;;AAGE;;AAEF;AACF;AACE;;AAEN;;;;;;;;;;;;AAeJ;;"}
+{"version":3,"file":"useListboxNav.js","sources":["../../../../../src/hooks/useListboxNav/useListboxNav.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiEA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;;;AAgBJ;AACA;AACA;AACA;;AAGE;AACF;;AAEE;AACF;;AAEE;AACF;;AAEE;AACF;;AAGA;;AAEE;;AACA;;AAEE;;;AAIJ;AACE;AACA;AACA;AAAe;;AAEf;AACE;AACA;AAAwB;;AAE1B;;;;;AAMF;AACE;AAAqB;;AAErB;AACE;AACA;AAA8B;;AAEhC;AACF;AAEA;AAEI;AACA;AACE;;;;;;AAOE;AACE;AACF;;;;AAG4B;AAC1B;AACA;;;AAGI;;AAEJ;;;;;AAKA;AACA;;AAEI;;;AAGJ;;;AAGN;AACF;AAIF;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AAEA;AACE;AACA;;;AAE6C;AAC3C;AACA;AAA+B;;AAE/B;AACF;;;;;AAMF;AAEI;AAAe;;AAEf;AACA;AACF;AAGF;AAEI;AACE;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;AACE;AACF;AACE;;AAEN;;;;;;;;;;;;AAeJ;;"}

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

@@ -31,6 +31,8 @@ function useMediaQuery(query, options = {}) {
             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);
@@ -41,9 +43,13 @@ function useMediaQuery(query, options = {}) {
                 mql.removeEventListener('change', handler);
             };
         }
-        // Legacy Safari fallback.
+        // 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]);

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

@@ -1 +1 @@
-{"version":3,"file":"useMediaQuery.js","sources":["../../../../../src/hooks/useMediaQuery/useMediaQuery.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;AAGI;AAEA;;;AAGJ;AAEA;;;;;;;;;;;;;AAaG;;AAKD;AAEA;;;AAOI;;;;AAMF;AAEA;AACE;AACF;AAEA;AACE;AACA;AACE;AACF;;;AAIF;AACA;AACE;AACF;AACF;AAEA;AACF;;"}
+{"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

@@ -1,5 +1,6 @@
 "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
@@ -21,8 +22,9 @@ import { useRef, useMemo, useEffect } from 'react';
  */
 function useThrottledCallback(fn, delay, options = {}) {
     const { leading = true, trailing = true } = options;
-    const fnRef = useRef(fn);
-    fnRef.current = fn;
+    // 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);
@@ -32,9 +34,12 @@ function useThrottledCallback(fn, delay, options = {}) {
             const args = lastArgsRef.current;
             lastArgsRef.current = null;
             if (args)
-                fnRef.current(...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".
@@ -66,7 +71,7 @@ function useThrottledCallback(fn, delay, options = {}) {
             lastCallRef.current = 0;
         };
         return wrapper;
-    }, [delay, leading, trailing]);
+    }, [delay, leading, trailing, stableFn]);
     useEffect(() => () => {
         if (timerRef.current !== null)
             clearTimeout(timerRef.current);

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

@@ -1 +1 @@
-{"version":3,"file":"useThrottledCallback.js","sources":["../../../../../src/hooks/useThrottledCallback/useThrottledCallback.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA;;;;;;;;;;;;;;;;;AAiBG;AACG;;AAOJ;AACA;AAEA;AACA;AACA;AAEA;AACE;AACE;AACA;AACA;AACA;AAAU;AACZ;AAEA;AACE;;;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;;"}
+{"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

@@ -52,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';
@@ -60,12 +67,15 @@ export { MATERIAL_PALETTE } from './components/controls/ColorPicker/palettes/mat
 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';
@@ -80,10 +90,9 @@ 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';
@@ -106,6 +115,12 @@ 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';
@@ -115,6 +130,8 @@ 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';
@@ -123,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';
@@ -140,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';
@@ -176,6 +211,7 @@ 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';
@@ -235,6 +271,9 @@ 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';
@@ -248,8 +287,22 @@ export { useThrottledCallback } from './hooks/useThrottledCallback/useThrottledC
 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,37 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __classPrivateFieldGet, __classPrivateFieldSet };
+//# sourceMappingURL=tslib.es6.js.map