@choksheak/react-utils 0.3.8 → 0.4.0

package/sharedQuery.cjs

@@ -1,356 +1,36 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"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; }
 
-// src/sharedQuery.ts
-var sharedQuery_exports = {};
-__export(sharedQuery_exports, {
-  SharedQueryConfig: () => SharedQueryConfig,
-  configureSharedQuery: () => configureSharedQuery,
-  sharedQuery: () => sharedQuery,
-  useSharedQuery: () => useSharedQuery
-});
-module.exports = __toCommonJS(sharedQuery_exports);
-var import_timeConstants2 = require("@choksheak/ts-utils/timeConstants");
-var import_object_sizeof = __toESM(require("object-sizeof"));
-var import_react3 = require("react");
+var _chunkUFJNJ3WVcjs = require('./chunk-UFJNJ3WV.cjs');
 
-// src/sharedState.ts
-var import_timeConstants = require("@choksheak/ts-utils/timeConstants");
-var import_react = require("react");
 
-// src/storage.ts
-var import_kvStore = require("@choksheak/ts-utils/kvStore");
-var import_localStore = require("@choksheak/ts-utils/localStore");
-var IS_NOT_BROWSER = typeof window === "undefined";
-function getStorageAdapter(options, defaultStoreExpiryMs) {
-  const { store } = options ?? {};
-  if (!store) {
-    return null;
-  }
-  if ("persistTo" in store && typeof store.persistTo === "string" && "key" in store && typeof store.key === "string") {
-    const expiryMs = store.expiryMs || defaultStoreExpiryMs;
-    const config = { ...store, expiryMs };
-    switch (store.persistTo) {
-      case "localStorage":
-        return localStoreAdapter(config);
-      case "indexedDb":
-        return kvStoreAdapter(config);
-      default:
-        store.persistTo;
-        throw new Error(`Unknown store.adapter ${store.persistTo}`);
-    }
-  }
-  return store;
-}
-function localStoreAdapter({
-  key,
-  expiryMs,
-  isValid
-}) {
-  const adapter = (0, import_localStore.createLocalStore)(key, { defaultExpiryMs: expiryMs });
-  return {
-    set: (key2, value) => {
-      if (IS_NOT_BROWSER) return;
-      adapter.set(key2, value);
-    },
-    get: (key2) => {
-      if (IS_NOT_BROWSER) return void 0;
-      const value = adapter.get(key2);
-      if (isValid && !isValid(value)) {
-        console.warn(
-          `localStorage adapter: Auto-discard invalid value for ${key2}: ${JSON.stringify(value)}`
-        );
-        adapter.delete(key2);
-        return void 0;
-      }
-      return value;
-    },
-    delete: (key2) => {
-      if (IS_NOT_BROWSER) return;
-      adapter.delete(key2);
-    },
-    clear: () => {
-      if (IS_NOT_BROWSER) return;
-      adapter.clear();
-    }
-  };
-}
-function kvStoreAdapter({
-  key,
-  expiryMs,
-  isValid
-}) {
-  const keyPrefix = key + ":";
-  return {
-    set: async (key2, value) => {
-      if (IS_NOT_BROWSER) return;
-      await import_kvStore.kvStore.set(keyPrefix + key2, value, expiryMs);
-    },
-    get: async (key2) => {
-      if (IS_NOT_BROWSER) return void 0;
-      const fullKey = keyPrefix + key2;
-      const value = await import_kvStore.kvStore.get(fullKey);
-      if (value !== void 0 && isValid && !isValid(value)) {
-        console.warn(
-          `indexedDb adapter: Auto-discard invalid value for ${key2}:`,
-          value
-        );
-        await import_kvStore.kvStore.delete(fullKey);
-        return void 0;
-      }
-      return value;
-    },
-    delete: async (key2) => {
-      if (IS_NOT_BROWSER) return;
-      await import_kvStore.kvStore.delete(keyPrefix + key2);
-    },
-    clear: async () => {
-      if (IS_NOT_BROWSER) return;
-      await import_kvStore.kvStore.clear();
-    }
-  };
-}
 
