@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/utils/caches.d.cts

@@ -0,0 +1,98 @@
+import { RateLimitOptions, ReactPromise } from './promises.cjs';
+import './results.cjs';
+
+/**
+ * Can be used to cache the result of a function call, for example for the `use` hook in React.
+ */
+declare function cacheFunction<F extends Function>(f: F): F;
+type CacheStrategy = "write-only" | "read-write" | "never";
+declare class AsyncCache<D extends any[], T> {
+    private readonly _fetcher;
+    private readonly _options;
+    private readonly _map;
+    constructor(_fetcher: (dependencies: D) => Promise<T>, _options?: {
+        onSubscribe?: (key: D, refresh: () => void) => (() => void);
+        rateLimiter?: Omit<RateLimitOptions, "batchCalls">;
+    });
+    private _createKeyed;
+    getValueCache(dependencies: D): AsyncValueCache<T>;
+    refreshWhere(predicate: (dependencies: D) => boolean): Promise<void>;
+    readonly isCacheAvailable: (key: D) => boolean;
+    readonly getIfCached: (key: D) => ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
+    }) | ({
+        status: "pending";
+    } & {
+        progress: void;
+    } & {
+        status: "pending";
+    }) | ({
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    });
+    readonly getOrWait: (key: D, cacheStrategy: CacheStrategy) => ReactPromise<T>;
+    readonly forceSetCachedValue: (key: D, value: T) => void;
+    readonly forceSetCachedValueAsync: (key: D, value: Promise<T>) => ReactPromise<boolean>;
+    readonly refresh: (key: D) => Promise<T>;
+    readonly invalidate: (key: D) => void;
+    readonly onStateChange: (key: D, callback: (value: T, oldValue: T | undefined) => void) => {
+        unsubscribe: () => void;
+    };
+}
+declare class AsyncValueCache<T> {
+    private readonly _options;
+    private _store;
+    private _pendingPromise;
+    private _fetcher;
+    private readonly _rateLimitOptions;
+    private _subscriptionsCount;
+    private _unsubscribers;
+    private _mostRecentRefreshPromiseIndex;
+    constructor(fetcher: () => Promise<T>, _options?: {
+        onSubscribe?: (refresh: () => void) => (() => void);
+        rateLimiter?: Omit<RateLimitOptions, "batchCalls">;
+    });
+    isCacheAvailable(): boolean;
+    getIfCached(): ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
+    }) | ({
+        status: "pending";
+    } & {
+        progress: void;
+    } & {
+        status: "pending";
+    }) | ({
+        status: "ok";
+        data: T;
+    } & {
+        status: "ok";
+    });
+    getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T>;
+    private _set;
+    private _setAsync;
+    private _refetch;
+    forceSetCachedValue(value: T): void;
+    forceSetCachedValueAsync(value: Promise<T>): ReactPromise<boolean>;
+    /**
+     * Refetches the value from the fetcher, and updates the cache with it.
+     */
+    refresh(): Promise<T>;
+    /**
+     * Invalidates the cache, marking it to refresh on the next read. If anyone was listening to it, it will refresh
+     * immediately.
+     */
+    invalidate(): void;
+    onStateChange(callback: (value: T, oldValue: T | undefined) => void): {
+        unsubscribe: () => void;
+    };
+}
+
+export { AsyncCache, cacheFunction };

package/dist/utils/caches.d.ts

@@ -1,10 +1,12 @@
-import { RateLimitOptions, ReactPromise } from "./promises";
+import { RateLimitOptions, ReactPromise } from './promises.js';
+import './results.js';
+
 /**
  * Can be used to cache the result of a function call, for example for the `use` hook in React.
  */
-export declare function cacheFunction<F extends Function>(f: F): F;
+declare function cacheFunction<F extends Function>(f: F): F;
 type CacheStrategy = "write-only" | "read-write" | "never";
