@httptoolkit/util 0.1.4 → 0.1.6

package/dist/promises.d.ts

@@ -6,11 +6,24 @@ export declare const delay: (ms: number, options?: {
      * block the process shutdown.
      */
     unref?: boolean;
-}) => Promise<unknown>;
+}) => Promise<void>;
 export declare function doWhile<T>(doFn: () => Promise<T>, whileFn: () => Promise<boolean> | boolean): Promise<void>;
-export interface Deferred<T> {
+/**
+ * A deferred is a promise (you can await it directly) but also exposes the promise
+ * explicitly at .promise, and exposes public resolve & reject callbacks for external
+ * resolution.
+ */
+export interface Deferred<T> extends Promise<T> {
     resolve: (arg: T) => void;
-    reject: (e?: Error) => void;
+    reject: (e: Error) => void;
     promise: Promise<T>;
 }
 export declare function getDeferred<T = void>(): Deferred<T>;
+/**
+ * Wrap a function, so that any parallel calls which happen while the async function
+ * is pending return the same value as the first call (so the function is only run
+ * once, but the result is shared). This is useful for expensive async functions or
+ * race conditions. This ignores arguments completely, and is only applicable for
+ * functions that don't need any other input.
+ */
+export declare function combineParallelCalls<T>(fn: () => Promise<T>): () => Promise<T>;

package/dist/promises.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDeferred = exports.doWhile = exports.delay = void 0;
+exports.combineParallelCalls = exports.getDeferred = exports.doWhile = exports.delay = void 0;
 const delay = (ms, options = {}) => new Promise((resolve) => {
     const timer = setTimeout(resolve, ms);
     if (options.unref && timer.unref) {
@@ -15,15 +15,32 @@ async function doWhile(doFn, whileFn) {
 }
 exports.doWhile = doWhile;
 function getDeferred() {
-    let resolve = undefined;
-    let reject = undefined;
-    let promise = new Promise((resolveCb, rejectCb) => {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolveCb, rejectCb) => {
         resolve = resolveCb;
         reject = rejectCb;
     });
-    // TS thinks we're using these before they're assigned, which is why
-    // we need the undefined types, and the any here.
-    return { resolve, reject, promise };
+    return Object.assign(promise, { resolve, reject, promise });
 }
 exports.getDeferred = getDeferred;
+/**
+ * Wrap a function, so that any parallel calls which happen while the async function
+ * is pending return the same value as the first call (so the function is only run
+ * once, but the result is shared). This is useful for expensive async functions or
+ * race conditions. This ignores arguments completely, and is only applicable for
+ * functions that don't need any other input.
+ */
+function combineParallelCalls(fn) {
+    let pendingPromise;
+    return () => {
+        if (pendingPromise === undefined) {
+            pendingPromise = fn().finally(() => {
+                pendingPromise = undefined;
+            });
+        }
+        return pendingPromise;
+    };
+}
+exports.combineParallelCalls = combineParallelCalls;
 //# sourceMappingURL=promises.js.map

package/dist/promises.js.map

@@ -1 +1 @@
-{"version":3,"file":"promises.js","sourceRoot":"","sources":["../src/promises.ts"],"names":[],"mappings":";;;AAEO,MAAM,KAAK,GAAG,CAAC,EAAU,EAAE,UAO9B,EAAE,EAAE,EAAE,CACN,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;IACpB,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAEtC,IAAI,OAAO,CAAC,KAAK,IAAK,KAAa,CAAC,KAAK,EAAE;QACtC,KAAa,CAAC,KAAK,EAAE,CAAC;KAC1B;AACL,CAAC,CAAC,CAAC;AAdM,QAAA,KAAK,SAcX;AAEA,KAAK,UAAU,OAAO,CACzB,IAAsB,EACtB,OAAyC;IAEzC,GAAG;QACC,MAAM,IAAI,EAAE,CAAC;KAChB,QAAQ,MAAM,OAAO,EAAE,EAAE;AAC9B,CAAC;AAPD,0BAOC;AAQD,SAAgB,WAAW;IACvB,IAAI,OAAO,GAAmC,SAAS,CAAC;IACxD,IAAI,MAAM,GAAsC,SAAS,CAAC;IAE1D,IAAI,OAAO,GAAG,IAAI,OAAO,CAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE;QACjD,OAAO,GAAG,SAAS,CAAC;QACpB,MAAM,GAAG,QAAQ,CAAC;IACtB,CAAC,CAAC,CAAC;IAEH,oEAAoE;IACpE,iDAAiD;IACjD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAS,CAAC;AAC/C,CAAC;AAZD,kCAYC"}
+{"version":3,"file":"promises.js","sourceRoot":"","sources":["../src/promises.ts"],"names":[],"mappings":";;;AAEO,MAAM,KAAK,GAAG,CAAC,EAAU,EAAE,UAO9B,EAAE,EAAE,EAAE,CACN,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;IAC1B,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAEtC,IAAI,OAAO,CAAC,KAAK,IAAK,KAAa,CAAC,KAAK,EAAE;QACtC,KAAa,CAAC,KAAK,EAAE,CAAC;KAC1B;AACL,CAAC,CAAC,CAAC;AAdM,QAAA,KAAK,SAcX;AAEA,KAAK,UAAU,OAAO,CACzB,IAAsB,EACtB,OAAyC;IAEzC,GAAG;QACC,MAAM,IAAI,EAAE,CAAC;KAChB,QAAQ,MAAM,OAAO,EAAE,EAAE;AAC9B,CAAC;AAPD,0BAOC;AAaD,SAAgB,WAAW;IACvB,IAAI,OAA4B,CAAC;IACjC,IAAI,MAA6B,CAAC;IAElC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE;QACnD,OAAO,GAAG,SAAS,CAAC;QACpB,MAAM,GAAG,QAAQ,CAAC;IACtB,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;AAChE,CAAC;AAVD,kCAUC;AAED;;;;;;GAMG;AACH,SAAgB,oBAAoB,CAAI,EAAoB;IACxD,IAAI,cAAsC,CAAC;IAE3C,OAAO,GAAG,EAAE;QACR,IAAI,cAAc,KAAK,SAAS,EAAE;YAC9B,cAAc,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE;gBAC/B,cAAc,GAAG,SAAS,CAAC;YAC/B,CAAC,CAAC,CAAC;SACN;QAED,OAAO,cAAc,CAAC;IAC1B,CAAC,CAAC;AACN,CAAC;AAZD,oDAYC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@httptoolkit/util",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A tiny utility package, sharing JS code widely used across HTTP Toolkit projects",
   "main": "dist/index.js",
   "files": [

package/src/promises.ts

@@ -8,7 +8,7 @@ export const delay = (ms: number, options: {
      */
     unref?: boolean
 } = {}) =>
-    new Promise((resolve) => {
+    new Promise<void>((resolve) => {
         const timer = setTimeout(resolve, ms);
 
         if (options.unref && (timer as any).unref) {
@@ -25,22 +25,46 @@ export async function doWhile<T>(
     } while (await whileFn());
 }
 
-export interface Deferred<T> {
+/**
+ * A deferred is a promise (you can await it directly) but also exposes the promise
+ * explicitly at .promise, and exposes public resolve & reject callbacks for external
+ * resolution.
+ */
+export interface Deferred<T> extends Promise<T> {
     resolve: (arg: T) => void,
-    reject: (e?: Error) => void,
+    reject: (e: Error) => void,
     promise: Promise<T>
 }
 
 export function getDeferred<T = void>(): Deferred<T> {
-    let resolve: undefined | ((arg: T) => void) = undefined;
-    let reject: undefined | ((e?: Error) => void) = undefined;
+    let resolve!: ((arg: T) => void);
+    let reject!: ((e: Error) => void);
 
-    let promise = new Promise<T>((resolveCb, rejectCb) => {
+    const promise = new Promise<T>((resolveCb, rejectCb) => {
         resolve = resolveCb;
         reject = rejectCb;
     });
 
-    // TS thinks we're using these before they're assigned, which is why
-    // we need the undefined types, and the any here.
-    return { resolve, reject, promise } as any;
+    return Object.assign(promise, { resolve, reject, promise });
+}
+
+/**
+ * Wrap a function, so that any parallel calls which happen while the async function
+ * is pending return the same value as the first call (so the function is only run
+ * once, but the result is shared). This is useful for expensive async functions or
+ * race conditions. This ignores arguments completely, and is only applicable for
+ * functions that don't need any other input.
+ */
+export function combineParallelCalls<T>(fn: () => Promise<T>): () => Promise<T> {
+    let pendingPromise: Promise<T> | undefined;
+
+    return () => {
+        if (pendingPromise === undefined) {
+            pendingPromise = fn().finally(() => {
+                pendingPromise = undefined;
+            });
+        }
+
+        return pendingPromise;
+    };
 }