@messaia/cdk 12.3.5-rc21 → 13.0.0-rc02

package/esm2020/lib/common/common.module.mjs

@@ -0,0 +1,118 @@
+import { Compiler, CompilerFactory, COMPILER_OPTIONS, NgModule, ViewEncapsulation } from '@angular/core';
+import { JitCompilerFactory } from '@angular/platform-browser-dynamic';
+import { DisableControlDirective } from './directives/disable-control.directive';
+import { DataSourcePipe } from './pipes/data-source.pipe';
+import { EnumPipe } from './pipes/enum.pipe';
+import { FileSizePipe } from './pipes/file-size.pipe';
+import { FilterPipe } from './pipes/filter.pipe';
+import { FirstLetterPipe } from './pipes/first-letter';
+import { KeysPipe } from './pipes/keys';
+import { MonthNamePipe } from './pipes/month-name.pipe';
+import { OnlyNumberDirective } from './pipes/only-number';
+import { OrderPipe } from './pipes/order.pipe';
+import { PlaceholderPipe } from './pipes/placeholder.pipe';
+import { SafeHtmlPipe } from './pipes/safe-html.pipe';
+import { TimePipe } from './pipes/time.pipe';
+import { TitleCase } from './pipes/titlecase.pipe';
+import { TruncatePipe } from './pipes/truncate.pipe';
+import { ValuesPipe } from './pipes/values';
+import * as i0 from "@angular/core";
+export { mixinControlValueAccessor } from './behaviors/control-value-accesor.mixin';
+export { mixinDisabled } from './behaviors/disabled.mixin';
+export { headerMetadataKey } from './constants/constants';
+export { Salutation } from './enums/salutation';
+export { Api, Display } from './functions/decorators';
+export { getEndpoint } from './functions/functions';
+export { Utils } from './functions/utils';
+export { AppStorage } from './helpers/app-storage';
+export { DynamicBuilder } from './helpers/dynamic-builder';
+export { AppSetting } from './models/app-setting';
+export { AuditUser } from './models/audit-user';
+export { KeyValue } from './models/key-value';
+export { SaveAction } from './models/save-action';
+export { DataSourcePipe } from './pipes/data-source.pipe';
+export { EnumPipe } from './pipes/enum.pipe';
+export { FirstLetterPipe } from './pipes/first-letter';
+export { KeysPipe } from './pipes/keys';
+export { OrderPipe } from './pipes/order.pipe';
+export { TitleCase } from './pipes/titlecase.pipe';
+export { ValuesPipe } from './pipes/values';
+export { BaseService } from './services/base.service';
+export { ContextHelper } from './services/context-helper';
+export { EnumService } from './services/enum.service';
+export { ServiceLocator } from './services/service-locator';
+const compilerOptions = {
+    useJit: true,
+    defaultEncapsulation: ViewEncapsulation.None
+};
+export function createCompiler(compilerFactory) {
+    return compilerFactory.createCompiler([compilerOptions]);
+}
+export const RUNTIME_COMPILER_PROVIDERS = [
+    { provide: COMPILER_OPTIONS, useValue: { compilerOptions }, multi: true },
+    { provide: CompilerFactory, useClass: JitCompilerFactory, deps: [COMPILER_OPTIONS] },
+    { provide: Compiler, useFactory: createCompiler, deps: [CompilerFactory] }
+];
+const COMMON_DECLARATIONS = [
+    TitleCase,
+    EnumPipe,
+    OrderPipe,
+    KeysPipe,
+    ValuesPipe,
+    DataSourcePipe,
+    FirstLetterPipe,
+    DisableControlDirective,
+    OnlyNumberDirective,
+    FileSizePipe,
+    FilterPipe,
+    PlaceholderPipe,
+    TruncatePipe,
+    TimePipe,
+    MonthNamePipe,
+    SafeHtmlPipe
+];
+export class VdCommonModule {
+}
+/** @nocollapse */ /** @nocollapse */ VdCommonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ VdCommonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdCommonModule, declarations: [TitleCase,
+        EnumPipe,
+        OrderPipe,
+        KeysPipe,
+        ValuesPipe,
+        DataSourcePipe,
+        FirstLetterPipe,
+        DisableControlDirective,
+        OnlyNumberDirective,
+        FileSizePipe,
+        FilterPipe,
+        PlaceholderPipe,
+        TruncatePipe,
+        TimePipe,
+        MonthNamePipe,
+        SafeHtmlPipe], exports: [TitleCase,
+        EnumPipe,
+        OrderPipe,
+        KeysPipe,
+        ValuesPipe,
+        DataSourcePipe,
+        FirstLetterPipe,
+        DisableControlDirective,
+        OnlyNumberDirective,
+        FileSizePipe,
+        FilterPipe,
+        PlaceholderPipe,
+        TruncatePipe,
+        TimePipe,
+        MonthNamePipe,
+        SafeHtmlPipe] });
+/** @nocollapse */ /** @nocollapse */ VdCommonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdCommonModule, providers: [...RUNTIME_COMPILER_PROVIDERS], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [COMMON_DECLARATIONS],
+                    declarations: [COMMON_DECLARATIONS],
+                    providers: [...RUNTIME_COMPILER_PROVIDERS]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.module.js","sourceRoot":"","sources":["../../../../../projects/cdk/src/lib/common/common.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { Compiler, CompilerFactory, CompilerOptions, COMPILER_OPTIONS, NgModule, StaticProvider, ViewEncapsulation } from '@angular/core';\r\nimport { JitCompilerFactory } from '@angular/platform-browser-dynamic';\r\nimport { DisableControlDirective } from './directives/disable-control.directive';\r\nimport { DataSourcePipe } from './pipes/data-source.pipe';\r\nimport { EnumPipe } from './pipes/enum.pipe';\r\nimport { FileSizePipe } from './pipes/file-size.pipe';\r\nimport { FilterPipe } from './pipes/filter.pipe';\r\nimport { FirstLetterPipe } from './pipes/first-letter';\r\nimport { KeysPipe } from './pipes/keys';\r\nimport { MonthNamePipe } from './pipes/month-name.pipe';\r\nimport { OnlyNumberDirective } from './pipes/only-number';\r\nimport { OrderPipe } from './pipes/order.pipe';\r\nimport { PlaceholderPipe } from './pipes/placeholder.pipe';\r\nimport { SafeHtmlPipe } from './pipes/safe-html.pipe';\r\nimport { TimePipe } from './pipes/time.pipe';\r\nimport { TitleCase } from './pipes/titlecase.pipe';\r\nimport { TruncatePipe } from './pipes/truncate.pipe';\r\nimport { ValuesPipe } from './pipes/values';\r\n\r\nexport { IControlValueAccessor, mixinControlValueAccessor } from './behaviors/control-value-accesor.mixin';\r\nexport { ICanDisable, mixinDisabled } from './behaviors/disabled.mixin';\r\nexport { headerMetadataKey } from './constants/constants';\r\nexport { Salutation } from './enums/salutation';\r\nexport { Api, Display } from './functions/decorators';\r\nexport { getEndpoint } from './functions/functions';\r\nexport { Utils } from './functions/utils';\r\nexport { AppStorage } from './helpers/app-storage';\r\nexport { DynamicBuilder } from './helpers/dynamic-builder';\r\nexport { AppSetting } from './models/app-setting';\r\nexport { AuditUser } from './models/audit-user';\r\nexport { IEntity } from './models/entity';\r\nexport { KeyValue } from './models/key-value';\r\nexport { SaveAction } from './models/save-action';\r\nexport { DataSourcePipe } from './pipes/data-source.pipe';\r\nexport { EnumPipe } from './pipes/enum.pipe';\r\nexport { FirstLetterPipe } from './pipes/first-letter';\r\nexport { KeysPipe } from './pipes/keys';\r\nexport { OrderPipe } from './pipes/order.pipe';\r\nexport { TitleCase } from './pipes/titlecase.pipe';\r\nexport { ValuesPipe } from './pipes/values';\r\nexport { BaseService } from './services/base.service';\r\nexport { ContextHelper } from './services/context-helper';\r\nexport { EnumService } from './services/enum.service';\r\nexport { ServiceLocator } from './services/service-locator';\r\n\r\nconst compilerOptions: CompilerOptions = {\r\n\tuseJit: true,\r\n\tdefaultEncapsulation: ViewEncapsulation.None\r\n};\r\n\r\nexport function createCompiler(compilerFactory: CompilerFactory) {\r\n\treturn compilerFactory.createCompiler([compilerOptions]);\r\n}\r\n\r\nexport const RUNTIME_COMPILER_PROVIDERS: StaticProvider[] = [\r\n\t{ provide: COMPILER_OPTIONS, useValue: { compilerOptions }, multi: true },\r\n\t{ provide: CompilerFactory, useClass: JitCompilerFactory, deps: [COMPILER_OPTIONS] },\r\n\t{ provide: Compiler, useFactory: createCompiler, deps: [CompilerFactory] }\r\n];\r\n\r\nconst COMMON_DECLARATIONS = [\r\n\tTitleCase,\r\n\tEnumPipe,\r\n\tOrderPipe,\r\n\tKeysPipe,\r\n\tValuesPipe,\r\n\tDataSourcePipe,\r\n\tFirstLetterPipe,\r\n\tDisableControlDirective,\r\n\tOnlyNumberDirective,\r\n\tFileSizePipe,\r\n\tFilterPipe,\r\n\tPlaceholderPipe,\r\n\tTruncatePipe,\r\n\tTimePipe,\r\n\tMonthNamePipe,\r\n\tSafeHtmlPipe\r\n];\r\n\r\n@NgModule({\r\n\timports: [],\r\n\texports: [COMMON_DECLARATIONS],\r\n\tdeclarations: [COMMON_DECLARATIONS],\r\n\tproviders: [...RUNTIME_COMPILER_PROVIDERS]\r\n})\r\nexport class VdCommonModule { }"]}

