@recursyve/nice-data-filter-kit 14.1.6 → 14.2.1

package/lib/components/nice-filter-view/store/nice-filter-view.query.d.ts

@@ -10,6 +10,7 @@ export declare class NiceFilterViewQuery extends QueryEntity<NiceFilterViewState
     selectFilterConfig(): Observable<FilterConfigurationModel[]>;
     selectFilterParameters(): Observable<FilterParametersModel>;
     selectFilterResult(): Observable<FilterResultModel | null>;
+    getParameters(): FilterParametersModel;
     static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterViewQuery, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NiceFilterViewQuery>;
 }

package/lib/components/nice-filter-view/store/nice-filter-view.service.d.ts

@@ -30,7 +30,6 @@ export declare class NiceFilterViewService<Filter extends NiceFilterService<any>
     upsertValue(value: any, key?: string): void;
     removeValue(value: any, key?: string): void;
     resetResult(waitForNextFilter: boolean): void;
-    getParameters(filterParameters?: FilterParametersModel): FilterParametersModel;
     static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterViewService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NiceFilterViewService<any>>;
 }

package/lib/components/nice-filter-view/store/nice-filter-view.store.d.ts

@@ -27,6 +27,7 @@ export declare class NiceFilterViewStore extends EntityStore<NiceFilterViewState
     addValue(value: any, opts?: AddEntitiesOptions): void;
     upsertValue(value: any, key?: string): void;
     removeValue(value: any, key?: string): void;
+    getParameters(filterParameters?: FilterParametersModel): FilterParametersModel;
     static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterViewStore, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NiceFilterViewStore>;
 }

package/lib/directive/public-api.d.ts

@@ -0,0 +1 @@
+export * from "./selectable-list/public-api";

package/lib/directive/selectable-list/model/load-all-entities-options.model.d.ts

@@ -0,0 +1,4 @@
+import { FilterQueryModel } from "../../../models/filter.model";
+export interface NiceSelectableListLoadAllEntitiesOptions {
+    query?: FilterQueryModel;
+}

package/lib/directive/selectable-list/model/selectable-list-options.model.d.ts

@@ -0,0 +1,4 @@
+export interface NiceSelectableListOptions {
+    idKey?: string;
+    preloadWindow?: number;
+}

package/lib/directive/selectable-list/providers/preload-selected-entities.provider.d.ts

