@buoy-gg/redux 3.0.1 → 3.0.2

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

@@ -1 +1,157 @@
-"use strict";import{reduxActionStore}from"./reduxActionStore";let middlewareActive=!1;export function isMiddlewareActive(){return middlewareActive}export const BUOY_JUMP_TO_STATE="@@buoy/JUMP_TO_STATE";export const BUOY_REPLAY_ACTION="@@buoy/REPLAY_ACTION";let storeDispatch=null;export function jumpToState(t){storeDispatch?storeDispatch({type:BUOY_JUMP_TO_STATE,payload:t}):console.warn("[BuoyRedux] Cannot jump to state - middleware not initialized")}export function replayAction(t){storeDispatch?storeDispatch(t):console.warn("[BuoyRedux] Cannot replay action - middleware not initialized")}export function withBuoyDevTools(t){return(e,o)=>o.type===BUOY_JUMP_TO_STATE?o.payload:t(e,o)}export const buoyReduxMiddleware=t=>(middlewareActive=!0,storeDispatch=t.dispatch,e=>o=>{const r=o,n=r.type;if(n?.startsWith("@@buoy/"))return e(o);const i=performance.now(),a=t.getState(),c=e(o),s=t.getState(),d=performance.now()-i;return reduxActionStore.addAction(r,a,s,d),c});export function createBuoyReduxMiddleware(t={}){const{maxActions:e=200,ignoreActions:o=[]}=t;return reduxActionStore.setMaxActions(e),t=>(middlewareActive=!0,storeDispatch=t.dispatch,e=>r=>{const n=r,i=n.type||"";if(i?.startsWith("@@buoy/"))return e(r);if(o.includes(i))return e(r);const a=performance.now(),c=t.getState(),s=e(r),d=t.getState(),u=performance.now()-a;return reduxActionStore.addAction(n,c,d,u),s})}
+"use strict";
+
+/**
+ * Buoy Redux Middleware for Redux Toolkit
+ *
+ * @example
+ * ```tsx
+ * import { configureStore } from '@reduxjs/toolkit';
+ * import { buoyReduxMiddleware, withBuoyDevTools } from '@buoy-gg/redux';
+ *
+ * const store = configureStore({
+ *   reducer: withBuoyDevTools(rootReducer),  // Enable time-travel
+ *   middleware: (getDefaultMiddleware) =>
+ *     getDefaultMiddleware().concat(buoyReduxMiddleware),
+ * });
+ * ```
+ */
+
+import { reduxActionStore } from "./reduxActionStore";
+
+// ============================================
+// Middleware Active Tracking
+// ============================================
+
+/** Flag to indicate middleware is handling action capture */
+let middlewareActive = false;
+
+/**
+ * Check if the explicit middleware is active
+ * Used by auto-instrument to avoid duplicate capture
+ */
+export function isMiddlewareActive() {
+  return middlewareActive;
+}
+
+// ============================================
+// Time-Travel Action Types
+// ============================================
+
+export const BUOY_JUMP_TO_STATE = "@@buoy/JUMP_TO_STATE";
+export const BUOY_REPLAY_ACTION = "@@buoy/REPLAY_ACTION";
+// Store reference to dispatch for time-travel
+let storeDispatch = null;
+
+/**
+ * Jump to a specific state (time-travel)
+ */
+export function jumpToState(state) {
+  if (storeDispatch) {
+    storeDispatch({
+      type: BUOY_JUMP_TO_STATE,
+      payload: state
+    });
+  } else {
+    console.warn("[BuoyRedux] Cannot jump to state - middleware not initialized");
+  }
+}
+
+/**
+ * Replay an action (dispatch it again)
+ */
+export function replayAction(action) {
+  if (storeDispatch) {
+    // Dispatch the original action directly
+    storeDispatch(action);
+  } else {
+    console.warn("[BuoyRedux] Cannot replay action - middleware not initialized");
+  }
+}
+
+/**
+ * Wrap your root reducer to enable time-travel support
+ *
+ * @example
+ * ```tsx
+ * const store = configureStore({
+ *   reducer: withBuoyDevTools(rootReducer),
+ *   middleware: (getDefault) => getDefault().concat(buoyReduxMiddleware),
+ * });
+ * ```
+ */
+export function withBuoyDevTools(reducer) {
+  return (state, action) => {
+    // Handle jump to state action
+    if (action.type === BUOY_JUMP_TO_STATE) {
+      const jumpAction = action;
+      return jumpAction.payload;
+    }
+
+    // Pass through to original reducer
+    return reducer(state, action);
+  };
+}
+
+/**
+ * Default middleware - just add to your store!
+ */
+export const buoyReduxMiddleware = storeApi => {
+  // Mark middleware as active so auto-instrument knows to skip
+  middlewareActive = true;
+
+  // Store dispatch reference for time-travel
+  storeDispatch = storeApi.dispatch;
+  return next => action => {
+    const actionObj = action;
+    const actionType = actionObj.type;
+
+    // Don't record devtools internal actions
+    if (actionType?.startsWith("@@buoy/")) {
+      return next(action);
+    }
+    const startTime = performance.now();
+    const prevState = storeApi.getState();
+    const result = next(action);
+    const nextState = storeApi.getState();
+    const duration = performance.now() - startTime;
+    reduxActionStore.addAction(actionObj, prevState, nextState, duration);
+    return result;
+  };
+};
+
+/**
+ * Create middleware with custom options
+ */
+export function createBuoyReduxMiddleware(options = {}) {
+  const {
+    maxActions = 200,
+    ignoreActions = []
+  } = options;
+  reduxActionStore.setMaxActions(maxActions);
+  return storeApi => {
+    // Mark middleware as active so auto-instrument knows to skip
+    middlewareActive = true;
+
+    // Store dispatch reference for time-travel
+    storeDispatch = storeApi.dispatch;
+    return next => action => {
+      const actionObj = action;
+      const actionType = actionObj.type || "";
+
+      // Don't record devtools internal actions
+      if (actionType?.startsWith("@@buoy/")) {
+        return next(action);
+      }
+      if (ignoreActions.includes(actionType)) {
+        return next(action);
+      }
+      const startTime = performance.now();
+      const prevState = storeApi.getState();
+      const result = next(action);
+      const nextState = storeApi.getState();
+      const duration = performance.now() - startTime;
+      reduxActionStore.addAction(actionObj, prevState, nextState, duration);
+      return result;
+    };
+  };
+}

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

