@ngutil/data 0.0.19 → 0.0.24

package/fesm2022/ngutil-data.mjs

@@ -1,11 +1,10 @@
-import { flattenDepth, isEqual, intersection, flattenDeep } from 'lodash';
-import * as i1 from '@ngutil/common';
-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';
-import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
+import { Directive, Input, inject, input, NgModule } from '@angular/core';
+import { DataSource as DataSource$1 } from '@angular/cdk/collections';
+import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
+import { BehaviorSubject, Observable, combineLatest, map, shareReplay, take, of, ReplaySubject, switchMap, distinctUntilChanged, tap, debounceTime, finalize, Subject, takeUntil, throwError } from 'rxjs';
+import { deepClone, deepFreeze, isPlainObject, toSorted, Busy } from '@ngutil/common';
+import { flattenDepth, isEqual, intersection, flattenDeep } from 'lodash';
 
 function pathGetterCompile(path) {
     if (!path || path.length === 0) {
@@ -725,8 +724,11 @@ function sliceInsert(slice, array, newItems) {
     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));
+    if (!isNaN(slice.end) && isFinite(slice.end)) {
+        result.length = slice.end;
+        result = result.concat(array.slice(slice.end));
+    }
+    return result;
 }
 function sliceClamp(slice, constraint) {
     return {
@@ -829,129 +831,6 @@ function compileExec(input, prev, compiler) {
     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 {
 }
 
@@ -1133,6 +1012,21 @@ class DataSource extends DataSource$1 {
     }
 }
 
+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);
+    }
+}
+
 /**
  * @example
  * ```html
@@ -1164,66 +1058,20 @@ class DataSource extends DataSource$1 {
  * ```
  */
 class DataSourceProxy extends DataSource$1 {
-    set value(value) {
-        this.#valueSub?.unsubscribe();
-        this.#valueSub = coerceDataSource(value)
-            .pipe(tap(v => {
-            if (v == null) {
-                throw new Error("Missing DataSource");
-            }
-        }))
-            .subscribe(this.#value);
-    }
-    #valueSub;
-    #value;
-    set forcedFilterInput(value) {
-        // this.query.filter.forced.update(value)
-        this.#filter.next(value);
-    }
-    #filter;
-    set forcedSorterInput(value) {
-        this.#sorter.next(value);
-    }
-    #sorter;
-    set forcedGrouperInput(value) {
-        this.#grouper.next(value);
-    }
-    #grouper;
-    set forcedSlimerInput(value) {
-        this.#slimer.next(value);
-    }
-    #slimer;
-    #subs;
-    constructor(busy) {
-        super();
+    constructor() {
+        super(...arguments);
         this.#value = new ReplaySubject(1);
         this.value$ = this.#value.pipe(takeUntilDestroyed());
         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 });
-        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.items$ = this.value$.pipe(switchMap(value => value.items$), shareReplay(1));
         this.#cvSubs = new Map();
-        if (busy != null) {
-            this.#subs.add(busy.connect(this.busy$).subscribe());
-        }
-        this.#subs.add(combineLatest({ query: this.query$, filter: this.#filter }).subscribe(({ query, filter }) => {
-            query.filter.forced.set(filter);
-        }));
-        this.#subs.add(combineLatest({ query: this.query$, sorter: this.#sorter }).subscribe(({ query, sorter }) => {
-            query.sorter.forced.set(sorter);
-        }));
-        this.#subs.add(combineLatest({ query: this.query$, grouper: this.#grouper }).subscribe(({ query, grouper }) => {
-            query.grouper.forced.set(grouper);
-        }));
-        this.#subs.add(combineLatest({ query: this.query$, slimer: this.#slimer }).subscribe(({ query, slimer }) => {
-            query.slimer.forced.set(slimer);
-        }));
     }
+    set value(value) {
+        this.#valueSub?.unsubscribe();
+        this.#valueSub = coerceDataSource(value).subscribe(this.#value);
+    }
+    #valueSub;
+    #value;
     #cvSubs;
     connect(collectionViewer) {
         const until = new Subject();
@@ -1238,10 +1086,9 @@ class DataSourceProxy extends DataSource$1 {
     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: { value: ["nuDataSource", "value"], forcedFilterInput: "forcedFilterInput", forcedSorterInput: "forcedSorterInput", forcedGrouperInput: "forcedGrouperInput", forcedSlimerInput: "forcedSlimerInput" }, exportAs: ["nuDataSource"], usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxy, deps: null, 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"] }, exportAs: ["nuDataSource"], usesInheritance: true, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxy, decorators: [{
             type: Directive,
@@ -1250,20 +1097,109 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImpor
                     selector: "[nuDataSource]",
                     exportAs: "nuDataSource"
                 }]
-        }], ctorParameters: () => [{ type: i1.Busy, decorators: [{
-                    type: Optional
-                }] }], propDecorators: { value: [{
+        }], propDecorators: { value: [{
                 type: Input,
                 args: [{ required: true, alias: "nuDataSource" }]
-            }], forcedFilterInput: [{
-                type: Input
-            }], forcedSorterInput: [{
-                type: Input
-            }], forcedGrouperInput: [{
-                type: Input
-            }], forcedSlimerInput: [{
-                type: Input
             }] } });
