@neovici/cosmoz-utils 6.24.0 → 6.25.1

package/dist/directives/assigned-ref.d.ts

@@ -0,0 +1,5 @@
+interface RefObject<T> {
+    current?: T;
+}
+export declare const assignedRef: (ref: RefObject<Element[]>) => unknown;
+export {};

package/dist/directives/assigned-ref.js

@@ -0,0 +1,41 @@
+import { noChange } from 'lit-html';
+import { AsyncDirective, directive } from 'lit-html/async-directive.js';
+/**
+ * Writes the slot's flattened assigned elements into the ref object,
+ * like ref() writes the element.
+ *
+ * Consumers read refObject.current at event time; a ref does not
+ * trigger renders.
+ */
+class AssignedRefDirective extends AsyncDirective {
+    _slot;
+    _ref;
+    #project = () => {
+        if (!this._slot || !this._ref) {
+            return;
+        }
+        this._ref.current = this._slot.assignedElements({ flatten: true });
+    };
+    #onSlotChange = () => this.#project();
+    update(part, [ref]) {
+        this._ref = ref;
+        const slot = part.element;
+        if (this._slot !== slot) {
+            this._slot?.removeEventListener('slotchange', this.#onSlotChange);
+            this._slot = slot;
+            slot.addEventListener('slotchange', this.#onSlotChange);
+        }
+        this.#project();
+    }
+    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;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    render(ref) {
+        return noChange;
+    }
+}
+export const assignedRef = directive(AssignedRefDirective);

package/dist/function.d.ts

@@ -6,5 +6,11 @@ export declare function constant(): () => undefined;
 export declare function constant<T>(v: T): () => T;
 export declare const constTrue: () => true, constUndefined: () => undefined, noop: () => undefined, identity: <T>(obj: T) => T, or: <A, F extends OrFn<A>>(...fns: F[]) => (...args: A[]) => boolean;
 export declare const once: <A extends Arr, R, F extends OnceFn<A, R> = OnceFn<A, R>>(fn: F, check?: OnceCheckFn<A>) => (...args: A) => any;
-export declare const invoke: <T, A extends unknown[]>(fn: T | ((...args: A) => T), ...args: A) => T;
+type Invoked<F> = F extends (...args: any[]) => infer R ? R : F;
+/**
+ * The args of a known function are checked against its tuple; for a
+ * value-or-function union the runtime dispatch decides the member, so
+ * the args cannot be typed.
+ */
+export declare const invoke: <F>(fn: F, ...args: F extends (...args: infer P) => unknown ? P : unknown[]) => Invoked<F>;
 export {};

package/dist/function.js

@@ -6,4 +6,11 @@ export const once = (fn, check = constTrue) => {
     let result;
     return (...args) => (result ??= check(args) ? fn(...args) : undefined);
 };
-export const invoke = (fn, ...args) => (typeof fn === 'function' ? fn(...args) : fn);
+/**
+ * The args of a known function are checked against its tuple; for a
+ * value-or-function union the runtime dispatch decides the member, so
+ * the args cannot be typed.
+ */
+export const invoke = (fn, ...args) => typeof fn === 'function'
+    ? fn(...args)
+    : fn;

package/dist/promise.d.ts

@@ -29,5 +29,5 @@ export declare const debounce$: <T extends unknown[], P>(fn: (...args: T) => P |
 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>>;
+export declare const invoke$: <T, A extends unknown[]>(fn: T | ((...args: A) => T | PromiseLike<T>), ...args: A) => Promise<Awaited<T> | Awaited<T> | Awaited<T extends (...args: any[]) => infer R ? R : T>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@neovici/cosmoz-utils",
-	"version": "6.24.0",
+	"version": "6.25.1",
 	"description": "Date, money and template management functions commonly needed in Cosmoz views.",
 	"keywords": [
 		"polymer",