@@ -1 +1,142 @@
-"use strict";import{reduxActionStore}from"./reduxActionStore";import{ReduxIcon}from"../components/ReduxIcon";const REDUX_CAPABILITIES={timeTravel:!1,toggle:!1,edit:!1,diff:!0,export:!0,import:!1,reset:!0,recording:!0};function toHistoryEntry(t,e,r){return{id:t.id,label:t.type,timestamp:t.timestamp,data:t.payload??t.action,prevState:t.prevState,nextState:t.nextState,hasStateChange:t.hasStateChange,duration:t.duration,source:"redux",isCurrent:0===e,isInFuture:!1,isSkipped:!1,meta:{fullAction:t.action}}}export function createReduxHistoryAdapter(t){const{icon:e=ReduxIcon,color:r="#764ABC",name:n="Redux"}=t??{};let o=0;return{id:"redux",name:n,icon:e,color:r,capabilities:REDUX_CAPABILITIES,subscribe:t=>reduxActionStore.subscribe(()=>{t()}),getEntries:()=>{const t=reduxActionStore.getActions();return t.map((e,r)=>toHistoryEntry(e,r,t.length))},getEntryCount:()=>reduxActionStore.getActions().length,getCurrentState:()=>{const t=reduxActionStore.getActions();if(0!==t.length)return t[0].nextState},getStateAtEntry:t=>{const e=reduxActionStore.getActionById(String(t));return e?.nextState},get currentIndex(){return o},jumpTo:t=>{const e=reduxActionStore.getActions().findIndex(e=>e.id===String(t));-1!==e&&(o=e)},get isRecording(){return reduxActionStore.getEnabled()},setRecording:t=>{reduxActionStore.setEnabled(t)},reset:()=>{reduxActionStore.clearActions(),o=0},exportHistory:()=>{const t=reduxActionStore.getActions();return JSON.stringify(t,null,2)}}}export const reduxHistoryAdapter=createReduxHistoryAdapter();
+"use strict";
+
+/**
+ * Redux History Adapter
+ *
+ * Wraps the existing reduxActionStore to implement the universal HistoryAdapter interface.
+ */
+
+import { reduxActionStore } from "./reduxActionStore";
+import { ReduxIcon } from "../components/ReduxIcon";
+
+/**
+ * Redux adapter capabilities
+ * Note: Full time-travel requires the instrument() pattern from redux-devtools.
+ * This adapter provides history viewing with basic navigation.
+ */
+const REDUX_CAPABILITIES = {
+  timeTravel: false,
+  // Would need instrument() for true time travel
+  toggle: false,
+  // Would need instrument() for skip/toggle
+  edit: false,
+  diff: true,
+  // We have prevState/nextState
+  export: true,
+  import: false,
+  reset: true,
+  recording: true
+};
+
+/**
+ * Convert ReduxAction to HistoryEntry
+ */
+function toHistoryEntry(action, index, _total) {
+  return {
+    id: action.id,
+    label: action.type,
+    timestamp: action.timestamp,
+    data: action.payload ?? action.action,
+    prevState: action.prevState,
+    nextState: action.nextState,
+    hasStateChange: action.hasStateChange,
+    duration: action.duration,
+    source: "redux",
+    isCurrent: index === 0,
+    // Most recent is current
+    isInFuture: false,
+    isSkipped: false,
+    meta: {
+      fullAction: action.action
+    }
+  };
+}
+
+/**
+ * Options for creating a Redux history adapter
+ */
+
+/**
+ * Create a Redux history adapter
+ *
+ * @param options - Optional configuration
+ * @returns HistoryAdapter instance
+ */
+export function createReduxHistoryAdapter(options) {
+  const {
+    icon = ReduxIcon,
+    color = "#764ABC",
+    // Redux purple
+    name = "Redux"
+  } = options ?? {};
+  let currentIndex = 0;
+  const adapter = {
+    // === Identity ===
+    id: "redux",
+    name,
+    icon,
+    color,
+    capabilities: REDUX_CAPABILITIES,
+    // === Subscription ===
+    subscribe: callback => {
+      return reduxActionStore.subscribe(() => {
+        callback();
+      });
+    },
+    // === Data Access ===
+    getEntries: () => {
+      const actions = reduxActionStore.getActions();
+      return actions.map((action, index) => toHistoryEntry(action, index, actions.length));
+    },
+    getEntryCount: () => {
+      return reduxActionStore.getActions().length;
+    },
+    getCurrentState: () => {
+      const actions = reduxActionStore.getActions();
+      if (actions.length === 0) return undefined;
+      // Most recent action's nextState is current state
+      return actions[0].nextState;
+    },
+    getStateAtEntry: entryId => {
+      const action = reduxActionStore.getActionById(String(entryId));
+      return action?.nextState;
+    },
+    // === Navigation ===
+    get currentIndex() {
+      return currentIndex;
+    },
+    jumpTo: entryId => {
+      const actions = reduxActionStore.getActions();
+      const index = actions.findIndex(a => a.id === String(entryId));
+      if (index !== -1) {
+        currentIndex = index;
+        // Note: This doesn't actually change app state without instrument()
+        // It just updates which entry is "selected" for viewing
+      }
+    },
+    // === Recording ===
+    get isRecording() {
+      return reduxActionStore.getEnabled();
+    },
+    setRecording: enabled => {
+      reduxActionStore.setEnabled(enabled);
+    },
+    // === Reset ===
+    reset: () => {
+      reduxActionStore.clearActions();
+      currentIndex = 0;
+    },
+    // === Export ===
+    exportHistory: () => {
+      const actions = reduxActionStore.getActions();
+      return JSON.stringify(actions, null, 2);
+    }
+  };
+  return adapter;
+}
+
+/**
+ * Default Redux adapter instance
+ * Use this if you only have one Redux store
+ */
+export const reduxHistoryAdapter = createReduxHistoryAdapter();

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

