@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.1

package/README.md

@@ -26,6 +26,7 @@ V tabeli so navedene kompatibilne verzije za commons knjižnico in povezane odvi
 
 | Commons | Angular | PrimeNG | Ngx-translate | Ngx-formly | Node                                 |
 |---------|---------|---------|---------------|------------|--------------------------------------|
+| 5.x.x   | 17.x.x  | 17.x.x  | 14.x.x        | 6.x.x      | ^18.13.0 \|\| ^20.9.0                |
 | 4.x.x   | 17.x.x  | 17.x.x  | 14.x.x        | 6.x.x      | ^18.13.0 \|\| ^20.9.0                |
 | 3.x.x   | 16.x.x  | 16.x.x  | 14.x.x        | 6.x.x      | ^16.14.0 \|\| ^18.10.0               |
 | 2.x.x   | 15.x.x  | 15.x.x  | 14.x.x        | 6.x.x      | ^14.20.0 \|\| ^16.13.0 \|\| ^18.10.0 |

package/core/README.md

@@ -0,0 +1,8 @@
+# @mediusinc/mng-commons/core
+
+Secondary entry point of `@mediusinc/mng-commons`. It can be used by importing from `@mediusinc/mng-commons/core`.
+
+## Dependencies within commons
+
+_This entry point has no other dependencies._
+

package/core/action/action-data.model.d.ts

@@ -0,0 +1,3 @@
+export type ActionData = {
+    [key: string]: any;
+};

package/core/action/action-parameters.model.d.ts

@@ -0,0 +1,17 @@
+import { ActivatedRoute } from '@angular/router';
+import { DataListParams } from '../data-list/data-list.model';
+import { IdType } from '../helpers/type-helpers';
+import { ActionData } from './action-data.model';
+export interface ActionParameters<Item> {
+    itemId?: IdType;
+    item?: Item;
+    actionData?: ActionData;
+    dataListParams?: DataListParams<any, any>;
+    sourceComponent?: any;
+    hostComponent?: unknown;
+    route?: ActivatedRoute;
+    selectedItems?: Item[];
+    locale?: string;
+    formItem?: Item | null;
+    submitResult?: Item | null;
+}

package/core/components/pages/error/error.page.component.d.ts

