@buoy-gg/zustand 2.1.8

package/lib/module/zustand/utils/zustandStateStore.js

@@ -0,0 +1 @@
+"use strict";const STORE_COLORS={counter:"#10B981",auth:"#8B5CF6",user:"#3B82F6",cart:"#EC4899",app:"#6366F1",ui:"#F59E0B",settings:"#14B8A6",theme:"#06B6D4",navigation:"#F97316",form:"#EF4444"};function getStoreColor(e){const t=e.toLowerCase();if(STORE_COLORS[t])return STORE_COLORS[t];for(const[e,s]of Object.entries(STORE_COLORS))if(t.includes(e))return s;const s=137*e.split("").reduce((e,t)=>e+t.charCodeAt(0),0)%360,n=.7*(1-Math.abs(1.2-1)),r=n*(1-Math.abs(s/60%2-1)),a=.6-n/2;let i=0,o=0,h=0;s<60?(i=n,o=r):s<120?(i=r,o=n):s<180?(o=n,h=r):s<240?(o=r,h=n):s<300?(i=r,h=n):(i=n,h=r);const g=e=>Math.round(255*(e+a)).toString(16).padStart(2,"0");return`#${g(i)}${g(o)}${g(h)}`}function formatPartialPreview(e,t=40){if(void 0===e)return"";if(null===e)return"null";try{if("function"==typeof e)return"(updater fn)";if("string"==typeof e)return e.length>t?`"${e.slice(0,t-3)}..."`:`"${e}"`;if("number"==typeof e||"boolean"==typeof e)return String(e);if(Array.isArray(e)){if(0===e.length)return"[]";const s=JSON.stringify(e);return s.length>t?`[${e.length} items]`:s}if("object"==typeof e){const s=Object.keys(e);if(0===s.length)return"{}";const n=JSON.stringify(e);return n.length<=t?n:`{ ${s.length} keys }`}return String(e).slice(0,t)}catch{return"[complex]"}}function getStateDiffSummary(e,t){if(e===t)return{summary:"no change",changedKeys:[],changedCount:0};if("object"!=typeof e||"object"!=typeof t||null===e||null===t)return{summary:"changed",changedKeys:[],changedCount:1};const s=Object.keys(e),n=Object.keys(t),r=n.filter(e=>!s.includes(e)),a=s.filter(e=>!n.includes(e)),i=[];for(const r of s)n.includes(r)&&e[r]!==t[r]&&i.push(r);const o=[...r,...a,...i],h=[];r.length>0&&h.push(`+${r.length}`),a.length>0&&h.push(`-${a.length}`),i.length>0&&h.push(`~${i.length}`);const g=o.length;return 0===h.length?{summary:"nested change",changedKeys:[],changedCount:1}:{summary:`${h.join(" ")} ${1===g?"key":"keys"}`,changedKeys:o,changedCount:g}}class ZustandStateStore{stateChanges=[];stores=new Map;listeners=new Set;storeListeners=new Set;maxChanges=200;idCounter=0;isEnabled=!0;addStateChange(e){if(!this.isEnabled)return;const{storeName:t,partial:s,replace:n,prevState:r,nextState:a,duration:i,category:o,isPersisted:h=!1}=e,g=r!==a,{summary:u,changedKeys:l,changedCount:c}=getStateDiffSummary(r,a),d=formatPartialPreview(s),f=(i??0)>16,C=o??(n?"replace":"setState"),S={id:`${Date.now()}-${++this.idCounter}`,storeName:t,timestamp:Date.now(),prevState:r,nextState:a,partial:s,duration:i,hasStateChange:g,replace:n,category:C,changedKeys:l,changedKeysCount:c,diffSummary:u,partialPreview:d,isSlowUpdate:f,isPersisted:h};this.stateChanges=[S,...this.stateChanges].slice(0,this.maxChanges);const y=this.stores.get(t);y&&y.stateChangeCount++,this.notifyListeners()}getStateChanges(){return[...this.stateChanges]}getStateChangeById(e){return this.stateChanges.find(t=>t.id===e)}clearStateChanges(){this.stateChanges=[];for(const e of this.stores.values())e.stateChangeCount=0;this.notifyListeners()}registerStore(e,t,s){if(this.stores.has(e))return;const n={name:e,api:t,stateChangeCount:0,isPersisted:s?.isPersisted??!1,persistName:s?.persistName,color:getStoreColor(e)};this.stores.set(e,n),this.notifyStoreListeners()}unregisterStore(e){this.stores.delete(e),this.notifyStoreListeners()}getStores(){return Array.from(this.stores.values())}getStore(e){return this.stores.get(e)}getStoreColor(e){return this.stores.get(e)?.color??getStoreColor(e)}filterStateChanges(e){let t=[...this.stateChanges];if(e.searchText){const s=e.searchText.toLowerCase();t=t.filter(e=>e.storeName.toLowerCase().includes(s)||e.partialPreview.toLowerCase().includes(s)||e.changedKeys.some(e=>e.toLowerCase().includes(s)))}return e.storeNames&&e.storeNames.length>0&&(t=t.filter(t=>e.storeNames.includes(t.storeName))),e.onlyWithChanges&&(t=t.filter(e=>e.hasStateChange)),t}getStats(){const e=this.stateChanges.length,t=this.stateChanges.filter(e=>e.hasStateChange).length,s=this.stores.size,n=this.stateChanges.filter(e=>void 0!==e.duration).map(e=>e.duration),r=n.length>0?n.reduce((e,t)=>e+t,0)/n.length:0;return{totalChanges:e,changesWithStateChange:t,changesWithoutStateChange:e-t,storeCount:s,averageDuration:Math.round(100*r)/100}}getUniqueStoreNames(){return Array.from(this.stores.keys()).sort()}setEnabled(e){this.isEnabled=e}getEnabled(){return this.isEnabled}setMaxChanges(e){this.maxChanges=e,this.stateChanges.length>e&&(this.stateChanges=this.stateChanges.slice(0,e),this.notifyListeners())}subscribe(e){return this.listeners.add(e),()=>{this.listeners.delete(e)}}subscribeToStores(e){return this.storeListeners.add(e),()=>{this.storeListeners.delete(e)}}notifyListeners(){const e=this.getStateChanges();this.listeners.forEach(t=>t(e))}notifyStoreListeners(){const e=this.getStores();this.storeListeners.forEach(t=>t(e))}}export const zustandStateStore=new ZustandStateStore;

