@buoy-gg/shared-ui 7.0.33 → 7.0.35

package/lib/commonjs/hooks/index.js

@@ -21,12 +21,30 @@ Object.defineProperty(exports, "logDeviceInfo", {
     return _useDeviceInfo.logDeviceInfo;
   }
 });
+Object.defineProperty(exports, "resetPersistedStateCache", {
+  enumerable: true,
+  get: function () {
+    return _usePersistedState.resetPersistedStateCache;
+  }
+});
+Object.defineProperty(exports, "useChangeLog", {
+  enumerable: true,
+  get: function () {
+    return _useChangeLog.useChangeLog;
+  }
+});
 Object.defineProperty(exports, "useDeviceInfo", {
   enumerable: true,
   get: function () {
     return _useDeviceInfo.useDeviceInfo;
   }
 });
+Object.defineProperty(exports, "useEventStoreEvents", {
+  enumerable: true,
+  get: function () {
+    return _useEventStoreEvents.useEventStoreEvents;
+  }
+});
 Object.defineProperty(exports, "useFilterManager", {
   enumerable: true,
   get: function () {
@@ -45,7 +63,15 @@ Object.defineProperty(exports, "useSafeAreaInsets", {
     return _useSafeAreaInsets.useSafeAreaInsets;
   }
 });
+Object.defineProperty(exports, "useSubscribedValue", {
+  enumerable: true,
+  get: function () {
+    return _useChangeLog.useSubscribedValue;
+  }
+});
 var _useFilterManager = require("./useFilterManager.js");
 var _usePersistedState = require("./usePersistedState.js");
+var _useChangeLog = require("./useChangeLog.js");
+var _useEventStoreEvents = require("./useEventStoreEvents.js");
 var _useSafeAreaInsets = require("./useSafeAreaInsets.js");
 var _useDeviceInfo = require("./useDeviceInfo.js");

package/lib/commonjs/hooks/safe-area-impl.js

@@ -7,7 +7,7 @@ exports.useNativeSafeAreaInsets = exports.safeAreaType = exports.hasSafeAreaPack
 /**
  * Auto-generated safe area implementation
  * Detected: none
- * Generated at: 2026-09-02T23:25:39.783Z
+ * Generated at: 2026-09-04T23:36:20.710Z
  *
  * DO NOT EDIT - This file is generated by scripts/detect-safe-area.js
  *

package/lib/commonjs/hooks/useChangeLog.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useChangeLog = useChangeLog;
+exports.useSubscribedValue = useSubscribedValue;
+var _react = require("react");
+/**
+ * React bindings for `ChangeLog` — what useReduxActions, useZustandStateChanges
+ * and useJotaiAtomChanges each re-derived: seed state from the log, subscribe
+ * for the lifetime of the component, hold a filter, memoize the filtered
+ * list, and expose clear / pause / lookup.
+ *
+ * Tool-specific stats and registries (stores, atoms) compose on top — see
+ * `useSubscribedValue` for the registry half.
+ */
+
+function useChangeLog(log, options = {}) {
+  const [items, setItems] = (0, _react.useState)(() => log.getAll());
+  const [filter, setFilter] = (0, _react.useState)(() => options.initialFilter ?? {});
+  const [isEnabled, setIsEnabled] = (0, _react.useState)(() => log.getEnabled());
+  (0, _react.useEffect)(() => log.subscribe(setItems), [log]);
+  const filterItems = options.filterItems;
+  const filteredItems = (0, _react.useMemo)(() => filterItems ? filterItems(items, filter) : items, [items, filter, filterItems]);
+  const clear = (0, _react.useCallback)(() => {
+    log.clear();
+  }, [log]);
+  const toggleCapture = (0, _react.useCallback)(() => {
+    const next = !isEnabled;
+    log.setEnabled(next);
+    setIsEnabled(next);
+  }, [log, isEnabled]);
+  const getById = (0, _react.useCallback)(id => log.getById(id), [log]);
+  return {
+    items,
+    filteredItems,
+    filter,
+    setFilter,
+    isEnabled,
+    toggleCapture,
+    clear,
+    getById
+  };
+}
+
+/**
+ * Hold a value that a store pushes through a `(value) => void` listener —
+ * a registry of stores, atoms, sources. Seeded synchronously from `read`.
+ */
+function useSubscribedValue(read, subscribe) {
+  const [value, setValue] = (0, _react.useState)(read);
+  (0, _react.useEffect)(() => subscribe(setValue), [subscribe]);
+  return value;
+}

package/lib/commonjs/hooks/useEventStoreEvents.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useEventStoreEvents = useEventStoreEvents;
+var _react = require("react");
+/**
+ * React bindings for a `BaseEventStore` — what useRouteEvents and
+ * useStorageEvents each hand-rolled: subscribe while enabled (which
+ * auto-starts the store's capture), coalesce bursts onto one animation
+ * frame so a storm of writes is one commit instead of one per emission,
+ * select/limit the list, and report whether capture is live.
+ */
+
+function useEventStoreEvents(store, options = {}) {
+  const {
+    enabled = true,
+    maxEvents = 500,
+    select
+  } = options;
+  const [events, setEvents] = (0, _react.useState)([]);
+  // Tracked locally so it updates reactively with the subscription.
+  const [isActive, setIsActive] = (0, _react.useState)(enabled);
+  (0, _react.useEffect)(() => {
+    if (!enabled) {
+      setIsActive(false);
+      return;
+    }
+
+    // Frame-coalesced: bursts land as ONE commit per frame instead of one
+    // per emission — the dominant live-churn cost measured on the network
+    // tool (tool-bench 2026-07-06).
+    let rafId = null;
+    let pending = null;
+    const unsubscribe = store.subscribeToEvents(all => {
+      pending = all;
+      if (rafId != null) return;
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        if (!pending) return;
+        let next = pending;
+        pending = null;
+        if (select) next = select(next);
+        if (next.length > maxEvents) next = next.slice(0, maxEvents);
+        setEvents(next);
+      });
+    });
+    setIsActive(true);
+    return () => {
+      unsubscribe();
+      if (rafId != null) cancelAnimationFrame(rafId);
+      // Not setting isActive=false here: a dependency change re-subscribes
+      // immediately, and that is not "stopped".
+    };
+  }, [store, enabled, maxEvents, select]);
+  const clearEvents = (0, _react.useCallback)(() => {
+    store.clearEvents();
+  }, [store]);
+  return {
+    events,
+    clearEvents,
+    isActive
+  };
+}

