@okyrychenko-dev/react-action-guard 0.2.2 → 0.3.0

package/dist/index.d.cts

@@ -1,17 +1,16 @@
-import * as zustand from 'zustand';
-
-type BlockingAction = "add" | "remove" | "update" | "cancel" | "timeout";
-type MiddlewareBlockerConfig = BlockerConfig;
-interface MiddlewareContext {
-    action: BlockingAction;
-    blockerId: string;
-    config?: MiddlewareBlockerConfig;
-    timestamp: number;
-    prevState?: MiddlewareBlockerConfig;
-}
-type Middleware = (context: MiddlewareContext) => void | Promise<void>;
-
-declare const loggerMiddleware: Middleware;
+/**
+ * Hook to wrap async functions with automatic blocking/unblocking
+ *
+ * Creates a wrapper function that automatically adds a blocker before executing
+ * the async function and removes it after completion (success or failure).
+ *
+ * @template T - The return type of the async function
+ * @param actionId - Unique identifier for the action (used in blocker ID and reason)
+ * @param scope - Scope(s) to block during execution (default: "global")
+ * @returns Function that wraps async functions with blocking behavior
+ *
+ */
+declare const useAsyncAction: <T = unknown>(actionId: string, scope?: string | ReadonlyArray<string>) => ((asyncFn: () => Promise<T>) => Promise<T>);
 
 type AnalyticsEventData = Record<string, string | number | ReadonlyArray<string> | undefined>;
 type AnalyticsProvider = "ga" | "mixpanel" | "amplitude";
@@ -29,8 +28,21 @@ interface CustomAnalyticsConfig {
 }
 type AnalyticsConfig = GoogleAnalyticsConfig | MixpanelConfig | AmplitudeConfig | CustomAnalyticsConfig;
 
+type BlockingAction = "add" | "remove" | "update" | "cancel" | "timeout";
+type MiddlewareBlockerConfig = BlockerConfig;
+interface MiddlewareContext {
+    action: BlockingAction;
+    blockerId: string;
+    config?: MiddlewareBlockerConfig;
+    timestamp: number;
+    prevState?: MiddlewareBlockerConfig;
+}
+type Middleware = (context: MiddlewareContext) => void | Promise<void>;
+
 declare const createAnalyticsMiddleware: (config: AnalyticsConfig) => Middleware;
 
