@ngutil/data 0.0.102 → 0.0.105

package/provider/index.d.ts

@@ -1,4 +0,0 @@
-export { DataProvider } from "./provider";
-export { LocalProvider } from "./local";
-export { ArrayProvider } from "./array";
-export { ObservableProvider } from "./observable";

package/provider/local.d.ts

@@ -1,16 +0,0 @@
-import { Observable } from "rxjs";
-import { Model, ModelMeta, ModelMetaInput, ModelRefNorm } from "../model";
-import { QueryExecutor, QueryResult, QueryWithSlice, Slice } from "../query";
-import { DataProvider } from "./provider";
-export 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>;
-}

package/provider/observable.d.ts

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

package/provider/provider.d.ts

@@ -1,50 +0,0 @@
-import type { Observable } from "rxjs";
-import type { Model, ModelMeta, ModelRefNorm } from "../model";
-import { type FilterNormalized, type QueryResult, type QueryWithSlice, type Slice, type SorterNormalized } from "../query";
-import { type GrouperNormalized } from "../query/grouper";
-import { type SlimerNormalized } from "../query/slimer";
-import { DataSource } from "../source";
-import type { CollectionStore } from "../store";
-export 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>;
-}

package/query/common.d.ts

@@ -1,2 +0,0 @@
-export declare function readonlyProp(o: unknown, n: string | symbol, v: unknown): void;
-export declare function normalize(obj: any, normalizer: (v: any) => any): any;

package/query/executor.d.ts

@@ -1,30 +0,0 @@
-import { Primitive } from "utility-types";
-import { Model } from "../model";
-import { QueryResult, QueryWithSlice } from "./query";
-declare const INPUT: unique symbol;
-interface PartialExecutor {
-    [INPUT]: any;
-}
-export interface QueryExecutors<T extends Model> {
-    readonly filterFn?: FilterExecutor<T>;
-    readonly sorterFn?: SorterExecutor<T>;
-    readonly grouperFn?: GrouperExecutor<T>;
-    readonly slicerFn?: SliceExecutor<T>;
-}
-export interface QueryExecutor<T extends Model> extends QueryExecutors<T> {
-    (items: readonly T[]): QueryResult<T>;
-}
-export 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[];
-}
-export {};

package/query/filter.d.ts

@@ -1,118 +0,0 @@
-import { AsPrimitive, MaxRecursion } from "@ngutil/common";
-import { Model } from "../model";
-import { QueryProperty, QueryPropertySet } from "./query-property";
-export 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 = "!"
-}
-export declare const OPERATORS: Array<string>;
-export type FilterCustom<T = any> = {
-    custom: string;
-    matcher?: FilterCustomMatcher<T>;
-};
-export type FilterCustomMatcher<T = any> = (item: T | null | undefined, value: any) => boolean;
-export type FilterOpMap = Record<string, FilterOp | FilterCustom>;
-export declare function asOperators(value: any): Array<{
-    op: FilterOp;
-    value: any;
-}>;
-export type Filter<T extends Model> = {
-    [key: string]: any;
-};
-export type Operators<T, P extends number[], D extends number = MaxRecursion> = P["length"] extends D ? never : SimpleOperators<T>;
-type SimpleOperators<T> = EqStrict<T> | NeqStrict<T> | Eq<T> | Neq<T> | Gt<T> | Gte<T> | Lt<T> | Lte<T> | Contains<T> | StartsWith<T> | Similarity<T> | EndsWith<T> | Regexp<T> | T | undefined | null;
-type EqStrict<T> = Operator<T, T, FilterOp.EqStrict, never, null>;
-type NeqStrict<T> = Operator<T, T, FilterOp.NeqStrict, never, null>;
-type Eq<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Eq, FilterOp.EqInsesitive, null>;
-type Neq<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Neq, FilterOp.NeqInsesitive, null>;
-type Gt<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Gt, FilterOp.GtInsesitive>;
-type Gte<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Gte, FilterOp.GteInsesitive>;
-type Lt<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Lt, FilterOp.LtInsesitive>;
-type Lte<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Lte, FilterOp.LteInsesitive>;
-type Contains<T> = Operator<T, string, FilterOp.Contains, FilterOp.ContainsInsesitive>;
-type StartsWith<T> = Operator<T, string, FilterOp.StartsWith, FilterOp.StartsWithInsesitive>;
-type Similarity<T> = Operator<T, string, FilterOp.Similarity, never, null>;
-type EndsWith<T> = Operator<T, string, FilterOp.EndsWith, FilterOp.EndsWithInsesitive>;
-type Regexp<T> = Operator<T, string, FilterOp.Regexp, FilterOp.RegexpInsesitive, RegExp>;
-type Operator<T, R, OP extends string, OPI extends string = never, ET = never> = (T extends R ? {
-    [k in OP]: T | ET | R;
-} : never) | (T extends string ? (OPI extends never ? never : {
-    [k in OPI]: string;
-}) : never);
-export type FilterFn<T = any> = (item: T) => boolean;
-/**
- * @example
- * ```ts
- * items.filter(filterBy({id: 42}))
- * ```
- */
-export 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;
-export type FilterNormalized = NormEntry;
-/**
- * @example
- * ```ts
- * filterNormalize({id: {">": 0, "<": 10}})
- * {op: "&", value: [{path: "id", op: ">", value: 0}, {path: "id", op: "<", value: 10}]}
- * ```
- */
-export declare function filterNormalize<T extends Model>(filters: Filter<T> | null | undefined, opmap?: FilterOpMap): FilterNormalized | undefined;
-export declare function filterIsNormnalized(filters: any): filters is FilterNormalized;
-export declare function filterMerge(...filters: Array<FilterNormalized | null | undefined>): any | undefined;
-export 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;
-}
-export declare class FilterPropertySet<T extends Model> extends QueryPropertySet<Filter<T>> {
-    protected newProperty(): FilterProperty<Model>;
-    protected merge(...args: any[]): NormEntry | undefined;
-}
-export declare function filterSimplify(filters: any): object | null;
-export {};

