@neovici/cosmoz-utils 6.22.2 → 6.24.0

package/dist/directives/forward-attributes.d.ts

@@ -0,0 +1,3 @@
+type Value = string | null | ((item: Element) => string | null);
+export declare const forwardAttributes: (attrs: Record<string, Value>) => unknown;
+export {};

package/dist/directives/forward-attributes.js

@@ -0,0 +1,64 @@
+import { noChange } from 'lit-html';
+import { AsyncDirective, directive } from 'lit-html/async-directive.js';
+import { invoke } from '../function';
+const write = (item, name, value) => {
+    if (value == null) {
+        item.removeAttribute(name);
+    }
+    else {
+        item.setAttribute(name, value);
+    }
+};
+const forward = (attrs, item) => {
+    for (const [name, value] of Object.entries(attrs)) {
+        write(item, name, invoke(value, item));
+    }
+};
+/**
+ * Forwards attributes onto every flattened assigned element of the slot
+ * the directive is placed on — on each render (state changes re-render
+ * the slot) and on slot changes (different elements are assigned).
+ *
+ * Values are strings, nulls (removals), or functions of the assigned
+ * element. Placement is the configuration: the placed slot states which
+ * members receive the attributes. Slot semantics decide membership:
+ * slotting forwards through nested slots, wrappers do not — a
+ * non-forwarding wrapper receives the attributes itself without
+ * exposing state.
+ */
+class ForwardAttributesDirective extends AsyncDirective {
+    _slot;
+    _attrs;
+    #forward = () => {
+        if (!this._slot || !this._attrs) {
+            return;
+        }
+        const items = this._slot.assignedElements({ flatten: true });
+        for (const item of items) {
+            forward(this._attrs, item);
+        }
+    };
+    #onSlotChange = () => this.#forward();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    render(attrs) {
+        return noChange;
+    }
+    update(part, [attrs]) {
+        this._attrs = attrs;
+        const slot = part.element;
+        if (this._slot !== slot) {
+            this._slot?.removeEventListener('slotchange', this.#onSlotChange);
+            this._slot = slot;
+            slot.addEventListener('slotchange', this.#onSlotChange);
+        }
+        this.#forward();
+        return noChange;
+    }
+    disconnected() {
+        // the slot outlives renders; the listener is owned for its lifetime
+        // and removed when the part is cleared (template swap, disconnect)
+        this._slot?.removeEventListener('slotchange', this.#onSlotChange);
+        this._slot = undefined;
+    }
+}
+export const forwardAttributes = directive(ForwardAttributesDirective);

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.24.0",
 	"description": "Date, money and template management functions commonly needed in Cosmoz views.",
 	"keywords": [
 		"polymer",
@@ -60,10 +60,10 @@
 		"./keybindings/*": "./dist/keybindings/*.js"
 	},
 	"dependencies": {
-		"@pionjs/pion": "^2.7.1"
+		"@pionjs/pion": "^2.16.3"
 	},
 	"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",