@smallpearl/ngx-helper 0.29.23

package/mat-entity-crud/src/mat-entity-crud.component.d.ts

@@ -0,0 +1,267 @@
+import { HttpClient, HttpContextToken } from '@angular/common/http';
+import { AfterViewInit, EventEmitter, Injector, QueryList, TemplateRef } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { MatColumnDef } from '@angular/material/table';
+import { SPContextMenuItem } from '@smallpearl/ngx-helper/mat-context-menu';
+import { SPMatEntityListComponent } from '@smallpearl/ngx-helper/mat-entity-list';
+import { DomSanitizer } from '@angular/platform-browser';
+import { SPEntityFieldSpec } from '@smallpearl/ngx-helper/entity-field';
+import { Observable, Subscription } from 'rxjs';
+import { FormViewHostComponent } from './form-view-host.component';
+import { SPMatEntityCrudComponentBase } from './mat-entity-crud-internal-types';
+import { ALLOW_ITEM_ACTION_FN, CRUD_OP_FN, NewItemSubType, SPMatEntityCrudConfig, SPMatEntityCrudResponseParser } from './mat-entity-crud-types';
+import { PreviewHostComponent } from './preview-host.component';
+import * as i0 from "@angular/core";
+export declare class SPMatEntityCrudComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> extends SPMatEntityListComponent<TEntity, IdKey> implements SPMatEntityCrudComponentBase<TEntity>, AfterViewInit {
+    private snackBar;
+    itemLabel: import("@angular/core").InputSignal<string | undefined>;
+    itemLabelPlural: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * Title string displayed above the component. If not specified, will use
+     * itemLabelPlural() as the title.
+     */
+    title: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     *
+     */
+    itemActions: import("@angular/core").InputSignal<SPContextMenuItem[]>;
+    /**
+     * Specify the list of router paths that will be set as the value for
+     * [routerLink] for the 'New {{ item }}' button. If not specified,
+     * if createEditTemplate is specified, it will be shown. If not, `action`
+     * out event will be raised with `{ role: '_new_' }`.
+     */
+    newItemLink: import("@angular/core").InputSignal<string | string[] | undefined>;
+    /**
+     * If not specified, will use label from SPMatEntityCrudConfig.i18n.newItemLabel.
+     */
+    newItemLabel: import("@angular/core").InputSignal<string | string[] | undefined>;
+    /**
+     * Text for the Edit <item> pane title
+     */
+    editItemTitle: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * If you want "New {{item}}" button to support multiple entity types,
+     * you can set this to `NewItemSubType[]`, where each element stands for for
+     * a dropdown menu item. Refer to `NewItemSubType` for details on this
+     * interface.
+     */
+    newItemSubTypes: import("@angular/core").InputSignal<NewItemSubType[] | undefined>;
+    /**
+     * If you want to take control of the network operations for the CRUD
+     * operations (GET/CREATE/UPDATE/DELETE), provide a value for this property.
+     */
+    crudOpFn: import("@angular/core").InputSignal<CRUD_OP_FN<TEntity, IdKey> | undefined>;
+    /**
+     * Item preview template.
+     */
+    previewTemplate: import("@angular/core").InputSignal<TemplateRef<any> | undefined>;
+    /**
+     * Whether to allow a context menu action or not. Return false to disable
+     * the action.
+     */
+    allowEntityActionFn: import("@angular/core").InputSignal<ALLOW_ITEM_ACTION_FN<TEntity> | undefined>;
+    /**
+     * A template that allows the header to be replaced. Usage:-
+     *
+     *    ```
+     *    <sp-map-entity-crud
+     *      [headerTemplate]="myCrudViewHeader"
+     *    ></sp-map-entity-crud>
+     *    <ng-template #myCrudViewHeader>...</ng-template>
+     *    ```
+     */
+    headerTemplate: import("@angular/core").InputSignal<TemplateRef<any> | undefined>;
+    /**
+     * Set this to the custom template identifier that will replace the
+     * "New {{Item}}" button portion. This template will expand towards the
+     * title which will be placed to its left (right in rtl).
+     *
+     *    ```
+     *    <sp-map-entity-crud
+     *      [actionsTemplate]="myCrudActions"
+     *    ></sp-map-entity-crud>
+     *    <ng-template #myCrudActions>...</ng-template>
+     *    ```
+     */
+    actionsTemplate: import("@angular/core").InputSignal<TemplateRef<any> | undefined>;
+    /**
+     * CRUD action response parser. This will be called with the response
+     * from CREATE & UPDATE operations to parse the response JSON and return
+     * the created/updated TEntity.
+     */
+    crudResponseParser: import("@angular/core").InputSignal<SPMatEntityCrudResponseParser | undefined>;
+    /**
+     * An ng-template name that contains the component which provides the
+     * create/edit CRUD action.
+     *
+     *  ```
+     *  <ng-template #createEdit let-data>
+     *    <app-create-edit-entity-demo [bridge]="data.bridge" [entity]="data.entity"></app-create-edit-entity-demo>
+     *  </ng-template>
+     *  ```
+     * Note how [bridge] & [entity] properties are set deriving them from the
+     * implicit template context. [entity] will be undefined for Create
+     * opreation and will be the valid entity for an Update.
+     * (app-create-edit-entity-demo here is the client code that implements the
+     * Create/Edit form)
+     */
+    createEditFormTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+    /**
+     * Disables the per item actions column, preventing 'Edit' & 'Delete'
+     * (and other user defined) item operations.
+     */
+    disableItemActions: import("@angular/core").InputSignal<boolean>;
+    /**
+     * Disables the Create function.
+     */
+    disableCreate: import("@angular/core").InputSignal<boolean>;
+    /**
+     * View refresh policy after a CREATE/UPDATE operation. Values
+     *  'none'   - Objects are not refreshed after an edit operation. The return
+     *             value of the edit operation is used as the object to
+     *             add/update the component's internal store. This is the default.
+     *  'object' - Refresh just the object that was returned from the
+     *             CREATE/UPDATE operation. Use this if the JSON object returned
+     *             after a successful CREATE/UPDATE op differs from the JSON
+     *             object returned for the GET request.
+     *  'all'    - Refresh the entire list after a CREATE/UPDATE operation. This
+     *             mimics the behaviour of legacy HTML apps with pure server
+     *             defined UI.
+     */
+    refreshAfterEdit: import("@angular/core").InputSignal<"object" | "none" | "all">;
+    /**
+     * HttpContext for crud requests - list, create, retrieve, update & delete.
+     * The value can be an object where the property names reflect the CRUD
+     * methods with each of these keys taking
+     * `[[HttpContextToken<any>, any]] | [HttpContextToken<any>, any]` as its
+     * value. This object has a special key 'crud', which if given a value for,
+     * would be used for all CRUD requests (CREATE|READ|UPDATE|DELETE).
+     *
+     * Alternatively the property can be set a
+     * `[[HttpContextToken<any>, any]] | [HttpContextToken<any>, any]` as its
+     * value, in which case the same context would be used for all HTTP requests.
+     */
+    crudHttpReqContext: import("@angular/core").InputSignal<[HttpContextToken<any>, any] | [[HttpContextToken<any>, any]] | {
+        create?: [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any];
+        retrieve?: [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any];
+        update?: [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any];
+        delete?: [[HttpContextToken<any>, any]] | [HttpContextToken<any>, any];
+    } | undefined>;
+    /**
+     * Width of the edit pane as a percentange of the overall <as-split> width.
+     */
+    editPaneWidth: import("@angular/core").InputSignal<number>;
+    /**
+     * Width of the preview pane as a percentange of the overall <as-split> width.
+     */
+    previewPaneWidth: import("@angular/core").InputSignal<number>;
+    private getLabel;
+    _itemLabel: import("@angular/core").Signal<string>;
+    _itemLabelPlural: import("@angular/core").Signal<string>;
+    _title: import("@angular/core").Signal<string | undefined>;
+    _endpointSansParams: import("@angular/core").Signal<string>;
+    _endpointParams: import("@angular/core").Signal<void>;
+    componentColumns: import("@angular/core").Signal<readonly MatColumnDef[]>;
+    _clientColumnDefs: QueryList<MatColumnDef>;
+    /**
+     * Event raised for user selecting an item action. It's also raised
+     * for 'New <Item>' action, if 'newItemLink' property is not set.
+     */
+    action: EventEmitter<{
+        role: string;
+        entity?: TEntity;
+    }>;
+    /**
+     * Event raised when create Create/Edit pane is activated & deactivated.
+     * Event contains two flags:-
+     *  activated - whether the createEdit form view was activated or
+     *              deactivated.
+     *  cancelled - whether the form view was cancelled by user. False for this
+     *              indicates that the form view was closed after a successful
+     *              edit operation.
+     */
+    entityViewPaneActivated: EventEmitter<{
+        activated: boolean;
+        cancelled: boolean | undefined;
+        mode: "edit" | "preview";
+    }>;
+    busyWheelId: string;
+    sub$: Subscription;
+    spEntitiesList: import("@angular/core").Signal<SPMatEntityListComponent<TEntity, IdKey> | undefined>;
+    crudConfig: SPMatEntityCrudConfig;
+    createEditHostComponent: import("@angular/core").Signal<FormViewHostComponent<any> | undefined>;
+    createEditViewActive: import("@angular/core").WritableSignal<boolean>;
+    canCancelEditCallback: () => boolean;
+    previewHostComponent: import("@angular/core").Signal<PreviewHostComponent<any> | undefined>;
+    previewActive: import("@angular/core").Signal<boolean>;
+    previewedEntity: import("@angular/core").WritableSignal<TEntity | undefined>;
+    entityPaneActive: import("@angular/core").Signal<boolean>;
+    entityPaneWidth: import("@angular/core").Signal<number>;
+    entitiesPaneWidth: import("@angular/core").Signal<number>;
+    entitiesPaneHidden: import("@angular/core").Signal<boolean>;
+    defaultItemCrudActions: import("@angular/core").WritableSignal<SPContextMenuItem[]>;
+    columnsWithAction: import("@angular/core").Signal<(string | SPEntityFieldSpec<TEntity, IdKey>)[]>;
+    _itemActions: import("@angular/core").Signal<SPContextMenuItem[]>;
+    visibleColumns: import("@angular/core").Signal<string[]>;
+    constructor(http: HttpClient, snackBar: MatSnackBar, sanitizer: DomSanitizer, injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    /**
+     * If the create/edit entity form is active, it calls its registered
+     * canCancelEdit callback to determine if it's okay to cancel the edit.
+     * You can use this method from the host component's router guard to
+     * ensure that any changes made to the form are not accidentally lost by
+     * navigating away from the CRUD page.
+     *
+     * If your CRUD page has multiple sp-mat-entity-crud components, you have to
+     * implement the logic to call this method on the appropriate component.
+     *
+     * If the the create/edit form is not active, this method returns true.
+     * @returns
+     */
+    canDeactivate(): boolean;
+    refresh(): void;
+    closeCreateEdit(cancelled: boolean): void;
+    canCancelEdit(): boolean;
+    registerCanCancelEditCallback(callback: () => boolean): void;
+    triggerEntityUpdate(entity: TEntity): void;
+    triggerEntityDelete(entity: TEntity): void;
+    create(entityValue: any): Observable<any>;
+    update(id: TEntity[IdKey], entityValue: any): Observable<any>;
+    /**
+     * Refresh the entity list, after a CRUD CREATE or UPDATE operation.
+     * @param resp This is the response from the CRUD operation (CREATE/UPDATE).
+     * @param method The CRUD operation post which REFRESH is requested.
+     * @returns Observable<TEntity|null>
+     */
+    doRefreshAfterEdit(resp: any, method: 'create' | 'update'): Observable<any>;
+    getCrudOpResponseParser(): SPMatEntityCrudResponseParser;
+    closePreview(): void;
+    private closePreviewImpl;
+    onItemAction(role: string, entity: TEntity): void;
+    onCreate(event: Event): void;
+    onUpdate(entity: TEntity): void;
+    /**
+     * Show the create/edit component. This is deliberately made public so as to
+     * be callable from the client. This allows the client to dynamically
+     * set the form edit template and then show the edit pane by calling this
+     * method.
+     * @param entity
+     * @param params
+     */
+    showCreateEditView(entity?: TEntity | undefined, params?: any): void;
+    showPreviewView(entity?: TEntity, params?: any): void;
+    hidePreviewView(): void;
+    onDelete(entity: TEntity): Promise<void>;
+    getUrl(endpoint: string): string;
+    getEntityUrl(entityId: TEntity[IdKey]): string;
+    handleSelectEntity(entity: TEntity | undefined): void;
+    handleNewItemSubType(subtype: NewItemSubType): void;
+    private getCrudReqHttpContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SPMatEntityCrudComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SPMatEntityCrudComponent<any, any>, "sp-mat-entity-crud", never, { "itemLabel": { "alias": "itemLabel"; "required": false; "isSignal": true; }; "itemLabelPlural": { "alias": "itemLabelPlural"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "itemActions": { "alias": "itemActions"; "required": false; "isSignal": true; }; "newItemLink": { "alias": "newItemLink"; "required": false; "isSignal": true; }; "newItemLabel": { "alias": "newItemLabel"; "required": false; "isSignal": true; }; "editItemTitle": { "alias": "editItemTitle"; "required": false; "isSignal": true; }; "newItemSubTypes": { "alias": "newItemSubTypes"; "required": false; "isSignal": true; }; "crudOpFn": { "alias": "crudOpFn"; "required": false; "isSignal": true; }; "previewTemplate": { "alias": "previewTemplate"; "required": false; "isSignal": true; }; "allowEntityActionFn": { "alias": "allowEntityActionFn"; "required": false; "isSignal": true; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; "isSignal": true; }; "actionsTemplate": { "alias": "actionsTemplate"; "required": false; "isSignal": true; }; "crudResponseParser": { "alias": "crudResponseParser"; "required": false; "isSignal": true; }; "createEditFormTemplate": { "alias": "createEditFormTemplate"; "required": false; "isSignal": true; }; "disableItemActions": { "alias": "disableItemActions"; "required": false; "isSignal": true; }; "disableCreate": { "alias": "disableCreate"; "required": false; "isSignal": true; }; "refreshAfterEdit": { "alias": "refreshAfterEdit"; "required": false; "isSignal": true; }; "crudHttpReqContext": { "alias": "crudHttpReqContext"; "required": false; "isSignal": true; }; "editPaneWidth": { "alias": "editPaneWidth"; "required": false; "isSignal": true; }; "previewPaneWidth": { "alias": "previewPaneWidth"; "required": false; "isSignal": true; }; }, { "action": "action"; "entityViewPaneActivated": "entityViewPaneActivated"; }, ["_clientColumnDefs"], ["[breadCrumbs]"], true, never>;
+}

package/mat-entity-crud/src/preview-host.component.d.ts

@@ -0,0 +1,19 @@
+import { EmbeddedViewRef, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { SPMatEntityCrudComponentBase } from './mat-entity-crud-internal-types';
+import * as i0 from "@angular/core";
+export declare class PreviewHostComponent<TEntity> implements OnInit, OnDestroy {
+    vc: import("@angular/core").Signal<ViewContainerRef | undefined>;
+    entityCrudComponentBase: import("@angular/core").InputSignal<SPMatEntityCrudComponentBase<TEntity>>;
+    clientViewTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+    entity: import("@angular/core").WritableSignal<TEntity | undefined>;
+    clientView: EmbeddedViewRef<any> | null;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    show(entity: TEntity | undefined, params?: any): void;
+    close(): void;
+    private createClientView;
+    destroyClientView(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewHostComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewHostComponent<any>, "sp-entity-crud-preview-host", never, { "entityCrudComponentBase": { "alias": "entityCrudComponentBase"; "required": true; "isSignal": true; }; "clientViewTemplate": { "alias": "clientViewTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/mat-entity-crud/src/preview-pane.component.d.ts

@@ -0,0 +1,27 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { SPMatEntityCrudComponentBase } from './mat-entity-crud-internal-types';
+import { SPMatEntityCrudConfig } from './mat-entity-crud-types';
+import * as i0 from "@angular/core";
+/**
+ * A preview pane container to provide a consistent UX for all preview panes.
+ * It consits of a toolbar on the top and a container div below that takes up
+ * the rest of the preview pane area.
+ */
+export declare class SPMatEntityCrudPreviewPaneComponent<TEntity> implements OnInit, OnDestroy {
+    entity: import("@angular/core").InputSignal<TEntity>;
+    entityCrudComponent: import("@angular/core").InputSignal<SPMatEntityCrudComponentBase<TEntity>>;
+    title: import("@angular/core").InputSignal<string | undefined>;
+    disableUpdate: import("@angular/core").InputSignal<boolean>;
+    hideUpdate: import("@angular/core").InputSignal<boolean>;
+    disableDelete: import("@angular/core").InputSignal<boolean>;
+    hideDelete: import("@angular/core").InputSignal<boolean>;
+    config: SPMatEntityCrudConfig;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onEdit(): void;
+    onDelete(): void;
+    onClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SPMatEntityCrudPreviewPaneComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SPMatEntityCrudPreviewPaneComponent<any>, "sp-mat-entity-crud-preview-pane", never, { "entity": { "alias": "entity"; "required": true; "isSignal": true; }; "entityCrudComponent": { "alias": "entityCrudComponent"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "disableUpdate": { "alias": "disableUpdate"; "required": false; "isSignal": true; }; "hideUpdate": { "alias": "hideUpdate"; "required": false; "isSignal": true; }; "disableDelete": { "alias": "disableDelete"; "required": false; "isSignal": true; }; "hideDelete": { "alias": "hideDelete"; "required": false; "isSignal": true; }; }, {}, never, ["[previewToolbarContent]", "[previewContent]"], true, never>;
+}

package/mat-entity-crud/src/providers.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { SPMatEntityCrudConfig } from './mat-entity-crud-types';
+export declare const SP_MAT_ENTITY_CRUD_CONFIG: InjectionToken<SPMatEntityCrudConfig>;

package/mat-entity-list/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/mat-entity-list-types';
+export * from './src/providers';
+export * from './src/mat-entity-list.component';

package/mat-entity-list/src/config.d.ts

@@ -0,0 +1,6 @@
+import { SPMatEntityListConfig } from './mat-entity-list-types';
+export declare const DefaultSPMatEntityListConfig: SPMatEntityListConfig;
+/**
+ * To be called from an object's constructor.
+ */
+export declare function getEntityListConfig(): SPMatEntityListConfig;

package/mat-entity-list/src/mat-entity-list-types.d.ts

@@ -0,0 +1,53 @@
+import { HttpContextToken } from "@angular/common/http";
+import { Observable } from "rxjs";
+export interface SPMatEntityListHttpContext {
+    entityName: string;
+    entityNamePlural: string;
+    endpoint: string;
+}
+export declare const SP_MAT_ENTITY_LIST_HTTP_CONTEXT: HttpContextToken<SPMatEntityListHttpContext>;
+/**
+ * Pagination HTTP request params. Actually copied from Angular's HttpParams
+ * declaration. The ReadonlyArray<string|number|boolean> is a bit of an
+ * overkill for pagination params, but what the heck. When you copy-paste,
+ * do it in full!
+ */
+export type SPPageParams = {
+    [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+};
+/**
+ * An interface that the clients should provide, either via a global config
+ * (see above), that handles parsing the GET response and returns the entities
+ * stored therein. This class will allow the entity-list component to be
+ * used across different pagination response types as long as the appropriate
+ * SPMatEntityListPaginator class is provided to the component.
+ */
+export interface SPMatEntityListPaginator {
+    getRequestPageParams: (endpoint: string, pageIndex: number, pageSize: number) => SPPageParams;
+    parseRequestResponse: <TEntity extends {
+        [P in IdKey]: PropertyKey;
+    }, IdKey extends string = 'id'>(entityName: string, entityNamePlural: string, endpoint: string, params: SPPageParams, resp: any) => {
+        total: number;
+        entities: TEntity[];
+    };
+}
+/**
+ * 'entity' is really TEntity arg of SPMatEntityListComponent<TEntity>.
+ * 'column' is the column name. This allows the same value function to support
+ * multiple columns further enabing DRY.
+ */
+export type COLUMN_VALUE_FN = (entity: any, column: string) => string | number | Date | boolean;
+/**
+ * Global config for SPMatEntityList component.
+ */
+export interface SPMatEntityListConfig {
+    urlResolver?: (endpoint: string) => string;
+    paginator?: SPMatEntityListPaginator;
+    defaultPageSize?: number;
+    pageSizes?: Array<number>;
+}
+/**
+ * Type for custom entities loader function, which if provided will be called
+ * instead of HttpClient.get.
+ */
+export type SPMatEntityListEntityLoaderFn = (params: any) => Observable<any>;

package/mat-entity-list/src/mat-entity-list.component.d.ts

@@ -0,0 +1,209 @@
+import { HttpClient, HttpContext, HttpContextToken } from '@angular/common/http';
+import { AfterViewInit, ElementRef, EventEmitter, Injector, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { PageEvent } from '@angular/material/paginator';
+import { MatSort } from '@angular/material/sort';
+import { MatColumnDef, MatTable, MatTableDataSource } from '@angular/material/table';
+import { DomSanitizer } from '@angular/platform-browser';
+import { SPEntityField, SPEntityFieldSpec } from '@smallpearl/ngx-helper/entity-field';
+import { Observable, Subscription } from 'rxjs';
+import { SPMatEntityListEntityLoaderFn, SPMatEntityListPaginator } from './mat-entity-list-types';
+import * as i0 from "@angular/core";
+export declare class HeaderAlignmentDirective implements AfterViewInit {
+    private el;
+    headerAlignment: import("@angular/core").InputSignal<string | undefined>;
+    constructor(el: ElementRef);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderAlignmentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HeaderAlignmentDirective, "[headerAlignment]", never, { "headerAlignment": { "alias": "headerAlignment"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A component to display a list of entities loaded from remote.
+ */
+export declare class SPMatEntityListComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> implements OnInit, OnDestroy, AfterViewInit {
+    protected http: HttpClient;
+    private sanitizer;
+    private injector;
+    entityName: import("@angular/core").InputSignal<string>;
+    entityNamePlural: import("@angular/core").InputSignal<string | undefined>;
+    /**
+     * The endpoint from where the entities are to be retrieved
+     */
+    endpoint: import("@angular/core").InputSignal<string>;
+    /**
+     * Custom entities loader function, which if provided will be called
+     * instead of HttpClient.get.
+     */
+    entityLoaderFn: import("@angular/core").InputSignal<SPMatEntityListEntityLoaderFn | undefined>;
+    /**
+     * The columns of the entity to be displayed. This is an array of
+     * SPEntityFieldSpec objects. If there's a one-to-one mapping between the
+     * column's field name, its title & the rendered value, a string can be
+     * specified instead. That is, the value of this property is a heterogeneous
+     * array consisting of SPEntityFieldSpec<> objects and strings.
+     */
+    columns: import("@angular/core").InputSignal<(string | SPEntityFieldSpec<TEntity, IdKey>)[]>;
+    /**
+     * Names of columns that are displayed. This will default to all the columns
+     * listed in columns.
+     */
+    displayedColumns: import("@angular/core").InputSignal<string[]>;
+    /**
+     * Number of entities per page. If this is not set and paginator is defined,
+     * the number of entities int in the first request, will be taken as the
+     * page size.
+     */
+    pageSize: import("@angular/core").InputSignal<number>;
+    /**
+     * Entity idKey, if idKey is different from the default 'id'.
+     */
+    idKey: import("@angular/core").InputSignal<string>;
+    /**
+     * Type of pagination -- continuous or discrete. 'infinite' pagination
+     * uses an 'infiniteScroll' and 'discrete' pagination uses a mat-paginator
+     * at the bottom to navigate between pages.
+     */
+    pagination: import("@angular/core").InputSignal<"infinite" | "discrete" | "none">;
+    /**
+     * Component specific paginator. Only used if pagination != 'none'.
+     */
+    paginator: import("@angular/core").InputSignal<SPMatEntityListPaginator | undefined>;
+    /**
+     *
+     */
+    sorter: import("@angular/core").InputSignal<MatSort | undefined>;
+    /**
+     * Disable sorting of rows
+     */
+    disableSort: import("@angular/core").InputSignal<boolean>;
+    /**
+     * Wrappers for infiniteScroll properties, for customization by the client
+     */
+    infiniteScrollContainer: import("@angular/core").InputSignal<any>;
+    infiniteScrollDistance: import("@angular/core").InputSignal<number>;
+    infiniteScrollThrottle: import("@angular/core").InputSignal<number>;
+    infiniteScrollWindow: import("@angular/core").InputSignal<boolean>;
+    /**
+     * Custom context to be set for HttpClient requests. In the client code
+     * specify this property by initializing a member variable as:
+  
+        ```
+        Component({
+          ...
+          template: `
+            <sp-mat-entity-list
+              [httpReqContext]="httpReqContext"
+            ></sp-mat-entity-list>
+          `
+        })
+        export class YourComponent {
+          httpReqContext: [HttpContextToken<any>, any] = [
+            SIDELOAD_TO_COMPOSITE_PARAMS, 'customers'
+          ];
+        }
+        ```
+     *
+     * Of course if you want to pass multiple context properties, declare the type
+     * as an array of array. That is, `[[HttpContextToken<any>, any]]` and
+     * initialize it appropriately.
+     */
+    httpReqContext: import("@angular/core").InputSignal<[HttpContextToken<any>, any] | [[HttpContextToken<any>, any]] | undefined>;
+    _entityNamePlural: import("@angular/core").Signal<string | undefined>;
+    _httpReqContext: import("@angular/core").Signal<HttpContext>;
+    _deferViewInit: import("@angular/core").InputSignal<boolean>;
+    firstLoadDone: boolean;
+    allColumnNames: import("@angular/core").WritableSignal<string[]>;
+    _displayedColumns: import("@angular/core").Signal<string[]>;
+    dataSource: import("@angular/core").WritableSignal<MatTableDataSource<TEntity, import("@angular/material/paginator").MatPaginator>>;
+    table: import("@angular/core").Signal<MatTable<any> | undefined>;
+    sort: import("@angular/core").Signal<MatSort | undefined>;
+    viewColumnDefs: import("@angular/core").Signal<readonly MatColumnDef[]>;
+    clientColumnDefs: QueryList<MatColumnDef>;
+    contentColumnDefs: MatColumnDef[];
+    subs$: Subscription;
+    entityCount: import("@angular/core").WritableSignal<number>;
+    pageIndex: import("@angular/core").WritableSignal<number>;
+    lastFetchedEntitiesCount: import("@angular/core").WritableSignal<number>;
+    _pageSize: import("@angular/core").Signal<number>;
+    _columns: import("@angular/core").Signal<SPEntityFieldSpec<TEntity, IdKey>[]>;
+    __columns: import("@angular/core").Signal<SPEntityField<TEntity, IdKey>[]>;
+    store: import("@ngneat/elf").Store<{
+        name: string;
+        state: {
+            entities: Record<TEntity[IdKey], TEntity>;
+            ids: TEntity[IdKey][];
+        };
+        config: {
+            idKey: IdKey;
+        };
+    }, {
+        entities: Record<TEntity[IdKey], TEntity>;
+        ids: TEntity[IdKey][];
+    }>;
+    entities$: Observable<TEntity[]>;
+    _paginator: SPMatEntityListPaginator | undefined;
+    loading: import("@angular/core").WritableSignal<boolean>;
+    hasMore: import("@angular/core").WritableSignal<boolean>;
+    activeEntity: import("@angular/core").WritableSignal<TEntity | undefined>;
+    activeEntityId: import("@angular/core").Signal<any>;
+    _prevActiveEntity: TEntity | undefined;
+    _activeEntityChange: import("@angular/core").EffectRef;
+    selectEntity: EventEmitter<TEntity | undefined>;
+    ngxHelperConfig: import("@smallpearl/ngx-helper/core").SPNgxHelperConfig;
+    fieldConfig: import("@smallpearl/ngx-helper/entity-field").SPEntityFieldConfig;
+    entityListConfig: import("./mat-entity-list-types").SPMatEntityListConfig;
+    endpointChanged: import("@angular/core").EffectRef;
+    constructor(http: HttpClient, sanitizer: DomSanitizer, injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    /**
+     * Clear all entities in store and reload them from endpoint as if
+     * the entities are being loaded for the first time.
+     */
+    refresh(): void;
+    addEntity(entity: TEntity): void;
+    /**
+     * Update an entity with a modified version. Can be used by CRUD UPDATE
+     * operation to update an entity in the local store that is used to as the
+     * source of MatTableDataSource.
+     * @param id
+     * @param entity
+     */
+    updateEntity(id: TEntity[IdKey], entity: TEntity): void;
+    /**
+     * Clients can call this method when it has deleted and entity via a CRUD
+     * operation. Depending on the pagination mode, MatEntityList implements
+     * an appropriate behavior.
+     *
+     * If the pagination is 'infinite', the relevent entity is removed from our
+     * entity list. View will be repained as data store has changed.
+     *
+     * If the pagination is 'discrete', the entity is removed from the page.
+     * If this is the only entity in the page, the current pageNumber is
+     * decremented by 1 if it's possible (if the current pageNumber > 1).
+     * The page is reloaded from remote.
+     */
+    removeEntity(id: TEntity[IdKey]): void;
+    /**
+     * Build the contentColumnDefs array by enumerating all of client's projected
+     * content with matColumnDef directive.
+     */
+    buildContentColumnDefs(): void;
+    /**
+     * Build the effective columns by parsing our own <ng-container matColumnDef>
+     * statements for each column in columns() property and client's
+     * <ng-container matColumnDef> provided via content projection.
+     */
+    buildColumns(): void;
+    setupSort(): void;
+    infiniteScrollLoadNextPage(ev: any): void;
+    loadMoreEntities(): void;
+    private findArrayInResult;
+    handlePageEvent(e: PageEvent): void;
+    getUrl(endpoint: string): string;
+    toggleActiveEntity(entity: TEntity | undefined): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SPMatEntityListComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SPMatEntityListComponent<any, any>, "sp-mat-entity-list", never, { "entityName": { "alias": "entityName"; "required": true; "isSignal": true; }; "entityNamePlural": { "alias": "entityNamePlural"; "required": false; "isSignal": true; }; "endpoint": { "alias": "endpoint"; "required": false; "isSignal": true; }; "entityLoaderFn": { "alias": "entityLoaderFn"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "displayedColumns": { "alias": "displayedColumns"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "idKey": { "alias": "idKey"; "required": false; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "sorter": { "alias": "sorter"; "required": false; "isSignal": true; }; "disableSort": { "alias": "disableSort"; "required": false; "isSignal": true; }; "infiniteScrollContainer": { "alias": "infiniteScrollContainer"; "required": false; "isSignal": true; }; "infiniteScrollDistance": { "alias": "infiniteScrollDistance"; "required": false; "isSignal": true; }; "infiniteScrollThrottle": { "alias": "infiniteScrollThrottle"; "required": false; "isSignal": true; }; "infiniteScrollWindow": { "alias": "infiniteScrollWindow"; "required": false; "isSignal": true; }; "httpReqContext": { "alias": "httpReqContext"; "required": false; "isSignal": true; }; "_deferViewInit": { "alias": "_deferViewInit"; "required": false; "isSignal": true; }; }, { "selectEntity": "selectEntity"; }, ["clientColumnDefs"], never, true, never>;
+}

package/mat-entity-list/src/providers.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+import { SPMatEntityListConfig } from './mat-entity-list-types';
+export declare const SP_MAT_ENTITY_LIST_CONFIG: InjectionToken<SPMatEntityListConfig>;