@ngutil/data 0.0.10 → 0.0.12

package/fesm2022/ngutil-data.mjs

@@ -1,5 +1,11 @@
-import { flattenDepth, flattenDeep, isEqual, intersection } from 'lodash';
-import { isPlainObject, deepClone } from '@ngutil/common';
+import { flattenDepth, intersection, flattenDeep, isEqual, sortBy as sortBy$1, groupBy as groupBy$1, merge } from 'lodash';
+import * as i1 from '@ngutil/common';
+import { isPlainObject, deepClone, toSorted, deepFreeze } from '@ngutil/common';
+import { BehaviorSubject, map, combineLatest, take, of, shareReplay, ReplaySubject, switchMap, distinctUntilChanged, Subject, tap, debounceTime, finalize, Observable, takeUntil, share, Subscription, throwError } from 'rxjs';
+import { DataSource as DataSource$1 } from '@angular/cdk/collections';
+import * as i0 from '@angular/core';
+import { Directive, Optional, Input } from '@angular/core';
+import { toSignal } from '@angular/core/rxjs-interop';
 
 function pathGetterCompile(path) {
     if (!path || path.length === 0) {
@@ -18,169 +24,6 @@ function makeGetter(part, parent) {
     }
 }
 
-/**
- * @example
- *```ts
- * items.toSorted(sortBy([{"author.name": "asc"}]))
- * ```
- */
-function sortBy(sorters) {
-    if (sorters.length === 0) {
-        throw new Error("Empty sorter");
-    }
-    return _sorterCompile(sorters);
-}
-/**
- * Normalize sorter definition
- *
- * @example
- * ```ts
- * normalizeSorter([{id: "asc"}]) -> [{path: "id", isAsc: true, emptyFirst: true}]
- * normalizeSorter([{id: {dir: "desc", emptyFirst: false}}]) -> [{path: "id", isAsc: false, emptyFirst: false}]
- * ```
- */
-function sorterNormalize(sorters) {
-    return flattenDeep(sorters.map((s) => Object.entries(s).map(([k, v]) => {
-        if (typeof v === "string") {
-            const isAsc = v.toLowerCase() === "asc";
-            return { path: k, isAsc, emptyFirst: isAsc ? false : true };
-        }
-        else if (isPlainObject(v)) {
-            return {
-                path: k,
-                isAsc: (v.dir || "asc").toLowerCase() === "asc",
-                emptyFirst: v.emptyFirst == null ? true : !!v.emptyFirst
-            };
-        }
-        else {
-            throw new Error(`Invalid sorter: ${v}`);
-        }
-    })));
-}
-function _sorterCompile(sorters) {
-    if (sorters.length === 0) {
-        return (_a, _b) => 0;
-    }
-    const norm = sorterNormalize(sorters).map(createComparator);
-    if (norm.length === 1) {
-        return norm[0];
-    }
-    const initial = norm.pop();
-    return norm.reduceRight((next, curr) => (a, b) => {
-        const r = curr(a, b);
-        return r === 0 ? next(a, b) : r;
-    }, initial);
-}
-function createComparator({ path, isAsc, emptyFirst }) {
-    const getter = pathGetterCompile(path);
-    if (isAsc) {
-        return (a, b) => compare(getter(a), getter(b), emptyFirst);
-    }
-    else {
-        return (a, b) => compare(getter(a), getter(b), !emptyFirst) * -1;
-    }
-}
-function compare(a, b, emptyFirst) {
-    // console.log("COMPARE", a, b)
-    if (a == null && b != null) {
-        return emptyFirst === true ? -1 : 1;
-    }
-    else if (a != null && b == null) {
-        return emptyFirst === true ? 1 : -1;
-    }
-    else if (a == null && b == null) {
-        return 0;
-    }
-    else if (isEqual(a, b)) {
-        return 0;
-    }
-    else if (typeof a === "number" && typeof b === "number") {
-        return a - b;
-    }
-    else if (typeof a === "string" && typeof b === "string") {
-        const al = a.length;
-        const bl = b.length;
-        // if both lengths is 0 the code execution not reach that point, because a === b
-        if (emptyFirst === true) {
-            if (al === 0) {
-                return -1;
-            }
-            else if (bl === 0) {
-                return 1;
-            }
-        }
-        else {
-            if (al === 0) {
-                return 1;
-            }
-            else if (bl === 0) {
-                return -1;
-            }
-        }
-        return a.localeCompare(b);
-    }
-    else if (Array.isArray(a) && Array.isArray(b)) {
-        const al = a.length;
-        const bl = b.length;
-        const l = Math.min(al, bl);
-        for (let i = 0; i < l; i++) {
-            const res = compare(a[i], b[i], emptyFirst);
-            if (res !== 0) {
-                return res;
-            }
-        }
-        if (al === bl) {
-            return 0;
-        }
-        if (emptyFirst === true) {
-            if (al === 0) {
-                return -1;
-            }
-            else if (bl === 0) {
-                return 1;
-            }
-        }
-        else {
-            if (al === 0) {
-                return 1;
-            }
-            else if (bl === 0) {
-                return -1;
-            }
-        }
-        return al - bl;
-    }
-    else if (isPlainObject(a) && isPlainObject(b)) {
-        return JSON.stringify(a).localeCompare(JSON.stringify(b));
-    }
-    return a > b ? -1 : 1;
-}
-function sorterMerge(...sorters) {
-    let result;
-    for (const sorter of sorters) {
-        if (sorter == null) {
-            continue;
-        }
-        if (result == null) {
-            result = deepClone(sorter);
-            continue;
-        }
-        for (const sentry of sorter) {
-            for (const [k, v] of Object.entries(sentry)) {
-                const existing = result.find((value) => value[k] != null);
-                if (existing) {
-                    ;
-                    existing[k] = deepClone(v);
-                }
-                else {
-                    result.push({ [k]: deepClone(v) });
-                }
-            }
-        }
-    }
-    return result;
-}
-
 const OPERATORS = [
     "==" /* FilterOp.Eq */,
     "===" /* FilterOp.EqStrict */,
@@ -466,9 +309,967 @@ function filterMerge(...filters) {
     return result;
 }
 
+function groupBy(grouper) {
+    return grouperCompile(grouper);
+}
+function grouperCompile(grouper) {
+    return _ => undefined;
+}
+function grouperMerge(...groupers) {
+    return undefined;
+}
+// import { Primitive } from "utility-types"
+// import { Eval, Flatten } from "@ngutil/common"
+// import { type Model } from "./query"
+// import { SorterFn } from "./sorter"
+// export interface Grouped<T extends Model> {
+//     items: T[]
+//     groups: Group<T>
+// }
+// export type GrouperFn<T extends Model> = (items: T[]) => any
+// export type GroupKey<T extends Model> = (item: T, index: number) => Primitive[]
+// export type GroupItemIsMatch<T extends Model> = (item: T, index: number) => boolean
+// export interface GrouperX<T extends Model> {
+//     name: string
+//     title?: string
+//     isMatch?: GroupKey<T>
+//     [key: string]: any
+// }
+// export interface GrouperXNormalized<T extends Model> extends GrouperX<T> {
+//     key: GroupKey<T>
+// }
+// type _Groupers<T extends Model, F> = keyof F | Grouper<T>
+// export type Grouper<T extends Model, F = Flatten<T>> = Eval<Array<_Groupers<T, F>>>
+// export type GrouperNormalized<T extends Model> = { [key: string]: GrouperXNormalized<T> }
+// export interface Group<T extends Model, G extends Grouper<T> = Grouper<T>> {
+//     grouper: G
+//     begin: number
+//     end: number
+// }
+// /**
+//  * @example
+//  * ```ts
+//  * const grouped = groupBy(["status"])(items)
+//  * // expexted: {[status]: [...items]}
+//  *
+//  * const grouped = groupBy(["name", "age"])(items)
+//  * // expected {[status]: {[age]: [...items]}}
+//  *
+//  * const STATUS_LABELS = {active: "Active", inactive: "Inactive"}
+//  * const grouped = groupBy([(item) => (STATUS_LABELS[item.status] || "Undefined")])(items)
+//  * // expected {["Active" | "Inactive" | "Undefined"]: [...items]}
+//  *
+//  * const grouped = groupBy([(item) => (STATUS_LABELS[item.status] || "Undefined"), "age"])(items)
+//  * // expected {["Active" | "Inactive" | "Undefined"]: {[age]: [...items]}}
+//  * ```
+//  */
+// export function groupBy<T extends Model>(groupers: Grouper<T>): SorterFn<T> {
+//     return (_a, _b) => 0
+// }
+// export function grouperNormalize() {}
+// export function grouperCompile<T extends Model>(groupers: Grouper<T>): GrouperFn<T> {
+//     return _ => undefined
+// }
+// export function grouperMerge<T extends Model, F = Flatten<T>>(
+//     ...groupers: Array<Grouper<T, F> | undefined | null>
+// ): Grouper<T, F> | undefined {
+//     return undefined
+// }
+
+/**
+ * @example
+ *```ts
+ * items.toSorted(sortBy([{"author.name": "asc"}]))
+ * ```
+ */
+function sortBy(sorters) {
+    if (sorters.length === 0) {
+        throw new Error("Empty sorter");
+    }
+    return _sorterCompile(sorters);
+}
+/**
+ * Normalize sorter definition
+ *
+ * @example
+ * ```ts
+ * normalizeSorter([{id: "asc"}]) -> [{path: "id", isAsc: true, emptyFirst: true}]
+ * normalizeSorter([{id: {dir: "desc", emptyFirst: false}}]) -> [{path: "id", isAsc: false, emptyFirst: false}]
+ * ```
+ */
+function sorterNormalize(sorters) {
+    return flattenDeep(sorters.map((s) => Object.entries(s).map(([k, v]) => {
+        if (typeof v === "string") {
+            const isAsc = v.toLowerCase() === "asc";
+            return { path: k, isAsc, emptyFirst: isAsc ? false : true };
+        }
+        else if (isPlainObject(v)) {
+            return {
+                path: k,
+                isAsc: (v.dir || "asc").toLowerCase() === "asc",
+                emptyFirst: v.emptyFirst == null ? true : !!v.emptyFirst
+            };
+        }
+        else {
+            throw new Error(`Invalid sorter: ${v}`);
+        }
+    })));
+}
+function _sorterCompile(sorters) {
+    if (sorters.length === 0) {
+        return (_a, _b) => 0;
+    }
+    const norm = sorterNormalize(sorters).map(createComparator);
+    if (norm.length === 1) {
+        return norm[0];
+    }
+    const initial = norm.pop();
+    return norm.reduceRight((next, curr) => (a, b) => {
+        const r = curr(a, b);
+        return r === 0 ? next(a, b) : r;
+    }, initial);
+}
+function createComparator({ path, isAsc, emptyFirst }) {
+    const getter = pathGetterCompile(path);
+    if (isAsc) {
+        return (a, b) => compare(getter(a), getter(b), emptyFirst);
+    }
+    else {
+        return (a, b) => compare(getter(a), getter(b), !emptyFirst) * -1;
+    }
+}
+function compare(a, b, emptyFirst) {
+    // console.log("COMPARE", a, b)
+    if (a == null && b != null) {
+        return emptyFirst === true ? -1 : 1;
+    }
+    else if (a != null && b == null) {
+        return emptyFirst === true ? 1 : -1;
+    }
+    else if (a == null && b == null) {
+        return 0;
+    }
+    else if (isEqual(a, b)) {
+        return 0;
+    }
+    else if (typeof a === "number" && typeof b === "number") {
+        return a - b;
+    }
+    else if (typeof a === "string" && typeof b === "string") {
+        const al = a.length;
+        const bl = b.length;
+        // if both lengths is 0 the code execution not reach that point, because a === b
+        if (emptyFirst === true) {
+            if (al === 0) {
+                return -1;
+            }
+            else if (bl === 0) {
+                return 1;
+            }
+        }
+        else {
+            if (al === 0) {
+                return 1;
+            }
+            else if (bl === 0) {
+                return -1;
+            }
+        }
+        return a.localeCompare(b);
+    }
+    else if (Array.isArray(a) && Array.isArray(b)) {
+        const al = a.length;
+        const bl = b.length;
+        const l = Math.min(al, bl);
+        for (let i = 0; i < l; i++) {
+            const res = compare(a[i], b[i], emptyFirst);
+            if (res !== 0) {
+                return res;
+            }
+        }
+        if (al === bl) {
+            return 0;
+        }
+        if (emptyFirst === true) {
+            if (al === 0) {
+                return -1;
+            }
+            else if (bl === 0) {
+                return 1;
+            }
+        }
+        else {
+            if (al === 0) {
+                return 1;
+            }
+            else if (bl === 0) {
+                return -1;
+            }
+        }
+        return al - bl;
+    }
+    else if (isPlainObject(a) && isPlainObject(b)) {
+        return JSON.stringify(a).localeCompare(JSON.stringify(b));
+    }
+    return a > b ? -1 : 1;
+}
+function sorterMerge(...sorters) {
+    let result;
+    for (const sorter of sorters) {
+        if (sorter == null) {
+            continue;
+        }
+        if (result == null) {
+            result = deepClone(sorter);
+            continue;
+        }
+        for (const sentry of sorter) {
+            for (const [k, v] of Object.entries(sentry)) {
+                const existing = result.find((value) => value[k] != null);
+                if (existing) {
+                    ;
+                    existing[k] = deepClone(v);
+                }
+                else {
+                    result.push({ [k]: deepClone(v) });
+                }
+            }
+        }
+    }
+    return result;
+}
+
+function slimBy(slimer) { }
+function slimerNormalize(slimer) { }
+function slimerCompile(slimer) {
+    return item => item;
+}
+function slimerMerge(...slimers) { }
+
+function sliceMerge(...slices) {
+    let result = undefined;
+    for (const slice of slices) {
+        if (slice == null) {
+            continue;
+        }
+        if (result == null) {
+            result = deepClone(slice);
+        }
+        else {
+            result = { ...result, ...slice };
+        }
+    }
+    return result;
+}
+/**
+ * Apply slice to array, and force the result length to equal with Slice length,
+ * so fill array with undefined if not enought elements
+ */
+function sliceApply(slice, array) {
+    const result = array.slice(slice.start, slice.end);
+    result.length = slice.end - slice.start;
+    return result;
+}
+/**
+ * @returns Page numbers, eg.: `[10, 11, 12, 13, ...]`
+ */
+function sliceToPages(slice) {
+    if (slice.pageSize == null) {
+        throw new Error("Missing `step` from slice");
+    }
+    const start = Math.floor(slice.start / slice.pageSize);
+    const end = Math.ceil(slice.end / slice.pageSize);
+    return Array.from({ length: end - start }, (_, i) => start + i);
+}
+function sliceInsert(slice, array, newItems) {
+    if (slice.start === slice.end) {
+        return array;
+    }
+    let result = array.slice(0, slice.start);
+    result.length = slice.start;
+    result = result.concat(newItems);
+    result.length = slice.end;
+    return result.concat(array.slice(slice.end));
+}
+function sliceClamp(slice, constraint) {
+    return {
+        start: Math.max(slice.start, constraint.start),
+        end: Math.min(slice.end, constraint.end),
+        pageSize: slice.pageSize
+    };
+}
+function sliceEq(a, b) {
+    return a.start === b.start && a.end === b.end && a.pageSize === b.pageSize;
+}
+// TODO: sliceOverlap(other: Slice): Slice
+// TODO: sliceIncludes(other: Slice): boolean
+// TODO: sliceConcat(...slices: Slice[]): Slice[]
+// TODO: sliceDiff(slice: Slice): Slice[]
+
+const INPUT = Symbol("INPUT");
+function queryExecutor(query, previous) {
+    const executors = {
+        filterFn: filterExecutor(query.filter, previous?.filterFn),
+        sorterFn: sorterExecutor(query.sorter, previous?.sorterFn),
+        grouperFn: grouperExecutor(query.grouper, previous?.grouperFn),
+        slicerFn: sliceExecutor(query.slice, previous?.slicerFn)
+    };
+    const changed = previous == null || Object.entries(executors).some(([k, v]) => previous[k] !== v);
+    if (!changed) {
+        return previous;
+    }
+    const executor = (items) => {
+        if (items == null || items.length === 0) {
+            return { items: [], total: 0 };
+        }
+        let result = items;
+        if (executors.filterFn) {
+            result = result.filter(executors.filterFn);
+        }
+        if (executors.sorterFn) {
+            result = toSorted(result, executors.sorterFn);
+        }
+        const total = result.length;
+        // TODO: grouper
+        if (executors.slicerFn) {
+            result = executors.slicerFn(result);
+        }
+        return { items: result, total };
+    };
+    for (const [k, v] of Object.entries(executors)) {
+        Object.defineProperty(executor, k, {
+            value: v,
+            enumerable: true,
+            writable: false
+        });
+    }
+    return executor;
+}
+function filterExecutor(filter, prev) {
+    return compileExec(filter, prev, filterBy);
+}
+function sorterExecutor(sorter, prev) {
+    return compileExec(sorter, prev, sortBy$1);
+}
+function grouperExecutor(sorter, prev) {
+    return compileExec(sorter, prev, groupBy$1);
+}
+function sliceExecutor(slice, prev) {
+    return compileExec(slice, prev, sliceBy);
+}
+function sliceBy(slice) {
+    return (items) => items.slice(slice.start, slice.end);
+}
+function compileExec(input, prev, compiler) {
+    if (input == null) {
+        return undefined;
+    }
+    if (prev != null) {
+        // thorically input is readonly
+        if (prev[INPUT] === input || isEqual(prev[INPUT], input)) {
+            return prev;
+        }
+    }
+    const exec = compiler(input);
+    Object.defineProperty(exec, INPUT, {
+        value: input,
+        enumerable: true,
+        writable: false
+    });
+    return exec;
+}
+
+class ModelMeta {
+    static coerce(value) {
+        if (value instanceof ModelMeta) {
+            return value;
+        }
+        else {
+            return new ModelMeta(value);
+        }
+    }
+    #getKey;
+    constructor(props) {
+        this.keys = props.keys;
+        if (this.keys.length > 0) {
+            const getters = this.keys.map(pathGetterCompile);
+            if (props.trackBy == null) {
+                this.trackBy = (index, item) => getters.map(p => p(item)).join("∀");
+            }
+            else {
+                this.trackBy = props.trackBy;
+            }
+            this.#getKey = (item) => getters.map(p => p(item)).join("∀");
+        }
+        else {
+            if (props.trackBy == null) {
+                throw new Error("Can't compile track by function without `keys` declaration");
+            }
+            else {
+                this.trackBy = props.trackBy;
+            }
+        }
+    }
+    isEqual(a, b) {
+        return isEqual(a, b);
+    }
+    isEqualByTrack(a, b) {
+        if (a == null || b == null) {
+            return a == null && b == null;
+        }
+        if (a.index == null || b.index == null) {
+            return a.index == null && b.index == null;
+        }
+        if (a.model == null || b.model == null) {
+            return a.model == null && b.model == null;
+        }
+        return this.trackBy(a.index, a.model) === this.trackBy(b.index, b.model);
+    }
+    isEqualByKey(a, b) {
+        if (this.#getKey != null) {
+            if (a == null || b == null) {
+                return a == null && b == null;
+            }
+            return this.#getKey(a) === this.#getKey(b);
+        }
+        console.warn("Primary keys is not defined for", a, b);
+        return false;
+    }
+    normalizeRef(ref) {
+        if (ref instanceof ModelRefNorm) {
+            return ref;
+        }
+        if (ref.key != null && ref.index != null) {
+            throw new Error("Only provide `pk` or `index` value not both");
+        }
+        if (ref.key != null) {
+            const keyValue = (Array.isArray(ref.key) ? ref.key : [ref.key]);
+            if (keyValue.length > 0) {
+                if (this.keys.length === 0) {
+                    throw new Error("Can't normalize ref without `keys`");
+                }
+                if (keyValue.length !== this.keys.length) {
+                    throw new Error(`Wrong number of \`key\` values for this keys: [${this.keys.join(",")}]`);
+                }
+                return new ModelRefByKey(keyValue, this.keys);
+            }
+            else {
+                console.warn("Empty key in ModelRef", ref);
+            }
+        }
+        if (ref.index != null) {
+            return new ModelRefByIndex(ref.index);
+        }
+        throw new Error("Missing `key` or `index` value");
+    }
+}
+class ModelRefNorm {
+    #filter;
+    toFilter() {
+        if (this.#filter == null) {
+            return (this.#filter = this._asFilter());
+        }
+        return this.#filter;
+    }
+}
+class ModelRefByKey extends ModelRefNorm {
+    #keys;
+    constructor(key, keys) {
+        super();
+        this.key = key;
+        this.#keys = keys;
+    }
+    _asFilter() {
+        const filter = {};
+        for (let i = 0; i < this.#keys.length; i++) {
+            filter[this.#keys[i]] = this.key[i];
+        }
+        return filterBy(filter);
+    }
+}
+class ModelRefByIndex extends ModelRefNorm {
+    constructor(index) {
+        super();
+        this.index = index;
+    }
+    _asFilter() {
+        return (item, index) => this.index === index;
+    }
+}
+class UnknownMeta extends ModelMeta {
+    constructor() {
+        super({ keys: [], trackBy: (index) => index });
+    }
+}
+
+class CollectionStore {
+}
+
+class MemoryStore extends CollectionStore {
+    #data = new BehaviorSubject([]);
+    insertSlice(slice, items) {
+        this.#data.next(sliceInsert(slice, this.#data.value, items));
+        return this.#data;
+    }
+    hasSlice(slice) {
+        return this.#data.pipe(map(data => {
+            if (sliceEq(slice, sliceClamp(slice, { start: 0, end: data.length }))) {
+                for (let i = slice.start; i < slice.end; i++) {
+                    if (data[i] == null) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            else {
+                return false;
+            }
+        }));
+    }
+    getSlice(slice) {
+        return this.#data.pipe(map(data => sliceApply(slice, data)));
+    }
+    get(ref) {
+        return this.#data.pipe(map(data => data.find(ref.toFilter())));
+    }
+    indexOf(ref) {
+        return this.#data.pipe(map(data => data.findIndex(ref.toFilter())));
+    }
+    update(ref, item) {
+        return combineLatest({
+            index: this.indexOf(ref),
+            data: this.#data
+        }).pipe(take(1), map(({ index, data }) => {
+            if (index < 0) {
+                return index;
+            }
+            this.#data.next(sliceInsert({ start: index, end: index + 1 }, data, [item]));
+            return index;
+        }));
+    }
+    updateOrInsert(ref, item, position) {
+        return combineLatest({
+            index: this.indexOf(ref),
+            data: this.#data
+        }).pipe(take(1), map(({ index, data }) => {
+            if (index < 0) {
+                index = position == null ? data.length : position < 0 ? data.length : position;
+            }
+            this.#data.next(sliceInsert({ start: index, end: index + 1 }, data, [item]));
+            return index;
+        }));
+    }
+    del(ref) {
+        return combineLatest({
+            index: this.indexOf(ref),
+            data: this.#data
+        }).pipe(take(1), map(({ index, data }) => {
+            if (index < 0) {
+                return index;
+            }
+            const result = data.slice(0);
+            result.splice(index, 1);
+            this.#data.next(result);
+            return index;
+        }));
+    }
+    clear() {
+        if (this.#data.value.length > 0) {
+            this.#data.next([]);
+        }
+        return of(undefined);
+    }
+}
+
+class Property extends BehaviorSubject {
+    // readonly #signal: Signal<DeepReadonly<T> | undefined> = toSignal(this, { requireSync: true })
+    set(value, clone = true) {
+        if (!isEqual(this.value, value)) {
+            if (value != null) {
+                this.next(deepFreeze(clone ? deepClone(value) : value));
+            }
+            else {
+                this.next(undefined);
+            }
+        }
+    }
+    get() {
+        return this.value;
+    }
+    del() {
+        this.set(undefined);
+    }
+}
+class PropertyCombined {
+}
+function mergedProperty(merger, ...props) {
+    if (props.length > 1) {
+        return combineLatest(props).pipe(map(values => deepFreeze(merger(...values))));
+    }
+    else {
+        return props[0];
+    }
+}
+
+class FilterProperty extends Property {
+    update(other) {
+        this.set(filterMerge(this.value, other), false);
+    }
+}
+class FilterCombined extends PropertyCombined {
+    constructor() {
+        super(...arguments);
+        this.normal = new FilterProperty(undefined);
+        this.forced = new FilterProperty(undefined);
+        this.merged$ = mergedProperty(filterMerge, this.normal, this.forced);
+    }
+}
+
+class SorterProperty extends Property {
+    update(other) {
+        this.set(sorterMerge(this.value, other), false);
+    }
+}
+class SorterCombined extends PropertyCombined {
+    constructor() {
+        super(...arguments);
+        this.normal = new SorterProperty(undefined);
+        this.forced = new SorterProperty(undefined);
+        this.merged$ = mergedProperty(sorterMerge, this.normal, this.forced);
+    }
+}
+
+class SlimerProperty extends Property {
+    update(other) {
+        this.set(slimerMerge(this.value, other), false);
+    }
+}
+class SlimerCombined extends PropertyCombined {
+    constructor() {
+        super(...arguments);
+        this.normal = new SlimerProperty(undefined);
+        this.forced = new SlimerProperty(undefined);
+        this.merged$ = mergedProperty(slimerMerge, this.normal, this.forced);
+    }
+}
+
+class GrouperProperty extends Property {
+    update(other) {
+        this.set(grouperMerge(this.value, other), false);
+    }
+}
+class GrouperCombined extends PropertyCombined {
+    constructor() {
+        super(...arguments);
+        this.normal = new GrouperProperty(undefined);
+        this.forced = new GrouperProperty(undefined);
+        this.merged$ = mergedProperty(grouperMerge, this.normal, this.forced);
+    }
+}
+
+const DEBOUNCE_TIME = 50;
+class DataSource extends DataSource$1 {
+    #queryBase;
+    #slice;
+    #reload;
+    constructor(provider, store) {
+        super();
+        this.provider = provider;
+        this.busy$ = new BehaviorSubject(false);
+        this.total$ = new BehaviorSubject(undefined);
+        this.filter = new FilterCombined();
+        this.sorter = new SorterCombined();
+        this.slimer = new SlimerCombined();
+        this.grouper = new GrouperCombined();
+        this.#queryBase = combineLatest({
+            filter: this.filter.merged$,
+            sorter: this.sorter.merged$,
+            slimer: this.slimer.merged$,
+            grouper: this.grouper.merged$
+        }).pipe(shareReplay(1));
+        this.#slice = new ReplaySubject(1);
+        this.slice$ = this.#slice.pipe(switchMap(slice => this.provider.clampSlice(slice)), distinctUntilChanged(isEqual), map(slice => deepFreeze(deepClone(slice))), shareReplay(1));
+        this.#reload = new Subject();
+        this.reset$ = merge(this.#queryBase, this.#reload).pipe(tap(() => this.#setBusy(true)), switchMap(() => this.store.clear()), shareReplay(1));
+        this.query$ = combineLatest({ base: this.#queryBase, slice: this.slice$ }).pipe(map(({ base, slice }) => {
+            return { ...base, slice };
+        }), shareReplay(1));
+        this.items$ = combineLatest({ query: this.query$, reset: this.reset$ }).pipe(tap(() => this.#setBusy(true)), debounceTime(DEBOUNCE_TIME), switchMap(({ query }) => {
+            return this.store.hasSlice(query.slice).pipe(switchMap(hasSlice => {
+                if (hasSlice) {
+                    return this.store.getSlice(query.slice);
+                }
+                else {
+                    return this.provider.queryList(query).pipe(switchMap(result => {
+                        if (result.total != null) {
+                            this.total$.next(result.total);
+                        }
+                        return this.store.insertSlice(query.slice, result.items);
+                    }), take(1));
+                }
+            }));
+        }), finalize(() => this.#setBusy(false)), shareReplay(1));
+        this.#cvSubs = new Map();
+        if (store == null) {
+            store = new MemoryStore();
+        }
+        this.store = store;
+    }
+    setSlice(slice) {
+        this.#slice.next(slice);
+        return this;
+    }
+    all() {
+        return this.setSlice({ start: 0, end: Infinity });
+    }
+    realod() {
+        this.#reload.next();
+    }
+    getItem(ref) {
+        const refn = this.provider.meta.normalizeRef(ref);
+        return this.#storeFirst(query => this.store.get(refn), query => this.provider.queryItem(refn, query));
+    }
+    getItemPosition(ref) {
+        const refn = this.provider.meta.normalizeRef(ref);
+        return this.#storeFirst(query => this.store.indexOf(refn).pipe(map(i => (i < 0 ? undefined : i))), query => this.provider.queryPosition(refn, query));
+    }
+    realodItem(ref, insertPosition) {
+        const refn = this.provider.meta.normalizeRef(ref);
+        return this.query$.pipe(switchMap(query => this.provider.queryItem(refn, query)), switchMap(item => item != null ? this.store.updateOrInsert(refn, item, insertPosition).pipe(map(() => item)) : of(item)), take(1));
+    }
+    #storeFirst(storeFn, selfFn) {
+        return this.query$.pipe(take(1), switchMap(query => storeFn(query).pipe(switchMap(result => (result == null ? selfFn(query) : of(result))))));
+    }
+    #setBusy(busy) {
+        if (this.provider.isAsync) {
+            if (this.busy$.value !== busy) {
+                this.busy$.next(busy);
+            }
+        }
+    }
+    #cvSubs;
+    connect(collectionViewer) {
+        const until = new Subject();
+        this.#cvSubs.get(collectionViewer)?.next();
+        this.#cvSubs.set(collectionViewer, until);
+        return new Observable((subscriber) => {
+            const sub1 = collectionViewer.viewChange.subscribe(this.#slice);
+            const sub2 = this.items$.subscribe(subscriber);
+            return () => {
+                if (this.#cvSubs.get(collectionViewer) === until) {
+                    this.#cvSubs.delete(collectionViewer);
+                }
+                sub1.unsubscribe();
+                sub2.unsubscribe();
+            };
+        }).pipe(takeUntil(until));
+    }
+    disconnect(collectionViewer) {
+        this.#cvSubs.get(collectionViewer)?.next();
+        this.#cvSubs.delete(collectionViewer);
+    }
+}
+
+/**
+ * @example
+ * ```html
+ * <table [nuDataSource]="..." [filter]="{isActive: true}" [sorter]="[{name: 'asc'}]"></table>
+ * ```
+ *
+ * ```ts
+ * @Component({
+ *   template: `<table [nuDataSource]="users$"></table>`
+ * })
+ * class UserTable {
+ *   readonly userService = inject(UserService)
+ *   readonly users$ = UserService.all()
+ * }
+ * ```
+ *
+ * ```ts
+ * @Component({
+ *   selector: "table.my-table",
+ *   template: `
+ *   <cdk-virtual-scroll-viewport itemSize="50" class="example-viewport">
+ *       <div *cdkVirtualFor="let item of dataSource" class="example-item">{{item}}</div>
+ *   </cdk-virtual-scroll-viewport>
+ *   `
+ * })
+ * class TableComponent {
+ *   readonly dataSource = inject(DataSourceProxy)
+ * }
+ * ```
+ */
+class DataSourceProxy extends DataSource$1 {
+    set source(value) {
+        this.#valueSub?.unsubscribe();
+        this.#valueSub = coerceDataSource(value)
+            .pipe(tap(v => {
+            if (v == null) {
+                throw new Error("Missing DataSource");
+            }
+        }))
+            .subscribe(this.source$);
+    }
+    #valueSub;
+    set filter(value) {
+        this.#filter.next(value);
+    }
+    #filter;
+    // TODO: maybe mergedFilter$ = this.value$.pipe(switchMap(value => value.filter.merged$))
+    set sorter(value) {
+        this.#sorter.next(value);
+    }
+    #sorter;
+    set grouper(value) {
+        this.#grouper.next(value);
+    }
+    #grouper;
+    set slimer(value) {
+        this.#slimer.next(value);
+    }
+    #slimer;
+    #subs;
+    constructor(busy) {
+        super();
+        this.source$ = new ReplaySubject(1);
+        this.items$ = this.source$.pipe(switchMap(value => value.items$), share());
+        this.busy$ = this.source$.pipe(switchMap(value => value.busy$), share());
+        this.isBusy = toSignal(this.busy$, { rejectErrors: true, initialValue: false });
+        this.#filter = new ReplaySubject(1);
+        this.#sorter = new ReplaySubject(1);
+        this.#grouper = new ReplaySubject(1);
+        this.#slimer = new ReplaySubject(1);
+        this.#subs = new Subscription();
+        this.#cvSubs = new Map();
+        if (busy != null) {
+            this.#subs.add(busy.connect(this.busy$).subscribe());
+        }
+        this.#subs.add(combineLatest({ src: this.source$, filter: this.#filter }).subscribe(({ src, filter }) => {
+            src.filter.forced.set(filter);
+        }));
+        this.#subs.add(combineLatest({ src: this.source$, sorter: this.#sorter }).subscribe(({ src, sorter }) => {
+            src.sorter.forced.set(sorter);
+        }));
+        this.#subs.add(combineLatest({ src: this.source$, grouper: this.#grouper }).subscribe(({ src, grouper }) => {
+            src.grouper.forced.set(grouper);
+        }));
+        this.#subs.add(combineLatest({ src: this.source$, slimer: this.#slimer }).subscribe(({ src, slimer }) => {
+            src.slimer.forced.set(slimer);
+        }));
+    }
+    #cvSubs;
+    connect(collectionViewer) {
+        const until = new Subject();
+        this.#cvSubs.get(collectionViewer)?.next();
+        this.#cvSubs.set(collectionViewer, until);
+        return this.source$.pipe(switchMap(value => value.connect(collectionViewer)), takeUntil(until), finalize(() => this.#cvSubs.delete(collectionViewer)));
+    }
+    disconnect(collectionViewer) {
+        this.#cvSubs.get(collectionViewer)?.next();
+        this.#cvSubs.delete(collectionViewer);
+    }
+    ngOnDestroy() {
+        this.#valueSub?.unsubscribe();
+        this.#valueSub = undefined;
+        this.#subs.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxy, deps: [{ token: i1.Busy, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.6", type: DataSourceProxy, isStandalone: true, selector: "[nuDataSource]", inputs: { source: ["nuDataSource", "source"], filter: "filter", sorter: "sorter", grouper: "grouper", slimer: "slimer" }, exportAs: ["nuDataSource"], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxy, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[nuDataSource]",
+                    exportAs: "nuDataSource"
+                }]
+        }], ctorParameters: () => [{ type: i1.Busy, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { source: [{
+                type: Input,
+                args: [{ required: true, alias: "nuDataSource" }]
+            }], filter: [{
+                type: Input
+            }], sorter: [{
+                type: Input
+            }], grouper: [{
+                type: Input
+            }], slimer: [{
+                type: Input
+            }] } });
+function coerceDataSource(value) {
+    if (value instanceof DataSourceProxy) {
+        return value.source$;
+    }
+    else if (value instanceof DataSource) {
+        return of(value);
+    }
+    else if (value instanceof DataProvider) {
+        return of(value.toDataSource());
+    }
+    else {
+        return throwError(() => new Error("Invalid DataSource value"));
+    }
+}
+
+class DataProvider {
+    /**
+     * Froce Slice boundaries, useful in array, or obeservable providers
+     */
+    clampSlice(slice) {
+        return of(slice);
+    }
+    /**
+     * @returns New data source instance
+     */
+    toDataSource(store) {
+        return new DataSource(this, store);
+    }
+}
+
+class LocalProvider extends DataProvider {
+    #executor;
+    constructor(meta) {
+        super();
+        this.isAsync = false;
+        this.meta = ModelMeta.coerce(meta);
+    }
+    executor(request) {
+        return (this.#executor = queryExecutor(request, this.#executor));
+    }
+    queryList(request) {
+        const exec = this.executor(request);
+        return this.items$.pipe(map(items => exec(items)));
+    }
+    queryItem(ref, request) {
+        return this.queryList(request).pipe(map(list => list.items.find(ref.toFilter())));
+    }
+    queryPosition(ref, request) {
+        return this.queryList(request).pipe(map(list => list.items.findIndex(ref.toFilter())));
+    }
+    clampSlice(slice) {
+        return this.items$.pipe(take(1), map(items => sliceClamp(slice, { start: 0, end: items.length })));
+    }
+}
+
+class ArrayProvider extends LocalProvider {
+    constructor(meta, items) {
+        super(meta);
+        this.items$ = of(items);
+    }
+}
+
+class ObservableProvider extends LocalProvider {
+    constructor(meta, src) {
+        super(meta);
+        this.items$ = src;
+    }
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { filterBy, sortBy };
+export { ArrayProvider, CollectionStore, DataProvider, DataSource, DataSourceProxy, LocalProvider, MemoryStore, ModelMeta, ModelRefByIndex, ModelRefByKey, ModelRefNorm, ObservableProvider, UnknownMeta, filterBy, filterMerge, groupBy, grouperMerge, pathGetterCompile, queryExecutor, sliceApply, sliceClamp, sliceEq, sliceInsert, sliceMerge, sliceToPages, slimBy, slimerMerge, sortBy, sorterMerge };
 //# sourceMappingURL=ngutil-data.mjs.map