package/query/grouper.d.ts

@@ -1,17 +0,0 @@
-import { Flatten, Primitive } from "@ngutil/common";
-import { Model } from "../model";
-import { QueryProperty, QueryPropertySet } from "./query-property";
-export type GrouperFn<T = any> = (item: any) => Primitive;
-export type Grouper<T extends Model, F = Flatten<T>> = any;
-export type GrouperNormalized = any;
-export declare function groupBy<T extends Model, F = Flatten<T>>(grouper: Grouper<T, F>): GrouperFn<T>;
-export declare function grouperMerge<T extends Model, F = Flatten<T>>(...groupers: Array<Grouper<T, F> | undefined | null>): Grouper<T, F> | undefined;
-export declare function grouperNormalize<T extends Model>(grouper: Grouper<T>): GrouperNormalized;
-export declare class GrouperProperty<T extends Model> extends QueryProperty<Grouper<T>, GrouperNormalized> {
-    protected norm(a: any): any;
-    protected merge(a?: any, b?: any): any;
-}
-export declare class GrouperPropertySet<T extends Model> extends QueryPropertySet<Grouper<T>> {
-    protected newProperty(): GrouperProperty<Model>;
-    protected merge(...args: any[]): any;
-}

package/query/index.d.ts

@@ -1,8 +0,0 @@
-export { Filter, FilterNormalized, filterBy, filterMerge, filterNormalize, filterIsNormnalized, FilterOp, FilterOpMap, FilterCustom, FilterCustomMatcher, filterSimplify } from "./filter";
-export { Grouper, groupBy, grouperMerge } from "./grouper";
-export { Sorter, SorterNormalized, sortBy, sorterMerge, sorterNormalize, SortDir, SortDirection, SortDirExtra } from "./sorter";
-export { Slimer, slimBy, slimerMerge } from "./slimer";
-export { Slice, sliceMerge, sliceApply, sliceInsert, sliceToPages, sliceClamp, sliceEq } from "./slice";
-export { pathGetterCompile } from "./path";
-export { Query, QueryWithSlice, QueryResult, querySubject, QuerySubject } from "./query";
-export { queryExecutor, QueryExecutor } from "./executor";

package/query/path.d.ts

@@ -1,2 +0,0 @@
-export type PathGetter<T = any, R = any> = (obj: T) => R[];
-export declare function pathGetterCompile(path: string): PathGetter;

package/query/query-property.d.ts

@@ -1,25 +0,0 @@
-import { BehaviorSubject, Observable } from "rxjs";
-import type { DataProvider } from "../provider";
-export 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;
-}
-export 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;
-}
-export type QueryPropertySetOf<T, P, N extends string[]> = T & {
-    [K in N[number]]: P;
-};

