@okyrychenko-dev/react-action-guard 0.6.1 → 1.0.0

package/dist/index.cjs

@@ -1,14 +1,14 @@
 'use strict';
 
-var react = require('react');
 var reactZustandToolkit = require('@okyrychenko-dev/react-zustand-toolkit');
 var zustand = require('zustand');
 require('zustand/react/shallow');
 var jsxRuntime = require('react/jsx-runtime');
 var shallow = require('zustand/shallow');
 var middleware = require('zustand/middleware');
+var react = require('react');
 
-// src/hooks/useAsyncAction/useAsyncAction.ts
+// src/context/UIBlockingContext.tsx
 
 // src/store/uiBlockingStore.constants.ts
 var DEFAULT_SCOPE = "global";
@@ -24,16 +24,18 @@ function normalizeScopeToArray(scope) {
 }
 
 // src/store/uiBlockingStore.actions.ts
-var normalizePriority = (priority, fallback = DEFAULT_PRIORITY) => {
+function normalizePriority(priority, fallback = DEFAULT_PRIORITY) {
   return priority !== void 0 ? Math.max(0, priority) : fallback;
-};
-var createMiddlewareContext = (action, blockerId, config, prevState) => ({
-  action,
-  blockerId,
-  config,
-  timestamp: Date.now(),
-  ...prevState && { prevState }
-});
+}
+function createMiddlewareContext(action, blockerId, config, prevState) {
+  return {
+    action,
+    blockerId,
+    config,
+    timestamp: Date.now(),
+    ...prevState && { prevState }
+  };
+}
 var createUIBlockingActions = (set, get) => ({
   // State
   activeBlockers: /* @__PURE__ */ new Map(),
@@ -54,25 +56,24 @@ 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 {
       }
     }
   },
   // Actions
   /**
    * Adds a new blocker or overwrites an existing one.
-   * 
+   *
    * If a blocker with the same ID already exists, it will be replaced and any
    * existing timeout will be cleared. The blocker is active immediately after
    * being added. Triggers middleware with 'add' action.
-   * 
+   *
    * @param id - Unique identifier for the blocker. Must be unique within the store.
    * @param config - Blocker configuration. All fields are optional with defaults applied.
-   * 
+   *
    * @example
    * Basic usage
    * ```ts
@@ -82,7 +83,7 @@ var createUIBlockingActions = (set, get) => ({
    *   priority: 70
    * });
    * ```
-   * 
+   *
    * @example
    * With timeout
    * ```ts
@@ -93,7 +94,7 @@ var createUIBlockingActions = (set, get) => ({
    *   onTimeout: (id) => console.warn(`${id} timed out`)
    * });
    * ```
-   * 
+   *
    * @see {@link removeBlocker} to remove a blocker
    * @see {@link updateBlocker} to update an existing blocker
    */
