@buoy-gg/redux 2.1.11 → 2.1.13

package/lib/module/redux/hooks/useAutoInstrumentRedux.js

@@ -1,193 +1 @@
-"use strict";
-
-/**
- * React hook for auto-instrumenting Redux stores
- *
- * This hook automatically patches the Redux store when the component mounts,
- * providing zero-config action capture for the Redux DevTools.
- *
- * Usage:
- * - The hook attempts to use react-redux's useStore() to get the store
- * - If successful, it instruments the store automatically
- * - If react-redux is not available or not in a Provider, it fails gracefully
- *
- * @example
- * ```tsx
- * function ReduxDevTools() {
- *   const { isInstrumented, error } = useAutoInstrumentRedux();
- *
- *   if (error) {
- *     return <Text>Redux not available: {error}</Text>;
- *   }
- *
- *   return <ReduxActionList />;
- * }
- * ```
- */
-
-import { useEffect, useState, useRef, useCallback } from "react";
-import { instrumentStore, uninstrumentStore, isStoreInstrumented } from "../utils/autoInstrument";
-
-// ============================================
-// Safe Module Loading
-// ============================================
-
-/**
- * Safely attempt to load react-redux and get useStore hook
- */
-function getReactReduxUseStore() {
-  try {
-    // Dynamic require to handle cases where react-redux isn't installed
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const reactRedux = require("react-redux");
-    return reactRedux.useStore;
-  } catch {
-    // react-redux not available
-    return null;
-  }
-}
-
-// ============================================
-// Hook Types
-// ============================================
-
-// ============================================
-// Main Hook
-// ============================================
-
-/**
- * Hook to automatically instrument Redux store for DevTools
- *
- * This provides zero-config Redux action capture by:
- * 1. Using react-redux's useStore() to get the Redux store
- * 2. Automatically patching store.dispatch to capture actions
- * 3. Cleaning up when the component unmounts
- */
-export function useAutoInstrumentRedux(options = {}) {
-  const {
-    autoStart = true,
-    ...instrumentOptions
-  } = options;
-  const [isInstrumented, setIsInstrumented] = useState(false);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState(null);
-  const [store, setStore] = useState(null);
-  const cleanupRef = useRef(null);
-
-  // Check if react-redux is available
-  const useStoreHook = getReactReduxUseStore();
-  const isReactReduxAvailable = useStoreHook !== null;
-
-  // Try to get the store using react-redux's useStore
-  // This must be called unconditionally due to hooks rules
-  let reduxStore = null;
-  let storeError = null;
-  if (useStoreHook) {
-    try {
-      // eslint-disable-next-line react-hooks/rules-of-hooks
-      reduxStore = useStoreHook();
-    } catch (e) {
-      // Not inside a Provider or other error
-      storeError = e instanceof Error ? e.message : "Failed to access Redux store. Make sure your app is wrapped in a Redux Provider.";
-    }
-  } else {
-    storeError = "react-redux is not installed or not available";
-  }
-
-  // Function to start instrumentation
-  const startInstrumentation = useCallback(() => {
-    if (!reduxStore) {
-      setError(storeError || "No Redux store available");
-      setIsLoading(false);
-      return;
-    }
-
-    // Check if already instrumented
-    if (isStoreInstrumented(reduxStore)) {
-      setIsInstrumented(true);
-      setStore(reduxStore);
-      setIsLoading(false);
-      setError(null);
-      return;
-    }
-    try {
-      // Instrument the store
-      const cleanup = instrumentStore(reduxStore, instrumentOptions);
-      cleanupRef.current = cleanup;
-      setIsInstrumented(true);
-      setStore(reduxStore);
-      setError(null);
-    } catch (e) {
-      setError(e instanceof Error ? e.message : "Failed to instrument Redux store");
-      setIsInstrumented(false);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [reduxStore, storeError, instrumentOptions]);
-
-  // Function to stop instrumentation
-  const stopInstrumentation = useCallback(() => {
-    if (cleanupRef.current) {
-      cleanupRef.current();
-      cleanupRef.current = null;
-    }
-    if (store) {
-      uninstrumentStore(store);
-    }
-    setIsInstrumented(false);
-    setStore(null);
-  }, [store]);
-
-  // Auto-start instrumentation on mount
-  useEffect(() => {
-    if (autoStart) {
-      startInstrumentation();
-    } else {
-      setIsLoading(false);
-    }
-
-    // Cleanup on unmount
-    return () => {
-      // Note: We intentionally DON'T uninstrument on unmount
-      // This allows actions to continue being captured even when
-      // the DevTools modal is closed. The instrumentation persists
-      // for the lifetime of the app, similar to network/storage tools.
-    };
-  }, [autoStart, startInstrumentation]);
-  return {
-    isInstrumented,
-    isLoading,
-    error,
-    isReactReduxAvailable,
-    startInstrumentation,
-    stopInstrumentation,
-    store
-  };
-}
-
-/**
- * Lightweight hook to just check if Redux is available
- * without auto-instrumenting
- */
-export function useReduxAvailability() {
-  const useStoreHook = getReactReduxUseStore();
-  if (!useStoreHook) {
-    return {
-      isAvailable: false,
-      error: "react-redux is not installed"
-    };
-  }
-  try {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const store = useStoreHook();
-    return {
-      isAvailable: store !== null && store !== undefined,
-      error: null
-    };
-  } catch (e) {
-    return {
-      isAvailable: false,
-      error: e instanceof Error ? e.message : "Not inside a Redux Provider"
-    };
-  }
-}
+"use strict";import{useEffect,useState,useRef,useCallback}from"react";import{instrumentStore,uninstrumentStore,isStoreInstrumented}from"../utils/autoInstrument";function getReactReduxUseStore(){try{return require("react-redux").useStore}catch{return null}}export function useAutoInstrumentRedux(e={}){const{autoStart:t=!0,...r}=e,[u,n]=useState(!1),[s,a]=useState(!0),[l,o]=useState(null),[i,c]=useState(null),d=useRef(null),f=getReactReduxUseStore(),m=null!==f;let R=null,x=null;if(f)try{R=f()}catch(e){x=e instanceof Error?e.message:"Failed to access Redux store. Make sure your app is wrapped in a Redux Provider."}else x="react-redux is not installed or not available";const S=useCallback(()=>{if(!R)return o(x||"No Redux store available"),void a(!1);if(isStoreInstrumented(R))return n(!0),c(R),a(!1),void o(null);try{const e=instrumentStore(R,r);d.current=e,n(!0),c(R),o(null)}catch(e){o(e instanceof Error?e.message:"Failed to instrument Redux store"),n(!1)}finally{a(!1)}},[R,x,r]),v=useCallback(()=>{d.current&&(d.current(),d.current=null),i&&uninstrumentStore(i),n(!1),c(null)},[i]);return useEffect(()=>(t?S():a(!1),()=>{}),[t,S]),{isInstrumented:u,isLoading:s,error:l,isReactReduxAvailable:m,startInstrumentation:S,stopInstrumentation:v,store:i}}export function useReduxAvailability(){const e=getReactReduxUseStore();if(!e)return{isAvailable:!1,error:"react-redux is not installed"};try{return{isAvailable:null!=e(),error:null}}catch(e){return{isAvailable:!1,error:e instanceof Error?e.message:"Not inside a Redux Provider"}}}

package/lib/module/redux/hooks/useReduxActions.js

@@ -1,71 +1 @@
-"use strict";
-
-/**
- * Hook for consuming Redux actions from the store
- */
-
-import { useState, useEffect, useMemo, useCallback } from "react";
-import { reduxActionStore } from "../utils/reduxActionStore";
-export function useReduxActions() {
-  const [actions, setActions] = useState(() => reduxActionStore.getActions());
-  const [filter, setFilter] = useState({});
-  const [isEnabled, setIsEnabled] = useState(() => reduxActionStore.getEnabled());
-  const [selectedAction, setSelectedAction] = useState(null);
-
-  // Subscribe to store changes
-  useEffect(() => {
-    const unsubscribe = reduxActionStore.subscribe(newActions => {
-      setActions(newActions);
-    });
-    return () => {
-      unsubscribe();
-    };
-  }, []);
-
-  // Filter actions based on current filter
-  const filteredActions = useMemo(() => {
-    return reduxActionStore.filterActions(filter);
-  }, [actions, filter]);
-
-  // Get stats
-  const stats = useMemo(() => {
-    return reduxActionStore.getStats();
-  }, [actions]);
-
-  // Get unique action types
-  const actionTypes = useMemo(() => {
-    return reduxActionStore.getUniqueActionTypes();
-  }, [actions]);
-
-  // Clear actions
-  const clearActions = useCallback(() => {
-    reduxActionStore.clearActions();
-    setSelectedAction(null);
-  }, []);
-
-  // Toggle capture
-  const toggleCapture = useCallback(() => {
-    const newEnabled = !isEnabled;
-    reduxActionStore.setEnabled(newEnabled);
-    setIsEnabled(newEnabled);
-  }, [isEnabled]);
-
-  // Get action by ID
-  const getActionById = useCallback(id => {
-    return reduxActionStore.getActionById(id);
-  }, []);
-  return {
-    actions,
-    filteredActions,
-    filter,
-    setFilter,
-    stats,
-    clearActions,
-    isEnabled,
-    toggleCapture,
-    actionTypes,
-    getActionById,
-    selectedAction,
-    setSelectedAction
-  };
-}
+"use strict";import{useState,useEffect,useMemo,useCallback}from"react";import{reduxActionStore}from"../utils/reduxActionStore";export function useReduxActions(){const[e,t]=useState(()=>reduxActionStore.getActions()),[o,c]=useState({}),[s,r]=useState(()=>reduxActionStore.getEnabled()),[n,u]=useState(null);useEffect(()=>{const e=reduxActionStore.subscribe(e=>{t(e)});return()=>{e()}},[]);const i=useMemo(()=>reduxActionStore.filterActions(o),[e,o]),l=useMemo(()=>reduxActionStore.getStats(),[e]),a=useMemo(()=>reduxActionStore.getUniqueActionTypes(),[e]),A=useCallback(()=>{reduxActionStore.clearActions(),u(null)},[]),d=useCallback(()=>{const e=!s;reduxActionStore.setEnabled(e),r(e)},[s]),S=useCallback(e=>reduxActionStore.getActionById(e),[]);return{actions:e,filteredActions:i,filter:o,setFilter:c,stats:l,clearActions:A,isEnabled:s,toggleCapture:d,actionTypes:a,getActionById:S,selectedAction:n,setSelectedAction:u}}

package/lib/module/redux/index.js

@@ -1,13 +1 @@
-"use strict";
-
-// Types
-export * from "./types";
-
-// Utils
-export * from "./utils";
-
-// Hooks
-export * from "./hooks";
-
-// Components
-export * from "./components";
+"use strict";export*from"./types";export*from"./utils";export*from"./hooks";export*from"./components";

package/lib/module/redux/utils/autoInstrument.js

@@ -1,260 +1 @@
-"use strict";
-
-/**
- * Auto-instrumentation for Redux stores
- *
- * This module provides zero-config Redux DevTools integration by automatically
- * patching the store's dispatch method when the DevTools component mounts.
- *
- * Similar to how @buoy-gg/network patches globalThis.fetch, this patches
- * store.dispatch to capture all Redux actions without requiring manual
- * middleware configuration.
- */
-
-import { reduxActionStore } from "./reduxActionStore";
-import { BUOY_JUMP_TO_STATE, isMiddlewareActive } from "./buoyReduxMiddleware";
-
-// ============================================
-// Store Tracking
-// ============================================
-
-/** Symbol to mark stores that have been instrumented */
-const INSTRUMENTED_SYMBOL = Symbol.for("@@buoy/instrumented");
-
-/** Symbol to store original dispatch reference */
-const ORIGINAL_DISPATCH_SYMBOL = Symbol.for("@@buoy/originalDispatch");
-
-/** Symbol to store original reducer reference */
-const ORIGINAL_REDUCER_SYMBOL = Symbol.for("@@buoy/originalReducer");
-
-/** Reference to the active store for time-travel operations */
-let activeStore = null;
-
-/** Track if store has been enhanced for time-travel */
-let timeTravelEnabled = false;
-
-// ============================================
-// Type Definitions
-// ============================================
-
-// ============================================
-// Core Instrumentation
-// ============================================
-
-/**
- * Check if a store has already been instrumented
- */
-export function isStoreInstrumented(store) {
-  return store[INSTRUMENTED_SYMBOL] === true;
-}
-
-/**
- * Instrument a Redux store for action capture
- *
- * This function patches store.dispatch to capture all actions without
- * requiring the user to configure middleware manually.
- *
- * @param store - The Redux store to instrument
- * @param options - Configuration options
- * @returns Cleanup function to restore original dispatch
- */
-export function instrumentStore(store, options = {}) {
-  const instrumentedStore = store;
-
-  // Skip if middleware is already handling action capture
-  // This prevents duplicate recording when both mechanisms are active
-  if (isMiddlewareActive()) {
-    activeStore = store;
-    return () => {};
-  }
-
-  // Skip if already instrumented
-  if (instrumentedStore[INSTRUMENTED_SYMBOL]) {
-    // Update active store reference even if already instrumented
-    activeStore = store;
-    return () => {};
-  }
-  const {
-    enableTimeTravel = false,
-    maxActions = 200,
-    ignoreActions = []
-  } = options;
-
-  // Configure store
-  reduxActionStore.setMaxActions(maxActions);
-
-  // Store original dispatch
-  const originalDispatch = store.dispatch.bind(store);
-  instrumentedStore[ORIGINAL_DISPATCH_SYMBOL] = originalDispatch;
-
-  // Create instrumented dispatch
-  const instrumentedDispatch = action => {
-    // Skip if action is not a plain object with a type property
-    // This filters out thunk functions, promises, and other non-action dispatches
-    if (typeof action !== "object" || action === null || typeof action.type !== "string") {
-      return originalDispatch(action);
-    }
-    const actionType = action.type;
-
-    // Don't record devtools internal actions
-    if (actionType.startsWith("@@buoy/")) {
-      return originalDispatch(action);
-    }
-
-    // Don't record Redux internal actions
-    if (actionType.startsWith("@@redux/")) {
-      return originalDispatch(action);
-    }
-
-    // Check ignore list
-    if (ignoreActions.includes(actionType)) {
-      return originalDispatch(action);
-    }
-
-    // Capture timing and state
-    const startTime = performance.now();
-    const prevState = store.getState();
-    const result = originalDispatch(action);
-    const nextState = store.getState();
-    const duration = performance.now() - startTime;
-
-    // Record the action
-    reduxActionStore.addAction(action, prevState, nextState, duration);
-    return result;
-  };
-
-  // Replace dispatch
-  store.dispatch = instrumentedDispatch;
-  instrumentedStore[INSTRUMENTED_SYMBOL] = true;
-  activeStore = store;
-
-  // Enable time-travel if requested and store supports replaceReducer
-  if (enableTimeTravel && typeof store.replaceReducer === "function") {
-    enableTimeTravelSupport(store);
-  }
-
-  // Return cleanup function
-  return () => {
-    uninstrumentStore(store);
-  };
-}
-
-/**
- * Remove instrumentation from a store
- */
-export function uninstrumentStore(store) {
-  const instrumentedStore = store;
-  if (!instrumentedStore[INSTRUMENTED_SYMBOL]) {
-    return;
-  }
-
-  // Restore original dispatch
-  const originalDispatch = instrumentedStore[ORIGINAL_DISPATCH_SYMBOL];
-  if (originalDispatch) {
-    store.dispatch = originalDispatch;
-  }
-
-  // Restore original reducer if time-travel was enabled
-  const originalReducer = instrumentedStore[ORIGINAL_REDUCER_SYMBOL];
-  if (originalReducer && typeof store.replaceReducer === "function") {
-    store.replaceReducer(originalReducer);
-    timeTravelEnabled = false;
-  }
-
-  // Clean up symbols
-  delete instrumentedStore[INSTRUMENTED_SYMBOL];
-  delete instrumentedStore[ORIGINAL_DISPATCH_SYMBOL];
-  delete instrumentedStore[ORIGINAL_REDUCER_SYMBOL];
-
-  // Clear active store reference
-  if (activeStore === store) {
-    activeStore = null;
-  }
-}
-
-// ============================================
-// Time-Travel Support
-// ============================================
-
-/**
- * Enable time-travel support by wrapping the store's reducer
- *
- * This uses store.replaceReducer to inject our time-travel wrapper
- * dynamically, without requiring users to manually wrap their reducer.
- */
-function enableTimeTravelSupport(store) {
-  const instrumentedStore = store;
-
-  // Get current reducer by dispatching a probe action
-  // Note: This is a workaround since there's no store.getReducer()
-  // We'll wrap whatever reducer is currently active
-  const currentState = store.getState();
-
-  // Create a time-travel enabled reducer wrapper
-  const timeTravelReducer = (state = currentState, action) => {
-    // Handle jump to state action
-    if (action.type === BUOY_JUMP_TO_STATE) {
-      return action.payload;
-    }
-
-    // Get the result from the original dispatch flow
-    // Since we've already wrapped dispatch, we need to be careful here
-    // The state will be updated by the store's internal reducer
-    return state;
-  };
-
-  // Store reference (we can't actually get the original reducer directly)
-  // This approach has limitations - full time-travel works better with
-  // the explicit withBuoyDevTools wrapper
-  instrumentedStore[ORIGINAL_REDUCER_SYMBOL] = timeTravelReducer;
-  timeTravelEnabled = true;
-}
-
-/**
- * Jump to a specific state (time-travel)
- *
- * For full time-travel support, users should use withBuoyDevTools.
- * This limited version attempts to work with auto-instrumentation.
- */
-export function jumpToState(state) {
-  if (activeStore) {
-    activeStore.dispatch({
-      type: BUOY_JUMP_TO_STATE,
-      payload: state
-    });
-  } else {
-    console.warn("[BuoyRedux] Cannot jump to state - no store instrumented");
-  }
-}
-
-/**
- * Replay an action (dispatch it again)
- */
-export function replayAction(action) {
-  if (activeStore) {
-    activeStore.dispatch(action);
-  } else {
-    console.warn("[BuoyRedux] Cannot replay action - no store instrumented");
-  }
-}
-
-/**
- * Get the currently active (instrumented) store
- */
-export function getActiveStore() {
-  return activeStore;
-}
-
-/**
- * Check if auto-instrumentation is active
- */
-export function isAutoInstrumentActive() {
-  return activeStore !== null && isStoreInstrumented(activeStore);
-}
-
-/**
- * Check if time-travel support is enabled
- */
-export function isTimeTravelEnabled() {
-  return timeTravelEnabled;
-}
+"use strict";import{reduxActionStore}from"./reduxActionStore";import{BUOY_JUMP_TO_STATE,isMiddlewareActive}from"./buoyReduxMiddleware";const INSTRUMENTED_SYMBOL=Symbol.for("@@buoy/instrumented"),ORIGINAL_DISPATCH_SYMBOL=Symbol.for("@@buoy/originalDispatch"),ORIGINAL_REDUCER_SYMBOL=Symbol.for("@@buoy/originalReducer");let activeStore=null,timeTravelEnabled=!1;export function isStoreInstrumented(e){return!0===e[INSTRUMENTED_SYMBOL]}export function instrumentStore(e,t={}){const r=e;if(isMiddlewareActive())return activeStore=e,()=>{};if(r[INSTRUMENTED_SYMBOL])return activeStore=e,()=>{};const{enableTimeTravel:o=!1,maxActions:n=200,ignoreActions:i=[]}=t;reduxActionStore.setMaxActions(n);const c=e.dispatch.bind(e);return r[ORIGINAL_DISPATCH_SYMBOL]=c,e.dispatch=t=>{if("object"!=typeof t||null===t||"string"!=typeof t.type)return c(t);const r=t.type;if(r.startsWith("@@buoy/"))return c(t);if(r.startsWith("@@redux/"))return c(t);if(i.includes(r))return c(t);const o=performance.now(),n=e.getState(),a=c(t),u=e.getState(),S=performance.now()-o;return reduxActionStore.addAction(t,n,u,S),a},r[INSTRUMENTED_SYMBOL]=!0,activeStore=e,o&&"function"==typeof e.replaceReducer&&enableTimeTravelSupport(e),()=>{uninstrumentStore(e)}}export function uninstrumentStore(e){const t=e;if(!t[INSTRUMENTED_SYMBOL])return;const r=t[ORIGINAL_DISPATCH_SYMBOL];r&&(e.dispatch=r);const o=t[ORIGINAL_REDUCER_SYMBOL];o&&"function"==typeof e.replaceReducer&&(e.replaceReducer(o),timeTravelEnabled=!1),delete t[INSTRUMENTED_SYMBOL],delete t[ORIGINAL_DISPATCH_SYMBOL],delete t[ORIGINAL_REDUCER_SYMBOL],activeStore===e&&(activeStore=null)}function enableTimeTravelSupport(e){const t=e,r=e.getState();t[ORIGINAL_REDUCER_SYMBOL]=(e=r,t)=>t.type===BUOY_JUMP_TO_STATE?t.payload:e,timeTravelEnabled=!0}export function jumpToState(e){activeStore?activeStore.dispatch({type:BUOY_JUMP_TO_STATE,payload:e}):console.warn("[BuoyRedux] Cannot jump to state - no store instrumented")}export function replayAction(e){activeStore?activeStore.dispatch(e):console.warn("[BuoyRedux] Cannot replay action - no store instrumented")}export function getActiveStore(){return activeStore}export function isAutoInstrumentActive(){return null!==activeStore&&isStoreInstrumented(activeStore)}export function isTimeTravelEnabled(){return timeTravelEnabled}