package/query/query.d.ts

@@ -1,31 +0,0 @@
-import { Observable } from "rxjs";
-import { type DeepReadonly } from "@ngutil/common";
-import { type Model } from "../model";
-import type { DataProvider } from "../provider";
-import { type FilterNormalized, FilterProperty, FilterPropertySet } from "./filter";
-import { type GrouperNormalized, GrouperProperty, GrouperPropertySet } from "./grouper";
-import { type QueryPropertySetOf } from "./query-property";
-import { type Slice } from "./slice";
-import { type SlimerNormalized, SlimerProperty, SlimerPropertySet } from "./slimer";
-import { type SorterNormalized, SorterProperty, SorterPropertySet } from "./sorter";
-export interface Query {
-    filter?: DeepReadonly<FilterNormalized>;
-    sorter?: DeepReadonly<SorterNormalized>;
-    slimer?: DeepReadonly<SlimerNormalized>;
-    grouper?: DeepReadonly<GrouperNormalized>;
-}
-export interface QueryWithSlice<T extends Model> extends Query {
-    slice: DeepReadonly<Slice>;
-}
-export interface QueryResult<T extends Model> {
-    items: readonly T[];
-    total?: number;
-    groups?: any[];
-}
-export 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>;
-}
-export declare function querySubject<T extends Model, N extends string[]>(provider: DataProvider<T>, ...names: N): QuerySubject<T, N>;

package/query/slice.d.ts

@@ -1,32 +0,0 @@
-import { ListRange } from "@angular/cdk/collections";
-/**
- * @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]
- * ```
- */
-export 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;
-}
-export 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
- */
-export declare function sliceApply(slice: Slice, array: readonly any[]): any[];
-/**
- * @returns Page numbers, eg.: `[10, 11, 12, 13, ...]`
- */
-export declare function sliceToPages(slice: Slice): number[];
-export declare function sliceInsert(slice: Slice, array: readonly any[], newItems: readonly any[]): any[];
-export declare function sliceClamp(slice: Slice, constraint: Slice): Slice;
-export declare function sliceEq(a: Slice, b: Slice): boolean;

package/query/slimer.d.ts

@@ -1,28 +0,0 @@
-import { Model } from "../model";
-import { QueryProperty, QueryPropertySet } from "./query-property";
-/**
- * @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>}
- * ]
- * ```
- */
-export type Slimer<T extends Model> = any;
-export type SlimerNormalized = any;
-export type SlimerFn<T> = (item: T) => T;
-export declare function slimBy<T extends Model>(slimer: Slimer<T>): void;
-export declare function slimerNormalize<T extends Model>(slimer: Slimer<T>): SlimerNormalized;
-export declare function slimerMerge<T extends Model>(...slimers: Slimer<T>): any;
-export declare class SlimerProperty<T extends Model> extends QueryProperty<Slimer<T>, SlimerNormalized> {
-    protected norm(a: any): any;
-    protected merge(a?: any, b?: any): any;
-}
-export declare class SlimerPropertySet<T extends Model> extends QueryPropertySet<Slimer<T>> {
-    protected newProperty(): SlimerProperty<Model>;
-    protected merge(...args: any[]): any;
-}

package/query/sorter.d.ts