@@ -144,13 +145,13 @@ var createUIBlockingActions = (set, get) => ({
   },
   /**
    * Updates an existing blocker or creates it if it doesn't exist.
-   * 
+   *
    * Merges the provided configuration with existing blocker data. If the timeout
    * is changed, the timeout timer is restarted. Triggers middleware with 'update' action.
-   * 
+   *
    * @param id - Identifier of the blocker to update
    * @param config - Partial configuration to merge with existing blocker data
-   * 
+   *
    * @example
    * Update blocker reason
    * ```ts
@@ -158,7 +159,7 @@ var createUIBlockingActions = (set, get) => ({
    *   reason: 'Saving additional data...'
    * });
    * ```
-   * 
+   *
    * @example
    * Extend timeout
    * ```ts
@@ -166,7 +167,7 @@ var createUIBlockingActions = (set, get) => ({
    *   timeout: 60000 // Extend to 60 seconds
    * });
    * ```
-   * 
+   *
    * @see {@link addBlocker} to create a new blocker
    */
   updateBlocker: (id, config = {}) => {
@@ -242,12 +243,12 @@ var createUIBlockingActions = (set, get) => ({
   },
   /**
    * Removes a blocker from the store.
-   * 
+   *
    * Clears any associated timeout and triggers middleware with 'remove' action.
    * Safe to call even if the blocker doesn't exist (no-op in that case).
-   * 
+   *
    * @param id - Identifier of the blocker to remove
-   * 
+   *
    * @example
    * ```ts
    * // Add and remove a blocker
@@ -255,7 +256,7 @@ var createUIBlockingActions = (set, get) => ({
    * // ... later
    * store.getState().removeBlocker('temp');
    * ```
-   * 
+   *
    * @see {@link addBlocker} to add a blocker
    * @see {@link clearAllBlockers} to remove all blockers at once
    */
@@ -275,28 +276,28 @@ var createUIBlockingActions = (set, get) => ({
   },
   /**
    * Checks if one or more scopes are currently blocked.
-   * 
+   *
    * Returns true if ANY blocker affects the specified scope(s). Global scope
    * blockers will cause this to return true for any scope check.
-   * 
+   *
    * @param scope - Scope(s) to check. Defaults to "global" if not specified.
    *                Can be a single scope string or array of scopes.
    * @returns true if any of the specified scopes are currently blocked
-   * 
+   *
    * @example
    * Single scope check
    * ```ts
    * const isFormBlocked = store.getState().isBlocked('form');
    * console.log(isFormBlocked); // true or false
    * ```
-   * 
+   *
    * @example
    * Multiple scopes check
    * ```ts
    * const isBlocked = store.getState().isBlocked(['form', 'navigation']);
    * // Returns true if either 'form' OR 'navigation' has active blockers
    * ```
-   * 
+   *
    * @see {@link getBlockingInfo} for detailed blocker information
    */
   isBlocked: (scope = DEFAULT_SCOPE) => {
@@ -315,14 +316,14 @@ var createUIBlockingActions = (set, get) => ({
   },
   /**
    * Gets detailed information about all blockers affecting a specific scope.
-   * 
+   *
    * Returns an array of blocker objects sorted by priority (highest first).
    * Includes global blockers and scope-specific blockers. Each blocker object
    * contains id, reason, priority, scope, timestamp, and timeout information.
-   * 
+   *
    * @param scope - Scope to get blocking information for
    * @returns Array of {@link BlockerInfo} objects, sorted by priority descending
-   * 
+   *
    * @example
    * Display blocker details
    * ```ts
@@ -332,7 +333,7 @@ var createUIBlockingActions = (set, get) => ({
    *   console.log(`Priority: ${blocker.priority}`);
    * });
    * ```
-   * 
+   *
    * @example
    * Get highest priority blocker
    * ```ts
@@ -342,7 +343,7 @@ var createUIBlockingActions = (set, get) => ({
    *   console.log(`Top blocker: ${topBlocker.reason}`);
    * }
    * ```
-   * 
+   *
    * @see {@link isBlocked} for a simple boolean check
    * @see {@link BlockerInfo} for the structure of returned objects
    */
@@ -352,23 +353,24 @@ 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);
   },
   /**
    * Removes all active blockers from the store.
-   * 
+   *
    * Clears all timeouts and triggers middleware with 'clear' action.
    * Useful for resetting the blocking state.
-   * 
+   *
    * @example
    * ```ts
    * // Clear all blockers on logout
    * store.getState().clearAllBlockers();
    * ```
-   * 
+   *
    * @see {@link clearBlockersForScope} to clear blockers for a specific scope
    */
   clearAllBlockers: () => {
@@ -391,26 +393,26 @@ var createUIBlockingActions = (set, get) => ({
   },
   /**
    * Removes all blockers that affect a specific scope.
-   * 
+   *
    * Clears timeouts for removed blockers and triggers middleware with
    * 'clear_scope' action. Global scope blockers are NOT cleared by this method.
-   * 
+   *
    * @param scope - Scope to clear blockers for
-   * 
+   *
    * @example
    * Clear form blockers
    * ```ts
    * // Clear all blockers affecting 'form' scope
    * store.getState().clearBlockersForScope('form');
    * ```
-   * 
+   *
    * @example
    * Clear on navigation
    * ```ts
    * // Clear navigation blockers when user navigates away
    * store.getState().clearBlockersForScope('navigation');
    * ```
-   * 
+   *
    * @see {@link clearAllBlockers} to clear all blockers
    */
   clearBlockersForScope: (scope) => {
@@ -448,18 +450,24 @@ var createUIBlockingActions = (set, get) => ({
 });
 var {
   Provider: BaseUIBlockingProvider,
-  useContext: useUIBlockingContext,
-  useContextStore: useUIBlockingStoreFromContext,
+  useContextStoreApi: useUIBlockingContext,
+  useContextStore: baseUseUIBlockingStoreFromContext,
   useIsInsideProvider: useIsInsideUIBlockingProvider,
-  useOptionalContext
+  useContextStoreOptional: useOptionalUIBlockingContext
 } = reactZustandToolkit.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);
     });
@@ -469,7 +477,7 @@ function UIBlockingProvider({
     {
       enableDevtools,
       devtoolsName,
-      onStoreCreate: handleStoreCreate,
+      onStoreInit: handleStoreInit,
       children
     }
   );
@@ -482,24 +490,31 @@ var devtoolsConfig = {
 };
 
 // src/store/uiBlockingStore.store.ts
-var { useStore: useUIBlockingStore, useStoreApi: uiBlockingStoreApi } = reactZustandToolkit.createShallowStore(middleware.devtools(createUIBlockingActions, devtoolsConfig));
+var storeBindings = reactZustandToolkit.createShallowStore(
+  middleware.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 zustand.useStore(store, shallow.useShallow(selector));
 }
-
-// src/hooks/useAsyncAction/useAsyncAction.ts
-var useAsyncAction = (actionId, scope, options) => {
-  const { addBlocker, removeBlocker } = useResolvedStoreWithSelector((state) => ({
+function useAsyncAction(actionId, scope, options) {
+  const { addBlocker, removeBlocker } = useResolvedValue((state) => ({
     addBlocker: state.addBlocker,
     removeBlocker: state.removeBlocker
   }));
@@ -524,22 +539,36 @@ var useAsyncAction = (actionId, scope, options) => {
     [actionId, scope, options?.timeout, options?.onTimeout, addBlocker, removeBlocker]
   );
   return executeWithBlocking;
-};
-var useBlocker = (blockerId, config, isActive = true) => {
-  const { addBlocker, removeBlocker } = useResolvedStoreWithSelector((state) => ({
+}
+function useBlocker(blockerId, config, isActive = true) {
+  const { addBlocker, removeBlocker, updateBlocker } = useResolvedValue((state) => ({
     addBlocker: state.addBlocker,
-    removeBlocker: state.removeBlocker
+    removeBlocker: state.removeBlocker,
+    updateBlocker: state.updateBlocker
   }));
+  const lastConfigRef = react.useRef(null);
   react.useEffect(() => {
     if (!isActive || !blockerId) {
       return;
     }
     addBlocker(blockerId, config);
+    lastConfigRef.current = config;
     return () => {
+      lastConfigRef.current = null;
       removeBlocker(blockerId);
     };
   }, [blockerId, isActive, addBlocker, removeBlocker]);
-};
+  react.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
 function createBlockerConfig(config) {
@@ -549,13 +578,13 @@ function createBlockerConfig(config) {
     priority: config.priority
   };
 }
-var useBlockingInfo = (scope = DEFAULT_SCOPE) => {
-  const store = useResolvedStore();
+function useBlockingInfo(scope = DEFAULT_SCOPE) {
+  const store = useResolvedStoreApi();
   const activeBlockers = zustand.useStore(store, (state) => state.activeBlockers);
   return react.useMemo(() => {
     return store.getState().getBlockingInfo(scope);
   }, [activeBlockers, scope, store]);
-};
+}
 function useConfigRef(config) {
   const configRef = react.useRef(config);
   react.useEffect(() => {
@@ -565,8 +594,8 @@ function useConfigRef(config) {
 }
 
 // src/hooks/useConditionalBlocker/useConditionalBlocker.ts
-var useConditionalBlocker = (blockerId, config) => {
-  const { addBlocker, removeBlocker } = useResolvedStoreWithSelector((state) => ({
+function useConditionalBlocker(blockerId, config) {
+  const { addBlocker, removeBlocker } = useResolvedValue((state) => ({
     addBlocker: state.addBlocker,
     removeBlocker: state.removeBlocker
   }));
@@ -601,8 +630,8 @@ var useConditionalBlocker = (blockerId, config) => {
       }
     };
   }, [checkCondition, blockerId, removeBlocker]);
-};
-var useConfirmableBlocker = (blockerId, config) => {
+}
+function useConfirmableBlocker(blockerId, config) {
   const [isDialogOpen, setIsDialogOpen] = react.useState(false);
   const [isExecuting, setIsExecuting] = react.useState(false);
   useBlocker(
@@ -621,9 +650,6 @@ var useConfirmableBlocker = (blockerId, config) => {
     setIsExecuting(true);
     try {
       await config.onConfirm();
-    } catch (error) {
-      console.error("[UIBlocking] Confirmable action error:", error);
-      throw error;
     } finally {
       setIsExecuting(false);
     }
@@ -645,12 +671,12 @@ var useConfirmableBlocker = (blockerId, config) => {
     onConfirm,
     onCancel
   };
-};
+}
 
 // src/hooks/useIsBlocked/useIsBlocked.ts
-var useIsBlocked = (scope) => {
-  return useResolvedStoreWithSelector((state) => state.isBlocked(scope));
-};
+function useIsBlocked(scope) {
+  return useResolvedValue((state) => state.isBlocked(scope));
+}
 
 // src/hooks/useScheduledBlocker/useScheduledBlocker.utils.ts
 var MAX_TIMEOUT_MS = 2147483647;
@@ -690,8 +716,8 @@ function isScheduleInPast(startTime, endTime, now) {
 }
 
 // src/hooks/useScheduledBlocker/useScheduledBlocker.ts
-var useScheduledBlocker = (blockerId, config) => {
-  const { addBlocker, removeBlocker } = useResolvedStoreWithSelector((state) => ({
+function useScheduledBlocker(blockerId, config) {
+  const { addBlocker, removeBlocker } = useResolvedValue((state) => ({
     addBlocker: state.addBlocker,
     removeBlocker: state.removeBlocker
   }));
@@ -712,7 +738,6 @@ var 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 = () => {
@@ -737,9 +762,6 @@ var 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);
@@ -748,7 +770,7 @@ var 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 () => {
@@ -756,13 +778,19 @@ var useScheduledBlocker = (blockerId, config) => {
       removeBlocker(blockerId);
     };
   }, [blockerId, addBlocker, removeBlocker, cleanup]);
-};
+}
 
 // src/middleware/analyticsMiddleware.utils.ts
-var capitalizeFirst = (str) => {
+function capitalizeFirst(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
-};
-var buildEventData = (context) => {
+}
+function getAnalyticsWindow() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  return window;
+}
+function buildEventData(context) {
   const eventData = {
     blocker_id: context.blockerId
   };
@@ -777,33 +805,36 @@ var buildEventData = (context) => {
     eventData.priority = priority;
   }
   return eventData;
-};
-var trackGoogleAnalytics = (action, eventData) => {
-  if (window.gtag) {
-    window.gtag("event", `ui_blocking_${action}`, eventData);
+}
+function trackGoogleAnalytics(action, eventData) {
+  const analyticsWindow = getAnalyticsWindow();
+  if (analyticsWindow?.gtag) {
+    analyticsWindow.gtag("event", `ui_blocking_${action}`, eventData);
   }
-};
-var trackMixpanel = (action, eventData) => {
-  if (window.mixpanel) {
+}
+function trackMixpanel(action, eventData) {
+  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);
   }
-};
-var trackAmplitude = (action, eventData) => {
-  if (window.amplitude) {
+}
+function trackAmplitude(action, eventData) {
+  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);
   }
-};
-var trackCustom = (trackFn, action, eventData) => {
+}
+function trackCustom(trackFn, action, eventData) {
   try {
     trackFn(`ui_blocking_${action}`, eventData);
   } catch {
   }
-};
+}
 
 // src/middleware/analyticsMiddleware.ts
-var trackEvent = (config, context, eventData) => {
+function trackEvent(config, context, eventData) {
   if ("provider" in config) {
     switch (config.provider) {
       case "ga":
@@ -820,25 +851,31 @@ var trackEvent = (config, context, eventData) => {
   if ("track" in config) {
     trackCustom(config.track, context.action, eventData);
   }
-};
-var createAnalyticsMiddleware = (config) => {
+}
+function createAnalyticsMiddleware(config) {
   return (context) => {
     const eventData = buildEventData(context);
     trackEvent(config, context, eventData);
   };
-};
+}
 
 // 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);
   });
 }
 
 // src/middleware/loggerMiddleware.utils.ts
-var getActionEmoji = (action) => {
+function getActionEmoji(action) {
   switch (action) {
     case "add":
       return "\u2795";
@@ -855,8 +892,8 @@ var getActionEmoji = (action) => {
     default:
       return "\u2753";
   }
-};
-var extractConfigDetails = (config) => {
+}
+function extractConfigDetails(config) {
   if (!config) {
     return {};
   }
@@ -869,8 +906,8 @@ var extractConfigDetails = (config) => {
     details.priority = priority;
   }
   return details;
-};
-var formatLogData = (context) => {
+}
+function formatLogData(context) {
   const configDetails = extractConfigDetails(context.config);
   const logData = {};
   if (context.scope !== void 0) {
@@ -889,26 +926,26 @@ var formatLogData = (context) => {
     return configDetails;
   }
   return Object.keys(logData).length === 1 && logData.config ? configDetails : logData;
-};
+}
 
 // src/middleware/loggerMiddleware.ts
 var LOG_PREFIX = "[UIBlocking]";
-var loggerMiddleware = (context) => {
+function 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) => {
+function handleAddAction(blockerId, timestamp, blockStartTimes) {
   blockStartTimes.set(blockerId, timestamp);
-};
+}
 
 // src/middleware/performanceMiddleware.ts
 var DEFAULT_SLOW_BLOCK_THRESHOLD = 3e3;
 var ACTION_ADD = "add";
 var ACTION_REMOVE = "remove";
-var handleRemoveAction = (context, blockStartTimes, slowBlockThreshold, onSlowBlock) => {
+function handleRemoveAction(context, blockStartTimes, slowBlockThreshold, onSlowBlock) {
   const startTime = blockStartTimes.get(context.blockerId);
   if (startTime === void 0) {
     return;
@@ -916,13 +953,10 @@ 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`
-    );
     onSlowBlock?.(context.blockerId, duration);
   }
-};
-var createPerformanceMiddleware = (config = {}) => {
+}
+function createPerformanceMiddleware(config = {}) {
   const { slowBlockThreshold = DEFAULT_SLOW_BLOCK_THRESHOLD, onSlowBlock } = config;
   const blockStartTimes = /* @__PURE__ */ new Map();
   return (context) => {
@@ -932,7 +966,7 @@ var createPerformanceMiddleware = (config = {}) => {
       handleRemoveAction(context, blockStartTimes, slowBlockThreshold, onSlowBlock);
     }
   };
-};
+}
 
 // src/createTypedHooks.ts
 function createTypedHooks() {
@@ -950,10 +984,17 @@ function createTypedHooks() {
   };
 }
 
-Object.defineProperty(exports, "createShallowStore", {
-  enumerable: true,
-  get: function () { return reactZustandToolkit.createShallowStore; }
-});
+// src/index.ts
+function useOptionalContext() {
+  return useOptionalUIBlockingContext();
+}
+function useResolvedStore() {
+  return useResolvedStoreApi();
+}
+function useResolvedStoreWithSelector(selector) {
+  return useResolvedValue(selector);
+}
+
 exports.UIBlockingProvider = UIBlockingProvider;
 exports.configureMiddleware = configureMiddleware;
 exports.createAnalyticsMiddleware = createAnalyticsMiddleware;
@@ -968,6 +1009,12 @@ exports.useConditionalBlocker = useConditionalBlocker;
 exports.useConfirmableBlocker = useConfirmableBlocker;
 exports.useIsBlocked = useIsBlocked;
 exports.useIsInsideUIBlockingProvider = useIsInsideUIBlockingProvider;
+exports.useOptionalContext = useOptionalContext;
+exports.useOptionalUIBlockingContext = useOptionalUIBlockingContext;
+exports.useResolvedStore = useResolvedStore;
+exports.useResolvedStoreApi = useResolvedStoreApi;
+exports.useResolvedStoreWithSelector = useResolvedStoreWithSelector;
+exports.useResolvedValue = useResolvedValue;
 exports.useScheduledBlocker = useScheduledBlocker;
 exports.useUIBlockingContext = useUIBlockingContext;
 exports.useUIBlockingStore = useUIBlockingStore;