package/esm2020/lib/common/directives/disable-control.directive.mjs

@@ -0,0 +1,34 @@
+import { Directive, Input } from '@angular/core';
+import { FormControlDirective, FormControlName, NgControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class DisableControlDirective {
+    /**
+     * Constructor
+     * @param ngControl
+     */
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+    }
+    /**
+     * disableControl: boolean
+     */
+    set disableControl(condition) {
+        const action = condition ? 'disable' : 'enable';
+        if (this.ngControl instanceof FormControlName) {
+            this.ngControl.formDirective?.control?.controls[this.ngControl.name][action]();
+        }
+        else if (this.ngControl instanceof FormControlDirective) {
+            this.ngControl?.control[action]();
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DisableControlDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: DisableControlDirective, deps: [{ token: i1.NgControl }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ DisableControlDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: DisableControlDirective, selector: "[disableControl]", inputs: { disableControl: "disableControl" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: DisableControlDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[disableControl]' }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl }]; }, propDecorators: { disableControl: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/common/functions/utils.mjs

@@ -0,0 +1,161 @@
+import { HttpParams } from '@angular/common/http';
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+//@dynamic
+export class Utils {
+    /**
+     * Creates a range
+     * @param size
+     * @param startAt
+     */
+    static range(start, stop, step) {
+        return Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + (i * step));
+    }
+    /**
+     * Removes empty values from the specified object
+     * @param obj
+     */
+    static removeEmptyValues(obj) {
+        return Object.entries(obj)
+            .filter(([_, v]) => v != null)
+            .reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});
+    }
+    /**
+     * Gets number of days left in the specified month
+     * @param date
+     * @param monthOffset
+     */
+    static daysLeftInMonth(date, monthOffset = 0) {
+        var time = new Date(date.getTime());
+        time.setMonth(date.getMonth() + monthOffset);
+        time.setDate(0);
+        return Math.max(0, time.getDate() > date.getDate() ? time.getDate() - date.getDate() : 0);
+    }
+    /**
+     * Gets the value of the specifed object and property
+     * @param object
+     * @param property
+     * @returns
+     */
+    static getPropertyValue(object, property) {
+        /* Property not found */
+        if (!object || typeof object === 'undefined' || !property) {
+            return null;
+        }
+        /* Index of next property split */
+        var index = property.indexOf('.');
+        /* Property split found; recursive call */
+        if (index > -1) {
+            return this.getPropertyValue(object[property.substring(0, index)], property.substr(index + 1));
+        }
+        /* No split; get property */
+        return object[property];
+    }
+    /**
+     * Sorts an array of object by the specified property
+     * @param array
+     * @param property
+     * @returns
+     */
+    static sortArray(array, property, reverse) {
+        let sortDir = reverse === true ? -1 : 1;
+        return array = (array?.sort((a, b) => (a[property] > b[property]) ? sortDir : ((b[property] > a[property]) ? (sortDir * -1) : 0)) || []);
+    }
+    /**
+     * Truncates a text
+     * @param text
+     * @param length
+     * @returns
+     */
+    static truncateText(text, length) {
+        /* If text is not a string, return an empty string */
+        if (typeof text !== 'string') {
+            return '';
+        }
+        /* Remove html tags */
+        text = text.replace(/<\/?[^>]+(>|$)/g, "");
+        /* Truncate the string */
+        let truncatedText = text.substr(0, length);
+        /* Add ellipsis to the text */
+        if (text.length > length) {
+            truncatedText = `${truncatedText.trim()}...`;
+        }
+        return truncatedText;
+    }
+    /**
+     * Convert Object to HttpParams
+     *
+     * @param body
+     */
+    static toHttpParams(body) {
+        if (!body) {
+            return new HttpParams();
+        }
+        Object.keys(body).forEach((key) => (body[key] == null || body[key] == '' || body[key] == 'undefined') && body[key] != 0 && delete body[key]);
+        return new HttpParams({ fromObject: body });
+    }
+    /**
+     * Cleans the objects
+     * Removes empty properties
+     * @param obj
+     */
+    static cleanObject(obj) {
+        try {
+            for (var propName in obj) {
+                if (obj[propName] === null || obj[propName] === undefined || obj[propName] === "") {
+                    delete obj[propName];
+                }
+            }
+        }
+        catch (error) { }
+        return obj;
+    }
+    /**
+     * Gets the query params and the hash from the specified url
+     * @param url
+     * @returns
+     */
+    static getUrlParts(url) {
+        try {
+            /* Get urls parts */
+            var urlHashParts = url?.split('#') ?? [];
+            /* Get hash */
+            var urlHash = urlHashParts[1] ?? null;
+            /* Get query parts */
+            var urlQueryParts = urlHashParts[0]?.split('?');
+            /* Get query params as object */
+            var urlParams = urlQueryParts[1]?.split("&").reduce((prev, curr) => {
+                var p = curr.split("=");
+                prev[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+                return prev;
+            }, {}) ?? null;
+            return { url: urlQueryParts[0], params: urlParams, hash: urlHash };
+        }
+        catch (error) {
+            return { url: url, params: null, hash: null };
+        }
+    }
+}
+/**
+ * Month names
+ */
+Utils.germanMonthNames = [
+    { name: 'Januar', id: 1 },
+    { name: 'Februar', id: 2 },
+    { name: 'März', id: 3 },
+    { name: 'April', id: 4 },
+    { name: 'Mai', id: 5 },
+    { name: 'Juni', id: 6 },
+    { name: 'Juli', id: 7 },
+    { name: 'August', id: 8 },
+    { name: 'September', id: 9 },
+    { name: 'Oktober', id: 10 },
+    { name: 'November', id: 11 },
+    { name: 'Dezember', id: 12 }
+];
+/** @nocollapse */ /** @nocollapse */ Utils.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: Utils, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ Utils.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: Utils, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: Utils, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/common/functions/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpParams } from '@angular/common/http';\r\nimport { Directive } from '@angular/core';\r\n\r\n//@dynamic\r\n@Directive()\r\nexport class Utils {\r\n\r\n    /**\r\n     * Month names\r\n     */\r\n    public static germanMonthNames: { name: string, id: number }[] = [\r\n        { name: 'Januar', id: 1 },\r\n        { name: 'Februar', id: 2 },\r\n        { name: 'März', id: 3 },\r\n        { name: 'April', id: 4 },\r\n        { name: 'Mai', id: 5 },\r\n        { name: 'Juni', id: 6 },\r\n        { name: 'Juli', id: 7 },\r\n        { name: 'August', id: 8 },\r\n        { name: 'September', id: 9 },\r\n        { name: 'Oktober', id: 10 },\r\n        { name: 'November', id: 11 },\r\n        { name: 'Dezember', id: 12 }\r\n    ];\r\n\r\n    /**\r\n     * Creates a range\r\n     * @param size \r\n     * @param startAt \r\n     */\r\n    public static range(start: number, stop: number, step: number): ReadonlyArray<number> {\r\n        return Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + (i * step))\r\n    }\r\n\r\n    /**\r\n     * Removes empty values from the specified object\r\n     * @param obj \r\n     */\r\n    public static removeEmptyValues(obj: any): any {\r\n        return Object.entries(obj)\r\n            .filter(([_, v]) => v != null)\r\n            .reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});\r\n    }\r\n\r\n    /**\r\n     * Gets number of days left in the specified month\r\n     * @param date \r\n     * @param monthOffset \r\n     */\r\n    public static daysLeftInMonth(date: Date, monthOffset = 0): number {\r\n        var time = new Date(date.getTime());\r\n        time.setMonth(date.getMonth() + monthOffset);\r\n        time.setDate(0);\r\n        return Math.max(0, time.getDate() > date.getDate() ? time.getDate() - date.getDate() : 0);\r\n    }\r\n\r\n    /**\r\n     * Gets the value of the specifed object and property\r\n     * @param object \r\n     * @param property \r\n     * @returns \r\n     */\r\n    public static getPropertyValue(object: Object, property: string): any {\r\n        /* Property not found */\r\n        if (!object || typeof object === 'undefined' || !property) {\r\n            return null;\r\n        }\r\n\r\n        /* Index of next property split */\r\n        var index = property.indexOf('.')\r\n\r\n        /* Property split found; recursive call */\r\n        if (index > -1) {\r\n            return this.getPropertyValue(object[property.substring(0, index)], property.substr(index + 1));\r\n        }\r\n\r\n        /* No split; get property */\r\n        return object[property];\r\n    }\r\n\r\n    /**\r\n     * Sorts an array of object by the specified property\r\n     * @param array \r\n     * @param property \r\n     * @returns \r\n     */\r\n    public static sortArray<T>(array: T[], property: string, reverse?: boolean) {\r\n        let sortDir = reverse === true ? -1 : 1;\r\n        return array = (array?.sort((a: T, b: T) => (a[property] > b[property]) ? sortDir : ((b[property] > a[property]) ? (sortDir * -1) : 0)) || []);\r\n    }\r\n\r\n    /**\r\n     * Truncates a text\r\n     * @param text \r\n     * @param length \r\n     * @returns \r\n     */\r\n    public static truncateText(text: string, length: number): string {\r\n        /* If text is not a string, return an empty string */\r\n        if (typeof text !== 'string') {\r\n            return '';\r\n        }\r\n\r\n        /* Remove html tags */\r\n        text = text.replace(/<\\/?[^>]+(>|$)/g, \"\");\r\n\r\n        /* Truncate the string */\r\n        let truncatedText: string = text.substr(0, length);\r\n\r\n        /* Add ellipsis to the text */\r\n        if (text.length > length) {\r\n            truncatedText = `${truncatedText.trim()}...`;\r\n        }\r\n\r\n        return truncatedText;\r\n    }\r\n\r\n    /**\r\n     * Convert Object to HttpParams\r\n     * \r\n     * @param body\r\n     */\r\n    public static toHttpParams(body: any): HttpParams {\r\n        if (!body) {\r\n            return new HttpParams();\r\n        }\r\n\r\n        Object.keys(body).forEach((key) => (body[key] == null || body[key] == '' || body[key] == 'undefined') && body[key] != 0 && delete body[key]);\r\n        return new HttpParams({ fromObject: body });\r\n    }\r\n\r\n    /**\r\n     * Cleans the objects\r\n     * Removes empty properties\r\n     * @param obj \r\n     */\r\n    public static cleanObject(obj: any): any {\r\n        try {\r\n            for (var propName in obj) {\r\n                if (obj[propName] === null || obj[propName] === undefined || obj[propName] === \"\") {\r\n                    delete obj[propName];\r\n                }\r\n            }\r\n        } catch (error) { }\r\n\r\n        return obj;\r\n    }\r\n\r\n    /**\r\n     * Gets the query params and the hash from the specified url\r\n     * @param url \r\n     * @returns \r\n     */\r\n    public static getUrlParts(url: string): { url: string, params: Object, hash: string } {\r\n        try {\r\n            /* Get urls parts */\r\n            var urlHashParts = url?.split('#') ?? [];\r\n\r\n            /* Get hash */\r\n            var urlHash = urlHashParts[1] ?? null;\r\n\r\n            /* Get query parts */\r\n            var urlQueryParts = urlHashParts[0]?.split('?');\r\n\r\n            /* Get query params as object */\r\n            var urlParams: Object = urlQueryParts[1]?.split(\"&\").reduce((prev, curr) => {\r\n                var p = curr.split(\"=\");\r\n                prev[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);\r\n                return prev;\r\n            }, {}) ?? null;\r\n\r\n            return { url: urlQueryParts[0], params: urlParams, hash: urlHash };\r\n        } catch (error) {\r\n            return { url: url, params: null, hash: null };\r\n        }\r\n    }\r\n}"]}

package/esm2020/lib/common/helpers/app-storage.mjs

@@ -0,0 +1,53 @@
+import { Directive } from "@angular/core";
+import * as i0 from "@angular/core";
+//@dynamic
+export class AppStorage {
+}
+/**
+ * Gets storage key
+ * @param key
+ */
+AppStorage.getKey = (key) => `${key}`;
+/**
+ * Sets a string from localStorage
+ * @param key The key of the item to store
+ * @param value The value to store
+ */
+AppStorage.setString = (key, value) => localStorage.setItem(AppStorage.getKey(key), value);
+/**
+ * Gets a string from localStorage
+ * @param key The key of the item
+ */
+AppStorage.getString = (key) => localStorage.getItem(AppStorage.getKey(key));
+/**
+ * Sets an object from localStorage
+ * @param key The key of the item to store
+ * @param value The value to store
+ */
+AppStorage.setObject = (key, value) => {
+    try {
+        AppStorage.setString(key, JSON.stringify(value));
+    }
+    catch (error) {
+        console.warn(error);
+    }
+};
+/**
+ * Gets an object from localStorage
+ * @param key The key of the item
+ */
+AppStorage.getObject = (key) => {
+    try {
+        return JSON.parse(AppStorage.getString(key));
+    }
+    catch (error) {
+        console.warn(error);
+        return null;
+    }
+};
+/** @nocollapse */ /** @nocollapse */ AppStorage.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: AppStorage, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ AppStorage.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.3", type: AppStorage, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: AppStorage, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/common/helpers/dynamic-builder.mjs

@@ -0,0 +1,49 @@
+import { CommonModule } from '@angular/common';
+import { Compiler, Component, Injectable, NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DynamicBuilder {
+    /**
+     * Constructor
+     * @param componentFactoryResolver
+     */
+    constructor(compiler) {
+        this.compiler = compiler;
+    }
+    /**
+     * Compiles the specified html
+     * @param viewContainerRef
+     * @param template
+     * @param data
+     */
+    compileHtml(viewContainerRef, template, data) {
+        /* Create a dynamic component */
+        var component = Component({ template: template })(class {
+        });
+        /* Destroys all views in this container */
+        viewContainerRef.clear();
+        /* Compile the given NgModule and all of its components */
+        const module = this.compiler.compileModuleAndAllComponentsSync(NgModule({
+            declarations: [component],
+            exports: [component],
+            entryComponents: [component],
+            imports: [CommonModule]
+        })(class {
+        }));
+        /* Retrieve the factory object that creates a component of the given type */
+        const componentFactory = module.componentFactories.find((comp) => comp.componentType === component);
+        /* Instantiate a single component and inserts its host view into this container */
+        const componentRef = viewContainerRef.createComponent(componentFactory);
+        /* Add properties to the component */
+        Object.assign(componentRef.instance, data);
+        /* Check this view and its children */
+        componentRef.changeDetectorRef.detectChanges();
+        return componentRef;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DynamicBuilder.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: DynamicBuilder, deps: [{ token: i0.Compiler }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DynamicBuilder.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: DynamicBuilder, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: DynamicBuilder, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.Compiler }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/common/models/app-setting.mjs

@@ -0,0 +1,10 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class AppSetting {
+}
+/** @nocollapse */ /** @nocollapse */ AppSetting.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: AppSetting, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ AppSetting.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: AppSetting });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: AppSetting, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLXNldHRpbmcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvc3JjL2xpYi9jb21tb24vbW9kZWxzL2FwcC1zZXR0aW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRzNDLE1BQU0sT0FBTyxVQUFVOzs2SUFBVixVQUFVO2lKQUFWLFVBQVU7MkZBQVYsVUFBVTtrQkFEdEIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuQEluamVjdGFibGUoKVxyXG5leHBvcnQgY2xhc3MgQXBwU2V0dGluZyB7XHJcbiAgICBwcm9kdWN0aW9uOiBib29sZWFuO1xyXG4gICAgZGVidWc6IGJvb2xlYW47XHJcbiAgICBhcGlVcmw6IHN0cmluZztcclxuICAgIGZyb250ZW5kVXJsOiBzdHJpbmc7XHJcbiAgICBwcm9qZWN0TmFtZTogc3RyaW5nO1xyXG4gICAgY29weXJpZ2h0OiBzdHJpbmc7XHJcbiAgICBhdXRoVXJsOiBzdHJpbmc7XHJcbiAgICBzcGFVcmw6IHN0cmluZztcclxuICAgIHBvc3RMb2dpblJvdXRlOiBzdHJpbmc7XHJcbiAgICBhdXRoQ2xpZW50SWQ6IHN0cmluZztcclxuICAgIGF1dGhSZXNwb25zZVR5cGU6IHN0cmluZztcclxuICAgIGF1dGhTY29wZTogc3RyaW5nO1xyXG59Il19

package/esm2020/lib/common/pipes/data-source.pipe.mjs

@@ -0,0 +1,15 @@
+import { Pipe } from '@angular/core';
+import { MatTableDataSource } from '@angular/material/table';
+import * as i0 from "@angular/core";
+export class DataSourcePipe {
+    transform(data) {
+        return data ? new MatTableDataSource(data) : null;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DataSourcePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: DataSourcePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+/** @nocollapse */ /** @nocollapse */ DataSourcePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: DataSourcePipe, name: "dataSource" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: DataSourcePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'dataSource' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1zb3VyY2UucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9zcmMvbGliL2NvbW1vbi9waXBlcy9kYXRhLXNvdXJjZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBQ3BELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQUc3RCxNQUFNLE9BQU8sY0FBYztJQUMxQixTQUFTLENBQUMsSUFBVztRQUNwQixPQUFPLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0lBQ25ELENBQUM7O2lKQUhXLGNBQWM7K0lBQWQsY0FBYzsyRkFBZCxjQUFjO2tCQUQxQixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTWF0VGFibGVEYXRhU291cmNlIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvdGFibGUnO1xyXG5cclxuQFBpcGUoeyBuYW1lOiAnZGF0YVNvdXJjZScgfSlcclxuZXhwb3J0IGNsYXNzIERhdGFTb3VyY2VQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XHJcblx0dHJhbnNmb3JtKGRhdGE6IGFueVtdKTogYW55IHtcclxuXHRcdHJldHVybiBkYXRhID8gbmV3IE1hdFRhYmxlRGF0YVNvdXJjZShkYXRhKSA6IG51bGw7XHJcblx0fVxyXG59Il19

package/esm2020/lib/common/pipes/enum.pipe.mjs

@@ -0,0 +1,23 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+export class EnumPipe {
+    /**
+     * Converts enum value to string
+     * @param value
+     * @param enumType
+     */
+    transform(value, enumType, prefix = '', suffix = '') {
+        return `${prefix}${enumType[value]}${suffix}`;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ EnumPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: EnumPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+/** @nocollapse */ /** @nocollapse */ EnumPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: EnumPipe, name: "enum", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: EnumPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'enum',
+                    /* Required to update the value when the promise is resolved */
+                    pure: false
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW51bS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvY29tbW9uL3BpcGVzL2VudW0ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFPcEQsTUFBTSxPQUFPLFFBQVE7SUFFcEI7Ozs7T0FJRztJQUNILFNBQVMsQ0FBQyxLQUFhLEVBQUUsUUFBYSxFQUFFLFNBQWlCLEVBQUUsRUFBRSxTQUFpQixFQUFFO1FBQy9FLE9BQU8sR0FBRyxNQUFNLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxHQUFHLE1BQU0sRUFBRSxDQUFDO0lBQy9DLENBQUM7OzJJQVRXLFFBQVE7eUlBQVIsUUFBUTsyRkFBUixRQUFRO2tCQUxwQixJQUFJO21CQUFDO29CQUNMLElBQUksRUFBRSxNQUFNO29CQUNaLCtEQUErRDtvQkFDL0QsSUFBSSxFQUFFLEtBQUs7aUJBQ1giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuXHJcbkBQaXBlKHtcclxuXHRuYW1lOiAnZW51bScsXHJcblx0LyogUmVxdWlyZWQgdG8gdXBkYXRlIHRoZSB2YWx1ZSB3aGVuIHRoZSBwcm9taXNlIGlzIHJlc29sdmVkICovXHJcblx0cHVyZTogZmFsc2VcclxufSlcclxuZXhwb3J0IGNsYXNzIEVudW1QaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XHJcblxyXG5cdC8qKlxyXG5cdCAqIENvbnZlcnRzIGVudW0gdmFsdWUgdG8gc3RyaW5nXHJcblx0ICogQHBhcmFtIHZhbHVlIFxyXG5cdCAqIEBwYXJhbSBlbnVtVHlwZSBcclxuXHQgKi9cclxuXHR0cmFuc2Zvcm0odmFsdWU6IG51bWJlciwgZW51bVR5cGU6IGFueSwgcHJlZml4OiBzdHJpbmcgPSAnJywgc3VmZml4OiBzdHJpbmcgPSAnJyk6IGFueSB7XHJcblx0XHRyZXR1cm4gYCR7cHJlZml4fSR7ZW51bVR5cGVbdmFsdWVdfSR7c3VmZml4fWA7XHJcblx0fVxyXG59Il19

package/esm2020/lib/common/pipes/file-size.pipe.mjs

@@ -0,0 +1,37 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+const defaultPrecisionMap = {
+    bytes: 0,
+    KB: 0,
+    MB: 1,
+    GB: 1,
+    TB: 2,
+    PB: 2
+};
+export class FileSizePipe {
+    constructor() {
+        this.units = ['bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    }
+    transform(bytes = 0, precision = defaultPrecisionMap) {
+        if (isNaN(parseFloat(String(bytes))) || !isFinite(bytes)) {
+            return '?';
+        }
+        let unitIndex = 0;
+        while (bytes >= 1024) {
+            bytes /= 1024;
+            unitIndex++;
+        }
+        const unit = this.units[unitIndex];
+        if (typeof precision === 'number') {
+            return `${bytes.toFixed(+precision)} ${unit}`;
+        }
+        return `${bytes.toFixed(precision[unit])} ${unit}`;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ FileSizePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FileSizePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+/** @nocollapse */ /** @nocollapse */ FileSizePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FileSizePipe, name: "fileSize" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FileSizePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'fileSize' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/common/pipes/filter.pipe.mjs

@@ -0,0 +1,23 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+export class FilterPipe {
+    /**
+     * Filters the specified array
+     * @param items The array to filter
+     * @param filterBy the term
+     * @returns
+     */
+    transform(items, filterBy) {
+        return items?.filter(item => item.id.indexOf(filterBy) !== -1);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ FilterPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FilterPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+/** @nocollapse */ /** @nocollapse */ FilterPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FilterPipe, name: "filter", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FilterPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'filter',
+                    pure: false
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvc3JjL2xpYi9jb21tb24vcGlwZXMvZmlsdGVyLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBTXBELE1BQU0sT0FBTyxVQUFVO0lBRW5COzs7OztPQUtHO0lBQ0gsU0FBUyxDQUFDLEtBQVksRUFBRSxRQUFnQjtRQUNwQyxPQUFPLEtBQUssRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ25FLENBQUM7OzZJQVZRLFVBQVU7MklBQVYsVUFBVTsyRkFBVixVQUFVO2tCQUp0QixJQUFJO21CQUFDO29CQUNGLElBQUksRUFBRSxRQUFRO29CQUNkLElBQUksRUFBRSxLQUFLO2lCQUNkIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG5AUGlwZSh7XHJcbiAgICBuYW1lOiAnZmlsdGVyJyxcclxuICAgIHB1cmU6IGZhbHNlXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBGaWx0ZXJQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBGaWx0ZXJzIHRoZSBzcGVjaWZpZWQgYXJyYXlcclxuICAgICAqIEBwYXJhbSBpdGVtcyBUaGUgYXJyYXkgdG8gZmlsdGVyXHJcbiAgICAgKiBAcGFyYW0gZmlsdGVyQnkgdGhlIHRlcm1cclxuICAgICAqIEByZXR1cm5zIFxyXG4gICAgICovXHJcbiAgICB0cmFuc2Zvcm0oaXRlbXM6IGFueVtdLCBmaWx0ZXJCeTogc3RyaW5nKTogYW55IHtcclxuICAgICAgICByZXR1cm4gaXRlbXM/LmZpbHRlcihpdGVtID0+IGl0ZW0uaWQuaW5kZXhPZihmaWx0ZXJCeSkgIT09IC0xKTtcclxuICAgIH1cclxufSJdfQ==