+declare const loggerMiddleware: Middleware;
+
 interface PerformanceConfig {
     slowBlockThreshold?: number;
     onSlowBlock?: (blockerId: string, duration: number) => void;
@@ -98,25 +110,10 @@ type UIBlockingStore = UIBlockingStoreState & UIBlockingStoreActions;
  * - Scope-based blocking (global, specific areas, or multiple scopes)
  * - Automatic cleanup on unmount (when using hooks)
  * - DevTools integration for debugging
+ * - Automatic shallow comparison for selectors
  *
  */
-declare const useUIBlockingStore: zustand.UseBoundStore<Omit<zustand.StoreApi<UIBlockingStore>, "setState" | "devtools"> & {
-    setState(partial: UIBlockingStore | Partial<UIBlockingStore> | ((state: UIBlockingStore) => UIBlockingStore | Partial<UIBlockingStore>), replace?: false | undefined, action?: (string | {
-        [x: string]: unknown;
-        [x: number]: unknown;
-        [x: symbol]: unknown;
-        type: string;
-    }) | undefined): void;
-    setState(state: UIBlockingStore | ((state: UIBlockingStore) => UIBlockingStore), replace: true, action?: (string | {
-        [x: string]: unknown;
-        [x: number]: unknown;
-        [x: symbol]: unknown;
-        type: string;
-    }) | undefined): void;
-    devtools: {
-        cleanup: () => void;
-    };
-}>;
+declare const useUIBlockingStore: <T>(selector: (state: UIBlockingStore) => T) => T;
 
 /**
  * Hook to automatically add and remove a blocker based on component lifecycle
@@ -131,32 +128,6 @@ declare const useUIBlockingStore: zustand.UseBoundStore<Omit<zustand.StoreApi<UI
  */
 declare const useBlocker: (blockerId: string, config: BlockerConfig, isActive?: boolean) => void;
 
-/**
- * Hook to check if a scope is currently blocked
- *
- * Returns a boolean indicating whether the specified scope(s) are blocked.
- * Automatically re-renders when the blocking state changes.
- *
- * @param scope - Scope or array of scopes to check (default: "global")
- * @returns True if any of the specified scopes are blocked
- *
- */
-declare const useIsBlocked: (scope?: string | ReadonlyArray<string>) => boolean;
-
-/**
- * Hook to wrap async functions with automatic blocking/unblocking
- *
- * Creates a wrapper function that automatically adds a blocker before executing
- * the async function and removes it after completion (success or failure).
- *
- * @template T - The return type of the async function
- * @param actionId - Unique identifier for the action (used in blocker ID and reason)
- * @param scope - Scope(s) to block during execution (default: "global")
- * @returns Function that wraps async functions with blocking behavior
- *
- */
-declare const useAsyncAction: <T = unknown>(actionId: string, scope?: string | ReadonlyArray<string>) => ((asyncFn: () => Promise<T>) => Promise<T>);
-
 /**
  * Configuration for conditional blocker hook.
  *
@@ -233,6 +204,18 @@ interface UseConfirmableBlockerReturn {
  */
 declare const useConfirmableBlocker: (blockerId: string, config: ConfirmableBlockerConfig) => UseConfirmableBlockerReturn;
 
+/**
+ * Hook to check if a scope is currently blocked
+ *
+ * Returns a boolean indicating whether the specified scope(s) are blocked.
+ * Automatically re-renders when the blocking state changes.
+ *
+ * @param scope - Scope or array of scopes to check (default: "global")
+ * @returns True if any of the specified scopes are blocked
+ *
+ */
+declare const useIsBlocked: (scope?: string | ReadonlyArray<string>) => boolean;
+
 /**
  * Schedule configuration for time-based blocking.
  *

package/dist/index.d.ts

@@ -1,17 +1,16 @@
-import * as zustand from 'zustand';
-
-type BlockingAction = "add" | "remove" | "update" | "cancel" | "timeout";
-type MiddlewareBlockerConfig = BlockerConfig;
-interface MiddlewareContext {
-    action: BlockingAction;
-    blockerId: string;
-    config?: MiddlewareBlockerConfig;
-    timestamp: number;
-    prevState?: MiddlewareBlockerConfig;
-}
-type Middleware = (context: MiddlewareContext) => void | Promise<void>;
-
-declare const loggerMiddleware: Middleware;
+/**
+ * Hook to wrap async functions with automatic blocking/unblocking
+ *
+ * Creates a wrapper function that automatically adds a blocker before executing
+ * the async function and removes it after completion (success or failure).
+ *
+ * @template T - The return type of the async function
+ * @param actionId - Unique identifier for the action (used in blocker ID and reason)
+ * @param scope - Scope(s) to block during execution (default: "global")
+ * @returns Function that wraps async functions with blocking behavior
+ *
+ */
+declare const useAsyncAction: <T = unknown>(actionId: string, scope?: string | ReadonlyArray<string>) => ((asyncFn: () => Promise<T>) => Promise<T>);
 
 type AnalyticsEventData = Record<string, string | number | ReadonlyArray<string> | undefined>;
 type AnalyticsProvider = "ga" | "mixpanel" | "amplitude";
@@ -29,8 +28,21 @@ interface CustomAnalyticsConfig {
 }
 type AnalyticsConfig = GoogleAnalyticsConfig | MixpanelConfig | AmplitudeConfig | CustomAnalyticsConfig;
 
+type BlockingAction = "add" | "remove" | "update" | "cancel" | "timeout";
+type MiddlewareBlockerConfig = BlockerConfig;
+interface MiddlewareContext {
+    action: BlockingAction;
+    blockerId: string;
+    config?: MiddlewareBlockerConfig;
+    timestamp: number;
+    prevState?: MiddlewareBlockerConfig;
+}
+type Middleware = (context: MiddlewareContext) => void | Promise<void>;
+
 declare const createAnalyticsMiddleware: (config: AnalyticsConfig) => Middleware;
 
+declare const loggerMiddleware: Middleware;
+
 interface PerformanceConfig {
     slowBlockThreshold?: number;
     onSlowBlock?: (blockerId: string, duration: number) => void;
@@ -98,25 +110,10 @@ type UIBlockingStore = UIBlockingStoreState & UIBlockingStoreActions;
  * - Scope-based blocking (global, specific areas, or multiple scopes)
  * - Automatic cleanup on unmount (when using hooks)
  * - DevTools integration for debugging
+ * - Automatic shallow comparison for selectors
  *
  */
-declare const useUIBlockingStore: zustand.UseBoundStore<Omit<zustand.StoreApi<UIBlockingStore>, "setState" | "devtools"> & {
-    setState(partial: UIBlockingStore | Partial<UIBlockingStore> | ((state: UIBlockingStore) => UIBlockingStore | Partial<UIBlockingStore>), replace?: false | undefined, action?: (string | {
-        [x: string]: unknown;
-        [x: number]: unknown;
-        [x: symbol]: unknown;
-        type: string;
-    }) | undefined): void;
-    setState(state: UIBlockingStore | ((state: UIBlockingStore) => UIBlockingStore), replace: true, action?: (string | {
-        [x: string]: unknown;
-        [x: number]: unknown;
-        [x: symbol]: unknown;
-        type: string;
-    }) | undefined): void;
-    devtools: {
-        cleanup: () => void;
-    };
-}>;
+declare const useUIBlockingStore: <T>(selector: (state: UIBlockingStore) => T) => T;
 
 /**
  * Hook to automatically add and remove a blocker based on component lifecycle
@@ -131,32 +128,6 @@ declare const useUIBlockingStore: zustand.UseBoundStore<Omit<zustand.StoreApi<UI
  */
 declare const useBlocker: (blockerId: string, config: BlockerConfig, isActive?: boolean) => void;
 
-/**
- * Hook to check if a scope is currently blocked
- *
- * Returns a boolean indicating whether the specified scope(s) are blocked.
- * Automatically re-renders when the blocking state changes.
- *
- * @param scope - Scope or array of scopes to check (default: "global")
- * @returns True if any of the specified scopes are blocked
- *
- */
-declare const useIsBlocked: (scope?: string | ReadonlyArray<string>) => boolean;
-
-/**
- * Hook to wrap async functions with automatic blocking/unblocking
- *
- * Creates a wrapper function that automatically adds a blocker before executing
- * the async function and removes it after completion (success or failure).
- *
- * @template T - The return type of the async function
- * @param actionId - Unique identifier for the action (used in blocker ID and reason)
- * @param scope - Scope(s) to block during execution (default: "global")
- * @returns Function that wraps async functions with blocking behavior
- *
- */
-declare const useAsyncAction: <T = unknown>(actionId: string, scope?: string | ReadonlyArray<string>) => ((asyncFn: () => Promise<T>) => Promise<T>);
-
 /**
  * Configuration for conditional blocker hook.
  *
@@ -233,6 +204,18 @@ interface UseConfirmableBlockerReturn {
  */
 declare const useConfirmableBlocker: (blockerId: string, config: ConfirmableBlockerConfig) => UseConfirmableBlockerReturn;
 
+/**
+ * Hook to check if a scope is currently blocked
+ *
+ * Returns a boolean indicating whether the specified scope(s) are blocked.
+ * Automatically re-renders when the blocking state changes.
+ *
+ * @param scope - Scope or array of scopes to check (default: "global")
+ * @returns True if any of the specified scopes are blocked
+ *
+ */
+declare const useIsBlocked: (scope?: string | ReadonlyArray<string>) => boolean;
+
 /**
  * Schedule configuration for time-based blocking.
  *

package/dist/index.js

@@ -1,8 +1,9 @@
-import { useEffect, useCallback, useRef, useState } from 'react';
-import { create } from 'zustand';
+import { useCallback, useEffect, useRef, useState } from 'react';
 import { devtools } from 'zustand/middleware';
+import { createStore, useStore } from 'zustand';
+import { useShallow } from 'zustand/shallow';
 
-// src/hooks/useBlocker.ts
+// src/hooks/useAsyncAction/useAsyncAction.ts
 
 // src/store/uiBlockingStore.constants.ts
 var DEFAULT_SCOPE = "global";
@@ -10,8 +11,13 @@ var DEFAULT_REASON = "Unknown";
 var DEFAULT_PRIORITY = 0;
 var ASYNC_ACTION_PRIORITY = 20;
 var DEVTOOLS_NAME = "UIBlocking";
-
-// src/store/uiBlockingStore.utils.ts
+function createShallowStore(storeCreator) {
+  const storeApi = createStore(storeCreator);
+  const useScopedStore = (selector) => {
+    return useStore(storeApi, useShallow(selector));
+  };
+  return { useStore: useScopedStore, useStoreApi: storeApi };
+}
 function normalizeScopeToArray(scope) {
   if (typeof scope === "string") {
     return [scope];
@@ -176,30 +182,14 @@ var devtoolsConfig = {
 };
 
 // src/store/uiBlockingStore.store.ts
-var useUIBlockingStore = create()(
-  devtools(createUIBlockingActions, devtoolsConfig)
-);
-
-// src/hooks/useBlocker.ts
-var useBlocker = (blockerId, config, isActive = true) => {
-  const { addBlocker, removeBlocker } = useUIBlockingStore();
-  useEffect(() => {
-    if (!isActive || !blockerId) {
-      return;
-    }
-    addBlocker(blockerId, config);
-    return () => {
-      removeBlocker(blockerId);
-    };
-  }, [blockerId, isActive, addBlocker, removeBlocker]);
-};
+var { useStore: useUIBlockingStore} = createShallowStore(devtools(createUIBlockingActions, devtoolsConfig));
 
-// src/hooks/useIsBlocked.ts
-var useIsBlocked = (scope) => {
-  return useUIBlockingStore((state) => state.isBlocked(scope));
-};
+// src/hooks/useAsyncAction/useAsyncAction.ts
 var useAsyncAction = (actionId, scope) => {
-  const { addBlocker, removeBlocker } = useUIBlockingStore();
+  const { addBlocker, removeBlocker } = useUIBlockingStore((state) => ({
+    addBlocker: state.addBlocker,
+    removeBlocker: state.removeBlocker
+  }));
   const executeWithBlocking = useCallback(
     async (asyncFn) => {
       const blockerId = `${actionId}-${Date.now().toString()}`;
@@ -218,15 +208,23 @@ var useAsyncAction = (actionId, scope) => {
   );
   return executeWithBlocking;
 };
-function useConfigRef(config) {
-  const configRef = useRef(config);
+var useBlocker = (blockerId, config, isActive = true) => {
+  const { addBlocker, removeBlocker } = useUIBlockingStore((state) => ({
+    addBlocker: state.addBlocker,
+    removeBlocker: state.removeBlocker
+  }));
   useEffect(() => {
-    configRef.current = config;
-  }, [config]);
-  return configRef;
-}
+    if (!isActive || !blockerId) {
+      return;
+    }
+    addBlocker(blockerId, config);
+    return () => {
+      removeBlocker(blockerId);
+    };
+  }, [blockerId, isActive, addBlocker, removeBlocker]);
+};
 
-// src/hooks/useBlocker.utils.ts
+// src/hooks/useBlocker/useBlocker.utils.ts
 function createBlockerConfig(config) {
   return {
     scope: config.scope,
@@ -234,10 +232,20 @@ function createBlockerConfig(config) {
     priority: config.priority
   };
 }
+function useConfigRef(config) {
+  const configRef = useRef(config);
+  useEffect(() => {
+    configRef.current = config;
+  }, [config]);
+  return configRef;
+}
 
-// src/hooks/useConditionalBlocker.ts
+// src/hooks/useConditionalBlocker/useConditionalBlocker.ts
 var useConditionalBlocker = (blockerId, config) => {
-  const { addBlocker, removeBlocker } = useUIBlockingStore();
+  const { addBlocker, removeBlocker } = useUIBlockingStore((state) => ({
+    addBlocker: state.addBlocker,
+    removeBlocker: state.removeBlocker
+  }));
   const intervalRef = useRef(null);
   const isBlockedRef = useRef(false);
   const configRef = useConfigRef(config);
@@ -249,11 +257,10 @@ var useConditionalBlocker = (blockerId, config) => {
     }
     if (shouldBlock) {
       addBlocker(blockerId, createBlockerConfig(currentConfig));
-      isBlockedRef.current = true;
     } else {
       removeBlocker(blockerId);
-      isBlockedRef.current = false;
     }
+    isBlockedRef.current = shouldBlock;
   }, [blockerId, addBlocker, removeBlocker, configRef]);
   useEffect(() => {
     checkCondition();
@@ -315,8 +322,55 @@ var useConfirmableBlocker = (blockerId, config) => {
     onCancel
   };
 };
+
+// src/hooks/useIsBlocked/useIsBlocked.ts
+var useIsBlocked = (scope) => {
+  return useUIBlockingStore((state) => state.isBlocked(scope));
+};
+
+// src/hooks/useScheduledBlocker/useScheduledBlocker.utils.ts
+var MAX_TIMEOUT_MS = 2147483647;
+function parseDate(date) {
+  return new Date(date).getTime();
+}
+function isValidTimestamp(timestamp) {
+  return !Number.isNaN(timestamp);
+}
+function calculateEndTime(schedule, startTime) {
+  if (schedule.duration) {
+    return startTime + schedule.duration;
+  }
+  if (schedule.end) {
+    const endTime = parseDate(schedule.end);
+    return isValidTimestamp(endTime) ? endTime : void 0;
+  }
+  return void 0;
+}
+function isSafeTimeout(delay) {
+  return delay > 0 && delay <= MAX_TIMEOUT_MS;
+}
+function isInBlockingPeriod(startTime, endTime, now) {
+  if (startTime > now) {
+    return false;
+  }
+  if (!endTime) {
+    return true;
+  }
+  return endTime > now;
+}
+function isScheduleInPast(startTime, endTime, now) {
+  if (!endTime) {
+    return false;
+  }
+  return endTime <= now && startTime <= now;
+}
+
+// src/hooks/useScheduledBlocker/useScheduledBlocker.ts
 var useScheduledBlocker = (blockerId, config) => {
-  const { addBlocker, removeBlocker } = useUIBlockingStore();
+  const { addBlocker, removeBlocker } = useUIBlockingStore((state) => ({
+    addBlocker: state.addBlocker,
+    removeBlocker: state.removeBlocker
+  }));
   const timeoutsRef = useRef({});
   const configRef = useConfigRef(config);
   const cleanup = useCallback(() => {
@@ -331,41 +385,47 @@ var useScheduledBlocker = (blockerId, config) => {
   }, []);
   useEffect(() => {
     const currentConfig = configRef.current;
-    const startTime = new Date(currentConfig.schedule.start).getTime();
+    const startTime = parseDate(currentConfig.schedule.start);
     const now = Date.now();
-    let endTime;
-    if (currentConfig.schedule.duration) {
-      endTime = startTime + currentConfig.schedule.duration;
-    } else if (currentConfig.schedule.end) {
-      endTime = new Date(currentConfig.schedule.end).getTime();
+    if (!isValidTimestamp(startTime)) {
+      console.error(`[UIBlocking] Invalid start time for blocker "${blockerId}"`);
+      return;
     }
-    const scheduleEnd = (end) => {
-      const remainingTime = end - Date.now();
+    const scheduleEnd = () => {
+      const endTime = calculateEndTime(currentConfig.schedule, startTime);
+      if (!endTime) {
+        return;
+      }
+      const remainingTime = endTime - Date.now();
       if (remainingTime > 0) {
         timeoutsRef.current.end = setTimeout(() => {
-          removeBlocker(blockerId);
           configRef.current.onScheduleEnd?.();
+          removeBlocker(blockerId);
         }, remainingTime);
       }
     };
+    const startBlocking = () => {
+      const cfg = configRef.current;
+      addBlocker(blockerId, createBlockerConfig(cfg));
+      cfg.onScheduleStart?.();
+      scheduleEnd();
+    };
     if (startTime > now) {
-      timeoutsRef.current.start = setTimeout(() => {
-        const cfg = configRef.current;
-        addBlocker(blockerId, createBlockerConfig(cfg));
-        cfg.onScheduleStart?.();
-        if (endTime) {
-          scheduleEnd(endTime);
-        }
-      }, startTime - now);
-    } else if (endTime && endTime > now) {
-      addBlocker(blockerId, createBlockerConfig(currentConfig));
-      currentConfig.onScheduleStart?.();
-      scheduleEnd(endTime);
-    } else if (!endTime && startTime <= now) {
-      addBlocker(blockerId, createBlockerConfig(currentConfig));
-      currentConfig.onScheduleStart?.();
+      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);
     } else {
-      console.warn(`[UIBlocking] Schedule is in the past for blocker "${blockerId}"`);
+      const endTime = calculateEndTime(currentConfig.schedule, startTime);
+      if (isInBlockingPeriod(startTime, endTime, now)) {
+        startBlocking();
+      } else if (isScheduleInPast(startTime, endTime, now)) {
+        console.warn(`[UIBlocking] Schedule is in the past for blocker "${blockerId}"`);
+      }
     }
     return () => {
       cleanup();
@@ -374,56 +434,6 @@ var useScheduledBlocker = (blockerId, config) => {
   }, [blockerId, addBlocker, removeBlocker, cleanup]);
 };
 
-// src/middleware/loggerMiddleware.utils.ts
-var getActionEmoji = (action) => {
-  switch (action) {
-    case "add":
-      return "\u2795";
-    case "remove":
-      return "\u2796";
-    case "update":
-      return "\u{1F504}";
-    case "cancel":
-      return "\u274C";
-    case "timeout":
-      return "\u23F1\uFE0F";
-    default:
-      return "\u2753";
-  }
-};
-var extractConfigDetails = (config) => {
-  if (!config) {
-    return {};
-  }
-  const { scope, reason, priority } = config;
-  const details = {
-    scope,
-    reason
-  };
-  if (priority !== void 0) {
-    details.priority = priority;
-  }
-  return details;
-};
-var formatLogData = (context) => {
-  const configDetails = extractConfigDetails(context.config);
-  if (context.prevState) {
-    return {
-      config: configDetails,
-      prevState: extractConfigDetails(context.prevState)
-    };
-  }
-  return configDetails;
-};
-
-// src/middleware/loggerMiddleware.ts
-var LOG_PREFIX = "[UIBlocking]";
-var loggerMiddleware = (context) => {
-  const emoji = getActionEmoji(context.action);
-  const logData = formatLogData(context);
-  console.log(LOG_PREFIX, emoji, context.blockerId, logData);
-};
-
 // src/middleware/analyticsMiddleware.utils.ts
 var capitalizeFirst = (str) => {
   return str.charAt(0).toUpperCase() + str.slice(1);
@@ -494,6 +504,56 @@ var createAnalyticsMiddleware = (config) => {
   };
 };
 
+// src/middleware/loggerMiddleware.utils.ts
+var getActionEmoji = (action) => {
+  switch (action) {
+    case "add":
+      return "\u2795";
+    case "remove":
+      return "\u2796";
+    case "update":
+      return "\u{1F504}";
+    case "cancel":
+      return "\u274C";
+    case "timeout":
+      return "\u23F1\uFE0F";
+    default:
+      return "\u2753";
+  }
+};
+var extractConfigDetails = (config) => {
+  if (!config) {
+    return {};
+  }
+  const { scope, reason, priority } = config;
+  const details = {
+    scope,
+    reason
+  };
+  if (priority !== void 0) {
+    details.priority = priority;
+  }
+  return details;
+};
+var formatLogData = (context) => {
+  const configDetails = extractConfigDetails(context.config);
+  if (context.prevState) {
+    return {
+      config: configDetails,
+      prevState: extractConfigDetails(context.prevState)
+    };
+  }
+  return configDetails;
+};
+
+// src/middleware/loggerMiddleware.ts
+var LOG_PREFIX = "[UIBlocking]";
+var loggerMiddleware = (context) => {
+  const emoji = getActionEmoji(context.action);
+  const logData = formatLogData(context);
+  console.log(LOG_PREFIX, emoji, context.blockerId, logData);
+};
+
 // src/middleware/performanceMiddleware.utils.ts
 var handleAddAction = (blockerId, timestamp, blockStartTimes) => {
   blockStartTimes.set(blockerId, timestamp);
@@ -511,7 +571,9 @@ var handleRemoveAction = (context, blockStartTimes, slowBlockThreshold, onSlowBl
   const duration = context.timestamp - startTime;
   blockStartTimes.delete(context.blockerId);
   if (duration >= slowBlockThreshold) {
-    console.warn(`[UIBlocking] Slow block detected: "${context.blockerId}" took ${duration.toString()}ms`);
+    console.warn(
+      `[UIBlocking] Slow block detected: "${context.blockerId}" took ${duration.toString()}ms`
+    );
     onSlowBlock?.(context.blockerId, duration);
   }
 };