@okyrychenko-dev/react-action-guard 0.7.0 → 1.0.1

package/dist/index.js

@@ -1,13 +1,12 @@
-import { useRef, useCallback, useEffect, useMemo, useState } from 'react';
 import { createStoreProvider, createShallowStore } from '@okyrychenko-dev/react-zustand-toolkit';
-export { createShallowStore } from '@okyrychenko-dev/react-zustand-toolkit';
 import { useStore } from 'zustand';
 import 'zustand/react/shallow';
 import { jsx } from 'react/jsx-runtime';
 import { useShallow } from 'zustand/shallow';
 import { devtools } from 'zustand/middleware';
+import { useRef, useCallback, useEffect, useMemo, useState } from 'react';
 
-// src/hooks/useAsyncAction/useAsyncAction.ts
+// src/context/UIBlockingContext.tsx
 
 // src/store/uiBlockingStore.constants.ts
 var DEFAULT_SCOPE = "global";
@@ -55,11 +54,10 @@ var createUIBlockingActions = (set, get) => ({
   },
   runMiddlewares: async (context) => {
     const { middlewares } = get();
-    for (const [name, middleware] of middlewares) {
+    for (const [, middleware] of middlewares) {
       try {
         await middleware(context);
-      } catch (error) {
-        console.error(`[UIBlocking] Middleware "${name}" error:`, error);
+      } catch {
       }
     }
   },
@@ -353,7 +351,8 @@ var createUIBlockingActions = (set, get) => ({
     for (const [id, blocker] of activeBlockers) {
       const blockerScopes = normalizeScopeToArray(blocker.scope);
       if (blocker.scope === DEFAULT_SCOPE || blockerScopes.includes(scope)) {
-        blockers.push({ id, ...blocker });
+        const { timeoutId: _timeoutId, ...publicBlocker } = blocker;
+        blockers.push({ id, ...publicBlocker });
       }
     }
     return blockers.sort((a, b) => b.priority - a.priority);
@@ -449,18 +448,24 @@ var createUIBlockingActions = (set, get) => ({
 });
 var {
   Provider: BaseUIBlockingProvider,
-  useContext: useUIBlockingContext,
-  useContextStore: useUIBlockingStoreFromContext,
+  useContextStoreApi: useUIBlockingContext,
+  useContextStore: baseUseUIBlockingStoreFromContext,
   useIsInsideProvider: useIsInsideUIBlockingProvider,
-  useOptionalContext
+  useContextStoreOptional: useOptionalUIBlockingContext
 } = createStoreProvider(createUIBlockingActions, "UIBlocking");
+function useUIBlockingStoreFromContext(selector, equalityFn) {
+  if (selector) {
+    return baseUseUIBlockingStoreFromContext(selector, equalityFn);
+  }
+  return baseUseUIBlockingStoreFromContext();
+}
 function UIBlockingProvider({
   children,
   enableDevtools = process.env.NODE_ENV === "development",
   devtoolsName = "UIBlocking",
   middlewares = []
 }) {
-  const handleStoreCreate = (store) => {
+  const handleStoreInit = (store) => {
     middlewares.forEach((mw, index) => {
       store.getState().registerMiddleware(`provider-middleware-${index.toString()}`, mw);
     });
@@ -470,7 +475,7 @@ function UIBlockingProvider({
     {
       enableDevtools,
       devtoolsName,
-      onStoreCreate: handleStoreCreate,
+      onStoreInit: handleStoreInit,
       children
     }
   );
@@ -483,24 +488,31 @@ var devtoolsConfig = {
 };
 
 // src/store/uiBlockingStore.store.ts
-var { useStore: useUIBlockingStore, useStoreApi: uiBlockingStoreApi } = createShallowStore(devtools(createUIBlockingActions, devtoolsConfig));
+var storeBindings = createShallowStore(
+  devtools(createUIBlockingActions, devtoolsConfig)
+);
+var uiBlockingStoreApi = storeBindings.useStoreApi;
+function useUIBlockingStore(selector, equalityFn) {
+  if (selector) {
+    return storeBindings.useStore(selector, equalityFn);
+  }
+  return storeBindings.useStore();
+}
 
 // src/context/useResolvedStore.ts
 function useOptionalContextStore() {
-  return useOptionalContext();
+  return useOptionalUIBlockingContext();
 }
-function useResolvedStore() {
+function useResolvedStoreApi() {
   const contextStore = useOptionalContextStore();
   return contextStore ?? uiBlockingStoreApi;
 }
-function useResolvedStoreWithSelector(selector) {
-  const store = useResolvedStore();
+function useResolvedValue(selector) {
+  const store = useResolvedStoreApi();
   return useStore(store, useShallow(selector));
 }
-
-// src/hooks/useAsyncAction/useAsyncAction.ts
 function useAsyncAction(actionId, scope, options) {
-  const { addBlocker, removeBlocker } = useResolvedStoreWithSelector((state) => ({
+  const { addBlocker, removeBlocker } = useResolvedValue((state) => ({
     addBlocker: state.addBlocker,
     removeBlocker: state.removeBlocker
   }));
@@ -527,19 +539,33 @@ function useAsyncAction(actionId, scope, options) {
   return executeWithBlocking;
 }
 function useBlocker(blockerId, config, isActive = true) {
-  const { addBlocker, removeBlocker } = useResolvedStoreWithSelector((state) => ({
+  const { addBlocker, removeBlocker, updateBlocker } = useResolvedValue((state) => ({
     addBlocker: state.addBlocker,
-    removeBlocker: state.removeBlocker
+    removeBlocker: state.removeBlocker,
+    updateBlocker: state.updateBlocker
   }));
+  const lastConfigRef = useRef(null);
   useEffect(() => {
     if (!isActive || !blockerId) {
       return;
     }
     addBlocker(blockerId, config);
+    lastConfigRef.current = config;
     return () => {
+      lastConfigRef.current = null;
       removeBlocker(blockerId);
     };
   }, [blockerId, isActive, addBlocker, removeBlocker]);
+  useEffect(() => {
+    if (!isActive || !blockerId) {
+      return;
+    }
+    if (lastConfigRef.current === config) {
+      return;
+    }
+    updateBlocker(blockerId, config);
+    lastConfigRef.current = config;
+  }, [blockerId, config, isActive, updateBlocker]);
 }
 
 // src/hooks/useBlocker/useBlocker.utils.ts
@@ -551,7 +577,7 @@ function createBlockerConfig(config) {
   };
 }
 function useBlockingInfo(scope = DEFAULT_SCOPE) {
-  const store = useResolvedStore();
+  const store = useResolvedStoreApi();
   const activeBlockers = useStore(store, (state) => state.activeBlockers);
   return useMemo(() => {
     return store.getState().getBlockingInfo(scope);
@@ -567,7 +593,7 @@ function useConfigRef(config) {
 
 // src/hooks/useConditionalBlocker/useConditionalBlocker.ts
 function useConditionalBlocker(blockerId, config) {
-  const { addBlocker, removeBlocker } = useResolvedStoreWithSelector((state) => ({
+  const { addBlocker, removeBlocker } = useResolvedValue((state) => ({
     addBlocker: state.addBlocker,
     removeBlocker: state.removeBlocker
   }));
@@ -622,9 +648,6 @@ function useConfirmableBlocker(blockerId, config) {
     setIsExecuting(true);
     try {
       await config.onConfirm();
-    } catch (error) {
-      console.error("[UIBlocking] Confirmable action error:", error);
-      throw error;
     } finally {
       setIsExecuting(false);
     }
@@ -650,7 +673,7 @@ function useConfirmableBlocker(blockerId, config) {
 
 // src/hooks/useIsBlocked/useIsBlocked.ts
 function useIsBlocked(scope) {
-  return useResolvedStoreWithSelector((state) => state.isBlocked(scope));
+  return useResolvedValue((state) => state.isBlocked(scope));
 }
 
 // src/hooks/useScheduledBlocker/useScheduledBlocker.utils.ts
@@ -692,7 +715,7 @@ function isScheduleInPast(startTime, endTime, now) {
 
 // src/hooks/useScheduledBlocker/useScheduledBlocker.ts
 function useScheduledBlocker(blockerId, config) {
-  const { addBlocker, removeBlocker } = useResolvedStoreWithSelector((state) => ({
+  const { addBlocker, removeBlocker } = useResolvedValue((state) => ({
     addBlocker: state.addBlocker,
     removeBlocker: state.removeBlocker
   }));
@@ -713,7 +736,6 @@ function useScheduledBlocker(blockerId, config) {
     const startTime = parseDate(currentConfig.schedule.start);
     const now = Date.now();
     if (!isValidTimestamp(startTime)) {
-      console.error(`[UIBlocking] Invalid start time for blocker "${blockerId}"`);
       return;
     }
     const scheduleEnd = () => {
@@ -738,9 +760,6 @@ function useScheduledBlocker(blockerId, config) {
     if (startTime > now) {
       const delay = startTime - now;
       if (!isSafeTimeout(delay)) {
-        console.warn(
-          `[UIBlocking] Schedule delay exceeds maximum timeout (${MAX_TIMEOUT_MS.toString()}ms) for blocker "${blockerId}"`
-        );
         return;
       }
       timeoutsRef.current.start = setTimeout(startBlocking, delay);
@@ -749,7 +768,7 @@ function useScheduledBlocker(blockerId, config) {
       if (isInBlockingPeriod(startTime, endTime, now)) {
         startBlocking();
       } else if (isScheduleInPast(startTime, endTime, now)) {
-        console.warn(`[UIBlocking] Schedule is in the past for blocker "${blockerId}"`);
+        return;
       }
     }
     return () => {
@@ -763,6 +782,12 @@ function useScheduledBlocker(blockerId, config) {
 function capitalizeFirst(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+function getAnalyticsWindow() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window;
+}
 function buildEventData(context) {
   const eventData = {
     blocker_id: context.blockerId
@@ -780,20 +805,23 @@ function buildEventData(context) {
   return eventData;
 }
 function trackGoogleAnalytics(action, eventData) {
-  if (window.gtag) {
-    window.gtag("event", `ui_blocking_${action}`, eventData);
+  const analyticsWindow = getAnalyticsWindow();
+  if (analyticsWindow?.gtag) {
+    analyticsWindow.gtag("event", `ui_blocking_${action}`, eventData);
   }
 }
 function trackMixpanel(action, eventData) {
-  if (window.mixpanel) {
+  const analyticsWindow = getAnalyticsWindow();
+  if (analyticsWindow?.mixpanel) {
     const eventName = `UI Blocking ${action.split("_").map(capitalizeFirst).join(" ")}`;
-    window.mixpanel.track(eventName, eventData);
+    analyticsWindow.mixpanel.track(eventName, eventData);
   }
 }
 function trackAmplitude(action, eventData) {
-  if (window.amplitude) {
+  const analyticsWindow = getAnalyticsWindow();
+  if (analyticsWindow?.amplitude) {
     const eventName = `UI Blocking ${action.split("_").map(capitalizeFirst).join(" ")}`;
-    window.amplitude.track(eventName, eventData);
+    analyticsWindow.amplitude.track(eventName, eventData);
   }
 }
 function trackCustom(trackFn, action, eventData) {
@@ -830,10 +858,16 @@ function createAnalyticsMiddleware(config) {
 }
 
 // src/middleware/configureMiddleware.ts
+var CONFIGURE_MIDDLEWARE_PREFIX = "middleware-";
 function configureMiddleware(middlewares) {
   const store = uiBlockingStoreApi.getState();
+  store.middlewares.forEach((_, name) => {
+    if (name.startsWith(CONFIGURE_MIDDLEWARE_PREFIX)) {
+      store.unregisterMiddleware(name);
+    }
+  });
   middlewares.forEach((middleware, index) => {
-    const name = `middleware-${index.toString()}`;
+    const name = `${CONFIGURE_MIDDLEWARE_PREFIX}${index.toString()}`;
     store.registerMiddleware(name, middleware);
   });
 }
@@ -917,9 +951,6 @@ function handleRemoveAction(context, blockStartTimes, slowBlockThreshold, onSlow
   const duration = context.timestamp - startTime;
   blockStartTimes.delete(context.blockerId);
   if (duration >= slowBlockThreshold) {
-    console.warn(
-      `[UIBlocking] Slow block detected: "${context.blockerId}" took ${duration.toString()}ms`
-    );
     onSlowBlock?.(context.blockerId, duration);
   }
 }
@@ -951,6 +982,17 @@ function createTypedHooks() {
   };
 }
 
-export { UIBlockingProvider, configureMiddleware, createAnalyticsMiddleware, createPerformanceMiddleware, createTypedHooks, loggerMiddleware, uiBlockingStoreApi, useAsyncAction, useBlocker, useBlockingInfo, useConditionalBlocker, useConfirmableBlocker, useIsBlocked, useIsInsideUIBlockingProvider, useScheduledBlocker, useUIBlockingContext, useUIBlockingStore, useUIBlockingStoreFromContext };
+// src/index.ts
+function useOptionalContext() {
+  return useOptionalUIBlockingContext();
+}
+function useResolvedStore() {
+  return useResolvedStoreApi();
+}
+function useResolvedStoreWithSelector(selector) {
+  return useResolvedValue(selector);
+}
+
+export { UIBlockingProvider, configureMiddleware, createAnalyticsMiddleware, createPerformanceMiddleware, createTypedHooks, loggerMiddleware, uiBlockingStoreApi, useAsyncAction, useBlocker, useBlockingInfo, useConditionalBlocker, useConfirmableBlocker, useIsBlocked, useIsInsideUIBlockingProvider, useOptionalContext, useOptionalUIBlockingContext, useResolvedStore, useResolvedStoreApi, useResolvedStoreWithSelector, useResolvedValue, useScheduledBlocker, useUIBlockingContext, useUIBlockingStore, useUIBlockingStoreFromContext };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map