@ngutil/data 0.0.10 → 0.0.12

package/source/proxy.directive.d.ts

@@ -0,0 +1,57 @@
+import { DataSource as CdkDataSource, CollectionViewer } from "@angular/cdk/collections";
+import { OnDestroy } from "@angular/core";
+import { Observable, ReplaySubject } from "rxjs";
+import { Busy, ConnectProtocol } from "@ngutil/common";
+import { Model } from "../model";
+import { Filter, Grouper, Slimer, Sorter } from "../query";
+import { DataSource } from "./source";
+import * as i0 from "@angular/core";
+export type DataSourceInput<T extends Model> = any;
+/**
+ * @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 = Model> extends CdkDataSource<T | undefined> implements OnDestroy, ConnectProtocol {
+    #private;
+    set source(value: DataSourceInput<T>);
+    readonly source$: ReplaySubject<DataSource<T>>;
+    readonly items$: Observable<import("@ngutil/data").PartialCollection<T>>;
+    readonly busy$: Observable<boolean>;
+    readonly isBusy: import("@angular/core").Signal<boolean>;
+    set filter(value: Filter<T>);
+    set sorter(value: Sorter<T>);
+    set grouper(value: Grouper<T>);
+    set slimer(value: Slimer<T>);
+    constructor(busy?: Busy<any>);
+    connect(collectionViewer: CollectionViewer): Observable<readonly (T | undefined)[]>;
+    disconnect(collectionViewer: CollectionViewer): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceProxy<any>, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DataSourceProxy<any>, "[nuDataSource]", ["nuDataSource"], { "source": { "alias": "nuDataSource"; "required": true; }; "filter": { "alias": "filter"; "required": false; }; "sorter": { "alias": "sorter"; "required": false; }; "grouper": { "alias": "grouper"; "required": false; }; "slimer": { "alias": "slimer"; "required": false; }; }, {}, never, never, true, never>;
+}

package/source/source.d.ts

@@ -0,0 +1,36 @@
+import { DataSource as CdkDataSource, CollectionViewer } from "@angular/cdk/collections";
+import { BehaviorSubject, Observable } from "rxjs";
+import { ConnectProtocol, DeepReadonly } from "@ngutil/common";
+import type { Model, ModelRef } from "../model";
+import type { DataProvider } from "../provider/provider";
+import type { Filter, Query, Slice, Sorter } from "../query";
+import { type CollectionStore, type PartialCollection } from "../store";
+import { FilterCombined, GrouperCombined, SlimerCombined, SorterCombined } from "./properties";
+type DSQuery<T extends Model> = Query<T> & {
+    slice: DeepReadonly<Slice>;
+};
+export declare class DataSource<T extends Model> extends CdkDataSource<T | undefined> implements ConnectProtocol {
+    #private;
+    readonly provider: DataProvider<T>;
+    readonly busy$: BehaviorSubject<boolean>;
+    readonly total$: BehaviorSubject<number | undefined>;
+    readonly filter: FilterCombined<Filter<T>>;
+    readonly sorter: SorterCombined<Sorter<T>>;
+    readonly slimer: SlimerCombined<any>;
+    readonly grouper: GrouperCombined<any>;
+    readonly slice$: Observable<Slice>;
+    readonly reset$: Observable<unknown>;
+    readonly query$: Observable<DSQuery<T>>;
+    readonly items$: Observable<PartialCollection<T>>;
+    readonly store: CollectionStore<T>;
+    constructor(provider: DataProvider<T>, store?: CollectionStore<T>);
+    setSlice(slice: Slice): this;
+    all(): this;
+    realod(): void;
+    getItem(ref: ModelRef): Observable<T | undefined>;
+    getItemPosition(ref: ModelRef): Observable<number | undefined>;
+    realodItem(ref: ModelRef, insertPosition?: number): Observable<T | undefined>;
+    connect(collectionViewer: CollectionViewer): Observable<readonly (T | undefined)[]>;
+    disconnect(collectionViewer: CollectionViewer): void;
+}
+export {};

package/store/collection-store.d.ts

@@ -0,0 +1,49 @@
+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

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

package/store/memory-store.d.ts

@@ -0,0 +1,16 @@
+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>;
+}