-export declare class AsyncCache<D extends any[], T> {
+declare class AsyncCache<D extends any[], T> {
     private readonly _fetcher;
     private readonly _options;
     private readonly _map;
@@ -17,16 +19,16 @@ export declare class AsyncCache<D extends any[], T> {
     refreshWhere(predicate: (dependencies: D) => boolean): Promise<void>;
     readonly isCacheAvailable: (key: D) => boolean;
     readonly getIfCached: (key: D) => ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
+    }) | ({
         status: "pending";
     } & {
         progress: void;
     } & {
         status: "pending";
-    }) | ({
-        status: "error";
-        error: unknown;
-    } & {
-        status: "error";
     }) | ({
         status: "ok";
         data: T;
@@ -57,16 +59,16 @@ declare class AsyncValueCache<T> {
     });
     isCacheAvailable(): boolean;
     getIfCached(): ({
+        status: "error";
+        error: unknown;
+    } & {
+        status: "error";
+    }) | ({
         status: "pending";
     } & {
         progress: void;
     } & {
         status: "pending";
-    }) | ({
-        status: "error";
-        error: unknown;
-    } & {
-        status: "error";
     }) | ({
         status: "ok";
         data: T;
@@ -92,4 +94,5 @@ declare class AsyncValueCache<T> {
         unsubscribe: () => void;
     };
 }
-export {};
+
+export { AsyncCache, cacheFunction };

package/dist/utils/caches.js

@@ -1,198 +1,193 @@
-import { DependenciesMap } from "./maps";
-import { filterUndefined } from "./objects";
-import { pending, rateLimited, resolved, runAsynchronously, wait } from "./promises";
-import { AsyncStore } from "./stores";
-/**
- * Can be used to cache the result of a function call, for example for the `use` hook in React.
- */
-export function cacheFunction(f) {
-    const dependenciesMap = new DependenciesMap();
-    return ((...args) => {
-        if (dependenciesMap.has(args)) {
-            return dependenciesMap.get(args);
-        }
-        const value = f(...args);
-        dependenciesMap.set(args, value);
-        return value;
-    });
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/caches.tsx
+var caches_exports = {};
+__export(caches_exports, {
+  AsyncCache: () => AsyncCache,
+  cacheFunction: () => cacheFunction
+});
+module.exports = __toCommonJS(caches_exports);
+var import_maps = require("./maps");
+var import_objects = require("./objects");
+var import_promises = require("./promises");
+var import_stores = require("./stores");
+function cacheFunction(f) {
+  const dependenciesMap = new import_maps.DependenciesMap();
+  return (...args) => {
+    if (dependenciesMap.has(args)) {
+      return dependenciesMap.get(args);
+    }
+    const value = f(...args);
+    dependenciesMap.set(args, value);
+    return value;
+  };
 }
-import.meta.vitest?.test("cacheFunction", ({ expect }) => {
-    // Test with a simple function
-    let callCount = 0;
-    const add = (a, b) => {
-        callCount++;
-        return a + b;
-    };
-    const cachedAdd = cacheFunction(add);
-    // First call should execute the function
-    expect(cachedAdd(1, 2)).toBe(3);
-    expect(callCount).toBe(1);
-    // Second call with same args should use cached result
-    expect(cachedAdd(1, 2)).toBe(3);
-    expect(callCount).toBe(1);
-    // Call with different args should execute the function again
-    expect(cachedAdd(2, 3)).toBe(5);
-    expect(callCount).toBe(2);
-    // Test with a function that returns objects
-    let objectCallCount = 0;
-    const createObject = (id) => {
-        objectCallCount++;
-        return { id };
+var AsyncCache = class {
+  constructor(_fetcher, _options = {}) {
+    this._fetcher = _fetcher;
+    this._options = _options;
+    this._map = new import_maps.DependenciesMap();
+    this.isCacheAvailable = this._createKeyed("isCacheAvailable");
+    this.getIfCached = this._createKeyed("getIfCached");
+    this.getOrWait = this._createKeyed("getOrWait");
+    this.forceSetCachedValue = this._createKeyed("forceSetCachedValue");
+    this.forceSetCachedValueAsync = this._createKeyed("forceSetCachedValueAsync");
+    this.refresh = this._createKeyed("refresh");
+    this.invalidate = this._createKeyed("invalidate");
+    this.onStateChange = this._createKeyed("onStateChange");
+  }
+  _createKeyed(functionName) {
+    return (key, ...args) => {
+      const valueCache = this.getValueCache(key);
+      return valueCache[functionName].apply(valueCache, args);
     };
-    const cachedCreateObject = cacheFunction(createObject);
-    // First call should execute the function
-    const obj1 = cachedCreateObject(1);
-    expect(obj1).toEqual({ id: 1 });
-    expect(objectCallCount).toBe(1);
-    // Second call with same args should use cached result
-    const obj2 = cachedCreateObject(1);
-    expect(obj2).toBe(obj1); // Same reference
-    expect(objectCallCount).toBe(1);
-});
-export class AsyncCache {
-    constructor(_fetcher, _options = {}) {
-        this._fetcher = _fetcher;
-        this._options = _options;
-        this._map = new DependenciesMap();
-        this.isCacheAvailable = this._createKeyed("isCacheAvailable");
-        this.getIfCached = this._createKeyed("getIfCached");
-        this.getOrWait = this._createKeyed("getOrWait");
-        this.forceSetCachedValue = this._createKeyed("forceSetCachedValue");
-        this.forceSetCachedValueAsync = this._createKeyed("forceSetCachedValueAsync");
-        this.refresh = this._createKeyed("refresh");
-        this.invalidate = this._createKeyed("invalidate");
-        this.onStateChange = this._createKeyed("onStateChange");
-        // nothing here yet
-    }
-    _createKeyed(functionName) {
-        return (key, ...args) => {
-            const valueCache = this.getValueCache(key);
-            return valueCache[functionName].apply(valueCache, args);
-        };
-    }
-    getValueCache(dependencies) {
-        let cache = this._map.get(dependencies);
-        if (!cache) {
-            cache = new AsyncValueCache(async () => await this._fetcher(dependencies), {
-                ...this._options,
-                onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe(dependencies, cb) : undefined,
-            });
-            this._map.set(dependencies, cache);
+  }
+  getValueCache(dependencies) {
+    let cache = this._map.get(dependencies);
+    if (!cache) {
+      cache = new AsyncValueCache(
+        async () => await this._fetcher(dependencies),
+        {
+          ...this._options,
+          onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe(dependencies, cb) : void 0
         }
-        return cache;
-    }
-    async refreshWhere(predicate) {
-        const promises = [];
-        for (const [dependencies, cache] of this._map) {
-            if (predicate(dependencies)) {
-                promises.push(cache.refresh());
+      );
+      this._map.set(dependencies, cache);
+    }
+    return cache;
+  }
+  async refreshWhere(predicate) {
+    const promises = [];
+    for (const [dependencies, cache] of this._map) {
+      if (predicate(dependencies)) {
+        promises.push(cache.refresh());
+      }
+    }
+    await Promise.all(promises);
+  }
+};
+var AsyncValueCache = class {
+  constructor(fetcher, _options = {}) {
+    this._options = _options;
+    this._subscriptionsCount = 0;
+    this._unsubscribers = [];
+    this._mostRecentRefreshPromiseIndex = 0;
+    this._store = new import_stores.AsyncStore();
+    this._rateLimitOptions = {
+      concurrency: 1,
+      throttleMs: 300,
+      ...(0, import_objects.filterUndefined)(_options.rateLimiter ?? {})
+    };
+    this._fetcher = (0, import_promises.rateLimited)(fetcher, {
+      ...this._rateLimitOptions,
+      batchCalls: true
+    });
+  }
+  isCacheAvailable() {
+    return this._store.isAvailable();
+  }
+  getIfCached() {
+    return this._store.get();
+  }
+  getOrWait(cacheStrategy) {
+    const cached = this.getIfCached();
+    if (cacheStrategy === "read-write" && cached.status === "ok") {
+      return (0, import_promises.resolved)(cached.data);
+    }
+    return this._refetch(cacheStrategy);
+  }
+  _set(value) {
+    this._store.set(value);
+  }
+  _setAsync(value) {
+    const promise = (0, import_promises.pending)(value);
+    this._pendingPromise = promise;
+    return (0, import_promises.pending)(this._store.setAsync(promise));
+  }
+  _refetch(cacheStrategy) {
+    if (cacheStrategy === "read-write" && this._pendingPromise) {
+      return this._pendingPromise;
+    }
+    const promise = (0, import_promises.pending)(this._fetcher());
+    if (cacheStrategy === "never") {
+      return promise;
+    }
+    return (0, import_promises.pending)(this._setAsync(promise).then(() => promise));
+  }
+  forceSetCachedValue(value) {
+    this._set(value);
+  }
+  forceSetCachedValueAsync(value) {
+    return this._setAsync(value);
+  }
+  /**
+   * Refetches the value from the fetcher, and updates the cache with it.
+   */
+  async refresh() {
+    return await this.getOrWait("write-only");
+  }
+  /**
+   * Invalidates the cache, marking it to refresh on the next read. If anyone was listening to it, it will refresh
+   * immediately.
+   */
+  invalidate() {
+    this._store.setUnavailable();
+    this._pendingPromise = void 0;
+    if (this._subscriptionsCount > 0) {
+      (0, import_promises.runAsynchronously)(this.refresh());
+    }
+  }
+  onStateChange(callback) {
+    const storeObj = this._store.onChange(callback);
+    (0, import_promises.runAsynchronously)(this.getOrWait("read-write"));
+    if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {
+      const unsubscribe = this._options.onSubscribe(() => {
+        (0, import_promises.runAsynchronously)(this.refresh());
+      });
+      this._unsubscribers.push(unsubscribe);
+    }
+    let hasUnsubscribed = false;
+    return {
+      unsubscribe: () => {
+        if (hasUnsubscribed) return;
+        hasUnsubscribed = true;
+        storeObj.unsubscribe();
+        if (--this._subscriptionsCount === 0) {
+          const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;
+          (0, import_promises.runAsynchronously)(async () => {
+            await (0, import_promises.wait)(5e3);
+            if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) {
+              this.invalidate();
             }
+          });
+          for (const unsubscribe of this._unsubscribers) {
+            unsubscribe();
+          }
         }
-        await Promise.all(promises);
-    }
-}
-class AsyncValueCache {
-    constructor(fetcher, _options = {}) {
-        this._options = _options;
-        this._subscriptionsCount = 0;
-        this._unsubscribers = [];
-        this._mostRecentRefreshPromiseIndex = 0;
-        this._store = new AsyncStore();
-        this._rateLimitOptions = {
-            concurrency: 1,
-            throttleMs: 300,
-            ...filterUndefined(_options.rateLimiter ?? {}),
-        };
-        this._fetcher = rateLimited(fetcher, {
-            ...this._rateLimitOptions,
-            batchCalls: true,
-        });
-    }
-    isCacheAvailable() {
-        return this._store.isAvailable();
-    }
-    getIfCached() {
-        return this._store.get();
-    }
-    getOrWait(cacheStrategy) {
-        const cached = this.getIfCached();
-        if (cacheStrategy === "read-write" && cached.status === "ok") {
-            return resolved(cached.data);
-        }
-        return this._refetch(cacheStrategy);
-    }
-    _set(value) {
-        this._store.set(value);
-    }
-    _setAsync(value) {
-        const promise = pending(value);
-        this._pendingPromise = promise;
-        return pending(this._store.setAsync(promise));
-    }
-    _refetch(cacheStrategy) {
-        if (cacheStrategy === "read-write" && this._pendingPromise) {
-            return this._pendingPromise;
-        }
-        const promise = pending(this._fetcher());
-        if (cacheStrategy === "never") {
-            return promise;
-        }
-        return pending(this._setAsync(promise).then(() => promise));
-    }
-    forceSetCachedValue(value) {
-        this._set(value);
-    }
-    forceSetCachedValueAsync(value) {
-        return this._setAsync(value);
-    }
-    /**
-     * Refetches the value from the fetcher, and updates the cache with it.
-     */
-    async refresh() {
-        return await this.getOrWait("write-only");
-    }
-    /**
-     * Invalidates the cache, marking it to refresh on the next read. If anyone was listening to it, it will refresh
-     * immediately.
-     */
-    invalidate() {
-        this._store.setUnavailable();
-        this._pendingPromise = undefined;
-        if (this._subscriptionsCount > 0) {
-            runAsynchronously(this.refresh());
-        }
-    }
-    onStateChange(callback) {
-        const storeObj = this._store.onChange(callback);
-        runAsynchronously(this.getOrWait("read-write"));
-        if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {
-            const unsubscribe = this._options.onSubscribe(() => {
-                runAsynchronously(this.refresh());
-            });
-            this._unsubscribers.push(unsubscribe);
-        }
-        let hasUnsubscribed = false;
-        return {
-            unsubscribe: () => {
-                if (hasUnsubscribed)
-                    return;
-                hasUnsubscribed = true;
-                storeObj.unsubscribe();
-                if (--this._subscriptionsCount === 0) {
-                    const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;
-                    runAsynchronously(async () => {
-                        // wait a few seconds; if anything changes during that time, we don't want to refresh
-                        // else we do unnecessary requests if we unsubscribe and then subscribe again immediately
-                        await wait(5000);
-                        if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) {
-                            this.invalidate();
-                        }
-                    });
-                    for (const unsubscribe of this._unsubscribers) {
-                        unsubscribe();
-                    }
-                }
-            },
-        };
-    }
-}
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncCache,
+  cacheFunction
+});
+//# sourceMappingURL=caches.js.map

package/dist/utils/caches.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/caches.tsx"],"sourcesContent":["import { DependenciesMap } from \"./maps\";\nimport { filterUndefined } from \"./objects\";\nimport { RateLimitOptions, ReactPromise, pending, rateLimited, resolved, runAsynchronously, wait } from \"./promises\";\nimport { AsyncStore } from \"./stores\";\n\n/**\n * Can be used to cache the result of a function call, for example for the `use` hook in React.\n */\nexport function cacheFunction<F extends Function>(f: F): F {\n  const dependenciesMap = new DependenciesMap<any, any>();\n\n  return ((...args: any) => {\n    if (dependenciesMap.has(args)) {\n      return dependenciesMap.get(args);\n    }\n\n    const value = f(...args);\n    dependenciesMap.set(args, value);\n    return value;\n  }) as any as F;\n}\nundefined?.test(\"cacheFunction\", ({ expect }) => {\n  // Test with a simple function\n  let callCount = 0;\n  const add = (a: number, b: number) => {\n    callCount++;\n    return a + b;\n  };\n\n  const cachedAdd = cacheFunction(add);\n\n  // First call should execute the function\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Second call with same args should use cached result\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Call with different args should execute the function again\n  expect(cachedAdd(2, 3)).toBe(5);\n  expect(callCount).toBe(2);\n\n  // Test with a function that returns objects\n  let objectCallCount = 0;\n  const createObject = (id: number) => {\n    objectCallCount++;\n    return { id };\n  };\n\n  const cachedCreateObject = cacheFunction(createObject);\n\n  // First call should execute the function\n  const obj1 = cachedCreateObject(1);\n  expect(obj1).toEqual({ id: 1 });\n  expect(objectCallCount).toBe(1);\n\n  // Second call with same args should use cached result\n  const obj2 = cachedCreateObject(1);\n  expect(obj2).toBe(obj1); // Same reference\n  expect(objectCallCount).toBe(1);\n});\n\n\ntype CacheStrategy = \"write-only\" | \"read-write\" | \"never\";\n\nexport class AsyncCache<D extends any[], T> {\n  private readonly _map = new DependenciesMap<D, AsyncValueCache<T>>();\n\n  constructor(\n    private readonly _fetcher: (dependencies: D) => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (key: D, refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    // nothing here yet\n  }\n\n  private _createKeyed<FunctionName extends keyof AsyncValueCache<T>>(\n    functionName: FunctionName,\n  ): (key: D, ...args: Parameters<AsyncValueCache<T>[FunctionName]>) => ReturnType<AsyncValueCache<T>[FunctionName]> {\n    return (key: D, ...args) => {\n      const valueCache = this.getValueCache(key);\n      return (valueCache[functionName] as any).apply(valueCache, args);\n    };\n  }\n\n  getValueCache(dependencies: D): AsyncValueCache<T> {\n    let cache = this._map.get(dependencies);\n    if (!cache) {\n      cache = new AsyncValueCache(\n        async () => await this._fetcher(dependencies),\n        {\n          ...this._options,\n          onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe!(dependencies, cb) : undefined,\n        },\n      );\n      this._map.set(dependencies, cache);\n    }\n    return cache;\n  }\n\n  async refreshWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<T>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.refresh());\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  readonly isCacheAvailable = this._createKeyed(\"isCacheAvailable\");\n  readonly getIfCached = this._createKeyed(\"getIfCached\");\n  readonly getOrWait = this._createKeyed(\"getOrWait\");\n  readonly forceSetCachedValue = this._createKeyed(\"forceSetCachedValue\");\n  readonly forceSetCachedValueAsync = this._createKeyed(\"forceSetCachedValueAsync\");\n  readonly refresh = this._createKeyed(\"refresh\");\n  readonly invalidate = this._createKeyed(\"invalidate\");\n  readonly onStateChange = this._createKeyed(\"onStateChange\");\n}\n\nclass AsyncValueCache<T> {\n  private _store: AsyncStore<T>;\n  private _pendingPromise: ReactPromise<T> | undefined;\n  private _fetcher: () => Promise<T>;\n  private readonly _rateLimitOptions: Omit<RateLimitOptions, \"batchCalls\">;\n  private _subscriptionsCount = 0;\n  private _unsubscribers: (() => void)[] = [];\n  private _mostRecentRefreshPromiseIndex = 0;\n\n  constructor(\n    fetcher: () => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    this._store = new AsyncStore();\n    this._rateLimitOptions = {\n      concurrency: 1,\n      throttleMs: 300,\n      ...filterUndefined(_options.rateLimiter ?? {}),\n    };\n\n\n    this._fetcher = rateLimited(fetcher, {\n      ...this._rateLimitOptions,\n      batchCalls: true,\n    });\n  }\n\n  isCacheAvailable(): boolean {\n    return this._store.isAvailable();\n  }\n\n  getIfCached() {\n    return this._store.get();\n  }\n\n  getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    const cached = this.getIfCached();\n    if (cacheStrategy === \"read-write\" && cached.status === \"ok\") {\n      return resolved(cached.data);\n    }\n\n    return this._refetch(cacheStrategy);\n  }\n\n  private _set(value: T): void {\n    this._store.set(value);\n  }\n\n  private _setAsync(value: Promise<T>): ReactPromise<boolean> {\n    const promise = pending(value);\n    this._pendingPromise = promise;\n    return pending(this._store.setAsync(promise));\n  }\n\n  private _refetch(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    if (cacheStrategy === \"read-write\" && this._pendingPromise) {\n      return this._pendingPromise;\n    }\n    const promise = pending(this._fetcher());\n    if (cacheStrategy === \"never\") {\n      return promise;\n    }\n    return pending(this._setAsync(promise).then(() => promise));\n  }\n\n  forceSetCachedValue(value: T): void {\n    this._set(value);\n  }\n\n  forceSetCachedValueAsync(value: Promise<T>): ReactPromise<boolean> {\n    return this._setAsync(value);\n  }\n\n  /**\n   * Refetches the value from the fetcher, and updates the cache with it.\n   */\n  async refresh(): Promise<T> {\n    return await this.getOrWait(\"write-only\");\n  }\n\n  /**\n   * Invalidates the cache, marking it to refresh on the next read. If anyone was listening to it, it will refresh\n   * immediately.\n   */\n  invalidate(): void {\n    this._store.setUnavailable();\n    this._pendingPromise = undefined;\n    if (this._subscriptionsCount > 0) {\n      runAsynchronously(this.refresh());\n    }\n  }\n\n  onStateChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {\n    const storeObj = this._store.onChange(callback);\n\n    runAsynchronously(this.getOrWait(\"read-write\"));\n\n    if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {\n      const unsubscribe = this._options.onSubscribe(() => {\n        runAsynchronously(this.refresh());\n      });\n      this._unsubscribers.push(unsubscribe);\n    }\n\n    let hasUnsubscribed = false;\n    return {\n      unsubscribe: () => {\n        if (hasUnsubscribed) return;\n        hasUnsubscribed = true;\n        storeObj.unsubscribe();\n        if (--this._subscriptionsCount === 0) {\n          const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;\n          runAsynchronously(async () => {\n            // wait a few seconds; if anything changes during that time, we don't want to refresh\n            // else we do unnecessary requests if we unsubscribe and then subscribe again immediately\n            await wait(5000);\n            if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) {\n              this.invalidate();\n            }\n          });\n\n          for (const unsubscribe of this._unsubscribers) {\n            unsubscribe();\n          }\n        }\n      },\n    };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/utils/compile-time.d.cts

@@ -0,0 +1,8 @@
+/**
+ * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some
+ * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed
+ * to exist at runtime).
+ */
+declare function scrambleDuringCompileTime<T>(t: T): T;
+
+export { scrambleDuringCompileTime };

package/dist/utils/compile-time.d.ts

@@ -3,4 +3,6 @@
  * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed
  * to exist at runtime).
  */
-export declare function scrambleDuringCompileTime<T>(t: T): T;
+declare function scrambleDuringCompileTime<T>(t: T): T;
+
+export { scrambleDuringCompileTime };

package/dist/utils/compile-time.js

@@ -1,11 +1,36 @@
-/**
- * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some
- * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed
- * to exist at runtime).
- */
-export function scrambleDuringCompileTime(t) {
-    if (Math.random() < 0.00001 && Math.random() > 0.99999 && Math.random() < 0.00001 && Math.random() > 0.99999) {
-        return "this will never happen";
-    }
-    return t;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/compile-time.tsx
+var compile_time_exports = {};
+__export(compile_time_exports, {
+  scrambleDuringCompileTime: () => scrambleDuringCompileTime
+});
+module.exports = __toCommonJS(compile_time_exports);
+function scrambleDuringCompileTime(t) {
+  if (Math.random() < 1e-5 && Math.random() > 0.99999 && Math.random() < 1e-5 && Math.random() > 0.99999) {
+    return "this will never happen";
+  }
+  return t;
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  scrambleDuringCompileTime
+});
+//# sourceMappingURL=compile-time.js.map

package/dist/utils/compile-time.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/compile-time.tsx"],"sourcesContent":["/**\n * Returns the first argument passed to it, but compilers won't be able to optimize it out. This is useful in some\n * cases where compiler warnings go awry; for example, when importing things that may not exist (but are guaranteed\n * to exist at runtime).\n */\nexport function scrambleDuringCompileTime<T>(t: T): T {\n  if (Math.random() < 0.00001 && Math.random() > 0.99999 && Math.random() < 0.00001 && Math.random() > 0.99999) {\n    return \"this will never happen\" as any;\n  }\n  return t;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,SAAS,0BAA6B,GAAS;AACpD,MAAI,KAAK,OAAO,IAAI,QAAW,KAAK,OAAO,IAAI,WAAW,KAAK,OAAO,IAAI,QAAW,KAAK,OAAO,IAAI,SAAS;AAC5G,WAAO;AAAA,EACT;AACA,SAAO;AACT;","names":[]}

package/dist/utils/crypto.d.cts

@@ -0,0 +1,8 @@
+declare function generateRandomValues(array: Uint8Array): typeof array;
+/**
+ * Generates a secure alphanumeric string using the system's cryptographically secure
+ * random number generator.
+ */
+declare function generateSecureRandomString(minBitsOfEntropy?: number): string;
+
+export { generateRandomValues, generateSecureRandomString };

package/dist/utils/crypto.d.ts

@@ -1,6 +1,8 @@
-export declare function generateRandomValues(array: Uint8Array): typeof array;
+declare function generateRandomValues(array: Uint8Array): typeof array;
 /**
  * Generates a secure alphanumeric string using the system's cryptographically secure
  * random number generator.
  */
-export declare function generateSecureRandomString(minBitsOfEntropy?: number): string;
+declare function generateSecureRandomString(minBitsOfEntropy?: number): string;
+
+export { generateRandomValues, generateSecureRandomString };