@@ -0,0 +1,8 @@
+import { CommonsService } from '../../../services/commons.service';
+import * as i0 from "@angular/core";
+export declare class ErrorPageComponent {
+    commons: CommonsService;
+    constructor(commons: CommonsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorPageComponent, "mng-error-page", never, {}, {}, never, never, true, never>;
+}

package/core/components/pages/not-found/not-found.page.component.d.ts

@@ -0,0 +1,8 @@
+import { CommonsService } from '../../../services/commons.service';
+import * as i0 from "@angular/core";
+export declare class NotFoundPageComponent {
+    commons: CommonsService;
+    constructor(commons: CommonsService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotFoundPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NotFoundPageComponent, "mng-not-found-page", never, {}, {}, never, never, true, never>;
+}

package/core/data-list/data-list-params-helpers.d.ts

@@ -0,0 +1,82 @@
+import { Params } from '@angular/router';
+import { TableLazyLoadEvent } from 'primeng/table';
+import { DataListFilter, DataListParams } from './data-list.model';
+/**
+ * Converts a TableLazyLoadEvent to DataListParams.
+ *
+ * @param {TableLazyLoadEvent} event - The event containing the data to convert.
+ * @return {DataListParams} - The converted DataListParams object.
+ */
+export declare function fromTableLoadToDataListParams(event: TableLazyLoadEvent): DataListParams;
+/**
+ * Converts the given parameters to URL query parameters.
+ * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListParams} params - The parameters to convert.
+ * @param {DataListParams|null} defaults - The default parameters used if no matching property in params is available. Defaults to { limit: 25, offset: 0 } if not provided.
+ * @returns {Params} - The URL query parameters object.
+ */
+export declare function dataListParamsToUrlQuery(params: DataListParams<any, any>, defaults?: DataListParams<any, any> | null): Params;
+/**
+ * Merges the provided parameters with default values and returns the merged object.
+ *
+ * @param {DataListParams} params - The parameters to merge with defaults.
+ * @param {DataListParams} defaults - The default values to merge with params (optional, default is { limit: 25, offset: 0 }).
+ * @returns {DataListParams} - The merged parameters object.
+ */
+export declare function mergeDataListParamsWithDefaults<Sorts = any, Filters extends keyof any = any>(params: DataListParams<Sorts, Filters>, defaults?: DataListParams<Sorts, Filters>): DataListParams<Sorts, Filters>;
+/**
+ * Converts an object of parameters to a URL query string for sorting.
+ * Sorts are formatted in Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ *
+ * @param {DataListParams} params - An optional object containing sort parameters.
+ * @returns A string representing the URL query or undefined if no sort parameters are provided.
+ */
+export declare function dataListParamsSortToUrlQuery(params?: DataListParams<any, any>): string | undefined;
+/**
+ * Converts a specific filter parameter (by key) from DataListParams object to a URL query string.
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListParams<any, Filters> | undefined} params - The DataListParams object containing the filters.
+ * @param {Filters} key - The key of the filter to convert.
+ * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the query string.
+ * @return {string | undefined} - The URL query string representing the specified filter, or undefined if the filter is not found.
+ */
+export declare function dataListParamsFiltersToUrlQuery<Filters extends keyof any = string>(params: DataListParams<any, Filters> | undefined, key: Filters, allowNull?: boolean): string | undefined;
+/**
+ * Converts a filter to a URL query string.
+ * Filter keys are "flattened" in the new object, values are formatted in Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {DataListFilter} paramFilter - The filter object to be converted.
+ * @param {boolean} [allowNull=false] - Indicates whether to allow null values in the filter.
+ * @returns {string|undefined} - The filter converted to a URL query string, or undefined if no filter is provided or the filter has empty or invalid values.
+ * @throws {CommonsInternalError} - If the filter has invalid values.
+ */
+export declare function dataListParamsFilterToUrlQuery(paramFilter?: DataListFilter, allowNull?: boolean): string | undefined;
+/**
+ * Converts URL query parameters to a DataListParams object.
+ * Sorts are formatted from Medius data API sort query language: `asc:prop1,desc:prop2`, ...
+ * Filter keys are all keys in Params object that are not matched elsewhere, values are formatted from Medius data API filter query language: `cs:eq:asd`, `in:asd,qwe`, `ex`, ...
+ *
+ * @param {Params} urlParams - The URL query parameters.
+ * @return {DataListParams} - The converted DataListParams object.
+ */
+export declare function fromUrlQueryToDataListParams(urlParams: Params): DataListParams;
+/**
+ * Makes a copy of the given DataListParams object.
+ *
+ * @param {DataListParams<Sorts, Filters>} params - The DataListParams object to be copied.
+ * @returns {DataListParams<Sorts, Filters>} - Returns a new copy of the DataListParams object.
+ */
+export declare function copyDataListParams<Sorts = string, Filters extends keyof any = string>(params: DataListParams<Sorts, Filters>): DataListParams<Sorts, Filters>;
+/**
+ * Converts a value to a URL query param string representation.
+ *
+ * @param {unknown} value - The value to be converted.
+ * @param {boolean} [allowNull=false] - Indicates whether null values are allowed.
+ * @returns {string} The URL parameter representation of the value.
+ * @throws {CommonsInternalError} If an undefined value is passed without allowNull set to true.
+ * @throws {CommonsInternalError} If the value is an object (excluding Date).
+ */
+export declare function dataListParamsFilterValueToUrlString(value: unknown, allowNull?: boolean): string;

package/core/data-providers/base.data-provider.d.ts

@@ -0,0 +1,32 @@
+import { ClassOptType, ClassType, ServiceClassOptType, ServiceClassType } from '../models/class-service.model';
+export type IDataProvider<ModelType = any, ServiceType = any, CT = ClassOptType<ModelType>, ST = ServiceClassOptType<ServiceType>> = {
+    classType: CT;
+    serviceType: ST;
+    isDataProvider: boolean;
+};
+/**
+ * A base data provider class used for handling data operations.
+ *
+ * @tparam Model - The type of data this data provider will handle.
+ * @tparam Service - The type of service used by this data provider (optional).
+ * @tparam ModelClass - The model type for the data provider  (optional).
+ * @tparam ServiceClass - The service type for the data provider  (optional).
+ */
+export declare class DataProviderInst<Model, Service = any, ModelClass = ClassOptType<Model>, ServiceClass = ServiceClassOptType<Service>> implements IDataProvider<Model, Service, ModelClass, ServiceClass> {
+    readonly classType: ModelClass;
+    readonly serviceType: ServiceClass;
+    protected constructor(classType: ModelClass, serviceType: ServiceClass);
+    get isDataProvider(): boolean;
+}
+export declare class DataProvider extends DataProviderInst<any> {
+    protected constructor();
+    static create<Model>(): DataProviderInst<Model, undefined, undefined, undefined>;
+    static fromClass<Model>(type: ClassType<Model>): DataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromClassWithService<Model, Service>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromService<Service, Model>(serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model>(): DataProviderInst<Model, undefined, undefined, undefined>;
+    static fromAnyParam<Model>(type: ClassType<Model>): DataProviderInst<Model, undefined, ClassType<Model>, undefined>;
+    static fromAnyParam<Model, Service = any>(type: undefined, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, undefined, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service = any>(type: ClassType<Model>, serviceType: ServiceClassType<Service>): DataProviderInst<Model, Service, ClassType<Model>, ServiceClassType<Service>>;
+    static fromAnyParam<Model, Service, ModelClass = ClassType<Model>, ServiceClass = ServiceClassType<Service>>(type?: ModelClass, serviceType?: ServiceClass): DataProviderInst<Model, Service, ModelClass, ServiceClass>;
+}

package/core/data-providers/lookup.data-provider.d.ts

@@ -0,0 +1,10 @@
+import { DataListParams } from '../data-list/data-list.model';
+import { ItemOrObservable } from '../helpers/type-helpers';
+import { ClassOptType, ServiceClassOptType } from '../models/class-service.model';
+import { IDataProvider } from './base.data-provider';
+export type LookupDataProviderLookupFnType<ModelType = any, ServiceType = undefined, ReturnType = ItemOrObservable<Array<ModelType>>> = (params: DataListParams | undefined, service: ServiceType, search?: string) => ReturnType;
+export interface ILookupDataProviderLookup<ModelType, ServiceType> {
+    lookup: LookupDataProviderLookupFnType<ModelType, ServiceType>;
+    withLookup(fn?: LookupDataProviderLookupFnType<ModelType, ServiceType>): this;
+}
+export type ILookupDataProvider<ModelType = any, ServiceType = any, CT = ClassOptType<ModelType>, ST = ServiceClassOptType<ServiceType>> = IDataProvider<ModelType, ServiceType, CT, ST> & ILookupDataProviderLookup<ModelType, ServiceType>;

package/core/descriptors/action.descriptor.d.ts

@@ -0,0 +1,12 @@
+import { IDataProvider } from '../data-providers/base.data-provider';
+import { ClassType } from '../models/class-service.model';
+import { IModelDescriptor } from './model.descriptor';
+export interface IActionDescriptor<Model, Service = any> {
+    model?: IModelDescriptor<Model>;
+    actionName: string;
+    actionNameLong: string;
+    parentType?: ClassType<unknown>;
+    parentTypeName?: string;
+    parentProperty?: string;
+    dataProvider?: IDataProvider<Model, Service>;
+}

package/core/descriptors/column.descriptor.d.ts

@@ -0,0 +1,3 @@
+export interface IColumnDescriptor<ColumnModel, TableModel, ColumnValue> {
+    property: string;
+}

package/core/descriptors/editor.descriptor.d.ts

@@ -0,0 +1,11 @@
+import { ArrayItemType } from '../helpers/type-helpers';
+import { IModelDescriptor } from './model.descriptor';
+export interface IEditorDescriptor<EditorModel> {
+    model: IModelDescriptor<EditorModel>;
+    isLocalized: boolean;
+    localizationLocaleProperty?: string;
+    localizationModel?: IModelDescriptor<any>;
+    localizationLocalizationProperty?: string;
+    localized<K extends keyof EditorModel, LocalizationModel = ArrayItemType<EditorModel[K]>>(property: K, model: IModelDescriptor<LocalizationModel>, localeProperty: keyof LocalizationModel): this;
+    localizedUnsafe<LocalizationModel>(property: string, model: IModelDescriptor<LocalizationModel>, localeProperty: string): this;
+}

package/core/descriptors/enum.descriptor.d.ts

@@ -0,0 +1,6 @@
+import { EnumType } from '../helpers/type-helpers';
+export interface IEnumDescriptor {
+    type: EnumType;
+    nameAsValue: boolean;
+    i18nBaseKey: string | null;
+}

package/core/descriptors/filter.descriptor.d.ts

@@ -0,0 +1,3 @@
+export interface IFilterDescriptor<FilterModel, TableModel> {
+    property: string;
+}

package/core/descriptors/lookup.descriptor.d.ts

@@ -0,0 +1,12 @@
+import { ILookupDataProvider, LookupDataProviderLookupFnType } from '../data-providers/lookup.data-provider';
+export interface ILookupDescriptor<Model, Service = any> {
+    optionsLabelProperty?: string;
+    optionsValueProperty?: string;
+    optionsTrackProperty?: string;
+    dataProvider: ILookupDataProvider<Model, Service>;
+    withOptionsLabelProperty(property: keyof Model): this;
+    withOptionsLabelPropertyUnsafe(property: string): this;
+    withOptionsTrackProperty(property: keyof Model): this;
+    withOptionsTrackPropertyUnsafe(property: string): this;
+    withLookup(lookup: LookupDataProviderLookupFnType<Model, Service>): this;
+}

package/core/descriptors/model.descriptor.d.ts

@@ -0,0 +1,8 @@
+import { ClassOptType } from '../models/class-service.model';
+export interface IModelDescriptor<Model, ModelClass = ClassOptType<Model>> {
+    type: ModelClass;
+    typeName?: string;
+    i18nBaseKey: string;
+    idProperty?: string;
+    titleProperty?: string;
+}

package/core/descriptors/table.descriptor.d.ts

@@ -0,0 +1,9 @@
+import { IColumnDescriptor } from './column.descriptor';
+import { IFilterDescriptor } from './filter.descriptor';
+import { IModelDescriptor } from './model.descriptor';
+export interface ITableDescriptor<TableModel, SortProperty, FilterProperty> {
+    model: IModelDescriptor<TableModel>;
+    withDefaultSortUnsafe(property: string, ascending?: boolean, order?: number, enabled?: boolean): this;
+    withSortUnsafe(property: string, isDefault: boolean, ascending?: boolean): this;
+    addFilterFromColumnDescriptorUnsafe<ColumnModel, ColumnValue>(column: IColumnDescriptor<ColumnModel, TableModel, ColumnValue>, forceSimple: boolean): IFilterDescriptor<any, TableModel>;
+}

package/core/descriptors/tableview.descriptor.d.ts

@@ -0,0 +1,11 @@
+import { IEditorDescriptor } from './editor.descriptor';
+import { IModelDescriptor } from './model.descriptor';
+import { ITableDescriptor } from './table.descriptor';
+export interface ITableviewDescriptor<TableviewModel, SortProperty, FilterProperty> {
+    model: IModelDescriptor<TableviewModel>;
+    table: ITableDescriptor<TableviewModel, SortProperty, FilterProperty>;
+    detailsEditor: IEditorDescriptor<TableviewModel>;
+    addEditor: IEditorDescriptor<TableviewModel>;
+    editEditor: IEditorDescriptor<TableviewModel>;
+    copy(): ITableviewDescriptor<TableviewModel, SortProperty, FilterProperty>;
+}

package/core/directives/component.directive.d.ts

@@ -0,0 +1,20 @@
+import { ComponentRef, InjectionToken, Injector, OnInit, Type } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ComponentDirective<C> implements OnInit {
+    private readonly injector;
+    private readonly elementRef;
+    private readonly applicationRef;
+    private readonly viewContainerRef;
+    component?: Type<C>;
+    componentIt?: InjectionToken<Type<C>>;
+    inputs?: {
+        [key: string]: any;
+    };
+    attachToHost: boolean;
+    nodeInjector?: Injector;
+    private componentInstanceEventEmitter;
+    componentRef: ComponentRef<C>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ComponentDirective<any>, "[mngComponent]", never, { "component": { "alias": "mngComponent"; "required": false; }; "componentIt": { "alias": "injectionToken"; "required": false; }; "inputs": { "alias": "inputs"; "required": false; }; "attachToHost": { "alias": "attachToHost"; "required": false; }; "nodeInjector": { "alias": "nodeInjector"; "required": false; }; }, { "componentInstanceEventEmitter": "instanceCreated"; }, never, never, true, never>;
+}

package/core/directives/dialog-keydown-handler.directive.d.ts

@@ -0,0 +1,12 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DialogKeydownHandlerDirective implements OnInit, OnDestroy {
+    private readonly dialogService;
+    private readonly dynamicDialog;
+    private readonly dialog;
+    private readonly dialogsWithKeydownListener;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogKeydownHandlerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogKeydownHandlerDirective, "[mngDialogKeydownHandler]", never, {}, {}, never, never, true, never>;
+}

package/core/directives/template.directive.d.ts

@@ -0,0 +1,12 @@
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TemplateDirective {
+    readonly template: TemplateRef<any>;
+    private readonly viewContainerRef;
+    type: string;
+    name: string;
+    getType(): string;
+    getViewContainerRef(): ViewContainerRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateDirective, "[mngTemplate]", never, { "type": { "alias": "type"; "required": false; }; "name": { "alias": "mngTemplate"; "required": true; }; }, {}, never, never, true, never>;
+}

package/core/enum/enum-helpers.d.ts

@@ -0,0 +1,49 @@
+import { EnumConstantType, EnumType } from '../helpers/type-helpers';
+import { EnumValue } from './enum.model';
+/**
+ * Returns array of names for constants in enum.
+ * @param enumType Enum object.
+ */
+export declare function getEnumConstantNames(enumType: EnumType): Array<string>;
+/**
+ * Returns array of names for constants in enum.
+ * @param enumObj Enum object.
+ */
+export declare function getEnumConstantNamesFromObject(enumObj: object): Array<string>;
+/**
+ * Returns array of string values for constants in enum.
+ * @param enumType Enum object.
+ */
+export declare function getEnumConstantValuesAsString(enumType: EnumType): Array<string>;
+/**
+ * Returns array of number values for constants in enum.
+ * @param enumType Enum object.
+ */
+export declare function getEnumConstantValuesAsNumber(enumType: EnumType): Array<number>;
+/**
+ * Returns array of type EnumValue for all constants in enum.
+ * @param enumType Enum object.
+ * @param nameAsValue If use name of constant as value (optional, default: false).
+ * @param titlePath Base path for title to use as translation (optional).
+ */
+export declare function fromEnumConstantsAsValueArray(enumType: EnumType, nameAsValue?: boolean, titlePath?: string): EnumValue[];
+/**
+ * Returns array of type EnumValue for provided values in enum.
+ * @param enumType Enum object.
+ * @param values Enum values (constants).
+ * @param nameAsValue If use name of constant as value (optional, default: false).
+ * @param titlePath Base path for title to use as translation (optional).
+ */
+export declare function fromEnumValuesAsValueArray<EnumConstant = EnumConstantType>(enumType: EnumType, values: Array<EnumConstant>, nameAsValue?: boolean, titlePath?: string): EnumValue[];
+/**
+ * Gets constant name for value.
+ * @param enumType Enum object.
+ * @param value Value of enum constant.
+ */
+export declare function getEnumConstantName<EnumConstant = EnumConstantType>(enumType: EnumType, value: EnumConstant): string | null;
+/**
+ * Gets constant name for value.
+ * @param enumObj Enum object.
+ * @param value Value of enum constant.
+ */
+export declare function getEnumConstantNameFromObject<EnumConstant = EnumConstantType>(enumObj: object, value: EnumConstant): string | null;

package/core/enum/enum.model.d.ts

@@ -0,0 +1,8 @@
+import { EnumConstantType, EnumType } from '../helpers/type-helpers';
+export interface EnumValue {
+    name?: string;
+    value: EnumConstantType;
+    title: string;
+    disabled?: boolean;
+}
+export type EnumFromProperty<Type, Property extends keyof Type> = Type[Property] extends EnumType | undefined | null ? NonNullable<Type[Property]> : never;

package/core/error/error-handler.d.ts

@@ -0,0 +1,6 @@
+import { ErrorHandler } from '@angular/core';
+export declare class CommonsErrorHandler implements ErrorHandler {
+    private static readonly logCategory;
+    private readonly logger;
+    handleError(error: Error): void;
+}

package/core/error/error-helpers.d.ts

@@ -0,0 +1,114 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { LogLevelEnum } from '../log/log.model';
+import { ACommonsErrorBase, ICommonsActionError } from './error.model';
+/**
+ * Converts RxJS subscription error to CommonsError.
+ * @param error Error.
+ * @param name Optional name to write in commons error.
+ * @param details Optional details of error.
+ */
+export declare function fromSubscribeError(error: any, name?: string, details?: any): ACommonsErrorBase;
+/**
+ * Checks if error is Http error (Angular or Commons).
+ * @param error
+ */
+export declare function isHttpErrorResponse(error: any): boolean;
+/**
+ * Gets HttpErrorResponse from error (Angular or Commons).
+ * @param error Error.
+ */
+export declare function getHttpErrorResponse(error: any): HttpErrorResponse | null;
+/**
+ * Gets HttpErrorResponse status from error (Angular or Commons).
+ * @param error Error.
+ */
+export declare function getHttpErrorResponseStatus(error: any): number | null;
+/**
+ * Get error log level. All is error, except if error is http error with status >=400 and <500.
+ * @param error Error.
+ */
+export declare function getErrorLogLevel(error: any): LogLevelEnum;
+/**
+ * Get error name (prototype name or type from commons error if name is not provided).
+ * @param error Error.
+ */
+export declare function getErrorName(error: any): string;
+/**
+ * Writes http error to string with all headers and body.
+ * @param error Http response error.
+ * @param opts Options for hiding parts of error:
+ *  - hideMessage Hides message of error (message include url, status and status text!).
+ *  - hideHeaders Hides headers.
+ *  - hideBody Hides JSON representation of body.
+ */
+export declare function httpErrorResponseToString(error: HttpErrorResponse, opts?: HttpErrorResponseToStringOptionsType): string;
+/**
+ * Error to string.
+ * @param error Error.
+ * @param opts Options for hiding parts of error:
+ * - hideMessage Hides message of error.
+ * - hideName Hides error name.
+ * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).
+ * - hideStack Hides stack of an error (if present).
+ * - hideDetails Hides JSON detail's representation of error (if present).
+ * - hideLocation Hides location (URL) where error was thrown.
+ * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).
+ */
+export declare function errorToString(error: Error, opts?: ErrorToStringOptionsType): string;
+/**
+ * Commons error to string.
+ * @param error Commons error.
+ * @param opts Options for hiding parts of error:
+ * - hideMessage Hides message of error.
+ * - hideName Hides error name.
+ * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).
+ * - hideStack Hides stack of an error (if present).
+ * - hideDetails Hides JSON detail's representation of error (if present).
+ * - hideLocation Hides location (URL) where error was thrown.
+ * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).
+ * - hideItems Hides all item information (http body, action context data).
+ * - hideActionData See @link(commonsActionErrorContextToString) for additional info.
+ * - hideQueryParams See @link(commonsActionErrorContextToString) for additional info.
+ */
+export declare function commonsErrorToString(error: ACommonsErrorBase, opts?: ErrorToStringOptionsType): string;
+/**
+ * Writes commons action error info from context as string.
+ * @param error Commons action error.
+ * @param opts Options for hiding parts of error:
+ * - hideItems Hides all item related information (item, form item, submit item, ...).
+ * - hideActionData Hides action data.
+ * - hideQueryParams Hides query params.
+ */
+export declare function commonsActionErrorContextToString(error: ICommonsActionError, opts?: ActionErrorContextToStringOptionsType): string;
+/**
+ * Writes cause of an error as string.
+ * @param error Error.
+ * @param opts Options for hiding parts of error:
+ * - causeOnErrorOnly Prints only if cause is instance of error.
+ * - causeAsJson Print error cause as a JSON (by default, if error only message and name will be printed).
+ */
+export declare function errorCauseToString(error: Error, opts?: ErrorCauseToStringOptionsType): string;
+export type ErrorToStringOptionsType = ErrorToStringOptionsBaseType & HttpErrorResponseToStringOptionsType & ActionErrorContextToStringOptionsType & ErrorCauseToStringOptionsType & {
+    hideDetails?: boolean;
+    hideLocation?: boolean;
+};
+export interface ErrorToStringOptionsBaseType {
+    hideName?: boolean;
+    hideStack?: boolean;
+    hideCause?: boolean;
+    hideHttp?: boolean;
+}
+export interface HttpErrorResponseToStringOptionsType {
+    hideMessage?: boolean;
+    hideHeaders?: boolean;
+    hideBody?: boolean;
+}
+export interface ActionErrorContextToStringOptionsType {
+    hideItems?: boolean;
+    hideActionData?: boolean;
+    hideQueryParams?: boolean;
+}
+export interface ErrorCauseToStringOptionsType {
+    causeOnErrorOnly?: boolean;
+    causeAsJson?: boolean;
+}

package/core/error/error.model.d.ts

@@ -0,0 +1,47 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { ActionParameters } from '../action/action-parameters.model';
+export type ErrorTypes = 'CommonsInternalError' | 'CommonsActionError' | 'CommonsHttpError';
+/**
+ * Main use for commons error from action execution.
+ * If http error is thrown, add it in cause.
+ */
+export interface ICommonsError extends Error {
+    type: ErrorTypes;
+    messageCode?: number | string;
+    message: string;
+    details?: any;
+    stack?: string;
+    cause?: Error | unknown;
+}
+export interface CommonsErrorBaseOptions {
+    name?: string;
+    messageCode?: number | string;
+    details?: any;
+    cause?: Error;
+    stack?: string;
+    location?: string;
+}
+export declare abstract class ACommonsErrorBase extends Error implements ICommonsError {
+    abstract readonly type: ErrorTypes;
+    readonly messageCode?: number | string;
+    readonly location?: string;
+    readonly details?: any;
+    protected constructor(message: string, options?: CommonsErrorBaseOptions);
+}
+export declare class CommonsInternalError extends ACommonsErrorBase implements ICommonsError {
+    readonly type = "CommonsInternalError";
+    constructor(message: string, options?: CommonsErrorBaseOptions);
+}
+export declare class CommonsHttpError extends ACommonsErrorBase implements ICommonsError {
+    readonly type = "CommonsHttpError";
+    readonly httpError: HttpErrorResponse;
+    constructor(message: string, httpError: HttpErrorResponse, options?: CommonsErrorBaseOptions);
+}
+export interface ICommonsActionError extends ICommonsError {
+    type: 'CommonsActionError';
+    httpError?: HttpErrorResponse;
+    actionContext?: ICommonsActionErrorContext;
+}
+export interface ICommonsActionErrorContext {
+    parameters: ActionParameters<any>;
+}

package/core/helpers/coercion.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { IdType, Nullable } from './type-helpers';
+export declare function boolean$Attribute(value: unknown): Observable<boolean>;
+export declare function number$Attribute(value: unknown): Observable<number>;
+export declare const toObservable: <T>(value: T | Observable<T>) => Observable<T>;
+export declare const itemIdToNumber: (value?: IdType) => number;
+export declare const itemIdToString: (value?: IdType) => string;
+export declare const itemIdToDefined: (value?: IdType) => IdType;
+export declare const valueToDefined: <T>(value: Nullable<T>) => T;

package/core/helpers/date.d.ts

@@ -0,0 +1,14 @@
+export type toIsoStringTypeOptType = 'date' | 'date-time' | 'dateTime';
+export type toIsoStringDateTimeOptsType = {
+    utc?: boolean;
+    noTimezone?: boolean;
+    noMillis?: boolean;
+};
+export declare function dateToIsoString(value: string | number | Date, type?: 'date'): string;
+export declare function dateToIsoString(value: string | number | Date, type: 'date-time' | 'dateTime', dateTimeOpts?: toIsoStringDateTimeOptsType): string;
+export declare function dateToIsoString(value: undefined | null | unknown, type?: 'date'): null;
+export declare function dateToIsoString(value: undefined | null | unknown, type: 'date-time' | 'dateTime', dateTimeOpts?: toIsoStringDateTimeOptsType): null;
+export declare function dateToIsoString(value: unknown, type?: toIsoStringTypeOptType, dateTimeOpts?: toIsoStringDateTimeOptsType): string | null;
+export declare function fromAngularDateFormatToPrime(ngDateFormat: string): string;
+export declare function angularDateFormatHasTime(ngDateFormat: string): boolean;
+export declare function angularDateFormatHasSeconds(ngDateFormat: string): boolean;

package/core/helpers/notification.d.ts

@@ -0,0 +1,2 @@
+import { Message, MessageService } from 'primeng/api';
+export declare function toastMessage(messageService: MessageService, title?: string, message?: string, severity?: 'success' | 'warn' | 'error', icon?: string): Message;

package/core/helpers/object.d.ts

@@ -0,0 +1,27 @@
+import { ClassType } from '../models/class-service.model';
+interface DeepCopyPropsOptions {
+    mapGettersToProperties?: boolean;
+}
+export interface DeepCopyOptions<P = object> extends DeepCopyPropsOptions {
+    objectPrototype?: ClassType<P>;
+}
+export declare function objectDeepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
+    mapGettersToProperties: true;
+}): T | Record<string, any>;
+export declare function objectDeepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
+    objectPrototype: ClassType<P>;
+} & {
+    mapGettersToProperties?: false;
+}): P;
+export declare function objectDeepCopy<T = object, P = object>(obj: T, options: DeepCopyOptions<P> & {
+    objectPrototype: ClassType<P>;
+} & {
+    mapGettersToProperties: true;
+}): P | Record<string, any>;
+export declare function objectDeepCopy<T = object, P = object>(obj: T, options?: DeepCopyOptions<P>): T;
+export declare function objectDeepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any>;
+export declare function getObjectProperties(obj: object): string[];
+export declare function getObjectGetters(obj: any): string[];
+export declare function getObjectPropertyByPath(value: any, path: string): any | undefined;
+export declare function flattenObjectKeys(objectModel: any): string[];
+export {};