package/lib/typescript/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @buoy-gg/zustand
+ *
+ * Zustand Store DevTools for React Native
+ *
+ * PUBLIC API - Only these exports are supported for external use.
+ *
+ * @example Recommended setup (one line, zero store modifications)
+ * ```tsx
+ * import { watchStores } from '@buoy-gg/zustand';
+ * import { useCounterStore } from './stores/counter';
+ * import { useAuthStore } from './stores/auth';
+ *
+ * // One call, anywhere at module scope or in your root layout:
+ * watchStores({
+ *   counterStore: useCounterStore,
+ *   authStore: useAuthStore,
+ * });
+ * ```
+ *
+ * @example Advanced: middleware for extra detail (partial + timing)
+ * ```tsx
+ * import { create } from 'zustand';
+ * import { buoyDevTools } from '@buoy-gg/zustand';
+ *
+ * const useCounterStore = create(
+ *   buoyDevTools(
+ *     (set) => ({
+ *       count: 0,
+ *       increment: () => set((s) => ({ count: s.count + 1 })),
+ *     }),
+ *     { name: 'counterStore' }
+ *   )
+ * );
+ * ```
+ */
+export { zustandToolPreset, createZustandTool } from "./preset";
+export { watchStores } from "./zustand/utils/buoyZustandMiddleware";
+export { buoyDevTools } from "./zustand/utils/buoyZustandMiddleware";
+export { isStoreInstrumented } from "./zustand/utils/buoyZustandMiddleware";
+export { useZustandStateChanges } from "./zustand/hooks/useZustandStateChanges";
+export type { UseZustandStateChangesResult } from "./zustand/hooks/useZustandStateChanges";
+export { ZustandModal } from "./zustand/components/ZustandModal";
+export { ZustandStateChangeItem } from "./zustand/components/ZustandStateChangeItem";
+export { ZustandStateDetailContent, ZustandStateDetailFooter, } from "./zustand/components/ZustandStateDetailContent";
+export { ZustandIcon, ZUSTAND_ICON_COLOR } from "./zustand/components/ZustandIcon";
+export type { ZustandModalProps, ZustandStateChange, ZustandStoreInfo, ZustandFilter, StateChangeCategory, BuoyZustandMiddlewareOptions, } from "./zustand/types";
+/** @internal */
+export { zustandStateStore } from "./zustand/utils/zustandStateStore";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/preset.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Pre-configured Zustand DevTools preset for FloatingDevTools
+ *
+ * ZERO-CONFIG: This preset is auto-discovered by FloatingDevTools!
+ * Just install @buoy-gg/zustand and wrap your stores with buoyDevTools().
+ *
+ * @example Automatic (recommended)
+ * ```tsx
+ * import { create } from 'zustand';
+ * import { buoyDevTools } from '@buoy-gg/zustand';
+ *
+ * const useCounterStore = create(
+ *   buoyDevTools(
+ *     (set) => ({ count: 0, increment: () => set((s) => ({ count: s.count + 1 })) }),
+ *     { name: 'counterStore' }
+ *   )
+ * );
+ *
+ * // The Zustand tool appears automatically in FloatingDevTools!
+ * <FloatingDevTools />
+ * ```
+ *
+ * @example Manual (only for custom configuration)
+ * ```tsx
+ * import { createZustandTool } from '@buoy-gg/zustand';
+ *
+ * const customZustandTool = createZustandTool({
+ *   name: "STATE",
+ *   iconColor: "#463B3F",
+ * });
+ *
+ * <FloatingDevTools apps={[customZustandTool]} />
+ * ```
+ */
+import { ZustandModal } from "./zustand/components/ZustandModal";
+/**
+ * Pre-configured Zustand DevTools preset for FloatingDevTools.
+ * Includes:
+ * - Live state change monitoring
+ * - State inspection (JSON viewer)
+ * - State diff visualization (tree + split)
+ * - Filter by store name
+ * - Changed keys tracking
+ */
+export declare const zustandToolPreset: {
+    id: string;
+    name: string;
+    description: string;
+    slot: "both";
+    icon: ({ size }: {
+        size: number;
+    }) => import("react").JSX.Element;
+    component: typeof ZustandModal;
+    props: {
+        enableSharedModalDimensions: boolean;
+    };
+};
+/**
+ * Create a custom Zustand DevTools configuration.
+ * Use this if you want to override default settings.
+ *
+ * @example
+ * ```tsx
+ * import { createZustandTool } from '@buoy-gg/zustand';
+ *
+ * const myZustandTool = createZustandTool({
+ *   name: "STATE",
+ *   iconColor: "#463B3F",
+ * });
+ * ```
+ */
+export declare function createZustandTool(options?: {
+    /** Tool name (default: "ZUSTAND") */
+    name?: string;
+    /** Tool description */
+    description?: string;
+    /** Custom tool ID (default: "zustand") */
+    id?: string;
+    /** Icon color */
+    iconColor?: string;
+    /** Enable shared modal dimensions */
+    enableSharedModalDimensions?: boolean;
+}): {
+    id: string;
+    name: string;
+    description: string;
+    slot: "both";
+    icon: ({ size }: {
+        size: number;
+    }) => import("react").JSX.Element;
+    component: typeof ZustandModal;
+    props: {
+        enableSharedModalDimensions: boolean;
+    };
+};
+//# sourceMappingURL=preset.d.ts.map

