@smallpearl/ngx-helper 0.33.50 → 20.0.2

package/core/index.d.ts

@@ -1 +1,3 @@
-export * from './src/version';
+declare const NGX_HELPER_VERSION = "0.1.0";
+
+export { NGX_HELPER_VERSION };

package/entities/index.d.ts

@@ -1,2 +1,313 @@
-export * from './src/paged-loader';
-export * from './src/paginator';
+import * as _ngneat_elf from '@ngneat/elf';
+import * as _ngneat_elf_pagination from '@ngneat/elf-pagination';
+import * as _smallpearl_ngx_helper_mat_entity_list from '@smallpearl/ngx-helper/mat-entity-list';
+import { SPMatEntityListPaginator } from '@smallpearl/ngx-helper/mat-entity-list';
+import * as _angular_core from '@angular/core';
+import { HttpContextToken, HttpContext, HttpParams, HttpClient } from '@angular/common/http';
+import { Observable, Subject, Subscription } from 'rxjs';
+
+/**
+ * A type representing an entity loader function that takes page number,
+ * page size, and an optional search value and returns an Observable of
+ * the response. This is similar the http.get() method of HttpClient but
+ * with pagination parameters. The return value is deliberately kept generic
+ * (Observable<any>) to allow flexibility in the response type. This reponse
+ * will be parsed by the provided paginator's parseRequestResponse() method.
+ * So as long as the function return type and paginator are compatible,
+ * any response type can be handled.
+ *
+ * Ideally the response should contain the total number of entities available
+ * at the remote and the array of entities for the requested page.
+ */
+type SPEntityLoaderFn = (page: number, pageSize: number, searchValue: string | undefined) => Observable<any>;
+/**
+ * Represents a request to load entities from the remote. This is used to
+ * compare two requests to determine if they are equal. This is useful to
+ * prevent duplicate requests being sent to the remote.
+ */
+declare class LoadRequest {
+    endpoint: string | SPEntityLoaderFn;
+    pageNumber: number;
+    searchStr: string | undefined;
+    force: boolean;
+    constructor(endpoint: string | SPEntityLoaderFn, pageNumber: number, searchStr: string | undefined, force?: boolean);
+    isEqualToAndNotForced(prev: LoadRequest): boolean;
+}
+type StateProps = {
+    allEntitiesLoaded: boolean;
+    loading: boolean;
+    loaded: boolean;
+};
+/**
+ * An abstract class that you can use wherever you would like to load entities
+ * from a remote endpoint in a paged manner. Entities can be loaded in one of
+ * two ways:
+ *
+ * 1. By providing an entityLoaderFn that takes an endpoint and HttpParams
+ *    and returns a Observable of entities.
+ * 2. Or by providing a URL and using the default loader that uses HttpClient
+ *    to load entities.
+ * This class uses RxJS to manage the loading of entities and provides
+ * signals to track the loading state, entity count, page index, page size,
+ * and whether more entities are available to load.
+ *
+ * How to use this class:
+ *
+ * 1. Dervice your component from SPPagedEntityLoader.
+ * 2. After your component is initialized, call the startLoader() method to
+ *    get the component going. This sets up the necessary subscriptions to
+ *    listen for load requests. Load requests are triggered by calling the
+ *    loadPage() or loadNextPage() methods.
+ * 3. If your component supports infinite scrolling, call loadMoreEntities()
+ *    method to load the next page of entities when it detects a scroll event.
+ * 4. If you component needs to load a specific page (via a pagination control),
+ *    call the loadPage(pageNumber) method to load the specified page.
+ * 5. Entities are stored in an internal entities store which is an @ngneat/elf
+ *    store. You can subscribe to the store's query to get the list of entities.
+ * 6. When your component is destroyed, call the stopLoader() method to clean up
+ *    internal subscriptions.
+ *
+ * The class is decorated with Angular's @Directive decorator so that we can
+ * use signals for the input properties and dependency injection for HttpClient.
+ * There are no abstract methods as such, but the class is meant to be extended
+ * by your component to provide the necessary configuration via input properties.
+ * This is why it is declared as abstract.
+ */
+declare abstract class SPPagedEntityLoader<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> {
+    static _entitiesCache: Map<string, {
+        refCount: number;
+        resp: any;
+    }>;
+    cacheKeys: Set<string>;
+    searchParamValue: string | undefined;
+    /**
+     * Entity name, that is used to form the "New { item }" menu item if
+     * inlineNew=true. This is also used as the key of the object in GET response
+     * if the reponse JSON is an object (sideloaded response), where the values
+     * are stored indexed by the server model name. For eg:-
+     *
+     * {
+     *    'customers': [
+     *      {...},
+     *      {...},
+     *      {...},
+     *    ]
+     * }
+     */
+    entityName: _angular_core.InputSignal<string>;
+    url: _angular_core.InputSignal<string | SPEntityLoaderFn>;
+    pageSize: _angular_core.InputSignal<number>;
+    paginator: _angular_core.InputSignal<SPMatEntityListPaginator | undefined>;
+    searchParamName: _angular_core.InputSignal<string>;
+    idKey: _angular_core.InputSignal<string>;
+    pluralEntityName: _angular_core.InputSignal<string | undefined>;
+    httpReqContext: _angular_core.InputSignal<[HttpContextToken<any>, any] | [[HttpContextToken<any>, any]] | HttpContext | undefined>;
+    httpParams: _angular_core.InputSignal<HttpParams | undefined>;
+    protected loadRequest$: Subject<LoadRequest>;
+    protected sub$: Subscription | undefined;
+    protected _pageSize: _angular_core.Signal<number>;
+    protected _pluralEntityName: _angular_core.Signal<string>;
+    protected _capitalizedEntityName: _angular_core.Signal<string>;
+    protected _httpReqContext: _angular_core.Signal<HttpContext>;
+    entityListConfig: _smallpearl_ngx_helper_mat_entity_list.SPMatEntityListConfig | null;
+    protected _paginator: _angular_core.Signal<SPMatEntityListPaginator>;
+    protected store: _ngneat_elf.Store<{
+        name: string;
+        state: {
+            entities: Record<TEntity[IdKey], TEntity>;
+            ids: TEntity[IdKey][];
+        } & StateProps & _ngneat_elf_pagination.PaginationState<0>;
+        config: never;
+    }, {
+        entities: Record<TEntity[IdKey], TEntity>;
+        ids: TEntity[IdKey][];
+    } & StateProps & _ngneat_elf_pagination.PaginationState<0>>;
+    protected http: HttpClient;
+    constructor();
+    /**
+     * Starts listening for load requests and processes them. Call this from your
+     * component's ngOnInit() or ngAfterViewInit() method.
+     */
+    startLoader(): void;
+    /**
+     * Stops listening for load requests and cleans up subscriptions.
+     */
+    stopLoader(): void;
+    hasStarted(): boolean;
+    /**
+     * Returns a boolean indicating whether all entities at the remote have been
+     * loaded. All entities are considered loaded when there are no more entities
+     * to load from the remote (that is all pages have been loaded without
+     * a search filter).
+     * @returns
+     */
+    allEntitiesLoaded(): boolean;
+    /**
+     * Returns the total number of entities at the remote as reported by the
+     * server (or load fn) during each load.
+     * @returns
+     */
+    totalEntitiesAtRemote(): number;
+    /**
+     * Returns number of entities currently stored in the internal store.
+     * @returns
+     */
+    totalEntitiesCount(): number;
+    /**
+     * Returns true if there are more entities to load from the remote.
+     * This is computed based on the total entities count and the number of
+     * entities loaded so far. For this method to work correctly, an initial
+     * load must have been performed to get the total count from the remote.
+     * @returns
+     */
+    hasMore(): boolean;
+    /**
+     * Returns true if a load operation is in progress. The load async operation
+     * method turns the loading state to true when a load operation starts and
+     * turns it to false when the operation completes.
+     * @returns
+     */
+    loading(): boolean;
+    /**
+     * Returns the loading state as an Observable that emits when the state changes.
+     * @returns
+     */
+    get loading$(): Observable<boolean>;
+    /**
+     * Boolean indicates whether the loader has completed at least one load
+     * operation.
+     */
+    loaded(): boolean;
+    /**
+     * Returns the endpoint URL if the loader was created with an endpoint.
+     * If the loader was created with a loader function, an empty string is
+     * returned.
+     * @returns
+     */
+    endpoint(): string;
+    /**
+     * Loads the specified page number of entities from the remote.
+     * @param pageNumber
+     */
+    loadPage(pageNumber: number): void;
+    /**
+     * Returns the total number of pages available at the remote.
+     * @returns
+     */
+    totalPages(): number;
+    /**
+     * Loads the next page of entities from the remote.
+     *
+     * @param searchParamValue Optional search parameter value. If specified
+     * and is different from the current search parameter value, the internal
+     * store is reset and entities are loaded from page 0 with the new search
+     * parameter value. Otherwise, the next page of entities is loaded.
+     */
+    loadNextPage(): void;
+    setSearchParamValue(searchStr: string): void;
+    setEntities(entities: TEntity[]): void;
+    getEntities(): TEntity[];
+    getEntity(id: TEntity[IdKey]): TEntity | undefined;
+    protected addAddlContextTokens(context: HttpContext): void;
+    protected doActualLoad(lr: LoadRequest): Observable<any>;
+    private existsInCache;
+    private getCacheKey;
+    private getFromCache;
+    addToCache(cacheKey: string, resp: any): void;
+    private removeFromCache;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SPPagedEntityLoader<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SPPagedEntityLoader<any, any>, "**spPagedEntityLoader**", never, { "entityName": { "alias": "entityName"; "required": true; "isSignal": true; }; "url": { "alias": "url"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "paginator": { "alias": "paginator"; "required": false; "isSignal": true; }; "searchParamName": { "alias": "searchParamName"; "required": false; "isSignal": true; }; "idKey": { "alias": "idKey"; "required": false; "isSignal": true; }; "pluralEntityName": { "alias": "pluralEntityName"; "required": false; "isSignal": true; }; "httpReqContext": { "alias": "httpReqContext"; "required": false; "isSignal": true; }; "httpParams": { "alias": "httpParams"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 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!
+ */
+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
+ * SPEntityListPaginator class is provided to the component.
+ */
+interface SPEntityListPaginator {
+    /**
+     * Return the HTTP request params for the given page index and page size as
+     * an object. For example, for a REST API that supports 'skip' and 'top' params,
+     * the implementation would be:
+     *
+     * ```typescript
+     * getRequestPageParams(endpoint: string, pageIndex: number, pageSize: number): SPPageParams {
+     *   return {
+     *     skip: pageIndex * pageSize,
+     *     top: pageSize
+     *   };
+     * }
+     * ```
+     * @param endpoint
+     * @param pageIndex
+     * @param pageSize
+     * @returns
+     */
+    getRequestPageParams: (endpoint: string, pageIndex: number, pageSize: number) => SPPageParams;
+    /**
+     * Parse the HTTP response received from the GET request and return an object
+     * containing the total number of entities available and the array of entities
+     * for the current page. For example, for the pure DRF paginated response
+     * like below:
+     * ```json
+     * {
+     *  "count": 102,
+     *  "next": "http://api.example.org/entities/?page=3",
+     *  "previous": "http://api.example.org/entities/?page=1",
+     *  "results": [
+     *    {
+     *      "id": 1,
+     *      "name": "Entity 1"
+     *    },
+     *    {
+     *      "id": 2,
+     *      "name": "Entity 2"
+     *    }
+     *  ]
+     * }
+     * ```
+     * The implementation would be:
+     * ```typescript
+     * 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[] } {
+     *   return {
+     *     total: resp.count,
+     *     entities: resp.results
+     *   };
+     * }
+     * ```
+     * @param entityName
+     * @param entityNamePlural
+     * @param endpoint
+     * @param params
+     * @param resp
+     * @returns
+     */
+    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[];
+    };
+}
+
+export { SPPagedEntityLoader };
+export type { SPEntityListPaginator, SPEntityLoaderFn, SPPageParams };

package/entity-field/index.d.ts

@@ -1,2 +1,101 @@
-export * from './src/entity-field';
-export * from './src/provider';
+import * as _smallpearl_ngx_helper_locale from '@smallpearl/ngx-helper/locale';
+import { SPIntlDateFormat } from '@smallpearl/ngx-helper/locale';
+import { Observable } from 'rxjs';
+import { InjectionToken } from '@angular/core';
+
+type FieldValueTypes = string | number | Date | boolean;
+/**
+ * This structure defines the data formatting details for a field of the
+ * entity. All entity fields need not necessarily be actual entity object's
+ * properties. Fields can also be computed fields, in which case the valueFn
+ * should be initialized with a valid function to provide the field's value.
+ */
+type SPEntityFieldSpec<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> = {
+    name: string;
+    label?: string | Observable<string>;
+    valueOptions?: {
+        dateTimeFormat?: SPIntlDateFormat;
+        isCurrency?: boolean;
+        currency?: string;
+        class?: string;
+        alignment?: 'start' | 'center' | 'end';
+        routerLink?: ((e: TEntity) => string[]) | [string];
+    };
+    valueFn?: (item: TEntity) => FieldValueTypes | Observable<FieldValueTypes>;
+};
+
+type FIELD_VALUE_FN = (entity: any, fieldName: string) => string | number | Date | boolean;
+/**
+ * Global config for SPEntityField component.
+ */
+interface SPEntityFieldConfig {
+    /**
+     * These are global field value functions.
+     *
+     * If a value function for a field is not explicitly specified, this map is
+     * looked up with the field name. If an entry exists in this table, it will
+     * be used to render the field's value.
+     *
+     * This is useful for formatting certain fields which tend to have the
+     * same name across the app. For instance fields such as 'amount', 'total'
+     * or 'balance'. Or 'date', 'timestamp', etc.
+     */
+    fieldValueFns?: Map<string, FIELD_VALUE_FN>;
+    /**
+     * Similar to above, but allows setting the options for certain fields
+     * globally. As in the case of `fieldValueFns`, the per field specification,
+     * if one exists, takes precedence over the global setting.
+     */
+    fieldValueOptions?: Map<string, SPEntityFieldSpec<any>['valueOptions']>;
+}
+declare const SP_ENTITY_FIELD_CONFIG: InjectionToken<SPEntityFieldConfig>;
+
+/**
+ * A class that represents a SPEntityFieldSpec<>. This is typically used
+ * by the library to evaluate a SPEntityFieldSpec<> object.
+ */
+declare class SPEntityField<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> {
+    fieldConfig?: SPEntityFieldConfig | undefined;
+    _fieldSpec: SPEntityFieldSpec<TEntity, IdKey>;
+    constructor(spec: SPEntityFieldSpec<TEntity, IdKey> | string, fieldConfig?: SPEntityFieldConfig | undefined);
+    get spec(): SPEntityFieldSpec<TEntity, IdKey>;
+    /**
+     * Returns the effective fieldValueOptions by merging the global field
+     * options (if one has been spefified) with the local field value options.
+     * @returns SPEntityFieldSpec<any>['valueOptions']
+     */
+    get options(): {
+        dateTimeFormat?: _smallpearl_ngx_helper_locale.SPIntlDateFormat;
+        isCurrency?: boolean;
+        currency?: string;
+        class?: string;
+        alignment?: "start" | "center" | "end";
+        routerLink?: [string] | ((e: TEntity) => string[]) | undefined;
+    };
+    /**
+     * @returns the label for the field.
+     */
+    label(): Observable<string>;
+    /**
+     * Given an entity, returns the value of the field matching the
+     * SPEntityFieldSpec<> in fieldSpec.
+     * @param entity TEntity instance which will be evaluated for
+     * SPEntityFieldSpec<>.
+     * @returns
+     */
+    value(entity: TEntity): any;
+    /**
+     * If specified, will be added to the CSS classes of the field's wrapper
+     * element.
+     */
+    get class(): string;
+    hasRouterLink(entity: TEntity): boolean;
+    getRouterLink(entity: TEntity): string[];
+}
+
+export { SPEntityField, SP_ENTITY_FIELD_CONFIG };
+export type { FIELD_VALUE_FN, SPEntityFieldConfig, SPEntityFieldSpec };

package/fesm2022/smallpearl-ngx-helper-entities.mjs

@@ -173,43 +173,43 @@ class SPPagedEntityLoader {
      *    ]
      * }
      */
-    entityName = input.required();
-    url = input.required();
+    entityName = input.required(...(ngDevMode ? [{ debugName: "entityName" }] : []));
+    url = input.required(...(ngDevMode ? [{ debugName: "url" }] : []));
     //** OPTIONAL ATTRIBUTES **//
     // Number of entities to be loaded per page from the server. This will be
     // passed to PagedEntityLoader to load entities in pages. Defaults to 50.
     // Adjust this accordingly based on the average size of your entities to
     // optimize server round-trips and memory usage.
-    pageSize = input(50);
+    pageSize = input(50, ...(ngDevMode ? [{ debugName: "pageSize" }] : []));
     // Paginator for the remote entity list. This is used to determine the
     // pagination parameters for the API request. If not specified, the global
     // paginator specified in SPMatEntityListConfig will be used. If that too is
     // not specified, a default paginator will be used. Default paginator can
     // handle DRF native PageNumberPagination and dynamic-rest style pagination.
-    paginator = input();
+    paginator = input(...(ngDevMode ? [undefined, { debugName: "paginator" }] : []));
     // Search parameter name to be used in the HTTP request.
     // Defaults to 'search'. That is when a search string is specified and
     // the entire entity list has not been fetched, a fresh HTTP request is made
     // to the remote server with `?<searchParamName>=<search string>` parameter.
-    searchParamName = input('search');
+    searchParamName = input('search', ...(ngDevMode ? [{ debugName: "searchParamName" }] : []));
     // Entity idKey, if idKey is different from the default 'id'.
-    idKey = input('id');
+    idKey = input('id', ...(ngDevMode ? [{ debugName: "idKey" }] : []));
     // Plural entity name, used when grouping options. If not specified, it is
     // derived by pluralizing the entityName.
-    pluralEntityName = input(undefined); // defaults to pluralized entityName
-    httpReqContext = input(undefined); // defaults to empty context
+    pluralEntityName = input(undefined, ...(ngDevMode ? [{ debugName: "pluralEntityName" }] : [])); // defaults to pluralized entityName
+    httpReqContext = input(undefined, ...(ngDevMode ? [{ debugName: "httpReqContext" }] : [])); // defaults to empty context
     // Parameters to be added to the HTTP request to retrieve data from
     // remote. This won't be used if `loadFromRemoteFn` is specified.
-    httpParams = input(undefined); // defaults to empty params
+    httpParams = input(undefined, ...(ngDevMode ? [{ debugName: "httpParams" }] : [])); // defaults to empty params
     // Mechanism to default pageSize to last entities length.
     loadRequest$ = new Subject();
     sub$;
-    _pageSize = computed(() => this.pageSize() ? this.pageSize() : 50);
+    _pageSize = computed(() => this.pageSize() ? this.pageSize() : 50, ...(ngDevMode ? [{ debugName: "_pageSize" }] : []));
     _pluralEntityName = computed(() => {
         const pluralEntityName = this.pluralEntityName();
         return pluralEntityName ? pluralEntityName : plural(this.entityName());
-    });
-    _capitalizedEntityName = computed(() => capitalize(this.entityName()));
+    }, ...(ngDevMode ? [{ debugName: "_pluralEntityName" }] : []));
+    _capitalizedEntityName = computed(() => capitalize(this.entityName()), ...(ngDevMode ? [{ debugName: "_capitalizedEntityName" }] : []));
     _httpReqContext = computed(() => {
         let reqContext = this.httpReqContext();
         const context = new HttpContext();
@@ -234,7 +234,7 @@ class SPPagedEntityLoader {
         // Give subclasses a chance to add their own context tokens.
         this.addAddlContextTokens(context);
         return context;
-    });
+    }, ...(ngDevMode ? [{ debugName: "_httpReqContext" }] : []));
     entityListConfig = inject(SP_MAT_ENTITY_LIST_CONFIG, {
         optional: true,
     });
