ranuts 0.4.1-alpha.2 → 0.5.0

package/dist/src/utils/memoize.d.ts

@@ -19,12 +19,6 @@ export type Func = (...args: any[]) => unknown;
  * ```
  */
 export declare const once: <T extends Func>(fn: T | unknown) => ((...args: Parameters<T>) => ReturnType<T>);
-/**
- * @description: Former name of `once`. The name is misleading — it does not cache per
- * argument, it simply runs once.
- * @deprecated Use [`once`](#once) instead; for the async case use [`singleFlight`](#singleflight).
- */
-export declare const memoize: typeof once;
 export interface SingleFlight<T> {
     (): Promise<T>;
     /** Drop the cached result so the next call runs again (connection lost, logout, forced refresh) */
@@ -35,7 +29,7 @@ export interface SingleFlight<T> {
 /**
  * @description: The async flavour of "run once": concurrent callers share one in-flight
  * promise, later callers reuse the resolved result, and **a rejection clears the cache**
- * so it can be retried (this is where it differs from `memoize` — caching a rejected
+ * so it can be retried (this is where it differs from `once` — caching a rejected
  * promise turns one flaky network blip into a permanent failure).
  *
  * The typical use is a resource that is initialised once but awaited by everyone: opening

package/dist/src/utils/memoize.js

@@ -0,0 +1,16 @@
+var u = (n) => {
+  let e = !1, t, r = n;
+  return (...l) => (e || (t = typeof r == "function" ? r(...l) : r, e = !0, r = void 0), t);
+}, c = (n) => {
+  let e = null;
+  const t = () => (e ??= n().catch((r) => {
+    throw e = null, r;
+  }), e);
+  return t.reset = () => {
+    e = null;
+  }, Object.defineProperty(t, "started", { get: () => e !== null }), t;
+};
+export {
+  u as once,
+  c as singleFlight
+};