@choksheak/react-utils 0.4.4 → 0.4.5

package/chunk-7D2YNZO3.cjs

@@ -1,577 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-var _chunkNGGNAAHAcjs = require('./chunk-NGGNAAHA.cjs');
-
-
-var _chunkCYTO5EZEcjs = require('./chunk-CYTO5EZE.cjs');
-
-
-var _chunkWXLUEDBOcjs = require('./chunk-WXLUEDBO.cjs');
-
-// src/sharedQuery.ts
-var _http = require('@choksheak/ts-utils/http');
-var _nonNil = require('@choksheak/ts-utils/nonNil');
-var _objectsizeof = require('object-sizeof'); var _objectsizeof2 = _interopRequireDefault(_objectsizeof);
-
-
-
-
-
-
-var _react = require('react');
-var _xxhashjs = require('xxhashjs'); var _xxhashjs2 = _interopRequireDefault(_xxhashjs);
-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)) {
-    console.warn(`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.http.use(_http.retries.call(void 0, ));
-    queryFn = async (...args) => {
-      let params = "";
-      const firstArg = _optionalChain([args, 'optionalAccess', _ => _[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 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.staleMs]), () => ( SharedQueryConfig.staleMs));
-  const expiryMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.expiryMs]), () => ( SharedQueryConfig.expiryMs));
-  const refetchOnStale = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _4 => _4.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 = _nullishCoalesce(options.persistTo, () => ( SharedQueryConfig.persistTo));
-    if (persistTo) {
-      options = {
-        ...options,
-        store: {
-          persistTo,
-          key: queryName,
-          expiryMs
-        }
-      };
-    }
-  }
-  const maxSize = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.maxSize]), () => ( SharedQueryConfig.maxSize));
-  const maxBytes = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.maxBytes]), () => ( SharedQueryConfig.maxBytes));
-  const keepLastNonEmptyData = Boolean(_optionalChain([options, 'optionalAccess', _7 => _7.keepLastNonEmptyData]));
-  const log = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.log]), () => ( SharedQueryConfig.log));
-  const queryState = _chunkNGGNAAHAcjs.sharedState.call(void 0, 
-    {},
-    // 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 = _objectsizeof2.default.call(void 0, 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 = _objectsizeof2.default.call(void 0, key) + _objectsizeof2.default.call(void 0, 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()} -> ${_objectsizeof2.default.call(void 0, 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 = _chunkCYTO5EZEcjs.stringifyDeterministicForKeys.call(void 0, args);
-      if (s.length > 30) {
-        s = _xxhashjs2.default.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 _nullishCoalesce(_optionalChain([inflightQueries, 'access', _9 => _9.get, 'call', _10 => _10(queryKey), 'optionalAccess', _11 => _11.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 _nullishCoalesce(_optionalChain([obj, 'access', _12 => _12.getAbortControllerByKey, 'call', _13 => _13(queryKey), 'optionalAccess', _14 => _14.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 = _optionalChain([queryState, 'access', _15 => _15.getSnapshot, 'call', _16 => _16(), 'optionalAccess', _17 => _17[queryKey]]);
-      if (waitedMs) {
-        log(`${queryKey}: Waited for ${waitedMs}ms before data is ready`);
-      }
-      if (_optionalChain([cached, 'optionalAccess', _18 => _18.data]) && !isExpired(_nullishCoalesce(cached.dataUpdatedMs, () => ( 0)))) {
-        if (!isStale(_nullishCoalesce(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 _optionalChain([queryState, 'access', _19 => _19.getSnapshot, 'call', _20 => _20(), 'optionalAccess', _21 => _21[queryKey]]);
-    },
-    /** Get the current stored data for a query key. */
-    getData(queryKey) {
-      const stateValue = _optionalChain([queryState, 'access', _22 => _22.getSnapshot, 'call', _23 => _23(), 'optionalAccess', _24 => _24[queryKey]]);
-      if (_optionalChain([stateValue, 'optionalAccess', _25 => _25.lastUpdatedMs])) {
-        if (isExpired(stateValue.lastUpdatedMs)) {
-          obj.deleteData(queryKey);
-          return void 0;
-        }
-      }
-      return _optionalChain([stateValue, 'optionalAccess', _26 => _26.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, (_nullishCoalesce(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, (_nullishCoalesce(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 = _chunkWXLUEDBOcjs.useDeepMemo.call(void 0, args);
-  const [queryState, setQueryState] = _chunkNGGNAAHAcjs.useSharedState.call(void 0, query.queryState);
-  const isMounted = _react.useRef.call(void 0, true);
-  const queryKey = _react.useMemo.call(void 0, 
-    () => query.getQueryKey(stableArgs),
-    [query, stableArgs]
-  );
-  const queryStateValue = _nullishCoalesce(queryState[queryKey], () => ( DEFAULT_QUERY_STATE_ENTRY));
-  const setQueryStateValue = _react.useCallback.call(void 0, 
-    (next) => {
-      setQueryState((prev) => {
-        const clone = { ...prev };
-        clone[queryKey] = typeof next === "function" ? next(_nullishCoalesce(clone[queryKey], () => ( DEFAULT_QUERY_STATE_ENTRY))) : next;
-        return clone;
-      });
-    },
-    [queryKey, setQueryState]
-  );
-  const [lastNonEmptyData, setLastNonEmptyData] = _react.useState.call(void 0, );
-  _react.useEffect.call(void 0, () => {
-    if (query.keepLastNonEmptyData && queryStateValue.data !== void 0) {
-      setLastNonEmptyData(queryStateValue.data);
-    }
-  }, [query.keepLastNonEmptyData, queryStateValue.data]);
-  const executeQuery = _react.useCallback.call(void 0, 
-    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 });
-        return state.data;
-      } 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]
-  );
-  _react.useEffect.call(void 0, () => {
-    isMounted.current = true;
-    query.mount(queryKey);
-    void executeQuery(false);
-    return () => {
-      isMounted.current = false;
-      query.unmount(queryKey);
-    };
-  }, [executeQuery, query, queryKey]);
-  return _react.useMemo.call(void 0, () => {
-    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);
-        _optionalChain([controller, 'optionalAccess', _27 => _27.abort, 'call', _28 => _28(reason)]);
-        return Boolean(controller);
-      },
-      getCachedOrFetch: async () => {
-        const data = await query.getCachedOrFetch(...stableArgs);
-        return _nonNil.nonNil.call(void 0, 
-          data.data,
-          typeof data.error === "string" ? data.error : JSON.stringify(data.error)
-        );
-      },
-      refetch: () => {
-        return executeQuery(true);
-      },
-      setData: (data, dataUpdatedMs) => {
-        query.setData(queryKey, data, dataUpdatedMs);
-      },
-      deleteData: () => {
-        query.deleteData(queryKey);
-      }
-    };
-  }, [
-    executeQuery,
-    lastNonEmptyData,
-    query,
-    queryKey,
-    queryStateValue,
-    stableArgs
-  ]);
-}
-
-
-
-
-
-
-exports.SharedQueryConfig = SharedQueryConfig; exports.configureSharedQuery = configureSharedQuery; exports.sharedQuery = sharedQuery; exports.useSharedQuery = useSharedQuery;

package/chunk-BQIRLDQC.min.mjs

@@ -1,2 +0,0 @@
-import{a as l}from"./chunk-VHMO75EY.min.mjs";import{MS_PER_DAY as y}from"@choksheak/ts-utils/timeConstants";import{useSyncExternalStore as v}from"react";var T={storeExpiryMs:30*y,lazyLoad:!1};function E(e){Object.assign(T,e)}function g(){let e=new Map,i=new Map;function S(o,n,t){let a=i.get(o);if(!a)return;let c=Array.from(a.values());for(let d of c)try{d(n,t)}catch(f){console.error("Error invoking subscriber:",f)}}return{get(o){return e.get(o)},set(o,n){let t=e.get(o);t!==n&&(e.set(o,n),S(o,n,t))},delete(o){e.delete(o)},setNoNotify(o,n){e.set(o,n)},subscribe(o,n){let t=i.get(o);return t||(t=new Set,i.set(o,t)),t.add(n),()=>{t.delete(n),t.size===0&&i.delete(o)}}}}function h(){if(typeof window<"u"){let e=window.globalThis;return e.reactUtilsPubSubStore||(e.reactUtilsPubSubStore=g())}return g()}var u=h(),p="state",m=0;function R(e,i){let S=()=>{},o=new Promise(r=>{S=r}),n=S,t=String(m++),a=l(i,T.storeExpiryMs);u.setNoNotify(t,e);let c=i?.lazyLoad,d=c!==void 0?c:T.lazyLoad;function f(r){let b=r!==void 0?r:e;u.set(t,b),s.initDone=!0,n()}let s={defaultValue:e,readyPromise:o,lazy:d,initStarted:!1,initDone:!1,subscribe(r){return u.subscribe(t,()=>r())},hasStore(){return!!a},setInStore(r){return a?.set(p,r)},getFromStore(){return a?.get(p)},getSnapshot(){return u.get(t)},setValue(r){if(typeof r=="function"){let b=u.get(t);r=r(b)}u.set(t,r),s.setInStore(r)},delete(){return u.set(t,e),a?.set(p,e)},initDefaultValueOnce(){if(s.initDone||s.initStarted)return;s.initStarted=!0;let r=s.getFromStore();if(r instanceof Promise)return r.then(f);f(r)}};return d||s.initDefaultValueOnce(),s}function P(e){return e.initDefaultValueOnce(),[v(S=>e.subscribe(S),()=>e.getSnapshot(),()=>e.getSnapshot()),e.setValue]}function C(e){return P(e)[0]}function K(e){return e.initDefaultValueOnce(),e.setValue}export{T as a,E as b,R as c,P as d,C as e,K as f};
-//# sourceMappingURL=chunk-BQIRLDQC.min.mjs.map

package/chunk-BQIRLDQC.min.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/sharedState.ts"],"sourcesContent":["/**\n * @packageDocumentation\n *\n * The \"shared state\" is a React state that shares the same value across the\n * entire app. Users declare a shared state constant that can be reused across\n * multiple components with the same underlying value.\n *\n * Shared states provide persistence to local storage and/or indexed DB out of\n * the box, by using \"@choksheak/ts-utils\". Note that no matter if the shared\n * state uses persistence or not, it will always maintain a copy of the state\n * in memory. Persisted values can be configured with an automatic expiration\n * duration.\n *\n * This module is largely similar to the open source \"jotai\" npm library. You\n * can use shared states to replace \"jotai\" in your code, and optionally make\n * use of the persistence mechanism. A quick migration guide from jotai is:\n *\n * ```\n *   atom()          -->  sharedState()\n *   useAtom()       -->  useSharedState()\n *   useAtomValue()  -->  useSharedStateValue()\n *   useSetAtom()    -->  useSharedStateSetter()\n * ```\n *\n * Example:\n * ```\n *   import { sharedState, useSharedState } from \"@choksheak/react-utils/sharedState\";\n *\n *   // Create a new shared state in the top level scope.\n *   // The first argument is the default value, which is required.\n *   // The second argument is an options object, and is optional (defaults\n *   // to storing in memory only without any persistence).\n *   const usersState = sharedState(\n *     [], { store: { persistTo: \"indexedDb\", key: \"users\" }}\n *   );\n *\n *   export const UsersComponent: React.FC = () => {\n *     // Get both the value and the setter.\n *     const [users, setUsers] = useSharedState(usersState);\n *     ...\n *   };\n *\n *   export const ReadOnlyComponent: React.FC = () => {\n *     // Get the value only.\n *     const users = useSharedStateValue(usersState);\n *     ...\n *   };\n *\n *   export const WriteOnlyComponent: React.FC = () => {\n *     // Get the setter only.\n *     const setUsers = useSharedStateSetter(usersState);\n *     ...\n *   };\n * ```\n */\n\nimport { MS_PER_DAY } from \"@choksheak/ts-utils/timeConstants\";\nimport { Dispatch, SetStateAction, useSyncExternalStore } from \"react\";\n\nimport { getStorageAdapter, StorageOptions } from \"./storage\";\n\n/************************************************************************/\n/* Global config                                                        */\n/************************************************************************/\n\n/**\n * These values are configurable by the user at any time.\n */\nexport const SharedStateConfig = {\n  /**\n   * Default duration for storage expiration in milliseconds. Initial value\n   * is 30 days, but can be changed to anything.\n   */\n  storeExpiryMs: 30 * MS_PER_DAY,\n\n  /**\n   * True to load from storage only on mount, false (default) to load in\n   * the top level scope when the shared state is defined.\n   */\n  lazyLoad: false,\n};\n\nexport type SharedStateConfig = typeof SharedStateConfig;\n\n/** Convenience function to update global defaults. */\nexport function configureSharedState(config: Partial<SharedStateConfig>) {\n  Object.assign(SharedStateConfig, config);\n}\n\n/************************************************************************/\n/* Pub-sub store\n/************************************************************************/\n\ntype Subscriber<T> = (next: T, prev: T) => void;\n\nfunction createPubSubStore() {\n  const dataByKey = new Map<string, unknown>();\n  const subscribersByKey = new Map<string, Set<Subscriber<unknown>>>();\n\n  function notify<T>(key: string, next: T, prev: T): void {\n    const subscribers = subscribersByKey.get(key);\n    if (!subscribers) return;\n\n    // Make copy to protect against mutation during iteration.\n    const copy = Array.from(subscribers.values());\n    for (const subscriber of copy) {\n      try {\n        subscriber(next, prev);\n      } catch (e) {\n        console.error(`Error invoking subscriber:`, e);\n      }\n    }\n  }\n\n  return {\n    // This could be undefined if T includes undefined, else it should never\n    // return undefined because the user has to always specify the default value.\n    get<T>(key: string): T {\n      return dataByKey.get(key) as T;\n    },\n\n    set<T>(key: string, value: T): void {\n      const prev = dataByKey.get(key) as T;\n\n      // Do nothing if no change.\n      if (prev === value) return;\n\n      dataByKey.set(key, value);\n      notify(key, value, prev);\n    },\n\n    delete(key: string): void {\n      dataByKey.delete(key);\n    },\n\n    setNoNotify<T>(key: string, value: T): void {\n      dataByKey.set(key, value);\n    },\n\n    // Subscribe to changes of a specific key\n    subscribe<T>(key: string, subscriber: Subscriber<T>): () => void {\n      let subscribers = subscribersByKey.get(key);\n      if (!subscribers) {\n        subscribers = new Set();\n        subscribersByKey.set(key, subscribers);\n      }\n\n      // Type coercion: we store Subscriber<unknown>\n      subscribers.add(subscriber as Subscriber<unknown>);\n\n      // Return unsubscribe function\n      return () => {\n        subscribers.delete(subscriber as Subscriber<unknown>);\n        if (subscribers.size === 0) subscribersByKey.delete(key);\n      };\n    },\n  } as const;\n}\n\n/**\n * Ensure we always use the same store. If we create two stores, then the\n * reactive updates will fail.\n */\nfunction getOrCreatePubSubStore() {\n  if (typeof window !== \"undefined\") {\n    const t = window.globalThis as unknown as {\n      reactUtilsPubSubStore: ReturnType<typeof createPubSubStore> | undefined;\n    };\n    return (\n      t.reactUtilsPubSubStore || (t.reactUtilsPubSubStore = createPubSubStore())\n    );\n  }\n  return createPubSubStore();\n}\n\nconst pubSubStore = getOrCreatePubSubStore();\n\n/************************************************************************/\n/* Shared state implementation                                          */\n/************************************************************************/\n\nconst STORAGE_KEY = \"state\";\n\n/** Options to configure a shared state. */\nexport type SharedStateOptions<T> = {\n  lazyLoad?: boolean;\n} & StorageOptions<T>;\n\nlet stateKey = 0;\n\n/**\n * Create a new shared state object. Put this code at the top level scope:\n *\n * Example:\n * ```\n *   const counterState = sharedState<number>(0);\n * ```\n */\nexport function sharedState<T>(\n  defaultValue: T,\n  options?: SharedStateOptions<T>,\n) {\n  let readyResolve: () => void = () => {};\n\n  const readyPromise = new Promise<void>((resolve) => {\n    readyResolve = resolve;\n  });\n\n  const resolveReadyPromise = readyResolve;\n\n  const pubSubKey = String(stateKey++);\n\n  // Use max of 1 storage adapter per shared state.\n  const storageAdapter = getStorageAdapter(\n    options,\n    SharedStateConfig.storeExpiryMs,\n  );\n\n  // Always set the default value first to avoid returning undefineds if that\n  // is not part of T. Don't notify with the default value.\n  pubSubStore.setNoNotify(pubSubKey, defaultValue);\n\n  const lazyLoad = options?.lazyLoad;\n  const lazy = lazyLoad !== undefined ? lazyLoad : SharedStateConfig.lazyLoad;\n\n  function completeInit(stored: T | undefined) {\n    const value = stored !== undefined ? stored : defaultValue;\n\n    pubSubStore.set(pubSubKey, value);\n\n    // @ts-expect-error ts(2540) - Assign to readonly property.\n    obj.initDone = true;\n    resolveReadyPromise();\n  }\n\n  const obj = {\n    defaultValue,\n\n    /** Allow users to await for the completion of data init. */\n    readyPromise,\n\n    lazy,\n\n    initStarted: false,\n    initDone: false,\n\n    /** `subscribe` function required by useSyncExternalStore. */\n    subscribe(subscriber: () => void): () => void {\n      return pubSubStore.subscribe(pubSubKey, () => subscriber());\n    },\n\n    /** Returns true if there is a backing store. */\n    hasStore(): boolean {\n      return Boolean(storageAdapter);\n    },\n\n    /**\n     * Set a value directly into the store. Does nothing if there is no\n     * backing store.\n     *\n     * Warning: If you want to set the value properly, you should use\n     * `setValue()` instead which also updates the in-memory copy.\n     */\n    setInStore(value: T): Promise<void> | void {\n      return storageAdapter?.set(STORAGE_KEY, value);\n    },\n\n    /**\n     * Get a value directly from the store. Returns undefined if there is no\n     * backing store.\n     */\n    getFromStore(): Promise<T | undefined> | T | undefined {\n      return storageAdapter?.get(STORAGE_KEY);\n    },\n\n    /**\n     * Get the value of the shared state.\n     *  `getSnapshot` function — must return same ref if value unchanged.\n     * Note that this would return the default value if data init from store is\n     * not completed yet.\n     */\n    getSnapshot(): T {\n      return pubSubStore.get(pubSubKey);\n    },\n\n    /** Set the value of the shared state. */\n    setValue(next: SetStateAction<T>): void {\n      if (typeof next === \"function\") {\n        const prev = pubSubStore.get<T>(pubSubKey);\n        next = (next as (p: T) => T)(prev);\n      }\n\n      pubSubStore.set(pubSubKey, next);\n      void obj.setInStore(next);\n    },\n\n    /**\n     * Remove the value of the shared state. Actually this just sets the value\n     * back to the given default value.\n     */\n    delete(): Promise<void> | void {\n      pubSubStore.set(pubSubKey, defaultValue);\n      return storageAdapter?.set(STORAGE_KEY, defaultValue);\n    },\n\n    /** Initial default handling. */\n    initDefaultValueOnce(): Promise<void> | void {\n      if (obj.initDone || obj.initStarted) return;\n      // @ts-expect-error ts(2540) - Assign to readonly property.\n      obj.initStarted = true;\n\n      const maybePromise = obj.getFromStore();\n\n      // Allow sync vs async code paths. This allows init to be fully completed\n      // from store before the sharedState() function returns.\n      if (maybePromise instanceof Promise) {\n        return maybePromise.then(completeInit);\n      } else {\n        const stored = maybePromise;\n        completeInit(stored);\n      }\n    },\n  } as const;\n\n  if (!lazy) {\n    obj.initDefaultValueOnce();\n  }\n\n  return obj;\n}\n\nexport type SharedState<T> = ReturnType<typeof sharedState<T>>;\n\n/**\n * React hook for subscribing to a key in the global store.\n *\n * Example:\n * ```\n *   const [counter, setCounter] = useSharedState(counterState);\n * ```\n */\nexport function useSharedState<T>(\n  state: SharedState<T>,\n): [T, Dispatch<SetStateAction<T>>] {\n  void state.initDefaultValueOnce();\n\n  const value = useSyncExternalStore(\n    (onStoreChange) => state.subscribe(onStoreChange),\n    () => state.getSnapshot(),\n    // getServerSnapshot is needed to prevent SSR dev errors in nextjs.\n    () => state.getSnapshot(),\n  );\n\n  return [value, state.setValue];\n}\n\n/**\n * Same as useSharedState(), but returns the value only.\n *\n * Example:\n * ```\n *   const counter = useSharedStateValue(counterState);\n * ```\n */\nexport function useSharedStateValue<T>(state: SharedState<T>) {\n  return useSharedState(state)[0];\n}\n\n/**\n * Same as useSharedState(), but returns the setter only.\n *\n * Example:\n * ```\n *   const setCounter = useSharedStateSetter(counterState);\n * ```\n */\nexport function useSharedStateSetter<T>(state: SharedState<T>) {\n  void state.initDefaultValueOnce();\n\n  return state.setValue;\n}\n"],"mappings":"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","names":["MS_PER_DAY","useSyncExternalStore","SharedStateConfig","MS_PER_DAY","configureSharedState","config","createPubSubStore","dataByKey","subscribersByKey","notify","key","next","prev","subscribers","copy","subscriber","e","value","getOrCreatePubSubStore","t","pubSubStore","STORAGE_KEY","stateKey","sharedState","defaultValue","options","readyResolve","readyPromise","resolve","resolveReadyPromise","pubSubKey","storageAdapter","getStorageAdapter","lazyLoad","lazy","completeInit","stored","obj","maybePromise","useSharedState","state","useSyncExternalStore","onStoreChange","useSharedStateValue","useSharedStateSetter"]}

package/chunk-CYTO5EZE.cjs

@@ -1,34 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/stringify.ts
-function stringifyDeterministicForKeys(params) {
-  const cache = /* @__PURE__ */ new Set();
-  return JSON.stringify(params, (_, value) => {
-    if (typeof value === "function") {
-      throw new Error(`Functions should not be passed into query parameters`);
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return value;
-    }
-    if (cache.has(value)) {
-      return "[Circular]";
-    }
-    cache.add(value);
-    if (value !== params) {
-      try {
-        JSON.stringify(value);
-      } catch (e) {
-        return "[Unserializable]";
-      }
-    }
-    return Object.keys(value).sort().reduce(
-      (result, key) => {
-        result[key] = value[key];
-        return result;
-      },
-      {}
-    );
-  });
-}
-
-
-
-exports.stringifyDeterministicForKeys = stringifyDeterministicForKeys;