-// src/sharedState.ts
-var SharedStateConfig = {
-  /**
-   * Default duration for storage expiration in milliseconds. Initial value
-   * is 30 days, but can be changed to anything.
-   */
-  storeExpiryMs: 30 * import_timeConstants.MS_PER_DAY,
-  /**
-   * True to load from storage only on mount, false (default) to load in
-   * the top level scope when the shared state is defined.
-   */
-  lazyLoad: false
-};
-function createPubSubStore() {
-  const dataByKey = /* @__PURE__ */ new Map();
-  const subscribersByKey = /* @__PURE__ */ new Map();
-  function notify(key, next, prev) {
-    const subscribers = subscribersByKey.get(key);
-    if (!subscribers) return;
-    const copy = Array.from(subscribers.values());
-    for (const subscriber of copy) {
-      try {
-        subscriber(next, prev);
-      } catch (e) {
-        console.error(`Error invoking subscriber:`, e);
-      }
-    }
-  }
-  return {
-    // This could be undefined if T includes undefined, else it should never
-    // return undefined because the user has to always specify the default value.
-    get(key) {
-      return dataByKey.get(key);
-    },
-    set(key, value) {
-      const prev = dataByKey.get(key);
-      if (prev === value) return;
-      dataByKey.set(key, value);
-      notify(key, value, prev);
-    },
-    delete(key) {
-      dataByKey.delete(key);
-    },
-    setNoNotify(key, value) {
-      dataByKey.set(key, value);
-    },
-    // Subscribe to changes of a specific key
-    subscribe(key, subscriber) {
-      let subscribers = subscribersByKey.get(key);
-      if (!subscribers) {
-        subscribers = /* @__PURE__ */ new Set();
-        subscribersByKey.set(key, subscribers);
-      }
-      subscribers.add(subscriber);
-      return () => {
-        subscribers.delete(subscriber);
-        if (subscribers.size === 0) subscribersByKey.delete(key);
-      };
-    }
-  };
-}
-var pubSubStore = createPubSubStore();
-var STORAGE_KEY = "state";
-var stateKey = 0;
-function sharedState(defaultValue, options) {
-  let readyResolve = () => {
-  };
-  const readyPromise = new Promise((resolve) => {
-    readyResolve = resolve;
-  });
-  const resolveReadyPromise = readyResolve;
-  const pubSubKey = String(stateKey++);
-  const storageAdapter = getStorageAdapter(
-    options,
-    SharedStateConfig.storeExpiryMs
-  );
-  pubSubStore.setNoNotify(pubSubKey, defaultValue);
-  const lazyLoad = options?.lazyLoad;
-  const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateConfig.lazyLoad;
-  const obj = {
-    /** Allow users to await for the completion of data init. */
-    readyPromise,
-    lazy,
-    initStarted: false,
-    initDone: false,
-    /** `subscribe` function required by useSyncExternalStore. */
-    subscribe(subscriber) {
-      return pubSubStore.subscribe(pubSubKey, () => subscriber());
-    },
-    /** Returns true if there is a backing store. */
-    hasStore() {
-      return Boolean(storageAdapter);
-    },
-    /**
-     * Set a value directly into the store. Does nothing if there is no
-     * backing store.
-     *
-     * Warning: If you want to set the value properly, you should use
-     * `setValue()` instead which also updates the in-memory copy.
-     */
-    async setInStore(value) {
-      return await storageAdapter?.set(STORAGE_KEY, value);
-    },
-    /**
-     * Get a value directly from the store. Returns undefined if there is no
-     * backing store.
-     */
-    async getFromStore() {
-      return await storageAdapter?.get(STORAGE_KEY);
-    },
-    /**
-     * Get the value of the shared state.
-     *  `getSnapshot` function — must return same ref if value unchanged.
-     * Note that this would return the default value if data init from store is
-     * not completed yet.
-     */
-    getSnapshot() {
-      return pubSubStore.get(pubSubKey);
-    },
-    /** Set the value of the shared state. */
-    setValue(next) {
-      if (typeof next === "function") {
-        const prev = pubSubStore.get(pubSubKey);
-        next = next(prev);
-      }
-      pubSubStore.set(pubSubKey, next);
-      void obj.setInStore(next);
-    },
-    /**
-     * Remove the value of the shared state. Actually this just sets the value
-     * back to the given default value.
-     */
-    delete() {
-      pubSubStore.set(pubSubKey, defaultValue);
-      void storageAdapter?.set(STORAGE_KEY, defaultValue);
-    },
-    /** Initial default handling. */
-    async initDefaultValueOnce() {
-      if (obj.initDone || obj.initStarted) return;
-      obj.initStarted = true;
-      const stored = await obj.getFromStore();
-      const value = stored !== void 0 ? stored : defaultValue;
-      pubSubStore.set(pubSubKey, value);
-      obj.initDone = true;
-      resolveReadyPromise();
-    }
-  };
-  if (!lazy) {
-    void obj.initDefaultValueOnce();
-  }
-  return obj;
-}
-function useSharedState(state) {
-  void state.initDefaultValueOnce();
-  const value = (0, import_react.useSyncExternalStore)(
-    (onStoreChange) => state.subscribe(onStoreChange),
-    () => state.getSnapshot(),
-    // getServerSnapshot is needed to prevent SSR dev errors in nextjs.
-    () => state.getSnapshot()
-  );
-  return [value, state.setValue];
-}
+var _chunk3X25NN6Xcjs = require('./chunk-3X25NN6X.cjs');
+require('./chunk-5PDGU37E.cjs');
 