@@ -0,0 +1,12 @@
+import { NiceSelectableListLoadAllEntitiesOptions } from "../model/load-all-entities-options.model";
+import * as i0 from "@angular/core";
+export declare abstract class NicePreloadSelectedEntitiesProvider<T, ID = number> {
+    abstract state: string;
+    abstract reloadEntity(entity: T): Promise<T>;
+    abstract reloadEntities(entities: T[]): Promise<T[]>;
+    abstract loadEntityById(id: ID): Promise<T>;
+    abstract loadEntitiesById(ids: ID[]): Promise<T[]>;
+    abstract loadAllEntities(options?: NiceSelectableListLoadAllEntitiesOptions): Promise<ID[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NicePreloadSelectedEntitiesProvider<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NicePreloadSelectedEntitiesProvider<any, any>>;
+}

package/lib/directive/selectable-list/providers/selectable-list-content.service.d.ts

@@ -0,0 +1,13 @@
+import { QueryList } from "@angular/core";
+import { NiceSelectableListCheckboxDirective } from "../selectable-list-checkbox.directive";
+import * as i0 from "@angular/core";
+export declare class SelectableListContentService {
+    private _state;
+    private _checkboxes;
+    get state(): string | null;
+    get checkboxes(): QueryList<NiceSelectableListCheckboxDirective>;
+    setState(state: string): void;
+    setCheckboxes(checkboxes: QueryList<NiceSelectableListCheckboxDirective>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableListContentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectableListContentService>;
+}

package/lib/directive/selectable-list/public-api.d.ts

@@ -0,0 +1,9 @@
+export * from "./model/selectable-list-options.model";
+export * from "./model/load-all-entities-options.model";
+export * from "./providers/preload-selected-entities.provider";
+export * from "./store/selectable-list.service";
+export * from "./store/selectable-list-state.service";
+export * from "./selectable-list.module";
+export * from "./selectable-list.directive";
+export * from "./selectable-list-checkbox.directive";
+export * from "./selectable-list-select-all.directive";

package/lib/directive/selectable-list/selectable-list-checkbox.directive.d.ts

@@ -0,0 +1,24 @@
+import { OnDestroy, OnInit } from "@angular/core";
+import { MatCheckbox } from "@angular/material/checkbox";
+import { SelectableListContentService } from "./providers/selectable-list-content.service";
+import { SelectableListService } from "./store/selectable-list.service";
+import * as i0 from "@angular/core";
+export declare class NiceSelectableListCheckboxDirective implements OnInit, OnDestroy {
+    readonly checkbox: MatCheckbox;
+    private service;
+    private selectableListService;
+    selectableEntity?: any;
+    selectPage?: boolean;
+    private selectableListStateService;
+    private selectableListStateQuery;
+    private unsubscribeAll$;
+    private get currentId();
+    constructor(checkbox: MatCheckbox, service: SelectableListContentService, selectableListService: SelectableListService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private handleSelectableEntity;
+    private handleSelectPage;
+    private updateCheckboxState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListCheckboxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceSelectableListCheckboxDirective, "mat-checkbox[niceSelectableListCheckbox]", never, { "selectableEntity": "selectableEntity"; "selectPage": "selectPage"; }, {}, never, never, false>;
+}

package/lib/directive/selectable-list/selectable-list-select-all.directive.d.ts

@@ -0,0 +1,18 @@
+import { OnInit } from "@angular/core";
+import { NiceFilterViewQuery } from "../../components/nice-filter-view/store/nice-filter-view.query";
+import { SelectableListContentService } from "./providers/selectable-list-content.service";
+import { SelectableListService } from "./store/selectable-list.service";
+import * as i0 from "@angular/core";
+export declare class NiceSelectableListSelectAllDirective implements OnInit {
+    private niceFilterViewQuery;
+    private service;
+    private selectableListService;
+    action: "select" | "unselect";
+    private selectableListStateService;
+    private selectableListStateQuery;
+    constructor(niceFilterViewQuery: NiceFilterViewQuery | null, service: SelectableListContentService, selectableListService: SelectableListService);
+    ngOnInit(): void;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListSelectAllDirective, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceSelectableListSelectAllDirective, "button[niceSelectableListSelectAll]", never, { "action": "action"; }, {}, never, never, false>;
+}

package/lib/directive/selectable-list/selectable-list.constant.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from "@angular/core";
+export declare const NICE_PRELOAD_SELECTED_ENTITIES_PROVIDER: InjectionToken<unknown>;

package/lib/directive/selectable-list/selectable-list.directive.d.ts

@@ -0,0 +1,18 @@
+import { AfterContentInit, OnChanges, OnInit, QueryList, SimpleChanges } from "@angular/core";
+import { NiceSelectableListOptions } from "./model/selectable-list-options.model";
+import { SelectableListContentService } from "./providers/selectable-list-content.service";
+import { NiceSelectableListCheckboxDirective } from "./selectable-list-checkbox.directive";
+import * as i0 from "@angular/core";
+export declare class NiceSelectableListDirective implements OnInit, OnChanges, AfterContentInit {
+    private service;
+    state: string;
+    options: NiceSelectableListOptions;
+    readonly checkboxes: QueryList<NiceSelectableListCheckboxDirective>;
+    private defaultOptions;
+    constructor(service: SelectableListContentService);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceSelectableListDirective, "[niceSelectableList]", never, { "state": "state"; "options": "options"; }, {}, ["checkboxes"], never, false>;
+}

package/lib/directive/selectable-list/selectable-list.module.d.ts

@@ -0,0 +1,12 @@
+import { ModuleWithProviders, Type } from "@angular/core";
+import { NicePreloadSelectedEntitiesProvider } from "./providers/preload-selected-entities.provider";
+import * as i0 from "@angular/core";
+import * as i1 from "./selectable-list.directive";
+import * as i2 from "./selectable-list-checkbox.directive";
+import * as i3 from "./selectable-list-select-all.directive";
+export declare class NiceSelectableListModule {
+    static register(...providers: Type<NicePreloadSelectedEntitiesProvider<any, any>>[]): ModuleWithProviders<NiceSelectableListModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceSelectableListModule, [typeof i1.NiceSelectableListDirective, typeof i2.NiceSelectableListCheckboxDirective, typeof i3.NiceSelectableListSelectAllDirective], never, [typeof i1.NiceSelectableListDirective, typeof i2.NiceSelectableListCheckboxDirective, typeof i3.NiceSelectableListSelectAllDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceSelectableListModule>;
+}

package/lib/directive/selectable-list/store/selectable-list-state.service.d.ts

@@ -0,0 +1,32 @@
+import { EntityStore } from "@datorama/akita";
+import { NiceSelectableListLoadAllEntitiesOptions } from "../model/load-all-entities-options.model";
+import { NiceSelectableListOptions } from "../model/selectable-list-options.model";
+import { NicePreloadSelectedEntitiesProvider } from "../providers/preload-selected-entities.provider";
+import { SelectableListState } from "./selectable-list.state";
+export declare class SelectableListStateService<T, ID = any> {
+    private store;
+    private preloadService?;
+    private options?;
+    get idKey(): string;
+    get preloadedWindow(): number;
+    constructor(store: EntityStore<SelectableListState<any>>, preloadService?: NicePreloadSelectedEntitiesProvider<T>, options?: NiceSelectableListOptions);
+    setActive(entity: T): void;
+    getIndex(identifier: number): number;
+    selectAll(options?: NiceSelectableListLoadAllEntitiesOptions): Promise<void>;
+    select(id: ID): Promise<void>;
+    selectEntity(entity: T): Promise<void>;
+    selectManyEntities(entities: T[]): Promise<void>;
+    unselectAll(): void;
+    unselect(id: ID): void;
+    unselectEntity(entity: T): void;
+    unselectManyEntities(entities: T[]): void;
+    setEntities(ids: ID[], activeId: ID): Promise<void>;
+    next(): Promise<void>;
+    previous(): Promise<void>;
+    first(): Promise<void>;
+    last(): Promise<void>;
+    removeActive(): Promise<void>;
+    loadActiveEntity(id: number, direction: number): Promise<void>;
+    loadEntities(loadExtremity: any): Promise<void>;
+    getListIdToLoad(loadExtremity: boolean): number[];
+}

package/lib/directive/selectable-list/store/selectable-list.service.d.ts

@@ -0,0 +1,23 @@
+import { EntityStore, QueryEntity } from "@datorama/akita";
+import { NiceSelectableListOptions } from "../model/selectable-list-options.model";
+import { NicePreloadSelectedEntitiesProvider } from "../providers/preload-selected-entities.provider";
+import { SelectableListStateService } from "./selectable-list-state.service";
+import { SelectableListState } from "./selectable-list.state";
+import * as i0 from "@angular/core";
+export declare class SelectableListService {
+    private providers;
+    private stores;
+    constructor(providers: NicePreloadSelectedEntitiesProvider<any>[]);
+    createState(name: string, options?: NiceSelectableListOptions): {
+        store: EntityStore<SelectableListState<any>, any, number>;
+        query: QueryEntity<SelectableListState<any>, any, number>;
+    };
+    getState(name: string): {
+        store: EntityStore<SelectableListState<any>, any, number>;
+        query: QueryEntity<SelectableListState<any>, any, number>;
+    };
+    withState<T, ID = any>(stateName: string, options?: NiceSelectableListOptions): SelectableListStateService<T, ID>;
+    query<T>(stateName: string): QueryEntity<SelectableListState<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectableListService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectableListService>;
+}

package/lib/directive/selectable-list/store/selectable-list.state.d.ts

@@ -0,0 +1,8 @@
+import { ActiveState, EntityState } from "@datorama/akita";
+export declare type SelectableListEntity<T> = T & {
+    loaded?: boolean;
+};
+export interface SelectableListState<T> extends EntityState<SelectableListEntity<T>, number>, ActiveState<any> {
+    allSelected: boolean;
+    unselectedEntity: any[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recursyve/nice-data-filter-kit",
-  "version": "14.1.6",
+  "version": "14.2.1",
   "exports": {
     ".": {
       "sass": "./_index.scss",

package/public-api.d.ts

@@ -1,4 +1,5 @@
 export * from "./lib/api/public-api";
 export * from "./lib/components/public-api";
+export * from "./lib/directive/public-api";
 export * from "./lib/models/public-api";
 export * from "./lib/utils/public-api";