@@ -1,55 +0,0 @@
-import { Observable } from "rxjs";
-import { Model } from "../model";
-import { QueryProperty, QueryPropertySet } from "./query-property";
-export type SorterFn<T = any> = (a: T, b: T) => number;
-export declare const enum SortDirection {
-    Asc = "asc",
-    Desc = "desc"
-}
-export type SortDir = SortDirection.Asc | SortDirection.Desc | "asc" | "desc";
-export type SortDirExtra = {
-    dir: SortDir;
-    emptyFirst: boolean;
-};
-export type Sorter<T extends Model> = Array<{
-    [key: string]: SortDir | SortDirExtra | NormalizedEntry | undefined;
-}>;
-type NormalizedEntry = {
-    path: string;
-    isAsc: boolean;
-    emptyFirst: boolean;
-    remove?: boolean;
-};
-export type SorterNormalized = Array<NormalizedEntry>;
-/**
- * @example
- *```ts
- * items.toSorted(sortBy([{"author.name": "asc"}]))
- * ```
- */
-export 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}]
- * ```
- */
-export declare function sorterNormalize<T extends Model>(sorters: Sorter<T> | SorterNormalized): SorterNormalized;
-export declare function sorterIsNormalized(sorter: any): sorter is SorterNormalized;
-export declare function compare(a: any, b: any, emptyFirst: boolean): number;
-export declare function sorterMerge(...sorters: (SorterNormalized | undefined | null)[]): SorterNormalized | undefined;
-export 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;
-}
-export 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;
-}
-export {};

package/source/index.d.ts

@@ -1,2 +0,0 @@
-export { DataSource } from "./source";
-export { DataSourceProxy, DataSourceProxyBusy, DataSourceProxyFilter, DataSourceProxyGrouper, DataSourceProxySlimer, DataSourceProxySorter, DataSourceProxyInput } from "./proxy.directive";

package/source/proxy.directive.d.ts

@@ -1,92 +0,0 @@
-import { DataSource as CdkDataSource, CollectionViewer } from "@angular/cdk/collections";
-import { OnDestroy } from "@angular/core";
-import { Observable } from "rxjs";
-import { ConnectProtocol } from "@ngutil/common";
-import { Model } from "../model";
-import { DataProvider } from "../provider/provider";
-import { Filter, Grouper, Slimer, Sorter } from "../query";
-import { DataSource } from "./source";
-import * as i0 from "@angular/core";
-export 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)
- * }
- * ```
- */
-export declare class DataSourceProxy<T extends Model> extends CdkDataSource<T | undefined> implements OnDestroy, ConnectProtocol {
-    #private;
-    set value(value: DataSourceProxyInput<T>);
-    readonly value$: Observable<DataSource<T>>;
-    readonly query$: Observable<import("../query").QuerySubject<T, ["normal", "forced"]>>;
-    readonly items$: Observable<import("@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>;
-}
-export declare class DataSourceProxyFilter<T extends Model, F extends Filter<T>> {
-    #private;
-    readonly filter: import("@angular/core").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>;
-}
-export declare class DataSourceProxySorter<T extends Model, S extends Sorter<T>> {
-    #private;
-    readonly sorter: import("@angular/core").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>;
-}
-export declare class DataSourceProxySlimer<T extends Model, S extends Slimer<T>> {
-    #private;
-    readonly slimer: import("@angular/core").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>;
-}
-export declare class DataSourceProxyGrouper<T extends Model, G extends Grouper<T>> {
-    #private;
-    readonly grouper: import("@angular/core").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>;
-}
-export declare class DataSourceProxyBusy {
-    #private;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceProxyBusy, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceProxyBusy, "[nuDataSource][nuBusy]", never, {}, {}, never, never, true, never>;
-}

package/source/source.d.ts

@@ -1,32 +0,0 @@
-import { DataSource as CdkDataSource, CollectionViewer } from "@angular/cdk/collections";
-import { BehaviorSubject, Observable } from "rxjs";
-import { ConnectProtocol } from "@ngutil/common";
-import type { Model, ModelRef } from "../model";
-import type { DataProvider } from "../provider/provider";
-import type { Filter, Slice } from "../query";
-import { type CollectionStore, type PartialCollection } from "../store";
-export declare class DataSource<T extends Model> extends CdkDataSource<T | undefined> implements ConnectProtocol {
-    #private;
-    readonly provider: DataProvider<T>;
-    readonly store: CollectionStore<T>;
-    readonly query$: import("../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$?: import("../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;
-}

package/store/collection-store.d.ts

@@ -1,49 +0,0 @@
-import { Observable } from "rxjs";
-import { DeepReadonly } from "@ngutil/common";
-import { Model, ModelRefNorm } from "../model";
-import { Slice } from "../query";
-export type PartialCollection<T> = readonly (T | undefined)[];
-export 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>;
-}

package/store/index.d.ts

@@ -1,2 +0,0 @@
-export { CollectionStore, PartialCollection } from "./collection-store";
-export { MemoryStore } from "./memory-store";

package/store/memory-store.d.ts

@@ -1,16 +0,0 @@
-import { Observable } from "rxjs";
-import { Model, ModelRefNorm } from "../model";
-import { Slice } from "../query";
-import { CollectionStore, PartialCollection } from "./collection-store";
-export 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>;
-}