@choksheak/react-utils 0.4.1 → 0.4.2

package/sharedQuery.mjs

@@ -1,561 +1,14 @@
 import {
-  sharedState,
-  useSharedState
-} from "./chunk-KRXENFK3.mjs";
+  SharedQueryConfig,
+  configureSharedQuery,
+  sharedQuery,
+  useSharedQuery
+} from "./chunk-X6EKF4N7.mjs";
+import "./chunk-KRXENFK3.mjs";
 import "./chunk-PHLY3LR4.mjs";
-import {
-  init_stringify,
-  stringifyDeterministicForKeys
-} from "./chunk-33UMQLKY.mjs";
-import {
-  useDeepMemo
-} from "./chunk-GPV6JIQK.mjs";
-import "./chunk-X6BYQHVC.mjs";
-
-// src/sharedQuery.ts
-import { http, retries } from "@choksheak/ts-utils/http";
-import getByteSize from "object-sizeof";
-import {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState
-} from "react";
-import XXH from "xxhashjs";
-init_stringify();
-var SharedQueryConfig = {
-  /** Refetch on every page load. */
-  staleMs: 0,
-  /** Keep in cache for a long time. */
-  expiryMs: 30 * 864e5,
-  /** Always refetch automatically if the data is stale. */
-  refetchOnStale: true,
-  /** No default persistence configured. */
-  persistTo: void 0,
-  /** 100 is not too large, but please tweak accordingly. */
-  maxSize: 100,
-  /** 100kb limit before discarding old records. */
-  maxBytes: 1e5,
-  /** Default to log to console. */
-  log: (...args) => console.log("[sharedQuery]", ...args)
-};
-function configureSharedQuery(config) {
-  Object.assign(SharedQueryConfig, config);
-}
-var seenQueryNames = /* @__PURE__ */ new Set();
-function sharedQuery(options) {
-  const url = options.url || "";
-  const queryName = options.queryName || url;
-  if (!queryName) {
-    throw new Error(`Either queryName or url must be specified.`);
-  }
-  if (seenQueryNames.has(queryName)) {
-    throw new Error(`Duplicate shared query name "${queryName}"`);
-  }
-  seenQueryNames.add(queryName);
-  const inflightQueries = /* @__PURE__ */ new Map();
-  const mountedKeys = /* @__PURE__ */ new Map();
-  let queryFn;
-  if (options.queryFn) {
-    queryFn = options.queryFn;
-  } else if (url) {
-    const fetcher = http.use(retries());
-    queryFn = async (...args) => {
-      let params = "";
-      const firstArg = args?.[0];
-      if (firstArg) {
-        if (typeof firstArg === "string") {
-          params = firstArg;
-        } else if (typeof firstArg === "object") {
-          const entries = [];
-          for (const [k, v] of Object.entries(firstArg)) {
-            if (v === void 0) continue;
-            if (Array.isArray(v)) {
-              for (const item of v) {
-                if (item === void 0) continue;
-                entries.push([k, String(item)]);
-              }
-            } else {
-              entries.push([k, String(v)]);
-            }
-          }
-          params = new URLSearchParams(entries).toString();
-        }
-        if (params) {
-          if (url.includes("?")) {
-            params = "&" + params;
-          } else {
-            params = "?" + params;
-          }
-        }
-      }
-      const response = await fetcher.get(url + params);
-      return await response.json();
-    };
-  } else {
-    throw new Error(`Either queryFn or url must be specified`);
-  }
-  const refetchFn = options.refetchFn;
-  const staleMs = options?.staleMs ?? SharedQueryConfig.staleMs;
-  const expiryMs = options?.expiryMs ?? SharedQueryConfig.expiryMs;
-  const refetchOnStale = options?.refetchOnStale ?? SharedQueryConfig.refetchOnStale;
-  const store = options.store;
-  if (store) {
-    if ("persistTo" in store && store.isValid) {
-      const isValid = store.isValid;
-      options = {
-        ...options,
-        store: {
-          ...store,
-          isValid: (u) => {
-            if (!u || typeof u !== "object") {
-              return false;
-            }
-            for (const v of Object.values(u)) {
-              if (!v || typeof v !== "object" || !("data" in v) || !("dataUpdatedMs" in v) || !("lastUpdatedMs" in v) || typeof v.dataUpdatedMs !== "number" || typeof v.lastUpdatedMs !== "number" || !isValid(v.data)) {
-                return false;
-              }
-            }
-            return true;
-          }
-        }
-      };
-    }
-  } else {
-    const persistTo = options.persistTo ?? SharedQueryConfig.persistTo;
-    if (persistTo) {
-      options = {
-        ...options,
-        store: {
-          persistTo,
-          key: queryName,
-          expiryMs
-        }
-      };
-    }
-  }
-  const maxSize = options?.maxSize ?? SharedQueryConfig.maxSize;
-  const maxBytes = options?.maxBytes ?? SharedQueryConfig.maxBytes;
-  const keepLastNonEmptyData = Boolean(options?.keepLastNonEmptyData);
-  const log = options?.log ?? SharedQueryConfig.log;
-  const queryState = sharedState(
-    {},
-    // defaultValue
-    options
-  );
-  function isStale(dataUpdatedMs) {
-    if (staleMs === 0) return true;
-    const ageMs = Date.now() - dataUpdatedMs;
-    return ageMs > staleMs;
-  }
-  function isExpired(dataUpdatedMs) {
-    if (expiryMs === 0) return false;
-    const ageMs = Date.now() - dataUpdatedMs;
-    return ageMs > expiryMs;
-  }
-  function enforceSizeLimit() {
-    if (!maxSize && !maxBytes) {
-      return;
-    }
-    const oldState = queryState.getSnapshot();
-    const oldSize = Object.keys(oldState).length;
-    if (oldSize <= 1) {
-      return;
-    }
-    const oldByteSize = getByteSize(oldState);
-    let numToCut = maxSize ? oldSize - maxSize : 0;
-    let bytesToCut = maxBytes ? oldByteSize - maxBytes : 0;
-    if (numToCut <= 0 && bytesToCut <= 0) {
-      log(
-        `No need to trim data for ${queryName}: size=${oldSize} (limit=${maxSize}), byteSize=${oldByteSize.toLocaleString()} (limit=${maxBytes.toLocaleString()})`
-      );
-      return;
-    }
-    log(
-      `Need to trim ${queryName}: numToCut=${numToCut}, bytesToCut=${bytesToCut}`
-    );
-    const newState = { ...oldState };
-    let needUpdate = false;
-    const deleteKeyIfNotMounted = (key, expired) => {
-      if (mountedKeys.has(key)) {
-        log(`Cannot clean up ${key} as it is mounted`);
-        return;
-      }
-      const byteSize = getByteSize(key) + getByteSize(newState[key]);
-      log(
-        `Cleaning up unmounted${expired ? ", expired" : ""} ${key} (byteSize=${byteSize.toLocaleString()})`
-      );
-      numToCut--;
-      bytesToCut -= byteSize;
-      delete newState[key];
-      needUpdate = true;
-    };
-    let entriesByTimeAscending = Object.entries(newState).sort(
-      (entry1, entry2) => entry1[1].lastUpdatedMs - entry2[1].lastUpdatedMs
-    );
-    for (const [key] of entriesByTimeAscending) {
-      if (!isExpired(newState[key].lastUpdatedMs)) {
-        break;
-      }
-      deleteKeyIfNotMounted(key, true);
-    }
-    if (numToCut > 0 || bytesToCut > 0) {
-      if (needUpdate) {
-        entriesByTimeAscending = Object.entries(newState).sort(
-          (entry1, entry2) => entry1[1].lastUpdatedMs - entry2[1].lastUpdatedMs
-        );
-      }
-      for (const [key] of entriesByTimeAscending) {
-        deleteKeyIfNotMounted(key, false);
-        if (numToCut <= 0 && bytesToCut <= 0) {
-          break;
-        }
-      }
-    }
-    if (!needUpdate) {
-      log(
-        `No trimmable entries found for ${queryName}: size=${oldSize} (limit=${maxSize}), byteSize=${oldByteSize.toLocaleString()} (limit=${maxBytes.toLocaleString()})`
-      );
-      return;
-    }
-    queryState.setValue(newState);
-    log(
-      `Trimmed data for ${queryName}: size=[${oldSize} -> ${Object.keys(newState).length}] (limit=${maxSize}), byteSize=[${oldByteSize.toLocaleString()} -> ${getByteSize(newState).toLocaleString()}] (limit=${maxBytes.toLocaleString()})`
-    );
-  }
-  function setData(queryKey, data, dataUpdatedMs = Date.now()) {
-    const entry = {
-      lastUpdatedMs: Date.now(),
-      loading: false,
-      data,
-      dataUpdatedMs
-    };
-    queryState.setValue((prev) => ({ ...prev, [queryKey]: entry }));
-    enforceSizeLimit();
-  }
-  async function startFetching(queryKey, queryType, args) {
-    log(`Start fetching ${queryKey}, queryType=${queryType}`);
-    try {
-      const data = await (queryType === "refetch" && refetchFn ? refetchFn(...args) : queryFn(...args));
-      log(`Successfully fetched ${queryKey}`);
-      setData(queryKey, data, Date.now());
-      return data;
-    } catch (e) {
-      log(`Failed to fetch ${queryKey} for queryType=${queryType}: ${e}`);
-      throw e;
-    } finally {
-      inflightQueries.delete(queryKey);
-    }
-  }
-  function dedupedFetch(queryKey, queryType, ...args) {
-    const inflightQuery = inflightQueries.get(queryKey);
-    if (inflightQuery) {
-      log(
-        `Deduplicating inflight fetch for ${queryKey}, queryType=${queryType}`
-      );
-      return inflightQuery.promise;
-    }
-    const promise = startFetching(queryKey, queryType, args);
-    const abortController = new AbortController();
-    inflightQueries.set(queryKey, { promise, abortController });
-    return promise;
-  }
-  const obj = {
-    queryName,
-    queryFn,
-    refetchFn,
-    expiryMs,
-    staleMs,
-    refetchOnStale,
-    maxSize,
-    maxBytes,
-    keepLastNonEmptyData,
-    log,
-    queryState,
-    /** Returns a key to identify requests based on the given args. */
-    getQueryKey(args) {
-      let s = stringifyDeterministicForKeys(args);
-      if (s.length > 30) {
-        s = XXH.h32(s, 39406).toString(16).slice(2);
-      }
-      return queryName + ":" + s;
-    },
-    /**
-     * Get the AbortController to abort the inflight query (if any).
-     *
-     * Note that once you get the controller, you can also get the signal easily
-     * using `controller.signal`. So if you need both the controller and the
-     * signal, just use this function.
-     */
-    getAbortController(args) {
-      const queryKey = obj.getQueryKey(args);
-      return obj.getAbortControllerByKey(queryKey);
-    },
-    getAbortControllerByKey(queryKey) {
-      return inflightQueries.get(queryKey)?.abortController ?? null;
-    },
-    /**
-     * Get the AbortSignal to check for query abortions.
-     *
-     * Example using fetch:
-     * ```
-     *   const getUserQuery = sharedQuery({
-     *     queryName: "getUser",
-     *     queryFn: (userId: string) => {
-     *       // Get the signal for this current execution.
-     *       const signal = getUserQuery.getAbortSignal([userId]);
-     *
-     *       // Pass the signal to fetch so that it can be aborted.
-     *       const response = await fetch(`/users/${userId}`, { signal });
-     *
-     *       // Check for errors.
-     *       if (!response.ok) {
-     *         throw new Error(response.statusText);
-     *       }
-     *
-     *       // Return the data.
-     *       return await response.json();
-     *     },
-     *   });
-     * ```
-     *
-     * Example using `http.ts`:
-     * ```
-     *   const getUserQuery = sharedQuery({
-     *     queryName: "getUser",
-     *     queryFn: (userId: string) => {
-     *       // Get the signal for this current execution.
-     *       const signal = getUserQuery.getAbortSignal([userId]);
-     *
-     *       // Pass the signal to fetch so that it can be aborted.
-     *       const response = await http.get(`/users/${userId}`, { signal });
-     *       return await response.json();
-     *     },
-     *   });
-     * ```
-     */
-    getAbortSignal(args) {
-      const queryKey = obj.getQueryKey(args);
-      return obj.getAbortSignalByKey(queryKey);
-    },
-    getAbortSignalByKey(queryKey) {
-      return obj.getAbortControllerByKey(queryKey)?.signal ?? null;
-    },
-    /** For cached data, we need to return the correct timestamps as well. */
-    async getCachedOrFetch(...args) {
-      const startMs = Date.now();
-      await queryState.readyPromise;
-      const waitedMs = Date.now() - startMs;
-      const queryKey = obj.getQueryKey(args);
-      const cached = queryState.getSnapshot()?.[queryKey];
-      if (waitedMs) {
-        log(`${queryKey}: Waited for ${waitedMs}ms before data is ready`);
-      }
-      if (cached?.data && !isExpired(cached.dataUpdatedMs ?? 0)) {
-        if (!isStale(cached.dataUpdatedMs ?? 0)) {
-          log(`Return fresh data ${queryKey} from cache without fetching`);
-          return cached;
-        }
-        if (refetchOnStale) {
-          log(`refetchOnStale for ${queryKey}`);
-          void dedupedFetch(queryKey, "query", ...args);
-        }
-        log(`Returning stale data for ${queryKey}`);
-        return cached;
-      }
-      const data = await dedupedFetch(queryKey, "query", ...args);
-      const now = Date.now();
-      return {
-        // Don't keep old error.
-        lastUpdatedMs: now,
-        loading: false,
-        data,
-        dataUpdatedMs: now
-      };
-    },
-    /** Get the entire stored entry for a query key. */
-    getQueryValue(queryKey) {
-      return queryState.getSnapshot()?.[queryKey];
-    },
-    /** Get the current stored data for a query key. */
-    getData(queryKey) {
-      const stateValue = queryState.getSnapshot()?.[queryKey];
-      if (stateValue?.lastUpdatedMs) {
-        if (isExpired(stateValue.lastUpdatedMs)) {
-          obj.deleteData(queryKey);
-          return void 0;
-        }
-      }
-      return stateValue?.data;
-    },
-    /** Set the data directly if the user obtained it from somewhere else. */
-    setData,
-    /**
-     * Do a new fetch even when the data is already cached, but don't fetch if
-     * another fetch is already inflight.
-     */
-    async updateFromSource(...args) {
-      const key = obj.getQueryKey(args);
-      return await dedupedFetch(key, "query", ...args);
-    },
-    /**
-     * Perform an explicit refetch. If `options.refetchFn` was not specified,
-     * then this would be identical to calling `obj.updateFromSource()`.
-     */
-    async refetch(...args) {
-      const key = obj.getQueryKey(args);
-      return await dedupedFetch(key, "refetch", ...args);
-    },
-    /** Delete the cached data for one set of arguments. */
-    deleteData(queryKey) {
-      const record = queryState.getSnapshot();
-      const clone = { ...record };
-      delete clone[queryKey];
-      queryState.setValue(clone);
-      const inflight = inflightQueries.get(queryKey);
-      if (inflight) {
-        inflightQueries.delete(queryKey);
-        inflight.abortController.abort("Deleted");
-      }
-    },
-    /** Delete all currently cached data & all inflight promises. */
-    clear() {
-      queryState.delete();
-      for (const { abortController } of Array.from(inflightQueries.values())) {
-        abortController.abort("Cleared");
-      }
-      inflightQueries.clear();
-    },
-    /** Keep track of mounted keys. */
-    mount(queryKey) {
-      mountedKeys.set(queryKey, (mountedKeys.get(queryKey) ?? 0) + 1);
-    },
-    /** Clean up mounted keys. */
-    unmount(queryKey) {
-      const count = mountedKeys.get(queryKey);
-      if (count === 1) {
-        mountedKeys.delete(queryKey);
-      } else {
-        mountedKeys.set(queryKey, (count ?? 0) - 1);
-      }
-    },
-    /**
-     * Discard the oldest entries if the size exceeds the limit. The last
-     * remaining record cannot be deleted no matter what the limit is.
-     */
-    enforceSizeLimit
-  };
-  return obj;
-}
-var DEFAULT_QUERY_STATE_ENTRY = {
-  lastUpdatedMs: 0,
-  loading: true
-};
-function useSharedQuery(query, ...args) {
-  const stableArgs = useDeepMemo(args);
-  const [queryState, setQueryState] = useSharedState(query.queryState);
-  const isMounted = useRef(true);
-  const queryKey = useMemo(
-    () => query.getQueryKey(stableArgs),
-    [query, stableArgs]
-  );
-  const queryStateValue = queryState[queryKey] ?? DEFAULT_QUERY_STATE_ENTRY;
-  const setQueryStateValue = useCallback(
-    (next) => {
-      setQueryState((prev) => {
-        const clone = { ...prev };
-        clone[queryKey] = typeof next === "function" ? next(clone[queryKey] ?? DEFAULT_QUERY_STATE_ENTRY) : next;
-        return clone;
-      });
-    },
-    [queryKey, setQueryState]
-  );
-  const [lastNonEmptyData, setLastNonEmptyData] = useState();
-  useEffect(() => {
-    if (query.keepLastNonEmptyData && queryStateValue.data !== void 0) {
-      setLastNonEmptyData(queryStateValue.data);
-    }
-  }, [query.keepLastNonEmptyData, queryStateValue.data]);
-  const execute = useCallback(
-    async (isRefetch) => {
-      query.log(
-        `Begin executing shared query ${queryKey}, isRefetch=${isRefetch}`
-      );
-      if (!isMounted.current) return;
-      setQueryStateValue((prev) => ({
-        // Keep old data and error.
-        ...prev,
-        lastUpdatedMs: Date.now(),
-        loading: true
-      }));
-      try {
-        let state;
-        if (isRefetch) {
-          const data = await query.refetch(...stableArgs);
-          const now = Date.now();
-          state = {
-            // Don't keep old error.
-            lastUpdatedMs: now,
-            loading: false,
-            data,
-            dataUpdatedMs: now
-          };
-        } else {
-          state = await query.getCachedOrFetch(...stableArgs);
-        }
-        if (!isMounted.current) return;
-        setQueryStateValue({ ...state, loading: false });
-      } catch (e) {
-        if (!isMounted.current) return;
-        const now = Date.now();
-        setQueryStateValue((prev) => ({
-          // Keep old data.
-          ...prev,
-          lastUpdatedMs: now,
-          loading: false,
-          error: e,
-          errorUpdatedMs: now
-        }));
-      }
-    },
-    [query, queryKey, setQueryStateValue, stableArgs]
-  );
-  useEffect(() => {
-    isMounted.current = true;
-    query.mount(queryKey);
-    void execute(false);
-    return () => {
-      isMounted.current = false;
-      query.unmount(queryKey);
-    };
-  }, [execute, query, queryKey]);
-  return useMemo(() => {
-    return {
-      ...queryStateValue,
-      // Fill with lastNonEmptyData when data is undefined.
-      data: queryStateValue.data !== void 0 ? queryStateValue.data : lastNonEmptyData,
-      latestData: queryStateValue.data,
-      // This works only if the user-given queryFn supports abort. If not,
-      // this function doesn't do anything, since we don't have any means to
-      // abort the running queryFn.
-      abortCurrentQuery: (reason) => {
-        const controller = query.getAbortControllerByKey(queryKey);
-        controller?.abort(reason);
-        return Boolean(controller);
-      },
-      refetch: () => {
-        return execute(true);
-      },
-      setData: (data, dataUpdatedMs) => {
-        query.setData(queryKey, data, dataUpdatedMs);
-      },
-      deleteData: () => {
-        query.deleteData(queryKey);
-      }
-    };
-  }, [execute, lastNonEmptyData, query, queryKey, queryStateValue]);
-}
+import "./chunk-4235I4VO.mjs";
+import "./chunk-4J7TN5JN.mjs";
+import "./chunk-R7POPVJR.mjs";
 export {
   SharedQueryConfig,
   configureSharedQuery,

package/sharedState.cjs

@@ -7,7 +7,7 @@
 
 var _chunk3X25NN6Xcjs = require('./chunk-3X25NN6X.cjs');
 require('./chunk-5PDGU37E.cjs');
-require('./chunk-74BS2FAO.cjs');
+require('./chunk-IS3BZTWE.cjs');
 
 
 

package/{sharedState.d.mts → sharedState.d.cts}

@@ -1,5 +1,5 @@
 import { SetStateAction, Dispatch } from 'react';
-import { StorageOptions } from './storage.mjs';
+import { StorageOptions } from './storage.cjs';
 import '@choksheak/ts-utils/duration';
 import '@choksheak/ts-utils/storageAdapter';
 

package/sharedState.d.ts

@@ -1,3 +1,8 @@
+import { SetStateAction, Dispatch } from 'react';
+import { StorageOptions } from './storage.js';
+import '@choksheak/ts-utils/duration';
+import '@choksheak/ts-utils/storageAdapter';
+
 /**
  * @packageDocumentation
  *
@@ -53,14 +58,13 @@
  *   };
  * ```
  */
-import { Dispatch, SetStateAction } from "react";
-import { StorageOptions } from "./storage";
+
 /************************************************************************/
 /************************************************************************/
 /**
  * These values are configurable by the user at any time.
  */
-export declare const SharedStateConfig: {
+declare const SharedStateConfig: {
     /**
      * Default duration for storage expiration in milliseconds. Initial value
      * is 30 days, but can be changed to anything.
@@ -72,11 +76,11 @@ export declare const SharedStateConfig: {
      */
     lazyLoad: boolean;
 };
-export type SharedStateConfig = typeof SharedStateConfig;
+type SharedStateConfig = typeof SharedStateConfig;
 /** Convenience function to update global defaults. */
-export declare function configureSharedState(config: Partial<SharedStateConfig>): void;
+declare function configureSharedState(config: Partial<SharedStateConfig>): void;
 /** Options to configure a shared state. */
-export type SharedStateOptions<T> = {
+type SharedStateOptions<T> = {
     lazyLoad?: boolean;
 } & StorageOptions<T>;
 /**
@@ -87,7 +91,7 @@ export type SharedStateOptions<T> = {
  *   const counterState = sharedState<number>(0);
  * ```
  */
-export declare function sharedState<T>(defaultValue: T, options?: SharedStateOptions<T>): {
+declare function sharedState<T>(defaultValue: T, options?: SharedStateOptions<T>): {
     /** Allow users to await for the completion of data init. */
     readonly readyPromise: Promise<void>;
     readonly lazy: boolean;
@@ -127,7 +131,7 @@ export declare function sharedState<T>(defaultValue: T, options?: SharedStateOpt
     /** Initial default handling. */
     readonly initDefaultValueOnce: () => Promise<void> | void;
 };
-export type SharedState<T> = ReturnType<typeof sharedState<T>>;
+type SharedState<T> = ReturnType<typeof sharedState<T>>;
 /**
  * React hook for subscribing to a key in the global store.
  *
@@ -136,7 +140,7 @@ export type SharedState<T> = ReturnType<typeof sharedState<T>>;
  *   const [counter, setCounter] = useSharedState(counterState);
  * ```
  */
-export declare function useSharedState<T>(state: SharedState<T>): [T, Dispatch<SetStateAction<T>>];
+declare function useSharedState<T>(state: SharedState<T>): [T, Dispatch<SetStateAction<T>>];
 /**
  * Same as useSharedState(), but returns the value only.
  *
@@ -145,7 +149,7 @@ export declare function useSharedState<T>(state: SharedState<T>): [T, Dispatch<S
  *   const counter = useSharedStateValue(counterState);
  * ```
  */
-export declare function useSharedStateValue<T>(state: SharedState<T>): T;
+declare function useSharedStateValue<T>(state: SharedState<T>): T;
 /**
  * Same as useSharedState(), but returns the setter only.
  *
@@ -154,4 +158,6 @@ export declare function useSharedStateValue<T>(state: SharedState<T>): T;
  *   const setCounter = useSharedStateSetter(counterState);
  * ```
  */
-export declare function useSharedStateSetter<T>(state: SharedState<T>): (next: SetStateAction<T>) => void;
+declare function useSharedStateSetter<T>(state: SharedState<T>): (next: SetStateAction<T>) => void;
+
+export { type SharedState, SharedStateConfig, type SharedStateOptions, configureSharedState, sharedState, useSharedState, useSharedStateSetter, useSharedStateValue };

package/sharedState.min.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkNTFFK7ZHmincjs = require('./chunk-NTFFK7ZH.min.cjs');require('./chunk-UFJQLQFI.min.cjs');require('./chunk-KE3RXVMS.min.cjs');exports.SharedStateConfig = _chunkNTFFK7ZHmincjs.a; exports.configureSharedState = _chunkNTFFK7ZHmincjs.b; exports.sharedState = _chunkNTFFK7ZHmincjs.c; exports.useSharedState = _chunkNTFFK7ZHmincjs.d; exports.useSharedStateSetter = _chunkNTFFK7ZHmincjs.f; exports.useSharedStateValue = _chunkNTFFK7ZHmincjs.e;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _chunkNTFFK7ZHmincjs = require('./chunk-NTFFK7ZH.min.cjs');require('./chunk-UFJQLQFI.min.cjs');require('./chunk-ZCDXPV3A.min.cjs');exports.SharedStateConfig = _chunkNTFFK7ZHmincjs.a; exports.configureSharedState = _chunkNTFFK7ZHmincjs.b; exports.sharedState = _chunkNTFFK7ZHmincjs.c; exports.useSharedState = _chunkNTFFK7ZHmincjs.d; exports.useSharedStateSetter = _chunkNTFFK7ZHmincjs.f; exports.useSharedStateValue = _chunkNTFFK7ZHmincjs.e;
 //# sourceMappingURL=sharedState.min.cjs.map

package/sharedState.min.mjs

@@ -1,2 +1,2 @@
-import{a,b,c,d,e,f}from"./chunk-KILGR7YA.min.mjs";import"./chunk-VHMO75EY.min.mjs";import"./chunk-MWDH7YON.min.mjs";export{a as SharedStateConfig,b as configureSharedState,c as sharedState,d as useSharedState,f as useSharedStateSetter,e as useSharedStateValue};
+import{a,b,c,d,e,f}from"./chunk-KILGR7YA.min.mjs";import"./chunk-VHMO75EY.min.mjs";import"./chunk-HRE7YPUJ.min.mjs";export{a as SharedStateConfig,b as configureSharedState,c as sharedState,d as useSharedState,f as useSharedStateSetter,e as useSharedStateValue};
 //# sourceMappingURL=sharedState.min.mjs.map

package/sharedState.mjs

@@ -7,7 +7,7 @@ import {
   useSharedStateValue
 } from "./chunk-KRXENFK3.mjs";
 import "./chunk-PHLY3LR4.mjs";
-import "./chunk-X6BYQHVC.mjs";
+import "./chunk-R7POPVJR.mjs";
 export {
   SharedStateConfig,
   configureSharedState,

package/storage.cjs

@@ -3,7 +3,7 @@
 
 
 var _chunk5PDGU37Ecjs = require('./chunk-5PDGU37E.cjs');
-require('./chunk-74BS2FAO.cjs');
+require('./chunk-IS3BZTWE.cjs');