package/lib/typescript/zustand/components/ZustandActionButton.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ZustandActionButton
+ *
+ * Generic action button for Zustand DevTools footer.
+ * Mirrors ReduxActionButton.tsx
+ */
+declare const buttonConfigs: {
+    copy: {
+        color: "#20C997";
+        backgroundColor: string;
+        borderColor: string;
+        textColor: "#20C997";
+    };
+    reset: {
+        color: "#FFA94D";
+        backgroundColor: string;
+        borderColor: string;
+        textColor: "#FFA94D";
+    };
+    clear: {
+        color: "#EF4444";
+        backgroundColor: string;
+        borderColor: string;
+        textColor: "#EF4444";
+    };
+    jump: {
+        color: "#FFA94D";
+        backgroundColor: string;
+        borderColor: string;
+        textColor: "#FFA94D";
+    };
+};
+export type ButtonType = keyof typeof buttonConfigs;
+interface ZustandActionButtonProps {
+    onPress: () => void;
+    text: string;
+    type: ButtonType;
+    disabled?: boolean;
+}
+export declare function ZustandActionButton({ onPress, text, type, disabled, }: ZustandActionButtonProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=ZustandActionButton.d.ts.map

package/lib/typescript/zustand/components/ZustandDetailViewToggle.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ZustandDetailViewToggle
+ *
+ * Three-card toggle for switching between Change, State, and Diff views.
+ * Mirrors ReduxDetailViewToggle.tsx
+ */
+import React from "react";
+export type ZustandDetailViewMode = "change" | "state" | "diff";
+interface ZustandDetailViewToggleProps {
+    activeView: ZustandDetailViewMode;
+    onViewChange: (view: ZustandDetailViewMode) => void;
+    diffDisabled?: boolean;
+}
+export declare const ZustandDetailViewToggle: React.NamedExoticComponent<ZustandDetailViewToggleProps>;
+export {};
+//# sourceMappingURL=ZustandDetailViewToggle.d.ts.map

package/lib/typescript/zustand/components/ZustandEventFilterView.d.ts

@@ -0,0 +1,10 @@
+import type { ZustandStoreInfo } from "../types";
+interface ZustandEventFilterViewProps {
+    ignoredPatterns: Set<string>;
+    onTogglePattern: (pattern: string) => void;
+    onAddPattern: (pattern: string) => void;
+    stores: ZustandStoreInfo[];
+}
+export declare function ZustandEventFilterView({ ignoredPatterns, onTogglePattern, onAddPattern, stores, }: ZustandEventFilterViewProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=ZustandEventFilterView.d.ts.map

package/lib/typescript/zustand/components/ZustandIcon.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Zustand DevTools icon
+ */
+declare const ZUSTAND_ICON_COLOR = "#463B3F";
+export declare function ZustandIcon({ size, color, }: {
+    size: number;
+    color?: string;
+}): import("react").JSX.Element;
+export { ZUSTAND_ICON_COLOR };
+//# sourceMappingURL=ZustandIcon.d.ts.map

package/lib/typescript/zustand/components/ZustandModal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Main Zustand DevTools modal
+ *
+ * Two tabs mirroring the Storage DevTools pattern:
+ * - Stores tab: Browse all registered stores and their current state
+ * - Events tab: Live state change monitoring with diffs
+ */
+import type { ZustandModalProps } from "../types";
+export declare function ZustandModal({ visible, onClose, onBack, onMinimize, enableSharedModalDimensions, }: ZustandModalProps): import("react").JSX.Element | null;
+//# sourceMappingURL=ZustandModal.d.ts.map

package/lib/typescript/zustand/components/ZustandStateChangeItem.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Compact list item for displaying a Zustand state change
+ *
+ * Mirrors ReduxActionItem.tsx - uses shared CompactRow for consistent styling
+ */
+import type { ZustandStateChange } from "../types";
+interface ZustandStateChangeItemProps {
+    change: ZustandStateChange;
+    onPress: (change: ZustandStateChange) => void;
+}
+export declare function ZustandStateChangeItem({ change, onPress, }: ZustandStateChangeItemProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=ZustandStateChangeItem.d.ts.map

package/lib/typescript/zustand/components/ZustandStateDetailContent.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ZustandStateDetailContent
+ *
+ * Detail view for a Zustand state change with 3 view modes:
+ * - CHANGE: View change details, partial, metadata
+ * - STATE: View current state after change
+ * - DIFF: Compare prev vs next state
+ *
+ * Mirrors ReduxActionDetailContent.tsx
+ */
+import type { ZustandStateChange } from "../types";
+interface ZustandStateDetailContentProps {
+    change: ZustandStateChange;
+    changes: ZustandStateChange[];
+    selectedIndex: number;
+    onIndexChange: (index: number) => void;
+    disableInternalFooter?: boolean;
+}
+export declare function ZustandStateDetailContent({ change, changes, selectedIndex, onIndexChange, disableInternalFooter, }: ZustandStateDetailContentProps): import("react").JSX.Element;
+/**
+ * External footer component for modal use
+ */
+export declare function ZustandStateDetailFooter({ change, changes, selectedIndex, onIndexChange, }: {
+    change: ZustandStateChange;
+    changes: ZustandStateChange[];
+    selectedIndex: number;
+    onIndexChange: (index: number) => void;
+}): import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=ZustandStateDetailContent.d.ts.map

package/lib/typescript/zustand/components/ZustandStateInfoView.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ZustandStateInfoView
+ *
+ * Displays comprehensive state change information including:
+ * - Change metadata (store, category, duration)
+ * - Partial data passed to setState
+ * - Changed keys list
+ *
+ * Mirrors ReduxActionInfoView.tsx
+ */
+import React from "react";
+import type { ZustandStateChange } from "../types";
+interface ZustandStateInfoViewProps {
+    change: ZustandStateChange;
+}
+export declare const ZustandStateInfoView: React.NamedExoticComponent<ZustandStateInfoViewProps>;
+export {};
+//# sourceMappingURL=ZustandStateInfoView.d.ts.map

package/lib/typescript/zustand/components/ZustandStoreBrowser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ZustandStoreBrowser
+ *
+ * Browse tab — shows all registered Zustand stores and their current state.
+ * Mirrors the Storage Browser pattern from @buoy-gg/storage.
+ *
+ * Each store is shown as an expandable row with its current state viewable
+ * via the shared DataViewer component.
+ */
+import type { ZustandStoreInfo } from "../types";
+interface ZustandStoreBrowserProps {
+    stores: ZustandStoreInfo[];
+    searchQuery: string;
+    onViewHistory: (storeName: string) => void;
+}
+export declare function ZustandStoreBrowser({ stores, searchQuery, onViewHistory, }: ZustandStoreBrowserProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=ZustandStoreBrowser.d.ts.map

package/lib/typescript/zustand/components/index.d.ts

@@ -0,0 +1,11 @@
+export { ZustandModal } from "./ZustandModal";
+export { ZustandIcon, ZUSTAND_ICON_COLOR } from "./ZustandIcon";
+export { ZustandStateChangeItem } from "./ZustandStateChangeItem";
+export { ZustandStateDetailContent, ZustandStateDetailFooter, } from "./ZustandStateDetailContent";
+export { ZustandStateInfoView } from "./ZustandStateInfoView";
+export { ZustandDetailViewToggle } from "./ZustandDetailViewToggle";
+export type { ZustandDetailViewMode } from "./ZustandDetailViewToggle";
+export { ZustandActionButton } from "./ZustandActionButton";
+export type { ButtonType } from "./ZustandActionButton";
+export { ZustandStoreBrowser } from "./ZustandStoreBrowser";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/zustand/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useZustandStateChanges } from "./useZustandStateChanges";
+export type { UseZustandStateChangesResult } from "./useZustandStateChanges";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/zustand/hooks/useZustandStateChanges.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Hook for consuming Zustand state changes from the store
+ *
+ * Mirrors useReduxActions.ts from @buoy-gg/redux
+ */
+import type { ZustandStateChange, ZustandStoreInfo, ZustandFilter } from "../types";
+export interface UseZustandStateChangesResult {
+    /** All captured state changes */
+    stateChanges: ZustandStateChange[];
+    /** Filtered state changes based on current filter */
+    filteredChanges: ZustandStateChange[];
+    /** Current filter settings */
+    filter: ZustandFilter;
+    /** Update filter settings */
+    setFilter: React.Dispatch<React.SetStateAction<ZustandFilter>>;
+    /** Statistics about captured changes */
+    stats: {
+        totalChanges: number;
+        changesWithStateChange: number;
+        changesWithoutStateChange: number;
+        storeCount: number;
+        averageDuration: number;
+    };
+    /** All registered stores */
+    stores: ZustandStoreInfo[];
+    /** Clear all captured state changes */
+    clearChanges: () => void;
+    /** Whether capture is enabled */
+    isEnabled: boolean;
+    /** Toggle capture on/off */
+    toggleCapture: () => void;
+    /** Get unique store names */
+    storeNames: string[];
+    /** Get state change by ID */
+    getChangeById: (id: string) => ZustandStateChange | undefined;
+}
+export declare function useZustandStateChanges(): UseZustandStateChangesResult;
+//# sourceMappingURL=useZustandStateChanges.d.ts.map

package/lib/typescript/zustand/index.d.ts

@@ -0,0 +1,12 @@
+export { ZustandModal } from "./components/ZustandModal";
+export { ZustandIcon, ZUSTAND_ICON_COLOR } from "./components/ZustandIcon";
+export { ZustandStateChangeItem } from "./components/ZustandStateChangeItem";
+export { ZustandStateDetailContent, ZustandStateDetailFooter, } from "./components/ZustandStateDetailContent";
+export { ZustandStateInfoView } from "./components/ZustandStateInfoView";
+export { ZustandDetailViewToggle } from "./components/ZustandDetailViewToggle";
+export { ZustandActionButton } from "./components/ZustandActionButton";
+export { zustandStateStore } from "./utils/zustandStateStore";
+export { watchStores, buoyDevTools, isStoreInstrumented, } from "./utils/buoyZustandMiddleware";
+export { useZustandStateChanges } from "./hooks/useZustandStateChanges";
+export type { ZustandModalProps, ZustandStateChange, ZustandStoreInfo, ZustandFilter, StateChangeCategory, BuoyZustandMiddlewareOptions, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/zustand/types/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Zustand DevTools types
+ */
+/**
+ * State change category
+ */
+export type StateChangeCategory = "setState" | "replace" | "persist" | "initial";
+/**
+ * Captured Zustand state change
+ */
+export interface ZustandStateChange {
+    id: string;
+    storeName: string;
+    timestamp: number;
+    prevState: unknown;
+    nextState: unknown;
+    partial: unknown;
+    duration?: number;
+    hasStateChange: boolean;
+    replace: boolean;
+    category: StateChangeCategory;
+    changedKeys: string[];
+    changedKeysCount: number;
+    diffSummary: string;
+    partialPreview: string;
+    isSlowUpdate: boolean;
+    isPersisted: boolean;
+}
+/**
+ * Tracked Zustand store metadata
+ */
+export interface ZustandStoreInfo {
+    name: string;
+    api: {
+        getState: () => unknown;
+        getInitialState?: () => unknown;
+        setState: (partial: unknown, replace?: boolean) => void;
+        subscribe: (listener: (state: unknown, prevState: unknown) => void) => () => void;
+    };
+    stateChangeCount: number;
+    isPersisted: boolean;
+    persistName?: string;
+    color: string;
+}
+/**
+ * Filter options
+ */
+export interface ZustandFilter {
+    searchText?: string;
+    storeNames?: string[];
+    onlyWithChanges?: boolean;
+}
+/**
+ * Modal props for ZustandModal
+ */
+export interface ZustandModalProps {
+    visible: boolean;
+    onClose: () => void;
+    onBack?: () => void;
+    onMinimize?: (modalState: unknown) => void;
+    enableSharedModalDimensions?: boolean;
+}
+/**
+ * Middleware options
+ */
+export interface BuoyZustandMiddlewareOptions {
+    /** Store name for display in DevTools */
+    name?: string;
+    /** Enable capture on creation (default: true) */
+    enabled?: boolean;
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/zustand/utils/buoyZustandMiddleware.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Buoy Zustand DevTools — Store instrumentation
+ *
+ * Two approaches, from easiest to most detailed:
+ *
+ * 1. watchStores() — RECOMMENDED. One line, zero store modifications.
+ *    Uses store.subscribe() externally. Never touches setState.
+ *    Safe to add/remove — cannot break your stores even if our code has bugs.
+ *
+ * 2. buoyDevTools() — Opt-in middleware for advanced use.
+ *    Wraps setState to capture the partial argument and timing.
+ *    Requires modifying each store's create() call.
+ */
+import type { BuoyZustandMiddlewareOptions } from "../types";
+/** Minimal store shape — what Zustand's create() returns */
+interface ZustandStoreHook {
+    getState: () => unknown;
+    getInitialState?: () => unknown;
+    setState: (partial: unknown, replace?: boolean) => void;
+    subscribe: (listener: (state: unknown, prevState: unknown) => void) => () => void;
+    [key: string]: unknown;
+}
+/**
+ * Watch multiple Zustand stores for state changes.
+ *
+ * This is the recommended, non-intrusive approach. It uses each store's
+ * `.subscribe()` method to observe changes from the outside — it never
+ * modifies `setState` or any store internals.
+ *
+ * **Safe by design:** Even if our listener code has a bug, it cannot break
+ * your stores. All listener code is wrapped in try/catch.
+ *
+ * @example
+ * ```tsx
+ * // In your _layout.tsx or App.tsx — ONE line:
+ * import { watchStores } from '@buoy-gg/zustand';
+ * import { useCounterStore } from './stores/counter';
+ * import { useAuthStore } from './stores/auth';
+ * import { useCartStore } from './stores/cart';
+ *
+ * watchStores({
+ *   counterStore: useCounterStore,
+ *   authStore: useAuthStore,
+ *   cartStore: useCartStore,
+ * });
+ * ```
+ *
+ * @param stores - Object mapping store names to Zustand store hooks
+ * @returns Cleanup function that removes all subscriptions
+ */
+export declare function watchStores(stores: Record<string, ZustandStoreHook>): () => void;
+/**
+ * Zustand middleware that instruments a store for Buoy DevTools.
+ *
+ * This is the advanced approach — it wraps setState to capture:
+ * - The partial argument passed to setState
+ * - Precise timing of each setState call
+ *
+ * Use this when you want maximum detail. For most cases, `watchStores()`
+ * is simpler and safer.
+ *
+ * @example
+ * ```tsx
+ * import { create } from 'zustand';
+ * import { buoyDevTools } from '@buoy-gg/zustand';
+ *
+ * const useCounterStore = create(
+ *   buoyDevTools(
+ *     (set) => ({
+ *       count: 0,
+ *       increment: () => set((s) => ({ count: s.count + 1 })),
+ *     }),
+ *     { name: 'counterStore' }
+ *   )
+ * );
+ * ```
+ */
+export declare function buoyDevTools<T>(config: (set: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void, get: () => T, api: Record<string, unknown>) => T, options?: BuoyZustandMiddlewareOptions): (set: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void, get: () => T, api: Record<string, unknown>) => T;
+/**
+ * Check if a store is being watched/instrumented
+ */
+export declare function isStoreInstrumented(store: Record<string | symbol, unknown>): boolean;
+export {};
+//# sourceMappingURL=buoyZustandMiddleware.d.ts.map

package/lib/typescript/zustand/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { zustandStateStore } from "./zustandStateStore";
+export { watchStores, buoyDevTools, isStoreInstrumented, } from "./buoyZustandMiddleware";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/zustand/utils/zustandStateStore.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Zustand state store - captures and stores Zustand state changes
+ *
+ * Mirrors the architecture of reduxActionStore.ts from @buoy-gg/redux
+ */
+import type { ZustandStateChange, ZustandStoreInfo, ZustandFilter, StateChangeCategory } from "../types";
+declare class ZustandStateStore {
+    private stateChanges;
+    private stores;
+    private listeners;
+    private storeListeners;
+    private maxChanges;
+    private idCounter;
+    private isEnabled;
+    addStateChange(params: {
+        storeName: string;
+        partial: unknown;
+        replace: boolean;
+        prevState: unknown;
+        nextState: unknown;
+        duration?: number;
+        category?: StateChangeCategory;
+        isPersisted?: boolean;
+    }): void;
+    getStateChanges(): ZustandStateChange[];
+    getStateChangeById(id: string): ZustandStateChange | undefined;
+    clearStateChanges(): void;
+    registerStore(name: string, api: ZustandStoreInfo["api"], options?: {
+        isPersisted?: boolean;
+        persistName?: string;
+    }): void;
+    unregisterStore(name: string): void;
+    getStores(): ZustandStoreInfo[];
+    getStore(name: string): ZustandStoreInfo | undefined;
+    getStoreColor(name: string): string;
+    filterStateChanges(filter: ZustandFilter): ZustandStateChange[];
+    getStats(): {
+        totalChanges: number;
+        changesWithStateChange: number;
+        changesWithoutStateChange: number;
+        storeCount: number;
+        averageDuration: number;
+    };
+    getUniqueStoreNames(): string[];
+    setEnabled(enabled: boolean): void;
+    getEnabled(): boolean;
+    setMaxChanges(max: number): void;
+    subscribe(listener: (changes: ZustandStateChange[]) => void): () => void;
+    subscribeToStores(listener: (stores: ZustandStoreInfo[]) => void): () => void;
+    private notifyListeners;
+    private notifyStoreListeners;
+}
+export declare const zustandStateStore: ZustandStateStore;
+export {};
+//# sourceMappingURL=zustandStateStore.d.ts.map