@ngutil/common 0.0.7 → 0.0.8

package/busy.d.ts

@@ -0,0 +1,98 @@
+import { InputSignal, Signal } from "@angular/core";
+import { Observable } from "rxjs";
+import { ConnectProtocol } from "./connect-protocol";
+import * as i0 from "@angular/core";
+export type BusyProgress = {
+    total: number;
+    current: number;
+    message?: string;
+};
+export type BusyEventParams = {
+    busy?: boolean;
+    progress?: BusyProgress;
+};
+export type BusyEvent = {
+    name: string;
+} & BusyEventParams;
+export type BusyConnectable = Observable<boolean | BusyEventParams> | BusyTracker<any> | Signal<boolean>;
+export declare class BusyState<T extends string> implements ConnectProtocol {
+    #private;
+    readonly current$: Observable<this>;
+    get isBusy(): boolean;
+    get progress(): BusyProgress | undefined;
+    is(name: T): boolean;
+    has(name: T): boolean;
+    set(name: T, busy: boolean | undefined, progress?: BusyProgress): void;
+    get(name: T): BusyEventParams | undefined;
+    keys(): string[];
+    entries(): [string, BusyEventParams][];
+    connect(o: Observable<typeof this> | typeof this, prefix?: string): Observable<unknown>;
+}
+/**
+ * ```ts
+ * @Component({
+ *   provides: [BusyTracker],
+ *   template: `
+ *     <spinner *ngIf="busy.is('reload') | async">
+ *     <spinner *ngIf="busy.any | async">
+ *     <button nuBusy="reload"></button>
+ *   `
+ * })
+ * export class Grid {
+ *   readonly busy = inject(BusyTracker<"create" | "reload" | "update" | "delete">)
+ * }
+ * ```
+ */
+export declare class BusyTracker<T extends string> implements ConnectProtocol {
+    private readonly parent?;
+    private readonly destroyRef;
+    private readonly _state;
+    readonly state$: Observable<BusyState<T>>;
+    readonly state: Signal<BusyState<T>>;
+    readonly any: Signal<boolean>;
+    readonly progress: Signal<BusyProgress | undefined>;
+    constructor(parent?: BusyTracker<any> | undefined);
+    init(name: T, busy: boolean, progress?: BusyProgress): void;
+    set(name: T, busy: boolean, progress?: BusyProgress): void;
+    is(name: T): Observable<boolean>;
+    watch(name: T): Observable<BusyEventParams | undefined>;
+    /**
+     * ```ts
+     * observable.pipe(this.busy.rx("save"))
+     * ```
+     */
+    rx(name: T): <S>(src: Observable<S>) => Observable<S>;
+    connect(value: BusyConnectable, name?: T): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BusyTracker<any>, [{ optional: true; skipSelf: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BusyTracker<any>>;
+}
+/**
+ * ```ts
+ * @Component({
+ *   template: `
+ *     <button nuBusy="save">SAVE</button>
+ *     <progress nuBusy="fileUpload">
+ *     <progress nuBusy="*">
+ *   `
+ * })
+ * ```
+ */
+export declare class Busy<T extends string> implements ConnectProtocol {
+    #private;
+    readonly tracker: BusyTracker<T>;
+    readonly name: InputSignal<T>;
+    readonly state$: Observable<{
+        isBusy: boolean;
+        isOthersBusy: boolean;
+        progress: BusyProgress | undefined;
+    }>;
+    readonly isBusy$: Observable<boolean>;
+    readonly isBusy: Signal<boolean | undefined>;
+    readonly isOthersBusy$: Observable<boolean>;
+    readonly isOthersBusy: Signal<boolean | undefined>;
+    readonly progress$: Observable<BusyProgress | undefined>;
+    readonly progress: Signal<BusyProgress | undefined>;
+    connect(value: BusyConnectable): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Busy<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Busy<any>, "[nuBusy]", ["nuBusy"], { "name": { "alias": "nuBusy"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/connect-protocol.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from "rxjs";
+/**
+ * @example
+ * ```ts
+ * class Busy implements ConnectProtocol {
+ *     connect(ob: Observable<any>): Observable<any> {
+ *         return new Observable(s => {
+ *             const sub = this.doSomething().subscribe(s)
+ *             return sub.unsubscribe.bind(sub)
+ *         })
+ *     }
+ * }
+ * ```
+ */
+export interface ConnectProtocol {
+    /**
+     * @returns When the observable is unsubscribed, the connect method cleans up everything
+     */
+    connect(...args: any[]): Observable<unknown>;
+}

package/esm2022/busy.mjs

@@ -0,0 +1,250 @@
+import { computed, DestroyRef, Directive, inject, Inject, Injectable, input, isSignal, Optional, SkipSelf } from "@angular/core";
+import { takeUntilDestroyed, toObservable, toSignal } from "@angular/core/rxjs-interop";
+import { BehaviorSubject, combineLatest, filter, finalize, isObservable, map, Observable, scan, shareReplay, switchMap, tap, throwError } from "rxjs";
+import { isEqual } from "lodash";
+import * as i0 from "@angular/core";
+export class BusyState {
+    constructor() {
+        this.#events = new BehaviorSubject(null);
+        this.#data = {};
+        this.current$ = this.#events.pipe(scan((state, current) => {
+            if (current == null) {
+                return state;
+            }
+            if (current.busy == null) {
+                delete state[current.name];
+            }
+            else {
+                state[current.name] = { busy: current.busy, progress: current.progress };
+            }
+            return state;
+        }, {}), tap(state => (this.#data = state)), map(() => this), shareReplay(1));
+    }
+    #events;
+    #data;
+    get isBusy() {
+        return Object.values(this.#data).some(v => v.busy);
+    }
+    get progress() {
+        let total = 0;
+        let current = 0;
+        const messages = [];
+        for (const v of Object.values(this.#data)) {
+            if (v.progress) {
+                total += v.progress.total;
+                current += v.progress.current;
+                if (v.progress.message) {
+                    messages.push(v.progress.message);
+                }
+            }
+        }
+        if (total !== 0 && current !== 0) {
+            return { total, current, message: messages.length > 0 ? messages.join("\n") : undefined };
+        }
+        return undefined;
+    }
+    is(name) {
+        return this.#data[name]?.busy === true;
+    }
+    has(name) {
+        return this.#data[name] != null;
+    }
+    set(name, busy, progress) {
+        const current = this.#data[name];
+        if (current == null || current.busy !== busy || !isEqual(current.progress, progress)) {
+            this.#events.next({ name, busy, progress });
+        }
+    }
+    get(name) {
+        return this.#data[name];
+    }
+    keys() {
+        return Object.keys(this.#data);
+    }
+    entries() {
+        return Object.entries(this.#data);
+    }
+    connect(o, prefix) {
+        if (o instanceof BusyState) {
+            return this.connect(o.current$, prefix);
+        }
+        else {
+            return new Observable(() => {
+                const otherKeys = [];
+                const sub = o.subscribe(otherState => {
+                    for (const [k, v] of otherState.entries()) {
+                        const key = prefix ? `${prefix}-${k}` : k;
+                        if (!otherKeys.includes(key)) {
+                            otherKeys.push(key);
+                        }
+                        this.set(key, v.busy, v.progress);
+                    }
+                });
+                return () => {
+                    sub.unsubscribe();
+                    for (const k of otherKeys) {
+                        this.set(k, undefined, undefined);
+                    }
+                };
+            });
+        }
+    }
+}
+/**
+ * ```ts
+ * @Component({
+ *   provides: [BusyTracker],
+ *   template: `
+ *     <spinner *ngIf="busy.is('reload') | async">
+ *     <spinner *ngIf="busy.any | async">
+ *     <button nuBusy="reload"></button>
+ *   `
+ * })
+ * export class Grid {
+ *   readonly busy = inject(BusyTracker<"create" | "reload" | "update" | "delete">)
+ * }
+ * ```
+ */
+export class BusyTracker {
+    constructor(parent) {
+        this.parent = parent;
+        this.destroyRef = inject(DestroyRef);
+        this._state = this.parent
+            ? this.parent._state
+            : new BusyState();
+        this.state$ = this._state.current$;
+        this.state = toSignal(this.state$, { requireSync: true });
+        this.any = computed(() => this.state().isBusy);
+        this.progress = computed(() => this.state().progress);
+    }
+    init(name, busy, progress) {
+        const state = this.state();
+        if (!state.has(name)) {
+            this.set(name, busy, progress);
+        }
+    }
+    set(name, busy, progress) {
+        this._state.set(name, busy, progress);
+    }
+    is(name) {
+        return this.state$.pipe(map(state => state.is(name)));
+    }
+    watch(name) {
+        return this.state$.pipe(map(state => state.get(name)));
+    }
+    /**
+     * ```ts
+     * observable.pipe(this.busy.rx("save"))
+     * ```
+     */
+    rx(name) {
+        return (src) => src.pipe(tap(() => this.set(name, true)), finalize(() => this.set(name, false)));
+    }
+    connect(value, name) {
+        if (isObservable(value)) {
+            if (name == null) {
+                return throwError(() => new Error("Missing `name` param"));
+            }
+            return new Observable(() => {
+                const sub = value.subscribe(busyValue => {
+                    if (typeof busyValue === "boolean") {
+                        this.set(name, busyValue);
+                    }
+                    else {
+                        this.set(name, !!busyValue.busy, busyValue.progress);
+                    }
+                });
+                return sub.unsubscribe.bind(sub);
+            }).pipe(takeUntilDestroyed(this.destroyRef));
+        }
+        else if (value instanceof BusyTracker) {
+            return this._state.connect(value.state$, name).pipe(takeUntilDestroyed(this.destroyRef));
+        }
+        else if (isSignal(value)) {
+            return this.connect(toObservable(value), name);
+        }
+        return throwError(() => new Error("Unsupported Busy source"));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: BusyTracker, deps: [{ token: BusyTracker, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: BusyTracker }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: BusyTracker, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: BusyTracker, decorators: [{
+                    type: Inject,
+                    args: [BusyTracker]
+                }, {
+                    type: SkipSelf
+                }, {
+                    type: Optional
+                }] }] });
+/**
+ * ```ts
+ * @Component({
+ *   template: `
+ *     <button nuBusy="save">SAVE</button>
+ *     <progress nuBusy="fileUpload">
+ *     <progress nuBusy="*">
+ *   `
+ * })
+ * ```
+ */
+export class Busy {
+    constructor() {
+        this.tracker = inject(BusyTracker, { skipSelf: true });
+        this.name = input.required({ alias: "nuBusy" });
+        this.#name = toObservable(this.name);
+        this.state$ = combineLatest({ name: this.#name, state: this.tracker.state$ }).pipe(map(({ name, state }) => {
+            if (name === "*") {
+                const isBusy = state.isBusy;
+                return {
+                    isBusy: isBusy,
+                    isOthersBusy: isBusy,
+                    progress: state.progress
+                };
+            }
+            const self = state.get(name);
+            if (self) {
+                const isBusy = self.busy === true;
+                return {
+                    isBusy: isBusy,
+                    isOthersBusy: state.isBusy && !isBusy,
+                    progress: self.progress
+                };
+            }
+            else {
+                return {
+                    isBusy: false,
+                    isOthersBusy: state.isBusy,
+                    progress: undefined
+                };
+            }
+        }), shareReplay(1));
+        this.isBusy$ = this.state$.pipe(map(v => v.isBusy), shareReplay(1));
+        this.isBusy = toSignal(this.isBusy$, { rejectErrors: true });
+        this.isOthersBusy$ = this.state$.pipe(map(v => v.isOthersBusy), shareReplay(1));
+        this.isOthersBusy = toSignal(this.isOthersBusy$, { rejectErrors: true });
+        this.progress$ = this.state$.pipe(map(v => v.progress), shareReplay(1));
+        this.progress = toSignal(this.progress$, { rejectErrors: true });
+    }
+    #name;
+    connect(value) {
+        return new Observable(() => {
+            const tsub = this.#name
+                .pipe(filter(name => name !== "*"), switchMap(name => this.tracker.connect(value, name)))
+                .subscribe();
+            return tsub.unsubscribe.bind(tsub);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: Busy, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "17.3.5", type: Busy, isStandalone: true, selector: "[nuBusy]", inputs: { name: { classPropertyName: "name", publicName: "nuBusy", isSignal: true, isRequired: true, transformFunction: null } }, exportAs: ["nuBusy"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: Busy, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[nuBusy]",
+                    exportAs: "nuBusy"
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"busy.js","sourceRoot":"","sources":["../../../../packages/common/src/busy.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    computed,\n    DestroyRef,\n    Directive,\n    inject,\n    Inject,\n    Injectable,\n    input,\n    InputSignal,\n    isSignal,\n    Optional,\n    Signal,\n    SkipSelf\n} from \"@angular/core\"\nimport { takeUntilDestroyed, toObservable, toSignal } from \"@angular/core/rxjs-interop\"\n\nimport {\n    BehaviorSubject,\n    combineLatest,\n    filter,\n    finalize,\n    isObservable,\n    map,\n    Observable,\n    scan,\n    shareReplay,\n    switchMap,\n    tap,\n    throwError\n} from \"rxjs\"\n\nimport { isEqual } from \"lodash\"\n\nimport { ConnectProtocol } from \"./connect-protocol\"\n\nexport type BusyProgress = { total: number; current: number; message?: string }\nexport type BusyEventParams = { busy?: boolean; progress?: BusyProgress }\nexport type BusyEvent = { name: string } & BusyEventParams\n\nexport type BusyConnectable = Observable<boolean | BusyEventParams> | BusyTracker<any> | Signal<boolean>\n\nexport class BusyState<T extends string> implements ConnectProtocol {\n    readonly #events = new BehaviorSubject<BusyEvent | null>(null)\n\n    #data: { [key: string]: BusyEventParams } = {}\n\n    readonly current$ = this.#events.pipe(\n        scan((state, current) => {\n            if (current == null) {\n                return state\n            }\n\n            if (current.busy == null) {\n                delete state[current.name]\n            } else {\n                state[current.name] = { busy: current.busy, progress: current.progress }\n            }\n            return state\n        }, {} as any),\n        tap(state => (this.#data = state)),\n        map(() => this),\n        shareReplay(1)\n    )\n\n    get isBusy(): boolean {\n        return Object.values(this.#data).some(v => v.busy)\n    }\n\n    get progress(): BusyProgress | undefined {\n        let total = 0\n        let current = 0\n        const messages = []\n\n        for (const v of Object.values(this.#data)) {\n            if (v.progress) {\n                total += v.progress.total\n                current += v.progress.current\n                if (v.progress.message) {\n                    messages.push(v.progress.message)\n                }\n            }\n        }\n\n        if (total !== 0 && current !== 0) {\n            return { total, current, message: messages.length > 0 ? messages.join(\"\\n\") : undefined }\n        }\n\n        return undefined\n    }\n\n    is(name: T): boolean {\n        return this.#data[name]?.busy === true\n    }\n\n    has(name: T): boolean {\n        return this.#data[name] != null\n    }\n\n    set(name: T, busy: boolean | undefined, progress?: BusyProgress) {\n        const current = this.#data[name]\n        if (current == null || current.busy !== busy || !isEqual(current.progress, progress)) {\n            this.#events.next({ name, busy, progress })\n        }\n    }\n\n    get(name: T): BusyEventParams | undefined {\n        return this.#data[name]\n    }\n\n    keys() {\n        return Object.keys(this.#data)\n    }\n\n    entries() {\n        return Object.entries(this.#data)\n    }\n\n    connect(o: Observable<typeof this> | typeof this, prefix?: string): Observable<unknown> {\n        if (o instanceof BusyState) {\n            return this.connect(o.current$, prefix)\n        } else {\n            return new Observable(() => {\n                const otherKeys: string[] = []\n\n                const sub = o.subscribe(otherState => {\n                    for (const [k, v] of otherState.entries()) {\n                        const key = prefix ? `${prefix}-${k}` : k\n                        if (!otherKeys.includes(key)) {\n                            otherKeys.push(key)\n                        }\n                        this.set(key as T, v.busy, v.progress)\n                    }\n                })\n\n                return () => {\n                    sub.unsubscribe()\n                    for (const k of otherKeys) {\n                        this.set(k as T, undefined, undefined)\n                    }\n                }\n            })\n        }\n    }\n}\n\n/**\n * ```ts\n * @Component({\n *   provides: [BusyTracker],\n *   template: `\n *     <spinner *ngIf=\"busy.is('reload') | async\">\n *     <spinner *ngIf=\"busy.any | async\">\n *     <button nuBusy=\"reload\"></button>\n *   `\n * })\n * export class Grid {\n *   readonly busy = inject(BusyTracker<\"create\" | \"reload\" | \"update\" | \"delete\">)\n * }\n * ```\n */\n@Injectable()\nexport class BusyTracker<T extends string> implements ConnectProtocol {\n    private readonly destroyRef = inject(DestroyRef)\n\n    private readonly _state = this.parent\n        ? (this.parent as unknown as { _state: BusyState<T> })._state\n        : new BusyState()\n\n    readonly state$ = this._state.current$\n\n    readonly state: Signal<BusyState<T>> = toSignal(this.state$, { requireSync: true })\n\n    readonly any = computed(() => this.state().isBusy)\n\n    readonly progress = computed(() => this.state().progress)\n\n    constructor(@Inject(BusyTracker) @SkipSelf() @Optional() private readonly parent?: BusyTracker<any>) {}\n\n    init(name: T, busy: boolean, progress?: BusyProgress) {\n        const state = this.state()\n        if (!state.has(name)) {\n            this.set(name, busy, progress)\n        }\n    }\n\n    set(name: T, busy: boolean, progress?: BusyProgress) {\n        this._state.set(name, busy, progress)\n    }\n\n    is(name: T): Observable<boolean> {\n        return this.state$.pipe(map(state => state.is(name)))\n    }\n\n    watch(name: T): Observable<BusyEventParams | undefined> {\n        return this.state$.pipe(map(state => state.get(name)))\n    }\n\n    /**\n     * ```ts\n     * observable.pipe(this.busy.rx(\"save\"))\n     * ```\n     */\n    rx(name: T) {\n        return <S>(src: Observable<S>) =>\n            src.pipe(\n                tap(() => this.set(name, true)),\n                finalize(() => this.set(name, false))\n            )\n    }\n\n    connect(value: BusyConnectable, name?: T): Observable<unknown> {\n        if (isObservable(value)) {\n            if (name == null) {\n                return throwError(() => new Error(\"Missing `name` param\"))\n            }\n\n            return new Observable(() => {\n                const sub = value.subscribe(busyValue => {\n                    if (typeof busyValue === \"boolean\") {\n                        this.set(name as T, busyValue)\n                    } else {\n                        this.set(name as T, !!busyValue.busy, busyValue.progress)\n                    }\n                })\n                return sub.unsubscribe.bind(sub)\n            }).pipe(takeUntilDestroyed(this.destroyRef))\n        } else if (value instanceof BusyTracker) {\n            return this._state.connect(value.state$, name).pipe(takeUntilDestroyed(this.destroyRef))\n        } else if (isSignal(value)) {\n            return this.connect(toObservable(value), name)\n        }\n        return throwError(() => new Error(\"Unsupported Busy source\"))\n    }\n}\n\n/**\n * ```ts\n * @Component({\n *   template: `\n *     <button nuBusy=\"save\">SAVE</button>\n *     <progress nuBusy=\"fileUpload\">\n *     <progress nuBusy=\"*\">\n *   `\n * })\n * ```\n */\n@Directive({\n    standalone: true,\n    selector: \"[nuBusy]\",\n    exportAs: \"nuBusy\"\n})\nexport class Busy<T extends string> implements ConnectProtocol {\n    readonly tracker: BusyTracker<T> = inject(BusyTracker, { skipSelf: true })\n\n    readonly name: InputSignal<T> = input.required<T>({ alias: \"nuBusy\" })\n    readonly #name = toObservable(this.name)\n\n    readonly state$ = combineLatest({ name: this.#name, state: this.tracker.state$ }).pipe(\n        map(({ name, state }) => {\n            if (name === \"*\") {\n                const isBusy = state.isBusy\n                return {\n                    isBusy: isBusy,\n                    isOthersBusy: isBusy,\n                    progress: state.progress\n                }\n            }\n\n            const self = state.get(name)\n            if (self) {\n                const isBusy = self.busy === true\n                return {\n                    isBusy: isBusy,\n                    isOthersBusy: state.isBusy && !isBusy,\n                    progress: self.progress\n                }\n            } else {\n                return {\n                    isBusy: false,\n                    isOthersBusy: state.isBusy,\n                    progress: undefined\n                }\n            }\n        }),\n        shareReplay(1)\n    )\n\n    readonly isBusy$ = this.state$.pipe(\n        map(v => v.isBusy),\n        shareReplay(1)\n    )\n    readonly isBusy = toSignal(this.isBusy$, { rejectErrors: true })\n\n    readonly isOthersBusy$ = this.state$.pipe(\n        map(v => v.isOthersBusy),\n        shareReplay(1)\n    )\n    readonly isOthersBusy = toSignal(this.isOthersBusy$, { rejectErrors: true })\n\n    readonly progress$ = this.state$.pipe(\n        map(v => v.progress),\n        shareReplay(1)\n    )\n    readonly progress = toSignal(this.progress$, { rejectErrors: true })\n\n    connect(value: BusyConnectable) {\n        return new Observable(() => {\n            const tsub = this.#name\n                .pipe(\n                    filter(name => name !== \"*\"),\n                    switchMap(name => this.tracker.connect(value, name))\n                )\n                .subscribe()\n            return tsub.unsubscribe.bind(tsub)\n        })\n    }\n}\n"]}

package/esm2022/connect-protocol.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdC1wcm90b2NvbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9zcmMvY29ubmVjdC1wcm90b2NvbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gXCJyeGpzXCJcblxuLyoqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIGNsYXNzIEJ1c3kgaW1wbGVtZW50cyBDb25uZWN0UHJvdG9jb2wge1xuICogICAgIGNvbm5lY3Qob2I6IE9ic2VydmFibGU8YW55Pik6IE9ic2VydmFibGU8YW55PiB7XG4gKiAgICAgICAgIHJldHVybiBuZXcgT2JzZXJ2YWJsZShzID0+IHtcbiAqICAgICAgICAgICAgIGNvbnN0IHN1YiA9IHRoaXMuZG9Tb21ldGhpbmcoKS5zdWJzY3JpYmUocylcbiAqICAgICAgICAgICAgIHJldHVybiBzdWIudW5zdWJzY3JpYmUuYmluZChzdWIpXG4gKiAgICAgICAgIH0pXG4gKiAgICAgfVxuICogfVxuICogYGBgXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29ubmVjdFByb3RvY29sIHtcbiAgICAvKipcbiAgICAgKiBAcmV0dXJucyBXaGVuIHRoZSBvYnNlcnZhYmxlIGlzIHVuc3Vic2NyaWJlZCwgdGhlIGNvbm5lY3QgbWV0aG9kIGNsZWFucyB1cCBldmVyeXRoaW5nXG4gICAgICovXG4gICAgY29ubmVjdCguLi5hcmdzOiBhbnlbXSk6IE9ic2VydmFibGU8dW5rbm93bj5cbn1cbiJdfQ==

package/esm2022/destruct.mjs

@@ -74,10 +74,10 @@ export class Destructible {
     dispose() {
         this.ngOnDestroy();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: Destructible, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.1.3", type: Destructible, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: Destructible, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.5", type: Destructible, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: Destructible, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: Destructible, decorators: [{
             type: Directive
         }] });
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/index.mjs

@@ -3,4 +3,7 @@ export { NumberWithUnit, UNIT_REGEX, NUMBER_REGEX } from "./number-with-unit";
 export { coerceBoolAttr } from "./bool-attr";
 export { rawCancelAnimationFrame, rawClearInterval, rawClearTimeout, rawRequestAnimationFrame, rawSetInterval, rawSetTimeout } from "./unngzone";
 export { FastDOM } from "./dom";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFlLE1BQU0sWUFBWSxDQUFBO0FBQ2hFLE9BQU8sRUFBRSxjQUFjLEVBQXVCLFVBQVUsRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUNsRyxPQUFPLEVBQUUsY0FBYyxFQUFnQixNQUFNLGFBQWEsQ0FBQTtBQUMxRCxPQUFPLEVBQ0gsdUJBQXVCLEVBQ3ZCLGdCQUFnQixFQUNoQixlQUFlLEVBQ2Ysd0JBQXdCLEVBQ3hCLGNBQWMsRUFDZCxhQUFhLEVBQ2hCLE1BQU0sWUFBWSxDQUFBO0FBQ25CLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxPQUFPLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBEZXN0cnVjdCwgRGVzdHJ1Y3RpYmxlLCBJRGlzcG9zYWJsZSB9IGZyb20gXCIuL2Rlc3RydWN0XCJcbmV4cG9ydCB7IE51bWJlcldpdGhVbml0LCBOdW1iZXJXaXRoVW5pdElucHV0LCBVTklUX1JFR0VYLCBOVU1CRVJfUkVHRVggfSBmcm9tIFwiLi9udW1iZXItd2l0aC11bml0XCJcbmV4cG9ydCB7IGNvZXJjZUJvb2xBdHRyLCBCb29sZWFuSW5wdXQgfSBmcm9tIFwiLi9ib29sLWF0dHJcIlxuZXhwb3J0IHtcbiAgICByYXdDYW5jZWxBbmltYXRpb25GcmFtZSxcbiAgICByYXdDbGVhckludGVydmFsLFxuICAgIHJhd0NsZWFyVGltZW91dCxcbiAgICByYXdSZXF1ZXN0QW5pbWF0aW9uRnJhbWUsXG4gICAgcmF3U2V0SW50ZXJ2YWwsXG4gICAgcmF3U2V0VGltZW91dFxufSBmcm9tIFwiLi91bm5nem9uZVwiXG5leHBvcnQgeyBGYXN0RE9NIH0gZnJvbSBcIi4vZG9tXCJcbmV4cG9ydCB7IE51bWJlclJhbmdlIH0gZnJvbSBcIi4vdHlwZS11dGlsXCJcbiJdfQ==
+export { Busy, BusyState, BusyTracker } from "./busy";
+export { isPrimitive } from "./types/primitive";
+export { deepClone, deepFreeze, isPlainObject, toSorted } from "./util";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFlLE1BQU0sWUFBWSxDQUFBO0FBQ2hFLE9BQU8sRUFBRSxjQUFjLEVBQXVCLFVBQVUsRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQTtBQUNsRyxPQUFPLEVBQUUsY0FBYyxFQUFnQixNQUFNLGFBQWEsQ0FBQTtBQUMxRCxPQUFPLEVBQ0gsdUJBQXVCLEVBQ3ZCLGdCQUFnQixFQUNoQixlQUFlLEVBQ2Ysd0JBQXdCLEVBQ3hCLGNBQWMsRUFDZCxhQUFhLEVBQ2hCLE1BQU0sWUFBWSxDQUFBO0FBQ25CLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxPQUFPLENBQUE7QUFFL0IsT0FBTyxFQUFFLElBQUksRUFBNEMsU0FBUyxFQUFFLFdBQVcsRUFBRSxNQUFNLFFBQVEsQ0FBQTtBQU0vRixPQUFPLEVBQXVCLFdBQVcsRUFBK0IsTUFBTSxtQkFBbUIsQ0FBQTtBQUVqRyxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxhQUFhLEVBQUUsUUFBUSxFQUFFLE1BQU0sUUFBUSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgQ29ubmVjdFByb3RvY29sIH0gZnJvbSBcIi4vY29ubmVjdC1wcm90b2NvbFwiXG5leHBvcnQgeyBEZXN0cnVjdCwgRGVzdHJ1Y3RpYmxlLCBJRGlzcG9zYWJsZSB9IGZyb20gXCIuL2Rlc3RydWN0XCJcbmV4cG9ydCB7IE51bWJlcldpdGhVbml0LCBOdW1iZXJXaXRoVW5pdElucHV0LCBVTklUX1JFR0VYLCBOVU1CRVJfUkVHRVggfSBmcm9tIFwiLi9udW1iZXItd2l0aC11bml0XCJcbmV4cG9ydCB7IGNvZXJjZUJvb2xBdHRyLCBCb29sZWFuSW5wdXQgfSBmcm9tIFwiLi9ib29sLWF0dHJcIlxuZXhwb3J0IHtcbiAgICByYXdDYW5jZWxBbmltYXRpb25GcmFtZSxcbiAgICByYXdDbGVhckludGVydmFsLFxuICAgIHJhd0NsZWFyVGltZW91dCxcbiAgICByYXdSZXF1ZXN0QW5pbWF0aW9uRnJhbWUsXG4gICAgcmF3U2V0SW50ZXJ2YWwsXG4gICAgcmF3U2V0VGltZW91dFxufSBmcm9tIFwiLi91bm5nem9uZVwiXG5leHBvcnQgeyBGYXN0RE9NIH0gZnJvbSBcIi4vZG9tXCJcbmV4cG9ydCB7IE51bWJlclJhbmdlIH0gZnJvbSBcIi4vdHlwZS11dGlsXCJcbmV4cG9ydCB7IEJ1c3ksIEJ1c3lFdmVudCwgQnVzeUV2ZW50UGFyYW1zLCBCdXN5UHJvZ3Jlc3MsIEJ1c3lTdGF0ZSwgQnVzeVRyYWNrZXIgfSBmcm9tIFwiLi9idXN5XCJcblxuZXhwb3J0IHsgQ29uY2F0IH0gZnJvbSBcIi4vdHlwZXMvY29uY2F0XCJcbmV4cG9ydCB7IEV2YWwsIElmQW55LCBJc0FueSwgSWZUdXBsZSwgSXNUdXBsZSwgVHVwbGVJdGVtcywgT2JqZWN0S2V5LCBNYXhSZWN1cnNpb24gfSBmcm9tIFwiLi90eXBlcy91dGlsXCJcbmV4cG9ydCB7IEZsYXR0ZW4sIEZsYXR0ZW5LZXlzIH0gZnJvbSBcIi4vdHlwZXMvZmxhdHRlblwiXG5leHBvcnQgeyBNZXJnZVVuaW9uIH0gZnJvbSBcIi4vdHlwZXMvbWVyZ2UtdW5pb25cIlxuZXhwb3J0IHsgUHJpbWl0aXZlLCBCdWlsdGlucywgaXNQcmltaXRpdmUsIEFzUHJpbWl0aXZlLCBUb1ByaW1pdGl2ZU1hcCB9IGZyb20gXCIuL3R5cGVzL3ByaW1pdGl2ZVwiXG5leHBvcnQgeyBEZWVwUmVhZG9ubHksIFJlYWRvbmx5RGF0ZSB9IGZyb20gXCIuL3R5cGVzL3JlYWRvbmx5XCJcbmV4cG9ydCB7IGRlZXBDbG9uZSwgZGVlcEZyZWV6ZSwgaXNQbGFpbk9iamVjdCwgdG9Tb3J0ZWQgfSBmcm9tIFwiLi91dGlsXCJcbiJdfQ==

package/esm2022/types/concat.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uY2F0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL3NyYy90eXBlcy9jb25jYXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbInR5cGUgQ29uY2F0VGFpbDxTRVAgZXh0ZW5kcyBzdHJpbmcsIFYgZXh0ZW5kcyBzdHJpbmc+ID0gViBleHRlbmRzIG5ldmVyID8gXCJcIiA6IGAke1NFUH0ke1Z9YFxuXG4vKipcbiAqIENvbmNhdGVuYXRlIHN0cmluZ3Mgd2l0aCBzZXBhcmF0b3JcbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIHR5cGUgQyA9IENvbmNhdDxcIi5cIiwgW1wiQVwiLCBcIkJcIiwgXCJDXCJdPiA9IFwiQS5CLkNcIlxuICogYGBgXG4gKi9cbmV4cG9ydCB0eXBlIENvbmNhdDxTRVAgZXh0ZW5kcyBzdHJpbmcsIFZBTFMgZXh0ZW5kcyBzdHJpbmdbXT4gPSBWQUxTIGV4dGVuZHMgW1xuICAgIGluZmVyIFYxIGV4dGVuZHMgc3RyaW5nLFxuICAgIC4uLmluZmVyIE9WIGV4dGVuZHMgc3RyaW5nW11cbl1cbiAgICA/IE9WW1wibGVuZ3RoXCJdIGV4dGVuZHMgMFxuICAgICAgICA/IGAke1YxfWBcbiAgICAgICAgOiBgJHtWMX0ke0NvbmNhdFRhaWw8U0VQLCBDb25jYXQ8U0VQLCBPVj4+fWBcbiAgICA6IG5ldmVyXG4iXX0=

package/esm2022/types/flatten.mjs

@@ -0,0 +1,68 @@
+export {};
+// ! TEST ONLY
+// enum CategoryState {
+//     Pending = "pending",
+//     Approved = "approved"
+// }
+// const enum ProductType {
+//     Normal = "normal",
+//     Virtual = "virtual"
+// }
+// interface UserName {
+//     first: string
+//     last: string
+//     title?: string
+// }
+// interface User {
+//     id: number
+//     name: UserName
+//     age: number
+//     state: "ACTIVE" | "INACTIVE"
+//     is_active: boolean
+//     created_time: Date
+// }
+// interface Category {
+//     id: number
+//     name: string
+//     state: CategoryState
+//     author: User
+//     parent: Category
+// }
+// interface Product {
+//     id: number
+//     name: string
+//     type: ProductType
+//     categories: Array<Category>
+//     [Symbol.iterator](): IteratorResult<any>
+// }
+// class Alma {
+//     id!: number
+//     author!: User
+//     xyz: any
+//     doSomething(): void {}
+// }
+// // TODO: ...
+// type Poly = { type: "user"; name: string; age: number } | { type: "product"; name: string; sku: string }
+// const flattened: Flatten<Product> = { name: 10, dsfsfd: "OK" }
+// const almax: Flatten<Alma, ["root"]> = {}
+// const almaxc: Flatten<Alma> = {}
+// const flattened2: Flatten<Array<[User, Alma]>> = { "*.1.author.age": 10 }
+// const flattened2b: Flatten<[User, Alma]> = { "1.author.age": 10 }
+// const flattened3: Flatten<{ [key: string | number]: any }> = { dsfsdf: 10 }
+// const TE: TupleEntries<[1, "ok", false]> = null
+// const anyArray: Flatten<Array<any>> = { "*.alma": 10 }
+// const anyArray2: Flatten<{ alma: any[] }> = { "alma.*.ok.x.y": 10 }
+// const cat: Flatten<Category> = { "parent.parent.parent.parent.author.id": 10 }
+// const dt: Flatten<[Date, string]> = { 0: new Date(), 1: "alma" }
+// const ro_cat: DeepReadonly<Flatten<Category>> = {}
+// ro_cat["author.age"] = 10
+// const ro_obj: DeepReadonly<Flatten<{ [key: string]: any }>> = {}
+// ro_obj["alma"]
+// type X<T, F = Flatten<T>> = { [K in keyof F]: { ok: F[K] } }
+// const ro_obj3: DeepReadonly<X<{ [key: string]: any }>> = {}
+// type Obj = { [key: string]: any }
+// export type Filter<T extends Obj> = _FilterLite<Flatten<T>>
+// type _FilterLite<F extends { [key: string]: any }> = { [K in keyof F]: boolean }
+// const xxx: Filter<Obj> = { 10: true }
+// const xxx_r: DeepReadonly<Filter<Obj>> = { alma: true }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flatten.js","sourceRoot":"","sources":["../../../../../packages/common/src/types/flatten.ts"],"names":[],"mappings":";AAuIA,cAAc;AACd,uBAAuB;AACvB,2BAA2B;AAC3B,4BAA4B;AAC5B,IAAI;AAEJ,2BAA2B;AAC3B,yBAAyB;AACzB,0BAA0B;AAC1B,IAAI;AAEJ,uBAAuB;AACvB,oBAAoB;AACpB,mBAAmB;AACnB,qBAAqB;AACrB,IAAI;AAEJ,mBAAmB;AACnB,iBAAiB;AACjB,qBAAqB;AACrB,kBAAkB;AAClB,mCAAmC;AACnC,yBAAyB;AACzB,yBAAyB;AACzB,IAAI;AAEJ,uBAAuB;AACvB,iBAAiB;AACjB,mBAAmB;AACnB,2BAA2B;AAC3B,mBAAmB;AACnB,uBAAuB;AACvB,IAAI;AAEJ,sBAAsB;AACtB,iBAAiB;AACjB,mBAAmB;AACnB,wBAAwB;AACxB,kCAAkC;AAClC,+CAA+C;AAC/C,IAAI;AAEJ,eAAe;AACf,kBAAkB;AAClB,oBAAoB;AACpB,eAAe;AAEf,6BAA6B;AAC7B,IAAI;AAEJ,eAAe;AACf,2GAA2G;AAE3G,iEAAiE;AACjE,4CAA4C;AAC5C,mCAAmC;AACnC,4EAA4E;AAC5E,oEAAoE;AACpE,8EAA8E;AAC9E,kDAAkD;AAClD,yDAAyD;AACzD,sEAAsE;AACtE,iFAAiF;AACjF,mEAAmE;AAEnE,qDAAqD;AACrD,4BAA4B;AAE5B,mEAAmE;AACnE,iBAAiB;AAEjB,+DAA+D;AAE/D,8DAA8D;AAE9D,oCAAoC;AAEpC,8DAA8D;AAE9D,mFAAmF;AAEnF,wCAAwC;AACxC,0DAA0D","sourcesContent":["/* eslint-disable @typescript-eslint/ban-types */\nimport { Concat } from \"./concat\"\nimport { MergeUnion } from \"./merge-union\"\nimport { Builtins } from \"./primitive\"\nimport { IsAny, IsTuple, MaxRecursion, TupleItems } from \"./util\"\n\ntype KeyTypes = string | number\nexport type FlattenExclude = Function\n\n/**\n * @param T - The object witch we want to flatten\n * @param P - The prefix of paths (default: [])\n * @param E - The value excludes (default: Function)\n * @param D - Max depth (default: 10)\n *\n * @example\n * Input type:\n * ```ts\n * interface User {\n *   id: number\n *   name: string\n * }\n *\n * interface Category {\n *   id: number\n *   title: string\n * }\n *\n * interface Article {\n *   id: number\n *   title: string\n *   author: User\n *   categories: Array<Category>\n * }\n * ```\n *\n * Result type:\n * type F = Flatten<Article> = {\n *   \"id\": number,\n *   \"title\": number,\n *   \"author.id\": number,\n *   \"author.name\": string,\n *   \"categories.*.id\": number,\n *   \"categories.*.title\": string,\n * }\n */\nexport type Flatten<T, P extends string[] = [], E = FlattenExclude, D extends number = MaxRecursion> = _Flatten<\n    T,\n    E,\n    P,\n    D\n>\n\ntype _Flatten<T, E, P extends string[], D extends number> = MergeUnion<_FlattenItem<T, E, P, D>>\n\ntype _FlattenItem<T, E, P extends string[], D extends number> = P[\"length\"] extends D\n    ? never\n    : T extends E\n      ? never\n      : IsAny<T> extends true\n        ? _Path<T, P>\n        : T extends Builtins\n          ? _Path<T, P>\n          : T extends Array<infer V>\n            ? IsTuple<T> extends true\n                ? _FlattenTuple<T, E, P, D>\n                : _FlattenArray<V, E, P, D>\n            : T extends object\n              ? _FlattenObject<T, E, P, D>\n              : _Path<T, P>\n\ntype _FlattenTuple<T extends any[], E, P extends string[], D extends number, I = TupleItems<T>> = {\n    [K in keyof I]: K extends KeyTypes\n        ? IsAny<I[K]> extends true\n            ? _Path<any, [...P, `${K}`]>\n            : _FlattenItem<I[K], E, [...P, `${K}`], D>\n        : never\n}[keyof I]\n\ntype _FlattenArray<T, E, P extends string[], D extends number> =\n    IsAny<T> extends true ? _Path<any, [...P, `*.${string}`]> : _FlattenItem<T, E, [...P, \"*\"], D>\n\ntype _FlattenObject<T extends object, E, P extends string[], D extends number> = {\n    [K in keyof T]-?: K extends KeyTypes\n        ? IsAny<T[K]> extends true\n            ? _Path<any, [...P, `${K}`]>\n            : _FlattenItem<T[K], E, [...P, `${K}`], D>\n        : never\n}[keyof T]\n\ntype _Path<T, P extends string[]> = P[\"length\"] extends 0 ? never : { [key in Concat<\".\", P>]: T }\n\n/**\n * @param T - The object witch we want to flatten\n * @param P - The prefix of paths (default: [])\n * @param E - The value excludes (default: Function)\n * @param D - Max depth (default: 10)\n *\n * @example\n * Input type:\n * ```ts\n * interface User {\n *   id: number\n *   name: string\n * }\n *\n * interface Category {\n *   id: number\n *   title: string\n * }\n *\n * interface Article {\n *   id: number\n *   title: string\n *   author: User\n *   categories: Array<Category>\n * }\n * ```\n *\n * Result type:\n * type FK = FlattenKeys<Article> =\n *   | \"id\"\n *   | \"title\"\n *   | \"author.id\"\n *   | \"author.name\"\n *   | \"categories.*.id\"\n *   | \"categories.*.title\"\n */\nexport type FlattenKeys<\n    T,\n    P extends string[] = [],\n    E = FlattenExclude,\n    D extends number = MaxRecursion\n> = keyof Flatten<T, P, E, D>\n\n// ! TEST ONLY\n// enum CategoryState {\n//     Pending = \"pending\",\n//     Approved = \"approved\"\n// }\n\n// const enum ProductType {\n//     Normal = \"normal\",\n//     Virtual = \"virtual\"\n// }\n\n// interface UserName {\n//     first: string\n//     last: string\n//     title?: string\n// }\n\n// interface User {\n//     id: number\n//     name: UserName\n//     age: number\n//     state: \"ACTIVE\" | \"INACTIVE\"\n//     is_active: boolean\n//     created_time: Date\n// }\n\n// interface Category {\n//     id: number\n//     name: string\n//     state: CategoryState\n//     author: User\n//     parent: Category\n// }\n\n// interface Product {\n//     id: number\n//     name: string\n//     type: ProductType\n//     categories: Array<Category>\n//     [Symbol.iterator](): IteratorResult<any>\n// }\n\n// class Alma {\n//     id!: number\n//     author!: User\n//     xyz: any\n\n//     doSomething(): void {}\n// }\n\n// // TODO: ...\n// type Poly = { type: \"user\"; name: string; age: number } | { type: \"product\"; name: string; sku: string }\n\n// const flattened: Flatten<Product> = { name: 10, dsfsfd: \"OK\" }\n// const almax: Flatten<Alma, [\"root\"]> = {}\n// const almaxc: Flatten<Alma> = {}\n// const flattened2: Flatten<Array<[User, Alma]>> = { \"*.1.author.age\": 10 }\n// const flattened2b: Flatten<[User, Alma]> = { \"1.author.age\": 10 }\n// const flattened3: Flatten<{ [key: string | number]: any }> = { dsfsdf: 10 }\n// const TE: TupleEntries<[1, \"ok\", false]> = null\n// const anyArray: Flatten<Array<any>> = { \"*.alma\": 10 }\n// const anyArray2: Flatten<{ alma: any[] }> = { \"alma.*.ok.x.y\": 10 }\n// const cat: Flatten<Category> = { \"parent.parent.parent.parent.author.id\": 10 }\n// const dt: Flatten<[Date, string]> = { 0: new Date(), 1: \"alma\" }\n\n// const ro_cat: DeepReadonly<Flatten<Category>> = {}\n// ro_cat[\"author.age\"] = 10\n\n// const ro_obj: DeepReadonly<Flatten<{ [key: string]: any }>> = {}\n// ro_obj[\"alma\"]\n\n// type X<T, F = Flatten<T>> = { [K in keyof F]: { ok: F[K] } }\n\n// const ro_obj3: DeepReadonly<X<{ [key: string]: any }>> = {}\n\n// type Obj = { [key: string]: any }\n\n// export type Filter<T extends Obj> = _FilterLite<Flatten<T>>\n\n// type _FilterLite<F extends { [key: string]: any }> = { [K in keyof F]: boolean }\n\n// const xxx: Filter<Obj> = { 10: true }\n// const xxx_r: DeepReadonly<Filter<Obj>> = { alma: true }\n"]}

package/esm2022/types/merge-union.mjs

@@ -0,0 +1,3 @@
+export {};
+// const final: MergeUnion<Test> = null as any
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2UtdW5pb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21tb24vc3JjL3R5cGVzL21lcmdlLXVuaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFnQkEsOENBQThDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZhbCB9IGZyb20gXCIuL3V0aWxcIlxuXG4vLyB0eXBlIFRlc3QgPVxuLy8gICAgIHwgeyBzdGF0ZTogXCJBQ1RJVkVcIiB9XG4vLyAgICAgfCB7IHN0YXRlOiBcIklOQUNUSVZFXCIgfVxuLy8gICAgIHwgeyB2aXNpYmxlOiBib29sZWFuIH1cbi8vICAgICB8IHsgaXNfYWN0aXZlOiB0cnVlIH1cbi8vICAgICB8IHsgaXNfYWN0aXZlOiBmYWxzZSB9XG5cbnR5cGUgQWxsS2V5czxUPiA9IFQgZXh0ZW5kcyBhbnkgPyBrZXlvZiBUIDogbmV2ZXJcblxudHlwZSBUeXBlT2ZLZXk8VCwgVEsgZXh0ZW5kcyBBbGxLZXlzPFQ+PiA9IFQgZXh0ZW5kcyB7IFtLIGluIFRLXT86IGFueSB9ID8gVFtUS10gOiBuZXZlclxuLy8gY29uc3QgX1N0YXRlOiBUeXBlT2ZLZXk8VGVzdCwgXCJzdGF0ZVwiPiA9IG51bGwgYXMgYW55XG5cbi8vIGV4cG9ydCB0eXBlIE1lcmdlVW5pb248VD4gPSBFdmFsPHsgW0sgaW4gQWxsS2V5czxUPl06IFR5cGVPZktleTxULCBLPiB9PlxuZXhwb3J0IHR5cGUgTWVyZ2VVbmlvbjxUPiA9IEV2YWw8eyBbSyBpbiBBbGxLZXlzPFQ+XTogVHlwZU9mS2V5PFQsIEs+IH0+XG4vLyBjb25zdCBmaW5hbDogTWVyZ2VVbmlvbjxUZXN0PiA9IG51bGwgYXMgYW55XG4iXX0=

package/esm2022/types/primitive.mjs

@@ -0,0 +1,3 @@
+import { isPrimitive } from "utility-types";
+export { isPrimitive };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbWl0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tbW9uL3NyYy90eXBlcy9wcmltaXRpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBYSxNQUFNLGVBQWUsQ0FBQTtBQUl0RCxPQUFPLEVBQWEsV0FBVyxFQUFFLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpc1ByaW1pdGl2ZSwgUHJpbWl0aXZlIH0gZnJvbSBcInV0aWxpdHktdHlwZXNcIlxuXG5pbXBvcnQgeyBJc0FueSB9IGZyb20gXCIuL3V0aWxcIlxuXG5leHBvcnQgeyBQcmltaXRpdmUsIGlzUHJpbWl0aXZlIH1cblxuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9iYW4tdHlwZXNcbmV4cG9ydCB0eXBlIEJ1aWx0aW5zID0gUHJpbWl0aXZlIHwgRnVuY3Rpb24gfCBEYXRlXG5cbmV4cG9ydCB0eXBlIFRvUHJpbWl0aXZlTWFwID0ge1xuICAgIHN0cmluZzogc3RyaW5nXG4gICAgZGVmYXVsdDogc3RyaW5nXG4gICAgbnVtYmVyOiBudW1iZXJcbiAgICBiaWdpbnQ6IGJpZ2ludFxuICAgIGJvb2xlYW46IGJvb2xlYW5cbiAgICBzeW1ib2w6IHN5bWJvbFxufVxuXG50eXBlIEFzU3RyaW5nPFQsIFAsIEYgPSBuZXZlcj4gPSBQIGV4dGVuZHMgc3RyaW5nID8gKFQgZXh0ZW5kcyBQcmltaXRpdmUgPyBQIDogRikgOiBuZXZlclxuXG4vLyB0eXBlIEhhc1RvU3RyaW5nPFQsIFAsIEYgPSBuZXZlcj4gPSBQIGV4dGVuZHMgUHJpbWl0aXZlID8gc3RyaW5nIDogVCBleHRlbmRzIHsgdG9TdHJpbmcoKTogc3RyaW5nIH0gPyBzdHJpbmcgOiBGXG5cbnR5cGUgSGFzVmFsdWVPZjxULCBQLCBGID0gbmV2ZXI+ID0gVCBleHRlbmRzIHsgdmFsdWVPZigpOiBQIH0gPyBQIDogRlxuXG50eXBlIEhhc1RvUHJpbWl0aXZlPFQsIFAsIEYgPSBuZXZlcj4gPSBUIGV4dGVuZHMgeyBbU3ltYm9sLnRvUHJpbWl0aXZlXShoaW50OiBzdHJpbmcpOiBQIH0gPyBQIDogRlxuXG50eXBlIF9Bc1ByaW1pdGl2ZTxULCBQPiA9IEhhc1RvUHJpbWl0aXZlPFQsIFAsIEhhc1ZhbHVlT2Y8VCwgUCwgQXNTdHJpbmc8VCwgUD4+PlxuXG5leHBvcnQgdHlwZSBBc1ByaW1pdGl2ZTxUPiA9XG4gICAgSXNBbnk8VD4gZXh0ZW5kcyB0cnVlXG4gICAgICAgID8gVG9QcmltaXRpdmVNYXBba2V5b2YgVG9QcmltaXRpdmVNYXBdXG4gICAgICAgIDogeyBbSyBpbiBrZXlvZiBUb1ByaW1pdGl2ZU1hcF06IF9Bc1ByaW1pdGl2ZTxULCBUb1ByaW1pdGl2ZU1hcFtLXT4gfVtrZXlvZiBUb1ByaW1pdGl2ZU1hcF1cbiJdfQ==

package/esm2022/types/readonly.mjs

@@ -0,0 +1,22 @@
+export {};
+// const o1: DeepReadonly<{ alma: 1; xyz: number }> = { alma: 1, xyz: 20 }
+// o1.xyz = 10
+// const a1: DeepReadonly<Array<number>> = [1]
+// a1[0] = 10
+// const t1: DeepReadonly<[1, "ok", true, { nice: number }]> = [1, "ok", true, { nice: 10 }]
+// t1[0] = 1
+// t1[3].nice = 10
+// t1.push()
+// const t2: DeepReadonly<[1, any]> = [1, "ok", true, { nice: 10 }]
+// t2[0] = 1
+// const m1: DeepReadonly<Map<string, { nice: boolean }>> = new Map()
+// m1.set("x", { nice: true })
+// interface Rec {
+//     id: number
+//     parent: Rec
+// }
+// const r1: DeepReadonly<Rec> = {} as any
+// r1.id = 10
+// r1.parent.parent.parent = 10
+// const d1: DeepReadonly<Date> = new Date()
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/types/util.mjs

@@ -0,0 +1,13 @@
+export {};
+// const exca1: ExcludeAny<any> = null
+// const exca2: ExcludeAny<string | any> = "nice"
+// const exca3: ExcludeAny<"p1" | "p2" | any> = "p2"
+// const exca4: ExcludeAny<"p1" | "p2"> = "p2"
+// // type X<T> = IsAny<T> extends true ? "T" : "F"
+// // const isAnyCheck: X<unknown> = "F"
+// // const isAnyCheck2: X<any> = "T"
+// // const isAnyCheck3: X<{ [key: string]: any }> = "F"
+// const po1: IsPlainObject<{ [key: string]: any }> = true
+// const po2: IsPlainObject<{ p1: boolean; p2: string }> = false
+// const po3: IsPlainObject<{ p1: boolean; p2: any }> = false
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbW1vbi9zcmMvdHlwZXMvdXRpbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBNERBLHNDQUFzQztBQUN0QyxpREFBaUQ7QUFDakQsb0RBQW9EO0FBQ3BELDhDQUE4QztBQUU5QyxtREFBbUQ7QUFFbkQsd0NBQXdDO0FBQ3hDLHFDQUFxQztBQUNyQyx3REFBd0Q7QUFDeEQsMERBQTBEO0FBQzFELGdFQUFnRTtBQUNoRSw2REFBNkQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNZXJnZVVuaW9uIH0gZnJvbSBcIi4vbWVyZ2UtdW5pb25cIlxuXG5leHBvcnQgdHlwZSBNYXhSZWN1cnNpb24gPSAxMFxuXG4vLyBjb25zdCDhl4XNtuG7viA9IFN5bWJvbChcIl9fYW55X19cIilcblxuLy8gaW50ZXJmYWNlIEFueU9iamVjdCB7XG4vLyAgICAg4ZeFzbbhu746IGJvb2xlYW5cbi8vIH1cblxuLy8gZXhwb3J0IHR5cGUgSXNBbnk8VD4gPSBBbnlPYmplY3QgZXh0ZW5kcyBUID8gdHJ1ZSA6IGZhbHNlXG5leHBvcnQgdHlwZSBJZkFueTxPLCBULCBGPiA9IDAgZXh0ZW5kcyAxICYgTyA/IFQgOiBGXG5leHBvcnQgdHlwZSBJc0FueTxUPiA9IElmQW55PFQsIHRydWUsIGZhbHNlPlxuXG5leHBvcnQgdHlwZSBJZlR1cGxlPE8sIFQsIEYsIEUgPSBuZXZlcj4gPVxuICAgIE8gZXh0ZW5kcyBBcnJheTxhbnk+ID8gKC0xIGV4dGVuZHMgT1tcImxlbmd0aFwiXSA/IEYgOiBPW1wibGVuZ3RoXCJdIGV4dGVuZHMgMCA/IEUgOiBUKSA6IEZcbmV4cG9ydCB0eXBlIElzVHVwbGU8VCwgRSA9IG5ldmVyPiA9IElmVHVwbGU8VCwgdHJ1ZSwgZmFsc2UsIEU+XG5cbi8qKlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiB0eXBlIFR1cGxlID0gVHVwbGVFbnRyaWVzPFsxLCBcIm9rXCIsIGZhbHNlXT5cbiAqIFR1cGxlID0gezA6IDEsIDE6IFwib2tcIiwgMjogZmFsc2V9XG4gKiBgYGBcbiAqL1xuZXhwb3J0IHR5cGUgVHVwbGVJdGVtczxUPiA9IFQgZXh0ZW5kcyBBcnJheTxhbnk+ID8gTWVyZ2VVbmlvbjxfVHVwbGVJdGVtczxUPj4gOiBuZXZlclxuXG50eXBlIF9UdXBsZUl0ZW1zPFxuICAgIFQgZXh0ZW5kcyBhbnlbXSxcbiAgICBLIGV4dGVuZHMgbnVtYmVyW10gPSBbXSxcbiAgICBPIGV4dGVuZHMgeyBba2V5OiBzdHJpbmddOiBudW1iZXIgfSA9IG5ldmVyXG4+ID0gVFtcImxlbmd0aFwiXSBleHRlbmRzIEtbXCJsZW5ndGhcIl1cbiAgICA/IE9cbiAgICA6IF9UdXBsZUl0ZW1zPFQsIFsuLi5LLCBLW1wibGVuZ3RoXCJdXSwgTyB8IHsgW2tleSBpbiBLW1wibGVuZ3RoXCJdXTogVFtLW1wibGVuZ3RoXCJdXSB9PlxuXG4vLyBUT0RPOlxuLy8gZXhwb3J0IHR5cGUgRXhjbHVkZUFueTxULCBVID0gVW5pb25pemU8eyBba2V5OiBzdHJpbmddOiBUIH0+PiA9IHsgW0sgaW4ga2V5b2YgVV06IElmQW55PFVbS10sIG5ldmVyLCBVW0tdPiB9W2tleW9mIFVdXG4vLyBleHBvcnQgdHlwZSBFeGNsdWRlQW55PFQ+ID0gQXJyYXk8VD5bbnVtYmVyXVxuXG5leHBvcnQgdHlwZSBPYmplY3RLZXkgPSBzdHJpbmcgfCBudW1iZXIgfCBzeW1ib2xcbi8vIGV4cG9ydCB0eXBlIFBsYWluT2JqZWN0PEtUIGV4dGVuZHMgT2JqZWN0S2V5ID0gT2JqZWN0S2V5PiA9IHsgW2tleSBpbiBLVF06IGFueSB9XG4vLyBleHBvcnQgdHlwZSBJZlBsYWluT2JqZWN0PE8sIFQsIEY+ID0gTyBleHRlbmRzIHsgW2tleTogT2JqZWN0S2V5XTogYW55IH1cbi8vICAgICA/IEV4Y2x1ZGVBbnk8T1trZXlvZiBPXT4gZXh0ZW5kcyBuZXZlclxuLy8gICAgICAgICA/IFRcbi8vICAgICAgICAgOiBGXG4vLyAgICAgOiBGXG4vLyBleHBvcnQgdHlwZSBJc1BsYWluT2JqZWN0PFQ+ID0gSWZQbGFpbk9iamVjdDxULCB0cnVlLCBmYWxzZT5cblxuLy8gZXhwb3J0IHR5cGUgSWZQbGFpbkFycmF5PE8sIFQsIEY+ID0gTyBleHRlbmRzIEFycmF5PGFueT4gPyAoRXhjbHVkZUFueTxPW251bWJlcl0+IGV4dGVuZHMgbmV2ZXIgPyBUIDogRikgOiBGXG4vLyBleHBvcnQgdHlwZSBJc1BsYWluQXJyYXk8VD4gPSBJZlBsYWluQXJyYXk8VCwgdHJ1ZSwgZmFsc2U+XG5cbi8qKlxuICogRXZhdWxhdGUgdHlwZSBleHByZXNzaW9uc1xuICpcbiAqIGBgYHRzXG4gKiBleHBvcnQgdHlwZSBLZXlPZjxUPiA9IEV2YWw8eyBbSyBpbiBrZXlvZiBUXTogVFtLXSBleHRlbmRzIG5ldmVyID8gbmV2ZXIgOiBLIH1ba2V5b2YgVF0+XG4gKiBgYGBcbiAqL1xuZXhwb3J0IHR5cGUgRXZhbDxUPiA9IEFycmF5PFQ+W251bWJlcl1cblxuLy8gY29uc3QgZXhjYTE6IEV4Y2x1ZGVBbnk8YW55PiA9IG51bGxcbi8vIGNvbnN0IGV4Y2EyOiBFeGNsdWRlQW55PHN0cmluZyB8IGFueT4gPSBcIm5pY2VcIlxuLy8gY29uc3QgZXhjYTM6IEV4Y2x1ZGVBbnk8XCJwMVwiIHwgXCJwMlwiIHwgYW55PiA9IFwicDJcIlxuLy8gY29uc3QgZXhjYTQ6IEV4Y2x1ZGVBbnk8XCJwMVwiIHwgXCJwMlwiPiA9IFwicDJcIlxuXG4vLyAvLyB0eXBlIFg8VD4gPSBJc0FueTxUPiBleHRlbmRzIHRydWUgPyBcIlRcIiA6IFwiRlwiXG5cbi8vIC8vIGNvbnN0IGlzQW55Q2hlY2s6IFg8dW5rbm93bj4gPSBcIkZcIlxuLy8gLy8gY29uc3QgaXNBbnlDaGVjazI6IFg8YW55PiA9IFwiVFwiXG4vLyAvLyBjb25zdCBpc0FueUNoZWNrMzogWDx7IFtrZXk6IHN0cmluZ106IGFueSB9PiA9IFwiRlwiXG4vLyBjb25zdCBwbzE6IElzUGxhaW5PYmplY3Q8eyBba2V5OiBzdHJpbmddOiBhbnkgfT4gPSB0cnVlXG4vLyBjb25zdCBwbzI6IElzUGxhaW5PYmplY3Q8eyBwMTogYm9vbGVhbjsgcDI6IHN0cmluZyB9PiA9IGZhbHNlXG4vLyBjb25zdCBwbzM6IElzUGxhaW5PYmplY3Q8eyBwMTogYm9vbGVhbjsgcDI6IGFueSB9PiA9IGZhbHNlXG4iXX0=