@neovici/cosmoz-utils 5.8.0 → 5.8.1

package/dist/array.d.ts

@@ -1 +1,6 @@
-export declare const array: (arr: unknown) => any[], without: (exclude: unknown, predicate?: <T>(obj: T) => T) => (list: unknown) => any[];
+export declare function array(): [];
+export declare function array(arr: null): [];
+export declare function array<T>(arr: T[]): T[];
+export declare function array<T>(arr: Iterable<T>): T[];
+export declare function array<T = unknown>(arr: T): T[];
+export declare const without: (exclude: unknown, predicate?: <T>(obj: T) => T) => (list: unknown) => unknown[];

package/dist/array.js

@@ -1,8 +1,9 @@
+/* eslint-disable func-style */
 import { identity } from './function';
 const isIterable = (x) => {
     return typeof x === 'object' && x !== null && Symbol.iterator in x;
 };
-export const array = (arr) => {
+export function array(arr) {
     if (arr == null) {
         return [];
     }
@@ -16,9 +17,9 @@ export const array = (arr) => {
         return Array.from(arr);
     }
     return [arr];
-}, 
+}
 // TODO: Improve definition
-without = (exclude, predicate = identity) => (list) => {
+export const without = (exclude, predicate = identity) => (list) => {
     const excludes = array(exclude).map(predicate);
     return array(list).filter((value) => !excludes.includes(predicate(value)));
 };

package/dist/directives/lazy-until.d.ts

@@ -10,7 +10,7 @@ export declare class UntilDirective extends AsyncDirective {
     private __values;
     private __weakThis;
     private __pauser;
-    render(...args: Array<unknown>): unknown;
+    render(...args: Array<unknown>): {};
     update(_part: Part, args: Array<unknown>): unknown;
     disconnected(): void;
     reconnected(): void;

package/dist/directives/measure.d.ts

@@ -1,12 +1,12 @@
 import { AttributePart } from 'lit-html';
 import { Directive } from 'lit-html/directive.js';
-declare type OnMeasure = (rects: DOMRectReadOnly[]) => void;
-declare type Select = (el: HTMLElement) => HTMLElement[];
+type OnMeasure = (rects: DOMRectReadOnly[]) => void;
+type Select = <T extends Element>(el: T) => T[];
 declare class MeasureDirective extends Directive {
     _observer?: ResizeObserver;
     render(): symbol;
     update(part: AttributePart, [select, onMeasure]: [Select, OnMeasure]): symbol;
-    measure(element: HTMLElement, select: Select, onMeasure: OnMeasure): symbol;
+    measure(element: Element, select: Select, onMeasure: OnMeasure): symbol;
 }
 export declare const measure: () => import("lit-html/directive.js").DirectiveResult<typeof MeasureDirective>;
 export {};

package/dist/function.d.ts

@@ -1,5 +1,5 @@
-declare type OrFn<T> = (...args: T[]) => boolean;
-declare type OnceFn<A, R> = (...args: A[]) => R;
-declare type OnceCheckFn<T> = (args: T[]) => boolean | undefined;
+type OrFn<T> = (...args: T[]) => boolean;
+type OnceFn<A, R> = (...args: A[]) => R;
+type OnceCheckFn<T> = (args: T[]) => boolean | undefined;
 export declare const constant: <T>(v?: T | undefined) => () => T | undefined, constTrue: () => boolean | undefined, constUndefined: () => unknown, noop: () => unknown, identity: <T>(obj: T) => T, or: <A, F extends OrFn<A>>(...fns: F[]) => (...args: A[]) => boolean, once: <A, R, F extends OnceFn<A, R>>(fn: F, check?: OnceCheckFn<A>) => (...args: A[]) => any;
 export {};

package/dist/haunted-polymer.d.ts

@@ -1,5 +1,9 @@
 import { BaseScheduler, GenericRenderer, ComponentOrVirtualComponent } from 'haunted';
 import { ChildPart } from 'lit-html';
+import { Rec } from './object';
+export type Constructor<T> = new (...args: any[]) => T;
+type Hook = <T>(a: T) => void;
+type Obj = Rec<string>;
 declare class Scheduler<P extends object, T extends HTMLElement | ChildPart, R extends GenericRenderer<T, P>, H extends ComponentOrVirtualComponent<T, P>, C extends (result: unknown) => void> extends BaseScheduler<P, T, R, H> {
     _commit: C;
     constructor(renderer: R, host: H, commitCallback: C);
@@ -10,13 +14,10 @@ interface PElement extends HTMLElement {
     disconnectedCallback(): void;
     set<T>(path: string, value: T): void;
     setProperties<T>(props: T): void;
-    _propertiesChanged<P, C, O>(currentProps: P, changedProps: C, oldProps: O): void;
+    _propertiesChanged<P extends Obj, C extends Obj, O>(currentProps: P, changedProps: C, oldProps: O): void;
     _hauntedUpdateFrameHandle: ReturnType<typeof requestAnimationFrame>;
-    _onlyHauntedPropertiesChanged<T>(changedProps: T): boolean;
+    _onlyHauntedPropertiesChanged<T extends Obj>(changedProps: T): boolean;
 }
-export declare type Constructor<T> = new (...args: any[]) => T;
-declare type Hook = <T>(a: T) => void;
-declare type Obj = Record<string, any>;
 /**
  * Creates a mixin that mixes a haunted hook with a polymer component.
  *
@@ -41,6 +42,7 @@ export declare const hauntedPolymer: (outputPath: string | Hook, hook?: Hook) =>
         dir: string;
         draggable: boolean;
         hidden: boolean;
+        inert: boolean;
         innerText: string;
         lang: string;
         readonly offsetHeight: number;
@@ -180,12 +182,14 @@ export declare const hauntedPolymer: (outputPath: string | Hook, hook?: Hook) =>
         ariaChecked: string | null;
         ariaColCount: string | null;
         ariaColIndex: string | null;
+        ariaColIndexText: string | null;
         ariaColSpan: string | null;
         ariaCurrent: string | null;
         ariaDisabled: string | null;
         ariaExpanded: string | null;
         ariaHasPopup: string | null;
         ariaHidden: string | null;
+        ariaInvalid: string | null;
         ariaKeyShortcuts: string | null;
         ariaLabel: string | null;
         ariaLevel: string | null;
@@ -202,6 +206,7 @@ export declare const hauntedPolymer: (outputPath: string | Hook, hook?: Hook) =>
         ariaRoleDescription: string | null;
         ariaRowCount: string | null;
         ariaRowIndex: string | null;
+        ariaRowIndexText: string | null;
         ariaRowSpan: string | null;
         ariaSelected: string | null;
         ariaSetSize: string | null;
@@ -210,6 +215,7 @@ export declare const hauntedPolymer: (outputPath: string | Hook, hook?: Hook) =>
         ariaValueMin: string | null;
         ariaValueNow: string | null;
         ariaValueText: string | null;
+        role: string | null;
         animate(keyframes: PropertyIndexedKeyframes | Keyframe[] | null, options?: number | KeyframeAnimationOptions | undefined): Animation;
         getAnimations(options?: GetAnimationsOptions | undefined): Animation[];
         after(...nodes: (string | Node)[]): void;
@@ -247,7 +253,9 @@ export declare const hauntedPolymer: (outputPath: string | Hook, hook?: Hook) =>
         onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
         onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
         onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onbeforeinput: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
         onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+        oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
         oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
         oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
         onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;

package/dist/hooks/use-host.d.ts

@@ -1,3 +1,3 @@
-declare type UseHost = <T extends HTMLElement>() => T;
+type UseHost = <T extends HTMLElement>() => T;
 export declare const useHost: UseHost;
 export {};

package/dist/hooks/use-meta.d.ts

@@ -1,3 +1,4 @@
+import { Rec } from '../object';
 /**
  * Copies properties of an Object into a memoized object.
  * Useful to create an object that does not change.
@@ -5,4 +6,4 @@
  * @param {Object} meta - The source object
  * @returns {Object} The memoized object.
  */
-export declare const useMeta: <T>(meta: T) => T;
+export declare const useMeta: <T extends Rec<PropertyKey, any>>(meta: T) => T;

package/dist/object.d.ts

@@ -1,5 +1,5 @@
 import { identity } from './function';
-declare type Rec<K extends PropertyKey = PropertyKey, V = any> = Record<K, V>;
+export type Rec<K extends PropertyKey = PropertyKey, V = any> = Record<K, V>;
 export declare function prop(): typeof identity;
 export declare function prop(a: '' | null | false | undefined | 0): typeof identity;
 export declare function prop<K extends PropertyKey>(key: K): <O extends Rec<K>>(obj: O) => O[K];
@@ -7,7 +7,7 @@ export declare const strProp: <K extends PropertyKey>(key: K) => <O extends Rec<
 export declare const transform: <K extends string, V, RK extends PropertyKey, RV>(obj: Record<K, V>, trans: (entries: [Extract<K, string>, V][]) => Iterable<readonly [RK, RV]>) => { [key in RK]: RV; };
 export declare const omit: <K extends PropertyKey>(keys: K[]) => <T extends Rec<PropertyKey, any>>(obj: T) => { [key in Exclude<keyof T, K>]: T[key]; };
 export declare const props: <K extends PropertyKey>(keys: K[]) => <T extends Rec<PropertyKey, any>>(obj: T) => { [key in K & keyof T]: T[key]; };
-declare type Merge<T1, T2> = {
+type Merge<T1, T2> = {
     [key in Exclude<keyof T1, keyof T2>]: T1[key];
 } & {
     [key in Exclude<keyof T2, keyof T1>]: T2[key];

package/dist/promise.d.ts

@@ -1,10 +1,10 @@
-declare type Pfn<T> = (arg?: T) => void;
+type Pfn<T> = (arg?: T) => void;
 export declare class ManagedPromise<T> extends Promise<T> {
     constructor(callback?: (resolve: Pfn<T>, reject: Pfn<T>) => void);
     resolve: Pfn<T>;
 }
 export declare const timeout$: (ms?: number) => Promise<unknown>;
-declare type Predicate<T extends Event> = (e: T) => boolean;
+type Predicate<T extends Event> = (e: T) => boolean;
 export declare const event$: <E extends Event, P extends Predicate<E>>(target: EventTarget, type: string, predicate?: P | undefined, timeout?: number) => Promise<unknown>;
 export declare const limit$: <T extends [], P>(fn: (...args: T) => PromiseLike<P>, limit: number) => (...args: T) => Promise<P>;
 export declare const debounce$: <T extends [], P>(fn: (...args: T) => PromiseLike<P>, ms?: number) => (...args: T) => Promise<unknown>;

package/dist/reduce/action.d.ts

@@ -1,4 +1,4 @@
-declare type Creator<T extends [], R extends object> = (...args: T) => R;
+type Creator<T extends [], R extends object> = (...args: T) => R;
 export interface Action<T = unknown> {
     type?: T;
     toString: () => string;
@@ -9,5 +9,5 @@ declare const action: <T, A extends [], R extends object>(type: T, create?: Crea
 }) & {
     type: T;
     toString(): T;
-}, type: <T>(action: Action<T>) => string | T;
+}, type: <T>(action: Action<T>) => string | NonNullable<T>;
 export { action, type };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@neovici/cosmoz-utils",
-	"version": "5.8.0",
+	"version": "5.8.1",
 	"description": "Date, money and template management functions commonly needed in Cosmoz views.",
 	"keywords": [
 		"polymer",
@@ -77,7 +77,7 @@
 		"@polymer/polymer": "^3.3.1",
 		"@semantic-release/changelog": "^6.0.0",
 		"@semantic-release/git": "^10.0.0",
-		"@web/test-runner": "^0.13.0",
+		"@web/test-runner": "^0.15.0",
 		"husky": "^8.0.0",
 		"lit-html": "^2.0.0",
 		"semantic-release": "^19.0.0",