-// 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 {
-        return "[Unserializable]";
-      }
-    }
-    return Object.keys(value).sort().reduce(
-      (result, key) => {
-        result[key] = value[key];
-        return result;
-      },
-      {}
-    );
-  });
-}
 
-// src/useDeepMemo.ts
-var import_isEqual = __toESM(require("lodash/isEqual"));
-var import_react2 = require("react");
-function useDeepMemo(value) {
-  const [state, setState] = (0, import_react2.useState)(value);
-  return (0, import_react2.useMemo)(() => {
-    if ((0, import_isEqual.default)(state, value)) {
-      return state;
-    }
-    setState(value);
-    return value;
-  }, [state, value]);
-}
+
+var _chunk5DO7KC3Lcjs = require('./chunk-5DO7KC3L.cjs');
+
+
+var _chunkWVLPJPWGcjs = require('./chunk-WVLPJPWG.cjs');
+require('./chunk-74BS2FAO.cjs');
 
 // src/sharedQuery.ts
+var _objectsizeof = require('object-sizeof'); var _objectsizeof2 = _interopRequireDefault(_objectsizeof);
+
+
+
+
+
+
+var _react = require('react');
+var _xxhashjs = require('xxhashjs'); var _xxhashjs2 = _interopRequireDefault(_xxhashjs);
+_chunk5DO7KC3Lcjs.init_stringify.call(void 0, );
 var SharedQueryConfig = {
   /** Refetch on every page load. */
   staleMs: 0,
   /** Keep in cache for a long time. */
-  expiryMs: 30 * import_timeConstants2.MS_PER_DAY,
+  expiryMs: 30 * 864e5,
   /** Always refetch automatically if the data is stale. */
   refetchOnStale: true,
   /** No default persistence configured. */
@@ -367,18 +47,59 @@ function configureSharedQuery(config) {
 }
 var seenQueryNames = /* @__PURE__ */ new Set();
 function sharedQuery(options) {
-  if (seenQueryNames.has(options.queryName)) {
-    throw new Error(`Duplicate shared query name "${options.queryName}"`);
+  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(options.queryName);
+  seenQueryNames.add(queryName);
   const inflightQueries = /* @__PURE__ */ new Map();
   const mountedKeys = /* @__PURE__ */ new Map();
-  const queryName = options.queryName;
-  const queryFn = options.queryFn;
+  let queryFn;
+  if (options.queryFn) {
+    queryFn = options.queryFn;
+  } else if (url) {
+    queryFn = (...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;
+          }
+        }
+      }
+      return _chunkUFJNJ3WVcjs.fetcher.url(url + params).get().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 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) {
@@ -402,7 +123,7 @@ function sharedQuery(options) {
       };
     }
   } else {
-    const persistTo = options.persistTo ?? SharedQueryConfig.persistTo;
+    const persistTo = _nullishCoalesce(options.persistTo, () => ( SharedQueryConfig.persistTo));
     if (persistTo) {
       options = {
         ...options,
@@ -414,11 +135,11 @@ function sharedQuery(options) {
       };
     }
   }
-  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(
+  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 = _chunk3X25NN6Xcjs.sharedState.call(void 0, 
     {},
     // defaultValue
     options
@@ -442,7 +163,7 @@ function sharedQuery(options) {
     if (oldSize <= 1) {
       return;
     }
-    const oldByteSize = (0, import_object_sizeof.default)(oldState);
+    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) {
@@ -461,7 +182,7 @@ function sharedQuery(options) {
         log(`Cannot clean up ${key} as it is mounted`);
         return;
       }
-      const byteSize = (0, import_object_sizeof.default)(key) + (0, import_object_sizeof.default)(newState[key]);
+      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()})`
       );
@@ -500,7 +221,7 @@ function sharedQuery(options) {
     }
     queryState.setValue(newState);
     log(
-      `Trimmed data for ${queryName}: size=[${oldSize} -> ${Object.keys(newState).length}] (limit=${maxSize}), byteSize=[${oldByteSize.toLocaleString()} -> ${(0, import_object_sizeof.default)(newState).toLocaleString()}] (limit=${maxBytes.toLocaleString()})`
+      `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()) {
@@ -554,7 +275,11 @@ function sharedQuery(options) {
     queryState,
     /** Returns a key to identify requests based on the given args. */
     getQueryKey(args) {
-      return queryName + ":" + stringifyDeterministicForKeys(args);
+      let s = _chunk5DO7KC3Lcjs.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).
@@ -568,12 +293,12 @@ function sharedQuery(options) {
       return obj.getAbortControllerByKey(queryKey);
     },
     getAbortControllerByKey(queryKey) {
-      return inflightQueries.get(queryKey)?.abortController ?? null;
+      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:
+     * Example using fetch:
      * ```
      *   const getUserQuery = sharedQuery({
      *     queryName: "getUser",
@@ -594,13 +319,27 @@ function sharedQuery(options) {
      *     },
      *   });
      * ```
+     *
+     * Example using `fetcher.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.
+     *       return fetcher.url(`/users/${userId}`).options({ signal }).get().json();
+     *     },
+     *   });
+     * ```
      */
     getAbortSignal(args) {
       const queryKey = obj.getQueryKey(args);
       return obj.getAbortSignalByKey(queryKey);
     },
     getAbortSignalByKey(queryKey) {
-      return obj.getAbortControllerByKey(queryKey)?.signal ?? null;
+      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) {
@@ -608,12 +347,12 @@ function sharedQuery(options) {
       await queryState.readyPromise;
       const waitedMs = Date.now() - startMs;
       const queryKey = obj.getQueryKey(args);
-      const cached = queryState.getSnapshot()?.[queryKey];
+      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 (cached?.data && !isExpired(cached.dataUpdatedMs ?? 0)) {
-        if (!isStale(cached.dataUpdatedMs ?? 0)) {
+      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;
         }
@@ -636,18 +375,18 @@ function sharedQuery(options) {
     },
     /** Get the entire stored entry for a query key. */
     getQueryValue(queryKey) {
-      return queryState.getSnapshot()?.[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 = queryState.getSnapshot()?.[queryKey];
-      if (stateValue?.lastUpdatedMs) {
+      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 stateValue?.data;
+      return _optionalChain([stateValue, 'optionalAccess', _26 => _26.data]);
     },
     /** Set the data directly if the user obtained it from somewhere else. */
     setData,
@@ -689,7 +428,7 @@ function sharedQuery(options) {
     },
     /** Keep track of mounted keys. */
     mount(queryKey) {
-      mountedKeys.set(queryKey, (mountedKeys.get(queryKey) ?? 0) + 1);
+      mountedKeys.set(queryKey, (_nullishCoalesce(mountedKeys.get(queryKey), () => ( 0))) + 1);
     },
     /** Clean up mounted keys. */
     unmount(queryKey) {
@@ -697,7 +436,7 @@ function sharedQuery(options) {
       if (count === 1) {
         mountedKeys.delete(queryKey);
       } else {
-        mountedKeys.set(queryKey, (count ?? 0) - 1);
+        mountedKeys.set(queryKey, (_nullishCoalesce(count, () => ( 0))) - 1);
       }
     },
     /**
@@ -713,31 +452,31 @@ var DEFAULT_QUERY_STATE_ENTRY = {
   loading: true
 };
 function useSharedQuery(query, ...args) {
-  const stableArgs = useDeepMemo(args);
-  const [queryState, setQueryState] = useSharedState(query.queryState);
-  const isMounted = (0, import_react3.useRef)(true);
-  const queryKey = (0, import_react3.useMemo)(
+  const stableArgs = _chunkWVLPJPWGcjs.useDeepMemo.call(void 0, args);
+  const [queryState, setQueryState] = _chunk3X25NN6Xcjs.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 = queryState[queryKey] ?? DEFAULT_QUERY_STATE_ENTRY;
-  const setQueryStateValue = (0, import_react3.useCallback)(
+  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(clone[queryKey] ?? DEFAULT_QUERY_STATE_ENTRY) : next;
+        clone[queryKey] = typeof next === "function" ? next(_nullishCoalesce(clone[queryKey], () => ( DEFAULT_QUERY_STATE_ENTRY))) : next;
         return clone;
       });
     },
     [queryKey, setQueryState]
   );
-  const [lastNonEmptyData, setLastNonEmptyData] = (0, import_react3.useState)();
-  (0, import_react3.useEffect)(() => {
+  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 execute = (0, import_react3.useCallback)(
+  const execute = _react.useCallback.call(void 0, 
     async (isRefetch) => {
       query.log(
         `Begin executing shared query ${queryKey}, isRefetch=${isRefetch}`
@@ -781,7 +520,7 @@ function useSharedQuery(query, ...args) {
     },
     [query, queryKey, setQueryStateValue, stableArgs]
   );
-  (0, import_react3.useEffect)(() => {
+  _react.useEffect.call(void 0, () => {
     isMounted.current = true;
     query.mount(queryKey);
     void execute(false);
@@ -790,16 +529,18 @@ function useSharedQuery(query, ...args) {
       query.unmount(queryKey);
     };
   }, [execute, query, queryKey]);
-  return (0, import_react3.useMemo)(() => {
+  return _react.useMemo.call(void 0, () => {
     return {
       ...queryStateValue,
-      lastNonEmptyData,
+      // 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);
+        _optionalChain([controller, 'optionalAccess', _27 => _27.abort, 'call', _28 => _28(reason)]);
         return Boolean(controller);
       },
       refetch: () => {
@@ -814,10 +555,9 @@ function useSharedQuery(query, ...args) {
     };
   }, [execute, lastNonEmptyData, query, queryKey, queryStateValue]);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SharedQueryConfig,
-  configureSharedQuery,
-  sharedQuery,
-  useSharedQuery
-});
+
+
+
+
+
+exports.SharedQueryConfig = SharedQueryConfig; exports.configureSharedQuery = configureSharedQuery; exports.sharedQuery = sharedQuery; exports.useSharedQuery = useSharedQuery;