@neovici/cosmoz-utils 6.22.2 → 6.23.0

package/dist/promise.d.ts

@@ -8,6 +8,25 @@ type Predicate<T extends Event> = (e: T) => boolean;
 export declare const event$: <E extends Event, P extends Predicate<E> = Predicate<E>>(target: EventTarget, type: string, predicate?: P, timeout?: number) => Promise<E>;
 export declare const limit$: <T extends unknown[], P>(fn: (...args: T) => PromiseLike<P>, limit: number) => (...args: T) => Promise<P>;
 export declare const debounce$: <T extends unknown[], P>(fn: (...args: T) => P | PromiseLike<P>, ms?: number) => (...args: T) => Promise<P>;
+/**
+ * Broadcasts the result of the wrapped function to every caller that is
+ * waiting for a result. Compose with `debounce$` to turn N concurrent calls
+ * into a single invocation that resolves all callers:
+ *
+ * ```js
+ * import { debounce$, share$ } from '@neovici/cosmoz-utils/promise';
+ *
+ * const statistics$ = share$(debounce$(fetchStatistics, 320));
+ * ```
+ *
+ * Since `debounce$` only resolves the last pending call, `share$` keeps
+ * track of pending callers and resolves them all when the inner promise
+ * resolves. In case of an error, only the last pending caller is rejected,
+ * to avoid amplifying one error into N rejections; earlier pending callers
+ * never settle. Only use with identical arguments: the first inner promise
+ * that settles broadcasts its result to all pending callers.
+ */
+export declare const share$: <T extends unknown[], P>(fn: (...args: T) => P | PromiseLike<P>) => (...args: T) => Promise<P>;
 export declare const log$: <T extends unknown[], P>(fn: (...args: T) => PromiseLike<P>) => (...args: T) => PromiseLike<P>;
 export declare const retry$: <T extends unknown[], P>(fn: (...args: T) => P | PromiseLike<P>, n: number) => (...args: T) => Promise<P>;
 export declare const invoke$: <T, A extends unknown[]>(fn: T | ((...args: A) => T | PromiseLike<T>), ...args: A) => Promise<Awaited<T> | Awaited<T>>;

package/dist/promise.js

@@ -63,6 +63,38 @@ export const debounce$ = (fn, ms) => {
         }, ms);
     });
 };
+/**
+ * Broadcasts the result of the wrapped function to every caller that is
+ * waiting for a result. Compose with `debounce$` to turn N concurrent calls
+ * into a single invocation that resolves all callers:
+ *
+ * ```js
+ * import { debounce$, share$ } from '@neovici/cosmoz-utils/promise';
+ *
+ * const statistics$ = share$(debounce$(fetchStatistics, 320));
+ * ```
+ *
+ * Since `debounce$` only resolves the last pending call, `share$` keeps
+ * track of pending callers and resolves them all when the inner promise
+ * resolves. In case of an error, only the last pending caller is rejected,
+ * to avoid amplifying one error into N rejections; earlier pending callers
+ * never settle. Only use with identical arguments: the first inner promise
+ * that settles broadcasts its result to all pending callers.
+ */
+export const share$ = (fn) => {
+    let pending = [];
+    return (...args) => new Promise((resolve, reject) => {
+        pending.push({ resolve, reject });
+        Promise.resolve(fn(...args)).then((result) => {
+            pending.forEach(({ resolve }) => resolve(result));
+            pending = [];
+        }, (error) => {
+            const last = pending.pop();
+            last?.reject(error);
+            pending = [];
+        });
+    });
+};
 export const log$ = (fn) => (...args) => fn(...args).then((response) => {
     // eslint-disable-next-line no-console
     console.log(response);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@neovici/cosmoz-utils",
-	"version": "6.22.2",
+	"version": "6.23.0",
 	"description": "Date, money and template management functions commonly needed in Cosmoz views.",
 	"keywords": [
 		"polymer",
@@ -63,7 +63,7 @@
 		"@pionjs/pion": "^2.7.1"
 	},
 	"devDependencies": {
-		"@changesets/cli": "^2.27.0",
+		"@changesets/cli": "^3.0.2",
 		"@commitlint/cli": "^19.0.0",
 		"@commitlint/config-conventional": "^19.0.0",
 		"@neovici/cfg": "^2.13.0",