@@ -248,7 +248,7 @@ class SPPagedEntityLoader {
             : entityListConfigPaginator
                 ? entityListConfigPaginator
                 : new DefaultPaginator();
-    });
+    }, ...(ngDevMode ? [{ debugName: "_paginator" }] : []));
     // We create it here so that store member variable will have the correct
     // type. Unfortunately elf doesn't have a simple generic type that we can
     // use to declare the type of the store and then initialize it later.
@@ -562,15 +562,15 @@ class SPPagedEntityLoader {
             }
         }
     }
-    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.6", ngImport: i0, type: SPPagedEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.1.6", type: SPPagedEntityLoader, isStandalone: true, selector: "**spPagedEntityLoader**", inputs: { entityName: { classPropertyName: "entityName", publicName: "entityName", isSignal: true, isRequired: true, transformFunction: null }, url: { classPropertyName: "url", publicName: "url", isSignal: true, isRequired: true, transformFunction: null }, pageSize: { classPropertyName: "pageSize", publicName: "pageSize", isSignal: true, isRequired: false, transformFunction: null }, paginator: { classPropertyName: "paginator", publicName: "paginator", isSignal: true, isRequired: false, transformFunction: null }, searchParamName: { classPropertyName: "searchParamName", publicName: "searchParamName", isSignal: true, isRequired: false, transformFunction: null }, idKey: { classPropertyName: "idKey", publicName: "idKey", isSignal: true, isRequired: false, transformFunction: null }, pluralEntityName: { classPropertyName: "pluralEntityName", publicName: "pluralEntityName", isSignal: true, isRequired: false, transformFunction: null }, httpReqContext: { classPropertyName: "httpReqContext", publicName: "httpReqContext", isSignal: true, isRequired: false, transformFunction: null }, httpParams: { classPropertyName: "httpParams", publicName: "httpParams", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: SPPagedEntityLoader, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    /** @nocollapse */ static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.16", type: SPPagedEntityLoader, isStandalone: true, selector: "**spPagedEntityLoader**", inputs: { entityName: { classPropertyName: "entityName", publicName: "entityName", isSignal: true, isRequired: true, transformFunction: null }, url: { classPropertyName: "url", publicName: "url", isSignal: true, isRequired: true, transformFunction: null }, pageSize: { classPropertyName: "pageSize", publicName: "pageSize", isSignal: true, isRequired: false, transformFunction: null }, paginator: { classPropertyName: "paginator", publicName: "paginator", isSignal: true, isRequired: false, transformFunction: null }, searchParamName: { classPropertyName: "searchParamName", publicName: "searchParamName", isSignal: true, isRequired: false, transformFunction: null }, idKey: { classPropertyName: "idKey", publicName: "idKey", isSignal: true, isRequired: false, transformFunction: null }, pluralEntityName: { classPropertyName: "pluralEntityName", publicName: "pluralEntityName", isSignal: true, isRequired: false, transformFunction: null }, httpReqContext: { classPropertyName: "httpReqContext", publicName: "httpReqContext", isSignal: true, isRequired: false, transformFunction: null }, httpParams: { classPropertyName: "httpParams", publicName: "httpParams", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.6", ngImport: i0, type: SPPagedEntityLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImport: i0, type: SPPagedEntityLoader, decorators: [{
             type: Directive,
             args: [{
                     selector: '**spPagedEntityLoader**',
                 }]
-        }], ctorParameters: () => [] });
+        }], ctorParameters: () => [], propDecorators: { entityName: [{ type: i0.Input, args: [{ isSignal: true, alias: "entityName", required: true }] }], url: [{ type: i0.Input, args: [{ isSignal: true, alias: "url", required: true }] }], pageSize: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageSize", required: false }] }], paginator: [{ type: i0.Input, args: [{ isSignal: true, alias: "paginator", required: false }] }], searchParamName: [{ type: i0.Input, args: [{ isSignal: true, alias: "searchParamName", required: false }] }], idKey: [{ type: i0.Input, args: [{ isSignal: true, alias: "idKey", required: false }] }], pluralEntityName: [{ type: i0.Input, args: [{ isSignal: true, alias: "pluralEntityName", required: false }] }], httpReqContext: [{ type: i0.Input, args: [{ isSignal: true, alias: "httpReqContext", required: false }] }], httpParams: [{ type: i0.Input, args: [{ isSignal: true, alias: "httpParams", required: false }] }] } });
 
 /**
  * Generated bundle index. Do not edit.