@@ -1 +1,8 @@
-"use strict";export{reduxActionStore}from"./reduxActionStore";export{buoyReduxMiddleware,createBuoyReduxMiddleware,withBuoyDevTools,jumpToState,replayAction,BUOY_JUMP_TO_STATE,BUOY_REPLAY_ACTION}from"./buoyReduxMiddleware";export{createReduxHistoryAdapter,reduxHistoryAdapter}from"./createReduxHistoryAdapter";export{instrumentStore,uninstrumentStore,isStoreInstrumented,isAutoInstrumentActive,getActiveStore,jumpToState as autoJumpToState,replayAction as autoReplayAction}from"./autoInstrument";
+"use strict";
+
+export { reduxActionStore } from "./reduxActionStore";
+export { buoyReduxMiddleware, createBuoyReduxMiddleware, withBuoyDevTools, jumpToState, replayAction, BUOY_JUMP_TO_STATE, BUOY_REPLAY_ACTION } from "./buoyReduxMiddleware";
+export { createReduxHistoryAdapter, reduxHistoryAdapter } from "./createReduxHistoryAdapter";
+
+// Auto-instrumentation (zero-config)
+export { instrumentStore, uninstrumentStore, isStoreInstrumented, isAutoInstrumentActive, getActiveStore, jumpToState as autoJumpToState, replayAction as autoReplayAction } from "./autoInstrument";