+class DataSourceProxyFilter {
+    #proxy;
+    constructor() {
+        this.#proxy = inject(DataSourceProxy);
+        this.filter = input.required();
+        this.filter$ = toObservable(this.filter);
+        combineLatest({ query: this.#proxy.query$, filter: this.filter$ })
+            .pipe(takeUntilDestroyed())
+            .subscribe(({ query, filter }) => query.filter.forced.set(filter));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxyFilter, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "17.3.6", type: DataSourceProxyFilter, isStandalone: true, selector: "[nuDataSource][filter]", inputs: { filter: { classPropertyName: "filter", publicName: "filter", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxyFilter, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[nuDataSource][filter]"
+                }]
+        }], ctorParameters: () => [] });
+class DataSourceProxySorter {
+    #proxy;
+    constructor() {
+        this.#proxy = inject(DataSourceProxy);
+        this.sorter = input.required();
+        this.sorter$ = toObservable(this.sorter);
+        combineLatest({ query: this.#proxy.query$, sorter: this.sorter$ })
+            .pipe(takeUntilDestroyed())
+            .subscribe(({ query, sorter }) => query.sorter.forced.set(sorter));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxySorter, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "17.3.6", type: DataSourceProxySorter, isStandalone: true, selector: "[nuDataSource][sorter]", inputs: { sorter: { classPropertyName: "sorter", publicName: "sorter", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxySorter, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[nuDataSource][sorter]"
+                }]
+        }], ctorParameters: () => [] });
+class DataSourceProxySlimer {
+    #proxy;
+    constructor() {
+        this.#proxy = inject(DataSourceProxy);
+        this.slimer = input.required();
+        this.slimer$ = toObservable(this.slimer);
+        combineLatest({ query: this.#proxy.query$, slimer: this.slimer$ })
+            .pipe(takeUntilDestroyed())
+            .subscribe(({ query, slimer }) => query.slimer.forced.set(slimer));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxySlimer, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "17.3.6", type: DataSourceProxySlimer, isStandalone: true, selector: "[nuDataSource][slimer]", inputs: { slimer: { classPropertyName: "slimer", publicName: "slimer", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxySlimer, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[nuDataSource][slimer]"
+                }]
+        }], ctorParameters: () => [] });
+class DataSourceProxyGrouper {
+    #proxy;
+    constructor() {
+        this.#proxy = inject(DataSourceProxy);
+        this.grouper = input.required();
+        this.grouper$ = toObservable(this.grouper);
+        combineLatest({ query: this.#proxy.query$, grouper: this.grouper$ })
+            .pipe(takeUntilDestroyed())
+            .subscribe(({ query, grouper }) => query.grouper.forced.set(grouper));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxyGrouper, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "17.3.6", type: DataSourceProxyGrouper, isStandalone: true, selector: "[nuDataSource][grouper]", inputs: { grouper: { classPropertyName: "grouper", publicName: "grouper", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxyGrouper, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[nuDataSource][grouper]"
+                }]
+        }], ctorParameters: () => [] });
+class DataSourceProxyBusy {
+    #proxy;
+    #busy;
+    constructor() {
+        this.#proxy = inject(DataSourceProxy);
+        this.#busy = inject(Busy);
+        this.busy$ = this.#proxy.value$.pipe(switchMap(value => value.busy$), shareReplay(1));
+        this.#busy.connect(this.busy$).pipe(takeUntilDestroyed()).subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxyBusy, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.6", type: DataSourceProxyBusy, isStandalone: true, selector: "[nuDataSource][nuBusy]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceProxyBusy, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: "[nuDataSource][nuBusy]"
+                }]
+        }], ctorParameters: () => [] });
 function coerceDataSource(value) {
     if (value instanceof DataSourceProxy) {
         return value.value$;
@@ -1279,18 +1215,126 @@ function coerceDataSource(value) {
     }
 }
 
-class DataProvider {
-    /**
-     * Froce Slice boundaries, useful in array, or obeservable providers
-     */
-    clampSlice(slice) {
-        return of(slice);
+class ModelMeta {
+    static coerce(value) {
+        if (value instanceof ModelMeta) {
+            return value;
+        }
+        else {
+            return new ModelMeta(value);
+        }
     }
-    /**
-     * @returns New data source instance
-     */
-    toDataSource(store) {
-        return new DataSource(this, store);
+    #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 });
     }
 }
 
@@ -1333,9 +1377,46 @@ class ObservableProvider extends LocalProvider {
     }
 }
 
+class DataSourceModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.6", ngImport: i0, type: DataSourceModule, imports: [DataSourceProxy,
+            DataSourceProxyBusy,
+            DataSourceProxyFilter,
+            DataSourceProxyGrouper,
+            DataSourceProxySlimer,
+            DataSourceProxySorter], exports: [DataSourceProxy,
+            DataSourceProxyBusy,
+            DataSourceProxyFilter,
+            DataSourceProxyGrouper,
+            DataSourceProxySlimer,
+            DataSourceProxySorter] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.6", ngImport: i0, type: DataSourceModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        DataSourceProxy,
+                        DataSourceProxyBusy,
+                        DataSourceProxyFilter,
+                        DataSourceProxyGrouper,
+                        DataSourceProxySlimer,
+                        DataSourceProxySorter
+                    ],
+                    exports: [
+                        DataSourceProxy,
+                        DataSourceProxyBusy,
+                        DataSourceProxyFilter,
+                        DataSourceProxyGrouper,
+                        DataSourceProxySlimer,
+                        DataSourceProxySorter
+                    ]
+                }]
+        }] });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-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 };
+export { ArrayProvider, CollectionStore, DataProvider, DataSource, DataSourceModule, DataSourceProxy, DataSourceProxyBusy, DataSourceProxyFilter, DataSourceProxyGrouper, DataSourceProxySlimer, DataSourceProxySorter, 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