@choksheak/react-utils 0.2.8 → 0.3.0

package/sharedQuery.mjs

@@ -13,108 +13,71 @@ import {
 import { MS_PER_DAY } from "@choksheak/ts-utils/timeConstants";
 import { useSyncExternalStore } from "react";
 
-// src/utils/storage.ts
+// src/storage.ts
 import { kvStore } from "@choksheak/ts-utils/kvStore";
+import { LocalStore } from "@choksheak/ts-utils/localStore";
 function getStorageAdapter(options, defaultStoreExpiryMs) {
-  const { localStorageKey, indexedDbKey, storeExpiryMs, store } = options ?? {};
-  if (store) {
-    return store;
-  }
-  const expiryMs = storeExpiryMs || defaultStoreExpiryMs;
-  if (localStorageKey) {
-    return new LocalStorageAdapter(localStorageKey, expiryMs);
-  }
-  if (indexedDbKey) {
-    return new IndexedDbAdapter(indexedDbKey, expiryMs);
-  }
-  return null;
-}
-var LocalStorageAdapter = class {
-  constructor(keyPrefix, expiryMs) {
-    this.keyPrefix = keyPrefix;
-    this.expiryMs = expiryMs;
-  }
-  save(key, value) {
-    if (typeof window === "undefined") return;
-    const fullKey = this.keyPrefix + ":" + key;
-    window.localStorage.setItem(
-      fullKey,
-      JSON.stringify({
-        value,
-        expiresAt: this.expiryMs ? Date.now() + this.expiryMs : 0
-      })
-    );
-  }
-  load(key) {
-    if (typeof window === "undefined") return void 0;
-    const fullKey = this.keyPrefix + ":" + key;
-    const raw = window.localStorage.getItem(fullKey);
-    if (!raw) return void 0;
-    try {
-      const box = JSON.parse(raw);
-      if (!box || box.expiresAt && Date.now() >= box.expiresAt) {
-        window.localStorage.removeItem(fullKey);
-        return void 0;
+  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;
+    switch (store.persistTo) {
+      case "localStorage": {
+        const adapter = new LocalStore(store.key, {
+          defaultExpiryMs: expiryMs
+        });
+        return {
+          set: (key, value) => {
+            if (typeof window === "undefined") return;
+            adapter.set(key, value);
+          },
+          get: (key) => {
+            if (typeof window === "undefined") return void 0;
+            return adapter.get(key);
+          },
+          delete: (key) => {
+            if (typeof window === "undefined") return;
+            adapter.delete(key);
+          },
+          clear: () => {
+            if (typeof window === "undefined") return;
+            adapter.clear();
+          }
+        };
       }
-      return box.value;
-    } catch {
-      window.localStorage.removeItem(fullKey);
-      return void 0;
-    }
-  }
-  delete(key) {
-    if (typeof window === "undefined") return;
-    const fullKey = this.keyPrefix + ":" + key;
-    window.localStorage.removeItem(fullKey);
-  }
-  clear() {
-    if (typeof window === "undefined") return;
-    for (const key of Object.keys(window.localStorage)) {
-      if (key.startsWith(this.keyPrefix)) {
-        window.localStorage.removeItem(key);
+      case "indexedDb": {
+        const keyPrefix = store.key + ":";
+        return {
+          set: async (key, value) => {
+            if (typeof window === "undefined") return;
+            await kvStore.set(keyPrefix + key, value, expiryMs);
+          },
+          get: async (key) => {
+            if (typeof window === "undefined") return void 0;
+            return await kvStore.get(keyPrefix + key);
+          },
+          delete: async (key) => {
+            if (typeof window === "undefined") return;
+            await kvStore.delete(keyPrefix + key);
+          },
+          clear: async () => {
+            if (typeof window === "undefined") return;
+            await kvStore.clear();
+          }
+        };
       }
+      default:
+        store.persistTo;
+        throw new Error(`Unknown store.adapter ${store.persistTo}`);
     }
   }
-};
-var IndexedDbAdapter = class {
-  constructor(keyPrefix, expiryMs) {
-    this.keyPrefix = keyPrefix;
-    this.expiryMs = expiryMs;
-  }
-  async save(key, value) {
-    if (typeof window === "undefined") return;
-    const fullKey = this.keyPrefix + ":" + key;
-    await kvStore.set(fullKey, JSON.stringify(value), this.expiryMs);
-  }
-  async load(key) {
-    if (typeof window === "undefined") return void 0;
-    const fullKey = this.keyPrefix + ":" + key;
-    const raw = await kvStore.get(fullKey);
-    if (raw === void 0) return void 0;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      await kvStore.delete(fullKey);
-      return void 0;
-    }
-  }
-  async delete(key) {
-    if (typeof window === "undefined") return;
-    const fullKey = this.keyPrefix + ":" + key;
-    await kvStore.delete(fullKey);
-  }
-  async clear() {
-    if (typeof window === "undefined") return;
-    await kvStore.forEach(async (k) => {
-      if (k.startsWith(this.keyPrefix)) {
-        await kvStore.delete(k);
-      }
-    });
-  }
-};
+  return store;
+}
 
 // src/sharedState.ts
-var SharedStateDefaults = {
+var SharedStateConfig = {
   /**
    * Default duration for storage expiration in milliseconds. Initial value
    * is 30 days, but can be changed to anything.
@@ -181,14 +144,14 @@ var SharedState = class {
     this.pubSubKey = String(stateKey++);
     this.storageAdapter = getStorageAdapter(
       options,
-      SharedStateDefaults.storeExpiryMs
+      SharedStateConfig.storeExpiryMs
     );
     this.setValueBounded = (next) => {
       this.setValue(next);
     };
     pubSubStore.setNoNotify(this.pubSubKey, defaultValue);
     const lazyLoad = options?.lazyLoad;
-    const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateDefaults.lazyLoad;
+    const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateConfig.lazyLoad;
     if (!lazy) {
       void this.initDefaultValueOnce();
     }
@@ -213,19 +176,19 @@ var SharedState = class {
       next = next(prev);
     }
     pubSubStore.set(this.pubSubKey, next);
-    void this.storageAdapter?.save(STORAGE_KEY, next);
+    void this.storageAdapter?.set(STORAGE_KEY, next);
   }
   // Remove the value of the shared state. Actually this just sets the value
   // back to the given default value.
   delete() {
     pubSubStore.set(this.pubSubKey, this.defaultValue);
-    void this.storageAdapter?.save(STORAGE_KEY, this.defaultValue);
+    void this.storageAdapter?.set(STORAGE_KEY, this.defaultValue);
   }
   // Initial default handling
   async initDefaultValueOnce() {
     if (this.initDone) return;
     this.initDone = true;
-    const v = await this.storageAdapter?.load(STORAGE_KEY);
+    const v = await this.storageAdapter?.get(STORAGE_KEY);
     pubSubStore.set(this.pubSubKey, v !== void 0 ? v : this.defaultValue);
   }
 };
@@ -243,7 +206,7 @@ function useSharedState(state) {
   return [value, state.setValueBounded];
 }
 
-// src/utils/stringify.ts
+// src/stringify.ts
 function stringifyDeterministicForKeys(params) {
   const cache = /* @__PURE__ */ new Set();
   return JSON.stringify(params, (_, value) => {
@@ -274,7 +237,7 @@ function stringifyDeterministicForKeys(params) {
   });
 }
 
-// src/utils/useDeepMemo.ts
+// src/useDeepMemo.ts
 import isEqual from "lodash/isEqual";
 import { useMemo, useState } from "react";
 function useDeepMemo(value) {
@@ -289,7 +252,7 @@ function useDeepMemo(value) {
 }
 
 // src/sharedQuery.ts
-var SharedQueryDefaults = {
+var SharedQueryConfig = {
   /** Refetch on every page load. */
   staleMs: 0,
   /** Keep in cache for a long time. */
@@ -305,6 +268,9 @@ var SharedQueryDefaults = {
   /** Default to log to console. */
   log: (...args) => console.log("[sharedQuery]", ...args)
 };
+function configureSharedQuery(config) {
+  Object.assign(SharedQueryConfig, config);
+}
 var SharedQuery = class {
   inflightQueries = /* @__PURE__ */ new Map();
   queryState;
@@ -326,29 +292,27 @@ var SharedQuery = class {
   constructor(options) {
     this.queryName = options.queryName;
     this.queryFn = options.queryFn;
-    this.staleMs = options?.staleMs ?? SharedQueryDefaults.staleMs;
-    this.expiryMs = options?.expiryMs ?? SharedQueryDefaults.expiryMs;
-    this.refetchOnStale = options?.refetchOnStale ?? SharedQueryDefaults.refetchOnStale;
-    if (!options.localStorageKey && !options.indexedDbKey) {
-      const persistTo = options.persistTo ?? SharedQueryDefaults.persistTo;
-      if (persistTo === "localStorage") {
-        options.localStorageKey = options.queryName;
-      } else if (persistTo === "indexedDb") {
-        options.indexedDbKey = options.queryName;
+    this.staleMs = options?.staleMs ?? SharedQueryConfig.staleMs;
+    this.expiryMs = options?.expiryMs ?? SharedQueryConfig.expiryMs;
+    this.refetchOnStale = options?.refetchOnStale ?? SharedQueryConfig.refetchOnStale;
+    if (!options.store) {
+      const persistTo = options.persistTo ?? SharedQueryConfig.persistTo;
+      if (persistTo) {
+        options.store = {
+          persistTo,
+          key: options.queryName,
+          expiryMs: this.expiryMs
+        };
       }
     }
-    this.maxSize = options?.maxSize ?? SharedQueryDefaults.maxSize;
-    this.maxBytes = options?.maxBytes ?? SharedQueryDefaults.maxBytes;
+    this.maxSize = options?.maxSize ?? SharedQueryConfig.maxSize;
+    this.maxBytes = options?.maxBytes ?? SharedQueryConfig.maxBytes;
     this.keepLastNonEmptyData = Boolean(options?.keepLastNonEmptyData);
-    this.log = options?.log ?? SharedQueryDefaults.log;
+    this.log = options?.log ?? SharedQueryConfig.log;
     this.queryState = sharedState(
       {},
       // defaultValue
-      {
-        ...options,
-        // Fallback to use expiryMs for the storeExpiryMs.
-        storeExpiryMs: options?.storeExpiryMs || this.expiryMs
-      }
+      options
     );
   }
   /** Returns a key to identify requests based on the given args. */
@@ -459,7 +423,14 @@ var SharedQuery = class {
   }
   /** Get the current stored data for a query key. */
   getData(queryKey) {
-    return this.queryState.getSnapshot()?.[queryKey]?.data;
+    const stateValue = this.queryState.getSnapshot()?.[queryKey];
+    if (stateValue?.lastUpdatedMs) {
+      if (this.isExpired(stateValue.lastUpdatedMs)) {
+        this.deleteData(queryKey);
+        return void 0;
+      }
+    }
+    return stateValue?.data;
   }
   /** Set the data directly if the user obtained it from somewhere else. */
   setData(queryKey, data, dataUpdatedMs = Date.now()) {
@@ -542,25 +513,41 @@ var SharedQuery = class {
     );
     const newState = { ...oldState };
     let needUpdate = false;
-    const entriesByTimeAscending = Object.entries(newState).sort(
-      (entry1, entry2) => entry1[1].lastUpdatedMs - entry2[1].lastUpdatedMs
-    );
-    for (const [key] of entriesByTimeAscending) {
+    const deleteKeyIfNotMounted = (key, expired) => {
       if (this.mountedKeys.has(key)) {
         this.log(`Cannot clean up ${key} as it is mounted`);
-        continue;
+        return;
       }
       const byteSize = getByteSize(key) + getByteSize(newState[key]);
       this.log(
-        `Cleaning up unmounted ${key} (byteSize=${byteSize.toLocaleString()})`
+        `Cleaning up unmounted${expired ? ", expired" : ""} ${key} (byteSize=${byteSize.toLocaleString()})`
       );
       numToCut--;
       bytesToCut -= byteSize;
       delete newState[key];
       needUpdate = true;
-      if (numToCut <= 0 && bytesToCut <= 0) {
+    };
+    let entriesByTimeAscending = Object.entries(newState).sort(
+      (entry1, entry2) => entry1[1].lastUpdatedMs - entry2[1].lastUpdatedMs
+    );
+    for (const [key] of entriesByTimeAscending) {
+      if (!this.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) {
       this.log(
@@ -586,7 +573,7 @@ var DEFAULT_QUERY_STATE_ENTRY = {
   lastUpdatedMs: 0,
   loading: true
 };
-function useSharedQuery(query, args = []) {
+function useSharedQuery(query, ...args) {
   const stableArgs = useDeepMemo(args);
   const [queryState, setQueryState] = useSharedState(query.queryState);
   const isMounted = useRef(true);
@@ -702,7 +689,8 @@ function useSharedQuery(query, args = []) {
 }
 export {
   SharedQuery,
-  SharedQueryDefaults,
+  SharedQueryConfig,
+  configureSharedQuery,
   sharedQuery,
   useSharedQuery
 };

package/sharedState.cjs

@@ -21,7 +21,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var sharedState_exports = {};
 __export(sharedState_exports, {
   SharedState: () => SharedState,
-  SharedStateDefaults: () => SharedStateDefaults,
+  SharedStateConfig: () => SharedStateConfig,
+  configureSharedState: () => configureSharedState,
   sharedState: () => sharedState,
   useSharedState: () => useSharedState,
   useSharedStateSetter: () => useSharedStateSetter,
@@ -31,108 +32,71 @@ module.exports = __toCommonJS(sharedState_exports);
 var import_timeConstants = require("@choksheak/ts-utils/timeConstants");
 var import_react = require("react");
 
-// src/utils/storage.ts
+// src/storage.ts
 var import_kvStore = require("@choksheak/ts-utils/kvStore");
+var import_localStore = require("@choksheak/ts-utils/localStore");
 function getStorageAdapter(options, defaultStoreExpiryMs) {
-  const { localStorageKey, indexedDbKey, storeExpiryMs, store } = options ?? {};
-  if (store) {
-    return store;
-  }
-  const expiryMs = storeExpiryMs || defaultStoreExpiryMs;
-  if (localStorageKey) {
-    return new LocalStorageAdapter(localStorageKey, expiryMs);
-  }
-  if (indexedDbKey) {
-    return new IndexedDbAdapter(indexedDbKey, expiryMs);
-  }
-  return null;
-}
-var LocalStorageAdapter = class {
-  constructor(keyPrefix, expiryMs) {
-    this.keyPrefix = keyPrefix;
-    this.expiryMs = expiryMs;
-  }
-  save(key, value) {
-    if (typeof window === "undefined") return;
-    const fullKey = this.keyPrefix + ":" + key;
-    window.localStorage.setItem(
-      fullKey,
-      JSON.stringify({
-        value,
-        expiresAt: this.expiryMs ? Date.now() + this.expiryMs : 0
-      })
-    );
-  }
-  load(key) {
-    if (typeof window === "undefined") return void 0;
-    const fullKey = this.keyPrefix + ":" + key;
-    const raw = window.localStorage.getItem(fullKey);
-    if (!raw) return void 0;
-    try {
-      const box = JSON.parse(raw);
-      if (!box || box.expiresAt && Date.now() >= box.expiresAt) {
-        window.localStorage.removeItem(fullKey);
-        return void 0;
+  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;
+    switch (store.persistTo) {
+      case "localStorage": {
+        const adapter = new import_localStore.LocalStore(store.key, {
+          defaultExpiryMs: expiryMs
+        });
+        return {
+          set: (key, value) => {
+            if (typeof window === "undefined") return;
+            adapter.set(key, value);
+          },
+          get: (key) => {
+            if (typeof window === "undefined") return void 0;
+            return adapter.get(key);
+          },
+          delete: (key) => {
+            if (typeof window === "undefined") return;
+            adapter.delete(key);
+          },
+          clear: () => {
+            if (typeof window === "undefined") return;
+            adapter.clear();
+          }
+        };
       }
-      return box.value;
-    } catch {
-      window.localStorage.removeItem(fullKey);
-      return void 0;
-    }
-  }
-  delete(key) {
-    if (typeof window === "undefined") return;
-    const fullKey = this.keyPrefix + ":" + key;
-    window.localStorage.removeItem(fullKey);
-  }
-  clear() {
-    if (typeof window === "undefined") return;
-    for (const key of Object.keys(window.localStorage)) {
-      if (key.startsWith(this.keyPrefix)) {
-        window.localStorage.removeItem(key);
+      case "indexedDb": {
+        const keyPrefix = store.key + ":";
+        return {
+          set: async (key, value) => {
+            if (typeof window === "undefined") return;
+            await import_kvStore.kvStore.set(keyPrefix + key, value, expiryMs);
+          },
+          get: async (key) => {
+            if (typeof window === "undefined") return void 0;
+            return await import_kvStore.kvStore.get(keyPrefix + key);
+          },
+          delete: async (key) => {
+            if (typeof window === "undefined") return;
+            await import_kvStore.kvStore.delete(keyPrefix + key);
+          },
+          clear: async () => {
+            if (typeof window === "undefined") return;
+            await import_kvStore.kvStore.clear();
+          }
+        };
       }
+      default:
+        store.persistTo;
+        throw new Error(`Unknown store.adapter ${store.persistTo}`);
     }
   }
-};
-var IndexedDbAdapter = class {
-  constructor(keyPrefix, expiryMs) {
-    this.keyPrefix = keyPrefix;
-    this.expiryMs = expiryMs;
-  }
-  async save(key, value) {
-    if (typeof window === "undefined") return;
-    const fullKey = this.keyPrefix + ":" + key;
-    await import_kvStore.kvStore.set(fullKey, JSON.stringify(value), this.expiryMs);
-  }
-  async load(key) {
-    if (typeof window === "undefined") return void 0;
-    const fullKey = this.keyPrefix + ":" + key;
-    const raw = await import_kvStore.kvStore.get(fullKey);
-    if (raw === void 0) return void 0;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      await import_kvStore.kvStore.delete(fullKey);
-      return void 0;
-    }
-  }
-  async delete(key) {
-    if (typeof window === "undefined") return;
-    const fullKey = this.keyPrefix + ":" + key;
-    await import_kvStore.kvStore.delete(fullKey);
-  }
-  async clear() {
-    if (typeof window === "undefined") return;
-    await import_kvStore.kvStore.forEach(async (k) => {
-      if (k.startsWith(this.keyPrefix)) {
-        await import_kvStore.kvStore.delete(k);
-      }
-    });
-  }
-};
+  return store;
+}
 
 // src/sharedState.ts
-var SharedStateDefaults = {
+var SharedStateConfig = {
   /**
    * Default duration for storage expiration in milliseconds. Initial value
    * is 30 days, but can be changed to anything.
@@ -144,6 +108,9 @@ var SharedStateDefaults = {
    */
   lazyLoad: false
 };
+function configureSharedState(config) {
+  Object.assign(SharedStateConfig, config);
+}
 var PubSubStore = class {
   dataByKey = /* @__PURE__ */ new Map();
   subscribersByKey = /* @__PURE__ */ new Map();
@@ -199,14 +166,14 @@ var SharedState = class {
     this.pubSubKey = String(stateKey++);
     this.storageAdapter = getStorageAdapter(
       options,
-      SharedStateDefaults.storeExpiryMs
+      SharedStateConfig.storeExpiryMs
     );
     this.setValueBounded = (next) => {
       this.setValue(next);
     };
     pubSubStore.setNoNotify(this.pubSubKey, defaultValue);
     const lazyLoad = options?.lazyLoad;
-    const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateDefaults.lazyLoad;
+    const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateConfig.lazyLoad;
     if (!lazy) {
       void this.initDefaultValueOnce();
     }
@@ -231,19 +198,19 @@ var SharedState = class {
       next = next(prev);
     }
     pubSubStore.set(this.pubSubKey, next);
-    void this.storageAdapter?.save(STORAGE_KEY, next);
+    void this.storageAdapter?.set(STORAGE_KEY, next);
   }
   // Remove the value of the shared state. Actually this just sets the value
   // back to the given default value.
   delete() {
     pubSubStore.set(this.pubSubKey, this.defaultValue);
-    void this.storageAdapter?.save(STORAGE_KEY, this.defaultValue);
+    void this.storageAdapter?.set(STORAGE_KEY, this.defaultValue);
   }
   // Initial default handling
   async initDefaultValueOnce() {
     if (this.initDone) return;
     this.initDone = true;
-    const v = await this.storageAdapter?.load(STORAGE_KEY);
+    const v = await this.storageAdapter?.get(STORAGE_KEY);
     pubSubStore.set(this.pubSubKey, v !== void 0 ? v : this.defaultValue);
   }
 };
@@ -269,7 +236,8 @@ function useSharedStateSetter(state) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SharedState,
-  SharedStateDefaults,
+  SharedStateConfig,
+  configureSharedState,
   sharedState,
   useSharedState,
   useSharedStateSetter,

package/sharedState.d.mts

@@ -1,5 +1,6 @@
 import { Dispatch, SetStateAction } from 'react';
-import { StorageOptions } from './utils/storage.mjs';
+import { StorageOptions } from './storage.mjs';
+import '@choksheak/ts-utils/storageAdapter';
 
 /**
  * @packageDocumentation
@@ -48,7 +49,7 @@ import { StorageOptions } from './utils/storage.mjs';
 /**
  * These values are configurable by the user at any time.
  */
-declare const SharedStateDefaults: {
+declare const SharedStateConfig: {
     /**
      * Default duration for storage expiration in milliseconds. Initial value
      * is 30 days, but can be changed to anything.
@@ -60,6 +61,9 @@ declare const SharedStateDefaults: {
      */
     lazyLoad: boolean;
 };
+type SharedStateConfig = typeof SharedStateConfig;
+/** Convenience function to update global defaults. */
+declare function configureSharedState(config: Partial<SharedStateConfig>): void;
 /** Options to configure a shared state. */
 type SharedStateOptions<T> = {
     lazyLoad?: boolean;
@@ -115,4 +119,4 @@ declare function useSharedStateValue<T>(state: SharedState<T>): T;
  */
 declare function useSharedStateSetter<T>(state: SharedState<T>): Dispatch<SetStateAction<T>>;
 
-export { SharedState, SharedStateDefaults, type SharedStateOptions, sharedState, useSharedState, useSharedStateSetter, useSharedStateValue };
+export { SharedState, SharedStateConfig, type SharedStateOptions, configureSharedState, sharedState, useSharedState, useSharedStateSetter, useSharedStateValue };

package/sharedState.d.ts

@@ -40,13 +40,13 @@
  * ```
  */
 import { Dispatch, SetStateAction } from "react";
-import { StorageOptions } from "./utils/storage";
+import { StorageOptions } from "./storage";
 /************************************************************************/
 /************************************************************************/
 /**
  * These values are configurable by the user at any time.
  */
-export declare const SharedStateDefaults: {
+export declare const SharedStateConfig: {
     /**
      * Default duration for storage expiration in milliseconds. Initial value
      * is 30 days, but can be changed to anything.
@@ -58,6 +58,9 @@ export declare const SharedStateDefaults: {
      */
     lazyLoad: boolean;
 };
+export type SharedStateConfig = typeof SharedStateConfig;
+/** Convenience function to update global defaults. */
+export declare function configureSharedState(config: Partial<SharedStateConfig>): void;
 /** Options to configure a shared state. */
 export type SharedStateOptions<T> = {
     lazyLoad?: boolean;