@smallpearl/ngx-helper 0.33.49 → 20.0.2

package/sideload/index.d.ts

@@ -1 +1,20 @@
-export * from './src/sideload';
+/**
+ * A function to merge sideloaded content into the main object thereby returning
+ * a composite object.
+ *
+ * @param resp - the JSON response object, typically received from remote for
+ * an HTTP request.
+ * @param targetObjKey - the key name of the target object into which the
+ * sideloaded data are to be merged.
+ * @param idKey - idKey. Function assumes that all the objects use the same
+ * key name as the unique object identifier.
+ * @param sideloadDataMap: An array of [string, string], where the first
+ * element specifies the property name of the target object and the second
+ * element the sideload data element's key. This is useful when the the
+ * target objet's property name that is to be merged with sideload data do not
+ * match.
+ * @returns Object with sideloaded data merged into the target object.
+ */
+declare function sideloadToComposite(resp: any, targetObjKey: string, idKey?: string, mergeStrategy?: 'inplace' | 'append', appendObjSuffix?: string, sideloadDataMap?: Array<[string, string, string?]>): any;
+
+export { sideloadToComposite };

package/stationary-with-line-items/index.d.ts

@@ -1 +1,78 @@
-export * from './src/stationary-with-line-items.component';
+import * as _smallpearl_ngx_helper_entity_field from '@smallpearl/ngx-helper/entity-field';
+import { SPEntityField, SPEntityFieldSpec } from '@smallpearl/ngx-helper/entity-field';
+import * as _angular_core from '@angular/core';
+import { OnInit, ChangeDetectorRef, TemplateRef } from '@angular/core';
+import { Observable } from 'rxjs';
+
+declare class FieldsRendererComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> implements OnInit {
+    cdr: ChangeDetectorRef;
+    entity: _angular_core.InputSignal<TEntity>;
+    fields: _angular_core.InputSignal<SPEntityField<TEntity, IdKey>[]>;
+    isString: _angular_core.Signal<boolean>;
+    stringValue: _angular_core.Signal<any>;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldsRendererComponent<any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldsRendererComponent<any, any>, "sp-fields-renderer", never, { "entity": { "alias": "entity"; "required": true; "isSignal": true; }; "fields": { "alias": "fields"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A component that renders a stationary with line items, such as invoice,
+ * payment receipt, bill, bill payment record, journal entry, etc. All these
+ * documents have a uniform format and this component abstracts out the
+ * information displayed in this type of document as properties that the client
+ * can provide while it takes care of the rendering.
+ *
+ * Ideally we would declare this as a wrapper class with the actual rendering
+ * to be performed by an inner replaceable component. This way the app will be
+ * able to support multiple stationary designs, which eventually can be
+ * chosen by the user. Perhaps even providing them a feature to design the
+ * stationary.
+ *
+ * This is the first towards that long path ahead.
+ */
+declare class StationaryWithLineItemsComponent<TEntity extends {
+    [P in IdKey]: PropertyKey;
+}, TEntityLineItem extends {
+    [P in IdKey]: PropertyKey;
+}, IdKey extends string = 'id'> implements OnInit {
+    entity: _angular_core.InputSignal<TEntity>;
+    title: _angular_core.InputSignal<string>;
+    number: _angular_core.InputSignal<string | number | undefined>;
+    leftHeader: _angular_core.InputSignal<string | (string | SPEntityFieldSpec<TEntity, IdKey>)[] | undefined>;
+    _leftHeaderFields: _angular_core.Signal<SPEntityField<TEntity, IdKey>[]>;
+    leftHeaderTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    rightHeader: _angular_core.InputSignal<string | (string | SPEntityFieldSpec<TEntity, IdKey>)[] | undefined>;
+    _rightHeaderFields: _angular_core.Signal<SPEntityField<TEntity, IdKey>[]>;
+    rightHeaderTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    items: _angular_core.InputSignal<{
+        [key: string]: string;
+    }[] | undefined>;
+    leftFooter: _angular_core.InputSignal<string | (string | SPEntityFieldSpec<TEntity, IdKey>)[] | undefined>;
+    _leftFooterFields: _angular_core.Signal<SPEntityField<TEntity, IdKey>[]>;
+    leftFooterTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    rightFooter: _angular_core.InputSignal<string | (string | SPEntityFieldSpec<TEntity, IdKey>)[] | undefined>;
+    _rightFooterFields: _angular_core.Signal<SPEntityField<TEntity, IdKey>[]>;
+    rightFooterTemplate: _angular_core.InputSignal<TemplateRef<any> | undefined>;
+    itemFieldName: _angular_core.InputSignal<string>;
+    itemColumnFields: _angular_core.InputSignal<(string | SPEntityFieldSpec<TEntity, IdKey>)[] | undefined>;
+    _itemColumnFields: _angular_core.Signal<SPEntityField<TEntity, IdKey>[]>;
+    _items: _angular_core.Signal<any>;
+    ngxEntityFieldConfig: _smallpearl_ngx_helper_entity_field.SPEntityFieldConfig;
+    constructor();
+    ngOnInit(): void;
+    isString(value: any): value is string;
+    /**
+     * Make the method a generic as we'll be using it for both TEntity and its
+     * child TEntityLineItem objects.
+     * @param fieldSpecs
+     * @returns
+     */
+    getSPEntityFields<T>(fieldSpecs: Array<SPEntityFieldSpec<TEntity, IdKey> | string> | string | undefined): Array<SPEntityField<TEntity, IdKey>>;
+    fieldLabel(field: SPEntityField<TEntity, IdKey>): Observable<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StationaryWithLineItemsComponent<any, any, any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StationaryWithLineItemsComponent<any, any, any>, "sp-stationary-with-line-items", never, { "entity": { "alias": "entity"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "number": { "alias": "number"; "required": false; "isSignal": true; }; "leftHeader": { "alias": "leftHeader"; "required": false; "isSignal": true; }; "leftHeaderTemplate": { "alias": "leftHeaderTemplate"; "required": false; "isSignal": true; }; "rightHeader": { "alias": "rightHeader"; "required": false; "isSignal": true; }; "rightHeaderTemplate": { "alias": "rightHeaderTemplate"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "leftFooter": { "alias": "leftFooter"; "required": false; "isSignal": true; }; "leftFooterTemplate": { "alias": "leftFooterTemplate"; "required": false; "isSignal": true; }; "rightFooter": { "alias": "rightFooter"; "required": false; "isSignal": true; }; "rightFooterTemplate": { "alias": "rightFooterTemplate"; "required": false; "isSignal": true; }; "itemFieldName": { "alias": "itemFieldName"; "required": false; "isSignal": true; }; "itemColumnFields": { "alias": "itemColumnFields"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FieldsRendererComponent, StationaryWithLineItemsComponent };

package/core/src/version.d.ts

@@ -1 +0,0 @@
-export declare const NGX_HELPER_VERSION = "0.1.0";

package/entities/src/paged-loader.d.ts

@@ -1,219 +0,0 @@
-import { HttpClient, HttpContext, HttpContextToken, HttpParams } from '@angular/common/http';
-import { SPMatEntityListPaginator } from '@smallpearl/ngx-helper/mat-entity-list';
-import { Observable, Subject, Subscription } from 'rxjs';
-import * as i0 from "@angular/core";
-/**
- * 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.
- */
-export 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.
- */
-export 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: import("@angular/core").InputSignal<string>;
-    url: import("@angular/core").InputSignal<string | SPEntityLoaderFn>;
-    pageSize: import("@angular/core").InputSignal<number>;
-    paginator: import("@angular/core").InputSignal<SPMatEntityListPaginator | undefined>;
-    searchParamName: import("@angular/core").InputSignal<string>;
-    idKey: import("@angular/core").InputSignal<string>;
-    pluralEntityName: import("@angular/core").InputSignal<string | undefined>;
-    httpReqContext: import("@angular/core").InputSignal<[HttpContextToken<any>, any] | [[HttpContextToken<any>, any]] | HttpContext | undefined>;
-    httpParams: import("@angular/core").InputSignal<HttpParams | undefined>;
-    protected loadRequest$: Subject<LoadRequest>;
-    protected sub$: Subscription | undefined;
-    protected _pageSize: import("@angular/core").Signal<number>;
-    protected _pluralEntityName: import("@angular/core").Signal<string>;
-    protected _capitalizedEntityName: import("@angular/core").Signal<string>;
-    protected _httpReqContext: import("@angular/core").Signal<HttpContext>;
-    entityListConfig: import("@smallpearl/ngx-helper/mat-entity-list").SPMatEntityListConfig | null;
-    protected _paginator: import("@angular/core").Signal<SPMatEntityListPaginator>;
-    protected store: import("@ngneat/elf").Store<{
-        name: string;
-        state: {
-            entities: Record<TEntity[IdKey], TEntity>;
-            ids: TEntity[IdKey][];
-        } & StateProps & import("@ngneat/elf-pagination").PaginationState<0>;
-        config: never;
-    }, {
-        entities: Record<TEntity[IdKey], TEntity>;
-        ids: TEntity[IdKey][];
-    } & StateProps & import("@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: i0.ɵɵFactoryDeclaration<SPPagedEntityLoader<any, any>, never>;
-    static ɵdir: i0.ɵɵ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>;
-}
-export {};

package/entities/src/paginator.d.ts

@@ -1,87 +0,0 @@
-/**
- * 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
- * SPEntityListPaginator class is provided to the component.
- */
-export 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[];
-    };
-}

package/entity-field/src/entity-field.d.ts

@@ -1,70 +0,0 @@
-import { SPIntlDateFormat } from '@smallpearl/ngx-helper/locale';
-import { Observable } from 'rxjs';
-import { SPEntityFieldConfig } from './provider';
-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.
- */
-export 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>;
-};
-/**
- * A class that represents a SPEntityFieldSpec<>. This is typically used
- * by the library to evaluate a SPEntityFieldSpec<> object.
- */
-export 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?: 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 {};

package/entity-field/src/provider.d.ts

@@ -1,27 +0,0 @@
-import { InjectionToken } from '@angular/core';
-import { SPEntityFieldSpec } from './entity-field';
-export type FIELD_VALUE_FN = (entity: any, fieldName: string) => string | number | Date | boolean;
-/**
- * Global config for SPEntityField component.
- */
-export 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']>;
-}
-export declare const SP_ENTITY_FIELD_CONFIG: InjectionToken<SPEntityFieldConfig>;

package/forms/src/validation-error-handler.d.ts

@@ -1,52 +0,0 @@
-import { HttpErrorResponse } from '@angular/common/http';
-import { ChangeDetectorRef } from '@angular/core';
-import { UntypedFormGroup } from '@angular/forms';
-import { Observable } from 'rxjs';
-/**
- * Handle's form validation errors sent from the server by setting the returned
- * error code in the respective control. Errors not associated with any control
- * in the form are attached to the form itself.
- *
- * These errors can then be rendered using error-tailor. All that needs to be
- * done is to import errorTailorImports in the respective page's module and set
- * the 'errorTailor' directive on the <form..> element.
- *
- * @param form FormGroup instance
- * @param error error object
- */
-export declare function handleValidationErrors(form: UntypedFormGroup, error: HttpErrorResponse, cdr?: ChangeDetectorRef): Observable<any>;
-/**
- * Returns an rxjs operator that would track an http request's error
- * state and if the return code is 400, would enumerate the error codes
- * set in the response body and set the error state of corresponding
- * form controls.
- *
- * Use it like below:
- *
- *  this.http.get<User>('https://google.com/..').pipe(
- *    setServerErrorsAsFormErrors(form),
- *    tap(user => {
- *      if (user) { // if user = null, it means there was a server validation
- *                  // error.
- *        this.user = user;
- *      }
- *    })
- *  ).subscribe();
- *
- * Note that setServerErrorsAsFormErrors() is the last operator in
- * the operators list. This is important because if a server validation
- * error is encountered, setServerErrorsAsFormErrors(), would place
- * the error on the respective form control and in the end would
- * return Observable<null>. Any subsequent opeators that are added
- * to the list after this should check for this null value in its
- * handler.
- *
- * @param form The FormGroup instance where the controls corresponding
- * to the errors are looked up and its control.error is set to the
- * returned error code.
- * @param cdr ChangeDetectorRef instance. If provided, it would be
- * used to detect changes after the error codes are set on the form
- * controls.
- * @returns An rxjs op that can be added to the pipe() arg list.
- */
-export declare function setServerErrorsAsFormErrors(form: UntypedFormGroup, cdr?: ChangeDetectorRef): <T>(source: Observable<T>) => Observable<T>;

package/hover-dropdown/src/hover-dropdown.directive.d.ts

@@ -1,41 +0,0 @@
-import { ElementRef, OnInit } from '@angular/core';
-import { MatMenuTrigger } from '@angular/material/menu';
-import * as i0 from "@angular/core";
-/**
- * A directive to make a button triggered mat-menu open during mouse hover.
- * Use it like this:
-
-      <button #menuTrigger="matMenuTrigger"
-        mat-icon-button
-        [matMenuTriggerFor]="children"
-        hoverDropDown
-        [menu]="children"
-        [hoverTrigger]="menuTrigger">
-        <mat-icon>menu</mat-icon>
-      </button>
-      <mat-menu #children="matMenu" hasBackdrop="false">
-        <button mat-menu-item (click)="onEdit()">Edit</button>
-        <button mat-menu-item (click)="onDelete()">Delete</button>
-      </mat-menu>
-
-  Note how hoverDropDown and [hoverTrigger] are used to wire up the button
-  and the associated mat-menu to the directive. Once setup like this, the
-  mat-menu will be opened whenever the mouse cursor hovers over the menu
-  trigger button.
-
-  Copied from:
-  https://stackoverflow.com/questions/54301126/how-to-show-the-angular-material-drop-down-on-mouse-over
- */
-export declare class HoverDropDownDirective implements OnInit {
-    private el;
-    static _menuClicked: boolean;
-    isInHoverBlock: boolean;
-    constructor(el: ElementRef);
-    hoverTrigger: import("@angular/core").InputSignal<MatMenuTrigger | null | undefined>;
-    menu: import("@angular/core").InputSignal<any>;
-    ngOnInit(): void;
-    private setHoverState;
-    private checkHover;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HoverDropDownDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<HoverDropDownDirective, "[hoverDropDown]", never, { "hoverTrigger": { "alias": "hoverTrigger"; "required": false; "isSignal": true; }; "menu": { "alias": "menu"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/locale/src/currency.pipe.d.ts

@@ -1,14 +0,0 @@
-import { PipeTransform } from '@angular/core';
-import * as i0 from "@angular/core";
-/**
- * This is a replacement for Angular's native currency pipe. This uses
- * web standardized Intl.NumberFormat() API to format currency. The advantage
- * of this over Angular's version is that this pipe allows the locale and
- * currency parameters to be dynamically changed during runtime.
- */
-export declare class SPCurrencyPipe implements PipeTransform {
-    constructor();
-    transform(value: number | bigint | string, currency?: string): string | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SPCurrencyPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<SPCurrencyPipe, "spCurrency", true>;
-}

package/locale/src/date.pipe.d.ts

@@ -1,14 +0,0 @@
-import { PipeTransform } from '@angular/core';
-import { SPIntlDateFormat } from './providers';
-import * as i0 from "@angular/core";
-/**
- * An alternative to the Angular built-in `DatePipe` based on the native `Intl.DateTimeFormat` API.
- * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
- * https://angular.io/api/common/DatePipe
- */
-export declare class SPDatePipe implements PipeTransform {
-    #private;
-    transform(value: Date | number | string, format?: SPIntlDateFormat, timeZone?: string): string | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SPDatePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<SPDatePipe, "spDate", true>;
-}

package/locale/src/format-currency.d.ts

@@ -1 +0,0 @@
-export declare function spFormatCurrency(value: number | bigint | string, currency?: string): string | null;

package/locale/src/format-date.d.ts

@@ -1,2 +0,0 @@
-import { SPIntlDateFormat } from "./providers";
-export declare function spFormatDate(value: Date | number | string, format?: SPIntlDateFormat, timeZone?: string): string;

package/locale/src/is-empty.d.ts

@@ -1 +0,0 @@
-export declare const isEmpty: (value: any) => boolean;