@ngutil/data 0.0.17 → 0.0.19

package/fesm2022/ngutil-data.mjs

@@ -1,7 +1,7 @@
-import { flattenDepth, intersection, flattenDeep, isEqual } from 'lodash';
+import { flattenDepth, isEqual, intersection, flattenDeep } 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, tap, debounceTime, finalize, Subject, Observable, takeUntil, share, Subscription, throwError } from 'rxjs';
+import { deepClone, deepFreeze, isPlainObject, toSorted } from '@ngutil/common';
+import { BehaviorSubject, Observable, combineLatest, map, shareReplay, take, of, ReplaySubject, switchMap, distinctUntilChanged, tap, debounceTime, finalize, Subject, 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';
@@ -24,6 +24,91 @@ function makeGetter(part, parent) {
     }
 }
 
+function readonlyProp(o, n, v) {
+    Object.defineProperty(o, n, {
+        value: v,
+        configurable: false,
+        enumerable: true,
+        writable: false
+    });
+}
+const NORMALIZED = Symbol("NORMALIZED");
+const IS_NORMALIZED = Symbol("IS_NORMALIZED");
+function normalize(obj, normalizer) {
+    if (obj[IS_NORMALIZED]) {
+        return obj;
+    }
+    if (obj[NORMALIZED] == null) {
+        const normalized = normalizer(obj);
+        Object.defineProperty(obj, NORMALIZED, {
+            value: normalized,
+            configurable: false,
+            enumerable: false,
+            writable: false
+        });
+        Object.defineProperty(normalize, IS_NORMALIZED, {
+            value: true,
+            configurable: false,
+            enumerable: false,
+            writable: false
+        });
+        return normalized;
+    }
+    return obj[NORMALIZED];
+}
+
+class QueryProperty extends BehaviorSubject {
+    set(value) {
+        this.#nextClone(value != null ? this.norm(value) : undefined);
+    }
+    update(value) {
+        const norm = value != null ? this.norm(value) : undefined;
+        if (!isEqual(this.value, norm)) {
+            this.#next(this.merge(this.value, norm));
+        }
+    }
+    del() {
+        this.set(undefined);
+    }
+    #next(value) {
+        if (!isEqual(this.value, value)) {
+            if (value == null) {
+                this.next(undefined);
+            }
+            else {
+                this.next(value);
+            }
+        }
+    }
+    #nextClone(value) {
+        if (!isEqual(this.value, value)) {
+            if (value == null) {
+                this.next(undefined);
+            }
+            else {
+                this.next(deepClone(value));
+            }
+        }
+    }
+}
+class QueryPropertySet extends Observable {
+    #combined;
+    constructor(...names) {
+        super(dest => this.#combined.subscribe(dest));
+        const observables = [];
+        const props = {};
+        for (const name of names) {
+            const o = this.newProperty();
+            observables.push(o);
+            props[name] = o;
+        }
+        this.#combined = combineLatest(observables).pipe(map(values => deepFreeze(this.merge(...values))), shareReplay(1));
+        for (const [k, v] of Object.entries(props)) {
+            readonlyProp(this, k, v);
+        }
+    }
+}
+
 const OPERATORS = [
     "==" /* FilterOp.Eq */,
     "===" /* FilterOp.EqStrict */,
@@ -70,107 +155,81 @@ function asOperators(value) {
 function filterBy(filters) {
     return _filterCompile(filters);
 }
-// TODO: Normalize filter
-// type _Filter = { path: string; op: FilterOp; value: any }
-// type _Or = { "|": Array<_Filter> }
-// type _And = { "&": Array<_Filter> }
-// export type NormalizedFilter = _Or | _And
-// /**
-//  * @example
-//  * ```ts
-//  * normalizeFilter({id: 2, name: {"=*": "AnyName"}}) -> {id: {"==": 2}, name: {"=*": "AnyName"}}}
-//  * normalizeFilter({id: {">": 0, "<": 10}}) -> {"&": [{id: {">": 0}}, {id: {"<": 10}}]}
-//  * ```
-//  */
-// export function normalizeFilter<T extends Model>(filters: Filters<T>): Filters<T> {
-//     return _normalizeFilter(filters)
-// }
-// function _normalizeFilter(filters: any, path?: string): any {
-//     const result = {} as any
-//     for (const [path, v] of Object.entries(filters)) {
-//         switch (path) {
-//             case FilterOp.And:
-//                 if (!Array.isArray(v)) {
-//                     throw new Error("The '&' (AND) operator must have array type")
-//                 }
-//                 if (!result[FilterOp.And]) {
-//                     result[FilterOp.And] = []
-//                 }
-//                 result[FilterOp.And] = result[FilterOp.And].concat(v.map(f => _normalizeFilter(f)))
-//                 break
-//             case FilterOp.Or:
-//                 if (!Array.isArray(v)) {
-//                     throw new Error("The '|' (OR) operator must have array type")
-//                 }
-//                 if (!result[FilterOp.Or]) {
-//                     result[FilterOp.Or] = []
-//                 }
-//                 result[FilterOp.Or] = result[FilterOp.Or].concat(v.map(f => _normalizeFilter(f)))
-//                 break
-//             default:
-//                 for (const entry of asOperators(v)) {
-//                     switch (entry.op) {
-//                         case FilterOp.And:
-//                             if (!result[FilterOp.And]) {
-//                                 result[FilterOp.And] = []
-//                             }
-//                             result[FilterOp.And] = result[FilterOp.And].concat(
-//                                 entry.value.map((v: any) => _normalizeFilter(v, path))
-//                             )
-//                             break
-//                         case FilterOp.Or:
-//                             if (!result[FilterOp.Or]) {
-//                                 result[FilterOp.Or] = []
-//                             }
-//                             result[FilterOp.Or] = result[FilterOp.Or].concat(
-//                                 entry.value.map((v: any) => _normalizeFilter(v, path))
-//                             )
-//                             break
-//                         default:
-//                             if (!result[FilterOp.And]) {
-//                                 result[FilterOp.And] = []
-//                             }
-//                             result[FilterOp.And].push({ path, ...entry })
-//                     }
-//                 }
-//         }
-//     }
-//     return result
-// }
-function _filterCompile(filters) {
-    let getter;
-    const result = [];
-    for (const [pth, value] of Object.entries(filters)) {
-        switch (pth) {
+/**
+ * @example
+ * ```ts
+ * filterNormalize({id: {">": 0, "<": 10}})
+ * {op: "&", value: [{path: "id", op: ">", value: 0}, {path: "id", op: "<", value: 10}]}
+ * ```
+ */
+function filterNormalize(filters) {
+    return _normalizeFilter(filters);
+}
+function _normalizeFilter(filters, parent) {
+    const norm = flattenDeep(Object.entries(filters).map(([path, value]) => {
+        switch (path) {
             case "&" /* FilterOp.And */:
                 if (!Array.isArray(value)) {
-                    throw new Error("Root '&' (AND) operator must have array type");
+                    throw new Error(`Operator AND (${"&" /* FilterOp.And */}) must have array type`);
                 }
-                result.splice(result.length, 0, ...value.map((_filterCompile)));
-                break;
+                return { op: "&" /* FilterOp.And */, value: value.map(v => _normalizeFilter(v, parent)) };
             case "|" /* FilterOp.Or */:
                 if (!Array.isArray(value)) {
-                    throw new Error("Root '|' (OR) operator must have array type");
+                    throw new Error(`Operator OR (${"|" /* FilterOp.Or */}) must have array type`);
                 }
-                result.push(or_(value.map((_filterCompile))));
-                break;
+                return { op: "|" /* FilterOp.Or */, value: value.map(v => _normalizeFilter(v, parent)) };
+            // TODO: check all filter, and if not found filter key, taht object maybne not a filter
             default:
-                getter = pathGetterCompile(pth);
                 if (isPlainObject(value)) {
-                    result.push(and_(Object.entries(value).map(([op, opv]) => filterCompileOp(getter, op, opv))));
+                    return _normalizeFilter(value, path);
+                }
+                if (parent != null) {
+                    return { path: parent, op: path, value };
                 }
                 else {
-                    result.push(filterCompileOp(getter, "==" /* FilterOp.Eq */, value));
+                    return { path, op: "===" /* FilterOp.EqStrict */, value };
                 }
-                break;
         }
+    }));
+    if (norm.length === 0) {
+        return norm;
+    }
+    else if (norm.length === 1) {
+        return norm[0];
+    }
+    else {
+        return { op: "&" /* FilterOp.And */, value: norm };
+    }
+}
+function _filterCompile(filters) {
+    const pathCache = {};
+    const getPath = (pth) => {
+        if (pathCache[pth] != null) {
+            return pathCache[pth];
+        }
+        return (pathCache[pth] = pathGetterCompile(pth));
+    };
+    const normalized = filterNormalize(filters);
+    return _filterCompileNorm(normalized, getPath);
+}
+function _filterCompileNorm(filter, getPath) {
+    switch (filter.op) {
+        case "&" /* FilterOp.And */:
+            return and_(filter.value.map(v => _filterCompileNorm(v, getPath)));
+        case "|" /* FilterOp.Or */:
+            return or_(filter.value.map(v => _filterCompileNorm(v, getPath)));
+        default:
+            return _filterComplileNormPath(getPath(filter.path), filter.op, filter.value, getPath);
     }
-    return and_(result);
 }
-function filterCompileOp(getter, op, value) {
+function _filterComplileNormPath(getter, op, value, getPath) {
     let lower;
     let regex;
     switch (op) {
+        case "&" /* FilterOp.And */:
+            return and_(value.map(v => _filterCompileNorm(v, getPath)));
+        case "|" /* FilterOp.Or */:
+            return or_(value.map(v => _filterCompileNorm(v, getPath)));
         case "==" /* FilterOp.Eq */:
             // eslint-disable-next-line eqeqeq
             return matcher(getter, v => v == value);
@@ -231,30 +290,6 @@ function filterCompileOp(getter, op, value) {
         case "~*" /* FilterOp.RegexpInsesitive */:
             regex = value instanceof RegExp ? value : new RegExp(value, "msvi");
             return matcher(getter, v => regex.test(v));
-        case "&" /* FilterOp.And */:
-            if (!Array.isArray(value)) {
-                throw new Error("Root '&' (AND) operator must have array type");
-            }
-            return and_(flattenDeep(value.map(v => {
-                if (isPlainObject(v)) {
-                    return Object.entries(v).map(([op, opv]) => filterCompileOp(getter, op, opv));
-                }
-                else {
-                    return filterCompileOp(getter, "==" /* FilterOp.Eq */, v);
-                }
-            })));
-        case "|" /* FilterOp.Or */:
-            if (!Array.isArray(value)) {
-                throw new Error("Root '|' (OR) operator must have array type");
-            }
-            return or_(flattenDeep(value.map(v => {
-                if (isPlainObject(v)) {
-                    return Object.entries(v).map(([op, opv]) => filterCompileOp(getter, op, opv));
-                }
-                else {
-                    return filterCompileOp(getter, "==" /* FilterOp.Eq */, v);
-                }
-            })));
     }
     throw new Error(`Unexpected operator: ${op}`);
 }
@@ -265,6 +300,9 @@ function and_(fns) {
     if (fns.length === 0) {
         return _ => true;
     }
+    if (fns.length === 1) {
+        return fns[0];
+    }
     return item => {
         for (const fn of fns) {
             if (!fn(item)) {
@@ -278,6 +316,9 @@ function or_(fns) {
     if (fns.length === 0) {
         return _ => true;
     }
+    if (fns.length === 1) {
+        return fns[0];
+    }
     return item => {
         for (const fn of fns) {
             if (fn(item)) {
@@ -308,6 +349,22 @@ function filterMerge(...filters) {
     }
     return result;
 }
+class FilterProperty extends QueryProperty {
+    merge(a, b) {
+        return filterMerge(a, b);
+    }
+    norm(a) {
+        return filterNormalize(a);
+    }
+}
+class FilterPropertySet extends QueryPropertySet {
+    newProperty() {
+        return new FilterProperty(undefined);
+    }
+    merge(...args) {
+        return filterMerge(...args);
+    }
+}
 
 function groupBy(grouper) {
     return grouperCompile(grouper);
@@ -318,6 +375,7 @@ function grouperCompile(grouper) {
 function grouperMerge(...groupers) {
     return undefined;
 }
+function grouperNormalize(grouper) { }
 // import { Primitive } from "utility-types"
 // import { Eval, Flatten } from "@ngutil/common"
 // import { type Model } from "./query"
@@ -375,6 +433,22 @@ function grouperMerge(...groupers) {
 // ): Grouper<T, F> | undefined {
 //     return undefined
 // }
+class GrouperProperty extends QueryProperty {
+    norm(a) {
+        return grouperNormalize;
+    }
+    merge(a, b) {
+        return grouperMerge(a, b);
+    }
+}
+class GrouperPropertySet extends QueryPropertySet {
+    newProperty() {
+        return new GrouperProperty(undefined);
+    }
+    merge(...args) {
+        return grouperMerge(...args);
+    }
+}
 
 /**
  * @example
@@ -398,22 +472,39 @@ function sortBy(sorters) {
  * ```
  */
 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}`);
+    return _sorterNormalize(sorters);
+}
+function _sorterNormalize(sorters) {
+    if (!Array.isArray(sorters)) {
+        sorters = [sorters];
+    }
+    return flattenDeep(sorters.map((s) => {
+        if (isPlainObject(s)) {
+            // entry is normalized
+            if (s["path"] != null && s["isAsc"] != null && s["emptyFirst"] != null) {
+                return s;
+            }
         }
-    })));
+        return Object.entries(s).map(([k, v]) => {
+            if (v == null) {
+                return { path: k, remove: true };
+            }
+            else 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) {
@@ -524,34 +615,49 @@ function sorterMerge(...sorters) {
             continue;
         }
         for (const sentry of sorter) {
-            for (const [k, v] of Object.entries(sentry)) {
-                const existing = result.find((value) => value[k] != null);
-                if (existing) {
-                    if (v == null) {
-                        delete existing[k];
-                        if (Object.keys(existing).length === 0) {
-                            result.splice(result.indexOf(existing), 1);
-                        }
-                    }
-                    else {
-                        ;
-                        existing[k] = deepClone(v);
-                    }
+            const existingIndex = result.findIndex(value => value.path === sentry.path);
+            if (existingIndex > -1) {
+                if (sentry.remove) {
+                    result.splice(existingIndex, 1);
                 }
-                else if (v != null) {
-                    result.push({ [k]: deepClone(v) });
+                else {
+                    result[existingIndex] = deepClone(sentry);
                 }
             }
+            else if (!sentry.remove) {
+                result.push(deepClone(sentry));
+            }
         }
     }
+    if (result?.length === 0) {
+        return undefined;
+    }
     return result;
 }
-function sorterFind(sorters, name) {
-    const sorter = sorters.find(v => v[name] != null);
-    if (sorter != null) {
-        return sorter[name];
+class SorterProperty extends QueryProperty {
+    norm(a) {
+        return sorterNormalize(a);
+    }
+    merge(a, b) {
+        return sorterMerge(a, b);
+    }
+}
+class SorterPropertySet extends QueryPropertySet {
+    of(name) {
+        return this.pipe(map(sorters => (sorters == null ? undefined : sorters.find(value => value.path === name))));
+    }
+    isAsc(name) {
+        return this.of(name).pipe(map(v => (v != null ? v.isAsc : undefined)));
+    }
+    isDesc(name) {
+        return this.of(name).pipe(map(v => (v != null ? !v.isAsc : undefined)));
+    }
+    newProperty() {
+        return new SorterProperty(undefined);
+    }
+    merge(...args) {
+        return sorterMerge(...args);
     }
-    return undefined;
 }
 
 function slimBy(slimer) { }
@@ -560,6 +666,22 @@ function slimerCompile(slimer) {
     return item => item;
 }
 function slimerMerge(...slimers) { }
+class SlimerProperty extends QueryProperty {
+    norm(a) {
+        return slimerNormalize(a);
+    }
+    merge(a, b) {
+        return slimerMerge(a, b);
+    }
+}
+class SlimerPropertySet extends QueryPropertySet {
+    newProperty() {
+        return new SlimerProperty(undefined);
+    }
+    merge(...args) {
+        return slimerMerge(...args);
+    }
+}
 
 function sliceMerge(...slices) {
     let result = undefined;
@@ -621,6 +743,19 @@ function sliceEq(a, b) {
 // TODO: sliceConcat(...slices: Slice[]): Slice[]
 // TODO: sliceDiff(slice: Slice): Slice[]
 
+function querySubject(...names) {
+    const filter = new FilterPropertySet(...names);
+    const sorter = new SorterPropertySet(...names);
+    const slimer = new SlimerPropertySet(...names);
+    const grouper = new GrouperPropertySet(...names);
+    const result = combineLatest({ filter, sorter, slimer, grouper }).pipe(shareReplay(1));
+    readonlyProp(result, "filter", filter);
+    readonlyProp(result, "sorter", sorter);
+    readonlyProp(result, "slimer", slimer);
+    readonlyProp(result, "grouper", grouper);
+    return result;
+}
+
 const INPUT = Symbol("INPUT");
 function queryExecutor(query, previous) {
     const executors = {
@@ -896,150 +1031,35 @@ class MemoryStore extends CollectionStore {
     }
 }
 
-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);
-        // TODO: normalized sorter
-        this.merged$ = mergedProperty(sorterMerge, this.normal, this.forced);
-    }
-    of(name) {
-        return this.merged$.pipe(map((sorters) => (sorters == null ? undefined : sorterFind(sorters, name))));
-    }
-    directionOf(name) {
-        return this.of(name).pipe(map(value => {
-            if (value == null) {
-                return undefined;
-            }
-            else if (typeof value === "string") {
-                return value;
-            }
-            else {
-                return value.dir;
-            }
-        }));
-    }
-    isSet(name) {
-        return this.directionOf(name).pipe(map(v => v != null));
-    }
-    isAsc(name) {
-        return this.directionOf(name).pipe(map(v => v === "asc" /* SortDirection.Asc */));
-    }
-    isDesc(name) {
-        return this.directionOf(name).pipe(map(v => v === "desc" /* SortDirection.Desc */));
-    }
-}
-
-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) {
+    #query;
+    constructor(provider, store = new MemoryStore(), query$ = querySubject("normal", "forced")) {
         super();
         this.provider = provider;
+        this.store = store;
+        this.query$ = query$;
         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 BehaviorSubject(undefined);
-        this.query$ = combineLatest({ base: this.#queryBase, reload: this.#reload }).pipe(tap(() => this.#setBusy(true)), 
+        this.#query = combineLatest({
+            query: this.query$,
+            reload: this.#reload
+        }).pipe(tap(() => this.#setBusy(true)), 
         // TODO: maybe silent reset or prevent items$ chenges
         // TODO: alternative solution use cacheId, and query item from store with this cacheId
-        switchMap(({ base }) => this.store.clear().pipe(map(() => base))), switchMap(queryBase => this.slice$.pipe(tap(() => this.#setBusy(true)), map(slice => {
-            return { ...queryBase, slice };
+        switchMap(({ query }) => this.store.clear().pipe(map(() => query))), switchMap(query => this.slice$.pipe(tap(() => this.#setBusy(true)), map(slice => {
+            return { ...query, slice };
         }))), shareReplay(1));
-        this.items$ = this.query$.pipe(tap(() => this.#setBusy(true)), debounceTime(DEBOUNCE_TIME), switchMap(query => this.store.hasSlice(query.slice).pipe(switchMap(hasSlice => {
+        this.items$ = this.#query.pipe(tap(() => this.#setBusy(true)), debounceTime(DEBOUNCE_TIME), 
+        // tap(query => console.log(query)),
+        switchMap(query => this.store.hasSlice(query.slice).pipe(take(1), switchMap(hasSlice => {
             if (hasSlice) {
-                return this.store.getSlice(query.slice);
+                return this.store.getSlice(query.slice).pipe(take(1));
             }
             else {
                 return this.provider.queryList(query).pipe(switchMap(result => {
@@ -1051,10 +1071,6 @@ class DataSource extends DataSource$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);
@@ -1067,19 +1083,25 @@ class DataSource extends DataSource$1 {
         this.#reload.next();
     }
     getItem(ref) {
+        return this.watchItem(ref).pipe(take(1));
+    }
+    watchItem(ref) {
         const refn = this.provider.meta.normalizeRef(ref);
         return this.#storeFirst(query => this.store.get(refn), query => this.provider.queryItem(refn, query));
     }
     getItemPosition(ref) {
+        return this.watchItemPosition(ref).pipe(take(1));
+    }
+    watchItemPosition(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));
+        return this.#query.pipe(take(1), switchMap(query => this.provider.queryItem(refn, query).pipe(take(1))), switchMap(item => item != null ? this.store.updateOrInsert(refn, item, insertPosition).pipe(map(() => item)) : of(item)));
     }
     #storeFirst(storeFn, selfFn) {
-        return this.query$.pipe(take(1), switchMap(query => storeFn(query).pipe(switchMap(result => (result == null ? selfFn(query) : of(result))))));
+        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) {
@@ -1152,25 +1174,22 @@ class DataSourceProxy extends DataSource$1 {
         }))
             .subscribe(this.#value);
     }
-    get value() {
-        return this.#valueSig();
-    }
     #valueSub;
     #value;
-    #valueSig;
-    set filter(value) {
+    set forcedFilterInput(value) {
+        // this.query.filter.forced.update(value)
         this.#filter.next(value);
     }
     #filter;
-    set sorter(value) {
+    set forcedSorterInput(value) {
         this.#sorter.next(value);
     }
     #sorter;
-    set grouper(value) {
+    set forcedGrouperInput(value) {
         this.#grouper.next(value);
     }
     #grouper;
-    set slimer(value) {
+    set forcedSlimerInput(value) {
         this.#slimer.next(value);
     }
     #slimer;
@@ -1179,7 +1198,7 @@ class DataSourceProxy extends DataSource$1 {
         super();
         this.#value = new ReplaySubject(1);
         this.value$ = this.#value.pipe(takeUntilDestroyed());
-        this.#valueSig = toSignal(this.value$);
+        this.query$ = this.value$.pipe(map(value => value.query$), shareReplay(1));
         this.items$ = this.value$.pipe(switchMap(value => value.items$), share());
         this.busy$ = this.value$.pipe(switchMap(value => value.busy$), share());
         this.isBusy = toSignal(this.busy$, { rejectErrors: true, initialValue: false });
@@ -1192,17 +1211,17 @@ class DataSourceProxy extends DataSource$1 {
         if (busy != null) {
             this.#subs.add(busy.connect(this.busy$).subscribe());
         }
-        this.#subs.add(combineLatest({ src: this.value$, filter: this.#filter }).subscribe(({ src, filter }) => {
-            src.filter.forced.set(filter);
+        this.#subs.add(combineLatest({ query: this.query$, filter: this.#filter }).subscribe(({ query, filter }) => {
+            query.filter.forced.set(filter);
         }));
-        this.#subs.add(combineLatest({ src: this.value$, sorter: this.#sorter }).subscribe(({ src, sorter }) => {
-            src.sorter.forced.set(sorter);
+        this.#subs.add(combineLatest({ query: this.query$, sorter: this.#sorter }).subscribe(({ query, sorter }) => {
+            query.sorter.forced.set(sorter);
         }));
-        this.#subs.add(combineLatest({ src: this.value$, grouper: this.#grouper }).subscribe(({ src, grouper }) => {
-            src.grouper.forced.set(grouper);
+        this.#subs.add(combineLatest({ query: this.query$, grouper: this.#grouper }).subscribe(({ query, grouper }) => {
+            query.grouper.forced.set(grouper);
         }));
-        this.#subs.add(combineLatest({ src: this.value$, slimer: this.#slimer }).subscribe(({ src, slimer }) => {
-            src.slimer.forced.set(slimer);
+        this.#subs.add(combineLatest({ query: this.query$, slimer: this.#slimer }).subscribe(({ query, slimer }) => {
+            query.slimer.forced.set(slimer);
         }));
     }
     #cvSubs;
@@ -1222,7 +1241,7 @@ class DataSourceProxy extends DataSource$1 {
         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: { value: ["nuDataSource", "value"], filter: "filter", sorter: "sorter", grouper: "grouper", slimer: "slimer" }, exportAs: ["nuDataSource"], usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.6", type: DataSourceProxy, isStandalone: true, selector: "[nuDataSource]", inputs: { value: ["nuDataSource", "value"], forcedFilterInput: "forcedFilterInput", forcedSorterInput: "forcedSorterInput", forcedGrouperInput: "forcedGrouperInput", forcedSlimerInput: "forcedSlimerInput" }, exportAs: ["nuDataSource"], usesInheritance: true, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxy, decorators: [{
             type: Directive,
@@ -1236,13 +1255,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImpor
                 }] }], propDecorators: { value: [{
                 type: Input,
                 args: [{ required: true, alias: "nuDataSource" }]
-            }], filter: [{
+            }], forcedFilterInput: [{
                 type: Input
-            }], sorter: [{
+            }], forcedSorterInput: [{
                 type: Input
-            }], grouper: [{
+            }], forcedGrouperInput: [{
                 type: Input
-            }], slimer: [{
+            }], forcedSlimerInput: [{
                 type: Input
             }] } });
 function coerceDataSource(value) {
@@ -1318,5 +1337,5 @@ class ObservableProvider extends LocalProvider {
  * Generated bundle index. Do not edit.
  */
 
-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, sorterFind, sorterMerge };
+export { ArrayProvider, CollectionStore, DataProvider, DataSource, DataSourceProxy, LocalProvider, MemoryStore, ModelMeta, ModelRefByIndex, ModelRefByKey, ModelRefNorm, ObservableProvider, UnknownMeta, filterBy, filterMerge, filterNormalize, groupBy, grouperMerge, pathGetterCompile, queryExecutor, querySubject, sliceApply, sliceClamp, sliceEq, sliceInsert, sliceMerge, sliceToPages, slimBy, slimerMerge, sortBy, sorterMerge, sorterNormalize };
 //# sourceMappingURL=ngutil-data.mjs.map