@ngutil/data 0.0.102 → 0.0.104

package/index.d.ts

@@ -1,12 +1,589 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./source/proxy.directive";
-export * from "./model";
-export * from "./provider";
-export * from "./query";
-export * from "./source";
-export * from "./store";
-export declare class DataSourceModule {
+import * as i0 from '@angular/core';
+import { TrackByFunction, OnDestroy } from '@angular/core';
+import * as _ngutil_data from '@ngutil/data';
+import { Primitive } from 'utility-types';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { Flatten, Primitive as Primitive$1, DeepReadonly, ConnectProtocol } from '@ngutil/common';
+import { DataSource as DataSource$1, CollectionViewer, ListRange } from '@angular/cdk/collections';
+
+type Model = {
+    [key: string]: any;
+};
+type ModelRef = {
+    key?: Primitive | Array<Primitive>;
+    index?: number;
+};
+type ModelRefFilter<T> = (item: T, index: number) => boolean;
+interface ModelMetaProps<T extends Model> {
+    readonly keys: readonly string[];
+    readonly trackBy?: TrackByFunction<T>;
+}
+type ModelMetaInput<T extends Model> = ModelMeta<T> | ModelMetaProps<T>;
+type TrackedModel<T extends Model> = {
+    index: number;
+    model: T;
+};
+declare class ModelMeta<T extends Model> implements ModelMetaProps<T> {
+    #private;
+    static coerce<M extends Model>(value: ModelMetaInput<M>): ModelMeta<M>;
+    readonly keys: readonly string[];
+    readonly trackBy: TrackByFunction<T>;
+    constructor(props: ModelMetaProps<T>);
+    isEqual(a: T, b: T): boolean;
+    isEqualByTrack(a: TrackedModel<T>, b: TrackedModel<T>): boolean;
+    isEqualByKey(a: T, b: T): boolean;
+    normalizeRef(ref: ModelRef | ModelRefNorm): ModelRefNorm;
+}
+declare abstract class ModelRefNorm {
+    #private;
+    readonly key?: readonly Primitive[];
+    readonly index?: number;
+    toFilter(): ModelRefFilter<any>;
+    protected abstract _asFilter(): ModelRefFilter<any>;
+}
+declare class ModelRefByKey extends ModelRefNorm {
+    #private;
+    readonly key: readonly Primitive[];
+    constructor(key: readonly Primitive[], keys: readonly string[]);
+    protected _asFilter(): ModelRefFilter<any>;
+}
+declare class ModelRefByIndex extends ModelRefNorm {
+    readonly index: number;
+    constructor(index: number);
+    protected _asFilter(): ModelRefFilter<any>;
+}
+declare class UnknownMeta<T extends Model> extends ModelMeta<T> {
+    constructor();
+}
+
+type GrouperFn<T = any> = (item: any) => Primitive$1;
+type Grouper<T extends Model, F = Flatten<T>> = any;
+type GrouperNormalized = any;
+declare function groupBy<T extends Model, F = Flatten<T>>(grouper: Grouper<T, F>): GrouperFn<T>;
+declare function grouperMerge<T extends Model, F = Flatten<T>>(...groupers: Array<Grouper<T, F> | undefined | null>): Grouper<T, F> | undefined;
+declare class GrouperProperty<T extends Model> extends QueryProperty<Grouper<T>, GrouperNormalized> {
+    protected norm(a: any): any;
+    protected merge(a?: any, b?: any): any;
+}
+declare class GrouperPropertySet<T extends Model> extends QueryPropertySet<Grouper<T>> {
+    protected newProperty(): GrouperProperty<Model>;
+    protected merge(...args: any[]): any;
+}
+
+/**
+ * @exmaple
+ * ```ts
+ * [
+ *  "field_name",
+ *  {"child_name": ["child_field_name"]},
+ *  {"children": ["children_field_name", {"$type": Article, slimer: ["id", "title"]}]},
+ *  {"$type": Employee, slimer: ["name"]}.
+ *  {"$filter": Filter<T, F>}
+ * ]
+ * ```
+ */
+type Slimer<T extends Model> = any;
+type SlimerNormalized = any;
+declare function slimBy<T extends Model>(slimer: Slimer<T>): void;
+declare function slimerMerge<T extends Model>(...slimers: Slimer<T>): any;
+declare class SlimerProperty<T extends Model> extends QueryProperty<Slimer<T>, SlimerNormalized> {
+    protected norm(a: any): any;
+    protected merge(a?: any, b?: any): any;
+}
+declare class SlimerPropertySet<T extends Model> extends QueryPropertySet<Slimer<T>> {
+    protected newProperty(): SlimerProperty<Model>;
+    protected merge(...args: any[]): any;
+}
+
+type PartialCollection<T> = readonly (T | undefined)[];
+declare abstract class CollectionStore<T extends Model> {
+    /**
+     * Update the given slice, and return all items observable
+     */
+    abstract insertSlice(slice: DeepReadonly<Slice>, items: readonly T[]): Observable<PartialCollection<T>>;
+    /**
+     * @returns `true` when the given slice is available in the cache
+     */
+    abstract hasSlice(slice: DeepReadonly<Slice>): Observable<boolean>;
+    /**
+     * @returns items by the given slice
+     */
+    abstract getSlice(slice: DeepReadonly<Slice>): Observable<PartialCollection<T>>;
+    /**
+     * Get item from collection
+     */
+    abstract get(ref: ModelRefNorm): Observable<T | undefined>;
+    /**
+     * Get index of item in collection, -1 if not found
+     */
+    abstract indexOf(ref: ModelRefNorm): Observable<number>;
+    /**
+     * Update item in collection
+     *
+     * @returns the updated index, or -1 if not found
+     */
+    abstract update(ref: ModelRefNorm, item: T): Observable<number>;
+    /**
+     * Update item if exists in collection, or insert at the given position
+     *
+     * @param position If positon is negative, insert at the end of collection
+     * @returns the updated index or index of where to insert
+     */
+    abstract updateOrInsert(ref: ModelRefNorm, item: T, position?: number): Observable<number>;
+    /**
+     * Remove item from collection
+     * @returns the index of deleted item, -1 if not found
+     */
+    abstract del(ref: ModelRefNorm): Observable<number>;
+    /**
+     * Removes all items from collection
+     */
+    abstract clear(): Observable<void>;
+}
+
+declare class MemoryStore<T extends Model> extends CollectionStore<T> {
+    #private;
+    insertSlice(slice: Slice, items: readonly T[]): Observable<PartialCollection<T>>;
+    hasSlice(slice: Slice): Observable<boolean>;
+    getSlice(slice: Slice): Observable<PartialCollection<T>>;
+    get(ref: ModelRefNorm): Observable<T | undefined>;
+    indexOf(ref: ModelRefNorm): Observable<number>;
+    update(ref: ModelRefNorm, item: T): Observable<number>;
+    updateOrInsert(ref: ModelRefNorm, item: T, position?: number): Observable<number>;
+    del(ref: ModelRefNorm): Observable<number>;
+    clear(): Observable<void>;
+}
+
+declare class DataSource<T extends Model> extends DataSource$1<T | undefined> implements ConnectProtocol {
+    #private;
+    readonly provider: DataProvider<T>;
+    readonly store: CollectionStore<T>;
+    readonly query$: QuerySubject<T, ["normal", "forced"]>;
+    readonly isBusy$: BehaviorSubject<boolean>;
+    readonly total$: BehaviorSubject<number | undefined>;
+    readonly slice$: Observable<Slice>;
+    readonly reset$: Observable<void>;
+    readonly items$: Observable<PartialCollection<T>>;
+    readonly isEmpty$: Observable<boolean>;
+    constructor(provider: DataProvider<T>, store?: CollectionStore<T>, query$?: QuerySubject<T, ["normal", "forced"]>);
+    setSlice(slice: Slice): this;
+    setFilter(filter: Partial<Record<"normal" | "forced", Filter<T>>>): this;
+    updateFilter(filter: Partial<Record<"normal" | "forced", Filter<T>>>): this;
+    all(): this;
+    reload(): void;
+    getItem(ref: ModelRef): Observable<T | undefined>;
+    watchItem(ref: ModelRef): Observable<T | undefined>;
+    getItemPosition(ref: ModelRef): Observable<number | undefined>;
+    watchItemPosition(ref: ModelRef): Observable<number | undefined>;
+    realodItem(ref: ModelRef, insertPosition?: number): Observable<T | undefined>;
+    connect(collectionViewer: CollectionViewer): Observable<PartialCollection<T>>;
+    disconnect(collectionViewer: CollectionViewer): void;
+}
+
+declare abstract class DataProvider<T extends Model> {
+    /**
+     * `true` when the provider is making async requests
+     */
+    abstract readonly isAsync: boolean;
+    /**
+     * Metadata of model
+     */
+    abstract readonly meta: ModelMeta<T>;
+    /**
+     * Emit event when data is changed
+     */
+    get changed$(): Observable<any>;
+    protected _changed: Observable<any>;
+    /**
+     * Query items by the given request
+     */
+    abstract queryList(request: QueryWithSlice<T>): Observable<QueryResult<T>>;
+    /**
+     * Query exactly one item by the given request
+     */
+    abstract queryItem(ref: ModelRefNorm, request?: QueryWithSlice<T>): Observable<T | undefined>;
+    /**
+     * Query item position in the list that matching by the given request
+     */
+    abstract queryPosition(ref: ModelRefNorm, request: QueryWithSlice<T>): Observable<number | undefined>;
+    /**
+     * Froce Slice boundaries, useful in array, or obeservable providers
+     */
+    clampSlice(slice: Slice): Observable<Slice>;
+    filterNormalize(filter: any): FilterNormalized | undefined;
+    filterMerge(...filters: any[]): FilterNormalized | undefined;
+    sorterNormalize(sorter: any): SorterNormalized;
+    sorterMerge(...sorters: any[]): SorterNormalized | undefined;
+    grouperNormalize(grouper: any): GrouperNormalized;
+    grouperMerge(...groupers: any[]): GrouperNormalized | undefined;
+    slimerNormalize(slimer: any): SlimerNormalized;
+    slimerMerge(...slimers: any[]): SlimerNormalized | undefined;
+    /**
+     * @returns New data source instance
+     */
+    toDataSource(store?: CollectionStore<T>): DataSource<T>;
+}
+
+declare abstract class LocalProvider<T extends Model> extends DataProvider<T> {
+    #private;
+    readonly isAsync = false;
+    readonly meta: ModelMeta<T>;
+    abstract readonly items$: Observable<readonly T[]>;
+    constructor(meta: ModelMetaInput<T>);
+    executor(request: QueryWithSlice<T>): QueryExecutor<T>;
+    queryList(request: QueryWithSlice<T>): Observable<QueryResult<T>>;
+    queryItem(ref: ModelRefNorm, request?: QueryWithSlice<T>): Observable<T | undefined>;
+    queryPosition(ref: ModelRefNorm, request: QueryWithSlice<T>): Observable<number | undefined>;
+    clampSlice(slice: Slice): Observable<Slice>;
+}
+
+declare class ArrayProvider<T extends Model> extends LocalProvider<T> {
+    readonly items$: Observable<readonly T[]>;
+    constructor(meta: ModelMetaInput<T>, items: readonly T[]);
+}
+
+declare class ObservableProvider<T extends Model> extends LocalProvider<T> {
+    readonly items$: Observable<readonly T[]>;
+    constructor(meta: ModelMetaInput<T>, src: Observable<readonly T[]>);
+}
+
+declare abstract class QueryProperty<I, O> extends BehaviorSubject<O | undefined> {
+    #private;
+    protected readonly provider: DataProvider<any>;
+    constructor(provider: DataProvider<any>);
+    set(value?: I | O): void;
+    update(value?: I | O): void;
+    del(): void;
+    /**
+     * Merge values and emit when changed (dont change original values)
+     */
+    protected abstract merge(a?: O, b?: O): O | undefined;
+    protected abstract norm(a: I | O): O | undefined;
+}
+declare abstract class QueryPropertySet<O> extends Observable<O> {
+    #private;
+    protected readonly provider: DataProvider<any>;
+    constructor(provider: DataProvider<any>, ...names: string[]);
+    protected abstract newProperty(): QueryProperty<any, any>;
+    protected abstract merge(...args: any[]): any | undefined;
+}
+type QueryPropertySetOf<T, P, N extends string[]> = T & {
+    [K in N[number]]: P;
+};
+
+declare enum FilterOp {
+    Eq = "==",
+    EqStrict = "===",
+    EqInsesitive = "==*",
+    Neq = "!=",
+    NeqStrict = "!==",
+    NeqInsesitive = "!=*",
+    Gt = ">",
+    GtInsesitive = ">*",
+    Gte = ">=",
+    GteInsesitive = ">=*",
+    Lt = "<",
+    LtInsesitive = "<*",
+    Lte = "<=",
+    LteInsesitive = "<=*",
+    Contains = "%",
+    ContainsInsesitive = "%*",
+    StartsWith = "^",
+    StartsWithInsesitive = "^*",
+    EndsWith = "$",
+    EndsWithInsesitive = "$*",
+    Similarity = "**",
+    Regexp = "~",
+    RegexpInsesitive = "~*",
+    Or = "|",
+    And = "&",
+    Not = "!"
+}
+type FilterCustom<T = any> = {
+    custom: string;
+    matcher?: FilterCustomMatcher<T>;
+};
+type FilterCustomMatcher<T = any> = (item: T | null | undefined, value: any) => boolean;
+type FilterOpMap = Record<string, FilterOp | FilterCustom>;
+type Filter<T extends Model> = {
+    [key: string]: any;
+};
+type FilterFn<T = any> = (item: T) => boolean;
+/**
+ * @example
+ * ```ts
+ * items.filter(filterBy({id: 42}))
+ * ```
+ */
+declare function filterBy<T extends Model>(filters: Filter<T>, opmap?: FilterOpMap): FilterFn<T>;
+type NormPath = {
+    path: string;
+    op: Exclude<FilterOp, FilterOp.Or | FilterOp.And | FilterOp.Not>;
+    value: any;
+};
+type NormOr = {
+    op: FilterOp.Or;
+    value: Array<NormEntry>;
+};
+type NormAnd = {
+    op: FilterOp.And;
+    value: Array<NormEntry>;
+};
+type NormNot = {
+    op: FilterOp.Not;
+    value: Array<NormEntry>;
+};
+type NormCustom = {
+    path: string;
+    op: FilterCustom;
+    value: any;
+};
+type NormEmpty = Record<string, never>;
+type NormEntry = NormPath | NormOr | NormAnd | NormNot | NormCustom | NormEmpty;
+type FilterNormalized = NormEntry;
+/**
+ * @example
+ * ```ts
+ * filterNormalize({id: {">": 0, "<": 10}})
+ * {op: "&", value: [{path: "id", op: ">", value: 0}, {path: "id", op: "<", value: 10}]}
+ * ```
+ */
+declare function filterNormalize<T extends Model>(filters: Filter<T> | null | undefined, opmap?: FilterOpMap): FilterNormalized | undefined;
+declare function filterIsNormnalized(filters: any): filters is FilterNormalized;
+declare function filterMerge(...filters: Array<FilterNormalized | null | undefined>): any | undefined;
+declare class FilterProperty<T extends Model> extends QueryProperty<Filter<T>, FilterNormalized> {
+    protected merge(a?: FilterNormalized | undefined, b?: FilterNormalized | undefined): FilterNormalized | undefined;
+    protected norm(a: FilterNormalized | Filter<T>): FilterNormalized | undefined;
+}
+declare class FilterPropertySet<T extends Model> extends QueryPropertySet<Filter<T>> {
+    protected newProperty(): FilterProperty<Model>;
+    protected merge(...args: any[]): NormEntry | undefined;
+}
+declare function filterSimplify(filters: any): object | null;
+
+type SorterFn<T = any> = (a: T, b: T) => number;
+declare const enum SortDirection {
+    Asc = "asc",
+    Desc = "desc"
+}
+type SortDir = SortDirection.Asc | SortDirection.Desc | "asc" | "desc";
+type SortDirExtra = {
+    dir: SortDir;
+    emptyFirst: boolean;
+};
+type Sorter<T extends Model> = Array<{
+    [key: string]: SortDir | SortDirExtra | NormalizedEntry | undefined;
+}>;
+type NormalizedEntry = {
+    path: string;
+    isAsc: boolean;
+    emptyFirst: boolean;
+    remove?: boolean;
+};
+type SorterNormalized = Array<NormalizedEntry>;
+/**
+ * @example
+ *```ts
+ * items.toSorted(sortBy([{"author.name": "asc"}]))
+ * ```
+ */
+declare function sortBy<T extends Model>(sorters: Sorter<T> | SorterNormalized): SorterFn<T>;
+/**
+ * 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}]
+ * ```
+ */
+declare function sorterNormalize<T extends Model>(sorters: Sorter<T> | SorterNormalized): SorterNormalized;
+declare function sorterMerge(...sorters: (SorterNormalized | undefined | null)[]): SorterNormalized | undefined;
+declare class SorterProperty<T extends Model> extends QueryProperty<Sorter<T>, SorterNormalized> {
+    protected norm(a: Sorter<T>): SorterNormalized | undefined;
+    protected merge(a?: SorterNormalized, b?: SorterNormalized): SorterNormalized | undefined;
+}
+declare class SorterPropertySet extends QueryPropertySet<SorterNormalized> {
+    of(name: string): Observable<NormalizedEntry | undefined>;
+    isAsc(name: string): Observable<boolean | undefined>;
+    isDesc(name: string): Observable<boolean | undefined>;
+    protected newProperty(): SorterProperty<Model>;
+    protected merge(...args: any[]): SorterNormalized | undefined;
+}
+
+/**
+ * @example
+ * ```ts
+ * {start: 0, end: 0} // empty range
+ * {start: 0, end: 1} // range with one item.eg sliceApply([1, 2, 3], {start:0, end:1}) -> [1]
+ * ```
+ */
+interface Slice extends ListRange {
+    /**
+     * Start of slice, exact index of item in list
+     */
+    readonly start: number;
+    /**
+     * End of slice, not include end index of item in list
+     */
+    readonly end: number;
+    readonly pageSize?: number;
+}
+declare function sliceMerge(...slices: Slice[]): Slice | undefined;
+/**
+ * Apply slice to array, and force the result length to equal with Slice length,
+ * so fill array with undefined if not enought elements
+ */
+declare function sliceApply(slice: Slice, array: readonly any[]): any[];
+/**
+ * @returns Page numbers, eg.: `[10, 11, 12, 13, ...]`
+ */
+declare function sliceToPages(slice: Slice): number[];
+declare function sliceInsert(slice: Slice, array: readonly any[], newItems: readonly any[]): any[];
+declare function sliceClamp(slice: Slice, constraint: Slice): Slice;
+declare function sliceEq(a: Slice, b: Slice): boolean;
+
+type PathGetter<T = any, R = any> = (obj: T) => R[];
+declare function pathGetterCompile(path: string): PathGetter;
+
+interface Query {
+    filter?: DeepReadonly<FilterNormalized>;
+    sorter?: DeepReadonly<SorterNormalized>;
+    slimer?: DeepReadonly<SlimerNormalized>;
+    grouper?: DeepReadonly<GrouperNormalized>;
+}
+interface QueryWithSlice<T extends Model> extends Query {
+    slice: DeepReadonly<Slice>;
+}
+interface QueryResult<T extends Model> {
+    items: readonly T[];
+    total?: number;
+    groups?: any[];
+}
+interface QuerySubject<T extends Model, N extends string[]> extends Observable<Query> {
+    readonly filter: QueryPropertySetOf<FilterPropertySet<T>, FilterProperty<T>, N>;
+    readonly sorter: QueryPropertySetOf<SorterPropertySet, SorterProperty<T>, N>;
+    readonly slimer: QueryPropertySetOf<SlimerPropertySet<T>, SlimerProperty<T>, N>;
+    readonly grouper: QueryPropertySetOf<GrouperPropertySet<T>, GrouperProperty<T>, N>;
+}
+declare function querySubject<T extends Model, N extends string[]>(provider: DataProvider<T>, ...names: N): QuerySubject<T, N>;
+
+declare const INPUT: unique symbol;
+interface PartialExecutor {
+    [INPUT]: any;
+}
+interface QueryExecutors<T extends Model> {
+    readonly filterFn?: FilterExecutor<T>;
+    readonly sorterFn?: SorterExecutor<T>;
+    readonly grouperFn?: GrouperExecutor<T>;
+    readonly slicerFn?: SliceExecutor<T>;
+}
+interface QueryExecutor<T extends Model> extends QueryExecutors<T> {
+    (items: readonly T[]): QueryResult<T>;
+}
+declare function queryExecutor<T extends Model>(query: QueryWithSlice<T>, previous?: QueryExecutor<T>): QueryExecutor<T>;
+interface FilterExecutor<T extends Model> extends PartialExecutor {
+    (item: T): boolean;
+}
+interface SorterExecutor<T extends Model> extends PartialExecutor {
+    (a: T, b: T): number;
+}
+interface GrouperExecutor<T extends Model> extends PartialExecutor {
+    (item: T): Primitive;
+}
+interface SliceExecutor<T extends Model> extends PartialExecutor {
+    (items: readonly T[]): T[];
+}
+
+type DataSourceProxyInput<T extends Model> = DataSourceProxy<T> | DataSource<T> | DataProvider<T>;
+/**
+ * @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)
+ * }
+ * ```
+ */
+declare class DataSourceProxy<T extends Model> extends DataSource$1<T | undefined> implements OnDestroy, ConnectProtocol {
+    #private;
+    set value(value: DataSourceProxyInput<T>);
+    readonly value$: Observable<DataSource<T>>;
+    readonly query$: Observable<QuerySubject<T, ["normal", "forced"]>>;
+    readonly items$: Observable<_ngutil_data.PartialCollection<T>>;
+    readonly isBusy$: Observable<boolean>;
+    readonly isEmpty$: Observable<boolean>;
+    connect(collectionViewer: CollectionViewer): Observable<readonly (T | undefined)[]>;
+    disconnect(collectionViewer: CollectionViewer): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceProxy<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceProxy<any>, "[nuDataSource]", ["nuDataSource"], { "value": { "alias": "nuDataSource"; "required": true; }; }, {}, never, never, true, never>;
+}
+declare class DataSourceProxyFilter<T extends Model, F extends Filter<T>> {
+    #private;
+    readonly filter: i0.InputSignal<F>;
+    readonly filter$: Observable<F>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceProxyFilter<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceProxyFilter<any, any>, "[nuDataSource][filter]", never, { "filter": { "alias": "filter"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class DataSourceProxySorter<T extends Model, S extends Sorter<T>> {
+    #private;
+    readonly sorter: i0.InputSignal<S>;
+    readonly sorter$: Observable<S>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceProxySorter<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceProxySorter<any, any>, "[nuDataSource][sorter]", never, { "sorter": { "alias": "sorter"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class DataSourceProxySlimer<T extends Model, S extends Slimer<T>> {
+    #private;
+    readonly slimer: i0.InputSignal<S>;
+    readonly slimer$: Observable<S>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceProxySlimer<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceProxySlimer<any, any>, "[nuDataSource][slimer]", never, { "slimer": { "alias": "slimer"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class DataSourceProxyGrouper<T extends Model, G extends Grouper<T>> {
+    #private;
+    readonly grouper: i0.InputSignal<G>;
+    readonly grouper$: Observable<G>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceProxyGrouper<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceProxyGrouper<any, any>, "[nuDataSource][grouper]", never, { "grouper": { "alias": "grouper"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class DataSourceProxyBusy {
+    #private;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceProxyBusy, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceProxyBusy, "[nuDataSource][nuBusy]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DataSourceModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DataSourceModule, never, [typeof i1.DataSourceProxy, typeof i1.DataSourceProxyBusy, typeof i1.DataSourceProxyFilter, typeof i1.DataSourceProxyGrouper, typeof i1.DataSourceProxySlimer, typeof i1.DataSourceProxySorter], [typeof i1.DataSourceProxy, typeof i1.DataSourceProxyBusy, typeof i1.DataSourceProxyFilter, typeof i1.DataSourceProxyGrouper, typeof i1.DataSourceProxySlimer, typeof i1.DataSourceProxySorter]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DataSourceModule, never, [typeof DataSourceProxy, typeof DataSourceProxyBusy, typeof DataSourceProxyFilter, typeof DataSourceProxyGrouper, typeof DataSourceProxySlimer, typeof DataSourceProxySorter], [typeof DataSourceProxy, typeof DataSourceProxyBusy, typeof DataSourceProxyFilter, typeof DataSourceProxyGrouper, typeof DataSourceProxySlimer, typeof DataSourceProxySorter]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DataSourceModule>;
 }
+
+export { ArrayProvider, CollectionStore, DataProvider, DataSource, DataSourceModule, DataSourceProxy, DataSourceProxyBusy, DataSourceProxyFilter, DataSourceProxyGrouper, DataSourceProxySlimer, DataSourceProxySorter, FilterOp, LocalProvider, MemoryStore, ModelMeta, ModelRefByIndex, ModelRefByKey, ModelRefNorm, ObservableProvider, SortDirection, UnknownMeta, filterBy, filterIsNormnalized, filterMerge, filterNormalize, filterSimplify, groupBy, grouperMerge, pathGetterCompile, queryExecutor, querySubject, sliceApply, sliceClamp, sliceEq, sliceInsert, sliceMerge, sliceToPages, slimBy, slimerMerge, sortBy, sorterMerge, sorterNormalize };
+export type { DataSourceProxyInput, Filter, FilterCustom, FilterCustomMatcher, FilterNormalized, FilterOpMap, Grouper, Model, ModelMetaInput, ModelMetaProps, ModelRef, ModelRefFilter, PartialCollection, Query, QueryExecutor, QueryResult, QuerySubject, QueryWithSlice, Slice, Slimer, SortDir, SortDirExtra, Sorter, SorterNormalized };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@ngutil/data",
-  "version": "0.0.102",
+  "version": "0.0.104",
   "peerDependencies": {
-    "@angular/cdk": "19.2.11",
-    "@angular/core": "19.2.8",
+    "@angular/cdk": "20.2.14",
+    "@angular/core": "20.3.13",
     "es-toolkit": "^1.35.0",
     "rxjs": "^7.8.1",
     "utility-types": "^3.11.0",
-    "@ngutil/common": "0.0.102",
-    "@ngutil/aria": "0.0.102"
+    "@ngutil/aria": "0.0.104",
+    "@ngutil/common": "0.0.104"
   },
   "publishConfig": {
     "access": "public",

package/model/index.d.ts

@@ -1 +0,0 @@
-export { Model, ModelRef, ModelRefNorm, ModelMeta, ModelMetaProps, ModelRefFilter, ModelMetaInput, ModelRefByIndex, ModelRefByKey, UnknownMeta } from "./meta";

package/model/meta.d.ts

@@ -1,51 +0,0 @@
-import { TrackByFunction } from "@angular/core";
-import { Primitive } from "utility-types";
-export type Model = {
-    [key: string]: any;
-};
-export type ModelRef = {
-    key?: Primitive | Array<Primitive>;
-    index?: number;
-};
-export type ModelRefFilter<T> = (item: T, index: number) => boolean;
-export interface ModelMetaProps<T extends Model> {
-    readonly keys: readonly string[];
-    readonly trackBy?: TrackByFunction<T>;
-}
-export type ModelMetaInput<T extends Model> = ModelMeta<T> | ModelMetaProps<T>;
-export type TrackedModel<T extends Model> = {
-    index: number;
-    model: T;
-};
-export declare class ModelMeta<T extends Model> implements ModelMetaProps<T> {
-    #private;
-    static coerce<M extends Model>(value: ModelMetaInput<M>): ModelMeta<M>;
-    readonly keys: readonly string[];
-    readonly trackBy: TrackByFunction<T>;
-    constructor(props: ModelMetaProps<T>);
-    isEqual(a: T, b: T): boolean;
-    isEqualByTrack(a: TrackedModel<T>, b: TrackedModel<T>): boolean;
-    isEqualByKey(a: T, b: T): boolean;
-    normalizeRef(ref: ModelRef | ModelRefNorm): ModelRefNorm;
-}
-export declare abstract class ModelRefNorm {
-    #private;
-    readonly key?: readonly Primitive[];
-    readonly index?: number;
-    toFilter(): ModelRefFilter<any>;
-    protected abstract _asFilter(): ModelRefFilter<any>;
-}
-export declare class ModelRefByKey extends ModelRefNorm {
-    #private;
-    readonly key: readonly Primitive[];
-    constructor(key: readonly Primitive[], keys: readonly string[]);
-    protected _asFilter(): ModelRefFilter<any>;
-}
-export declare class ModelRefByIndex extends ModelRefNorm {
-    readonly index: number;
-    constructor(index: number);
-    protected _asFilter(): ModelRefFilter<any>;
-}
-export declare class UnknownMeta<T extends Model> extends ModelMeta<T> {
-    constructor();
-}

package/provider/array.d.ts

@@ -1,7 +0,0 @@
-import { type Observable } from "rxjs";
-import type { Model, ModelMetaInput } from "../model";
-import { LocalProvider } from "./local";
-export declare class ArrayProvider<T extends Model> extends LocalProvider<T> {
-    readonly items$: Observable<readonly T[]>;
-    constructor(meta: ModelMetaInput<T>, items: readonly T[]);
-}