package/lib/commonjs/hooks/usePersistedState.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.resetPersistedStateCache = resetPersistedStateCache;
 exports.usePersistedState = usePersistedState;
 var _react = require("react");
 var _persistentStorage = require("../utils/persistentStorage.js");
@@ -13,25 +14,43 @@ var _persistentStorage = require("../utils/persistentStorage.js");
  */
 const hydratedCache = new Map();
 
+/** The two calls a backend needs. `persistentStorage` and AsyncStorage both fit. */
+
+function defaultParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * `useState` persisted through `persistentStorage` (FileSystem → AsyncStorage
  * → memory). Replaces the load-then-`hasLoaded`-guard `useEffect` pattern
  * every tool used to hand-roll.
  *
- * Values are JSON-serialized; the default is returned until hydration
- * completes (subsequent mounts of the same key hydrate synchronously from an
- * in-memory cache). The third tuple element reports hydration so callers can
- * defer writes that must not clobber a not-yet-loaded value.
+ * Values are JSON-serialized by default; the default is returned until
+ * hydration completes (subsequent mounts of the same key hydrate synchronously
+ * from an in-memory cache). The third tuple element reports hydration so
+ * callers can defer writes that must not clobber a not-yet-loaded value.
  *
  * ```tsx
  * const [tab, setTab, tabHydrated] = usePersistedState("@react_buoy_custom_flags_tab", "flags");
+ *
+ * // A Set, stored as an array:
+ * const [pins, setPins] = usePersistedState(key, new Set<string>(), {
+ *   parse: (raw) => new Set(JSON.parse(raw) as string[]),
+ *   serialize: (set) => JSON.stringify([...set]),
+ * });
  * ```
  */
-function usePersistedState(key, defaultValue) {
+function usePersistedState(key, defaultValue, options = {}) {
   const [value, setValue] = (0, _react.useState)(() => hydratedCache.has(key) ? hydratedCache.get(key) : defaultValue);
   const [hydrated, setHydrated] = (0, _react.useState)(() => hydratedCache.has(key));
   const keyRef = (0, _react.useRef)(key);
   keyRef.current = key;
+  const optionsRef = (0, _react.useRef)(options);
+  optionsRef.current = options;
   (0, _react.useEffect)(() => {
     if (hydratedCache.has(key)) {
       setValue(hydratedCache.get(key));
@@ -39,17 +58,22 @@ function usePersistedState(key, defaultValue) {
       return;
     }
     let cancelled = false;
-    _persistentStorage.persistentStorage.getItem(key).then(raw => {
+    const storage = optionsRef.current.storage ?? _persistentStorage.persistentStorage;
+    const parse = optionsRef.current.parse ?? defaultParse;
+    storage.getItem(key).then(raw => {
       if (cancelled) return;
       if (raw != null) {
+        let parsed;
         try {
-          const parsed = JSON.parse(raw);
-          hydratedCache.set(key, parsed);
-          setValue(parsed);
+          parsed = parse(raw);
         } catch {
           // Corrupt payload — fall back to the default and let the next
           // write repair it.
         }
+        if (parsed !== undefined) {
+          hydratedCache.set(key, parsed);
+          setValue(parsed);
+        }
       }
       setHydrated(true);
     }).catch(() => {
@@ -63,9 +87,20 @@ function usePersistedState(key, defaultValue) {
     setValue(prev => {
       const resolved = typeof next === "function" ? next(prev) : next;
       hydratedCache.set(keyRef.current, resolved);
-      _persistentStorage.persistentStorage.setItem(keyRef.current, JSON.stringify(resolved)).catch(() => {});
+      const storage = optionsRef.current.storage ?? _persistentStorage.persistentStorage;
+      const serialize = optionsRef.current.serialize ?? JSON.stringify;
+      try {
+        storage.setItem(keyRef.current, serialize(resolved)).catch(() => {});
+      } catch {
+        // Unserializable value — keep it in memory, skip the write.
+      }
       return resolved;
     });
   }, []);
   return [value, set, hydrated];
+}
+
+/** Test seam: forget every hydrated value. */
+function resetPersistedStateCache() {
+  hydratedCache.clear();
 }