@stemy/ngx-utils 12.1.3 → 12.1.6

package/esm2020/ngx-utils/directives/unordered-list-item.directive.mjs

@@ -0,0 +1,77 @@
+import { Directive, ElementRef, Input, Renderer2, ViewContainerRef } from "@angular/core";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+export class UnorderedListItemDirective {
+    constructor(elementRef, renderer, viewContainer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.viewContainer = viewContainer;
+    }
+    get elem() {
+        return this.elementRef.nativeElement;
+    }
+    ngOnChanges(changes) {
+        if (!this.templates || !this.defaultTemplates || !this.item)
+            return;
+        const promise = this.item.value instanceof Promise ? this.item.value : Promise.resolve(this.item.value);
+        promise.then(value => {
+            this.item.value = value;
+            this.path = ObjectUtils.isNullOrUndefined(this.path) ? "" : this.path.toString();
+            this.isArray = ObjectUtils.isArray(this.data);
+            this.isObject = ObjectUtils.isObject(this.data);
+            this.valueIsArray = ObjectUtils.isArray(this.item.value);
+            this.valueIsObject = ObjectUtils.isObject(this.item.value);
+            this.valueType = ObjectUtils.getType(this.item.value);
+            const context = this;
+            const template = this.templates.find(t => t.type == this.type && ObjectUtils.evaluate(t.selector, context)) || this.defaultTemplates[this.type];
+            // Set view
+            this.viewContainer.clear();
+            this.viewContainer.createEmbeddedView(template, context);
+            // Set classes
+            if (this.type !== "item")
+                return;
+            this.item.classList = [];
+            this.isClass("is-array", this.valueIsArray);
+            this.isClass("is-object", this.valueIsObject);
+            this.isClass("is-value", !this.valueIsObject && !this.valueIsArray);
+            this.isClass(`type-${this.valueType}`);
+            this.isClass(`path-${this.path.replace(/\./g, "-")}`);
+            this.isClass(`key-${this.item.key}`);
+        }, reason => {
+            console.log("Can't handle promise rejection", reason);
+        });
+    }
+    isClass(className, value = true) {
+        if (!value)
+            return;
+        this.item.classList.push(className);
+    }
+}
+UnorderedListItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UnorderedListItemDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+UnorderedListItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: UnorderedListItemDirective, selector: "[unorderedListItem]", inputs: { item: ["unorderedListItem", "item"], type: "type", data: "data", keyPrefix: "keyPrefix", listStyle: "listStyle", path: "path", level: "level", templates: "templates", defaultTemplates: "defaultTemplates" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UnorderedListItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unorderedListItem]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }]; }, propDecorators: { item: [{
+                type: Input,
+                args: ["unorderedListItem"]
+            }], type: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], keyPrefix: [{
+                type: Input
+            }], listStyle: [{
+                type: Input
+            }], path: [{
+                type: Input
+            }], level: [{
+                type: Input
+            }], templates: [{
+                type: Input
+            }], defaultTemplates: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unordered-list-item.directive.js","sourceRoot":"","sources":["../../../../src/ngx-utils/directives/unordered-list-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, ElementRef, Input, OnChanges, Renderer2, SimpleChanges, ViewContainerRef} from \"@angular/core\";\r\nimport {UnorderedListStyle, UnorderedListTemplates, UnorederedListTemplate} from \"../common-types\";\r\nimport {ObjectUtils} from \"../utils/object.utils\";\r\nimport {StringUtils} from \"../utils/string.utils\";\r\n\r\n@Directive({\r\n    selector: \"[unorderedListItem]\"\r\n})\r\nexport class UnorderedListItemDirective implements OnChanges {\r\n\r\n    @Input(\"unorderedListItem\") item: any;\r\n    @Input() type: string;\r\n    @Input() data: any;\r\n    @Input() keyPrefix: string;\r\n    @Input() listStyle: UnorderedListStyle;\r\n    @Input() path: string;\r\n    @Input() level: number;\r\n    @Input() templates: UnorederedListTemplate[];\r\n    @Input() defaultTemplates: UnorderedListTemplates;\r\n\r\n    isArray: boolean;\r\n    isObject: boolean;\r\n    valueIsArray: boolean;\r\n    valueIsObject: boolean;\r\n    valueType: string;\r\n\r\n    get elem(): HTMLElement {\r\n        return this.elementRef.nativeElement;\r\n    }\r\n\r\n    constructor(private elementRef: ElementRef, private renderer: Renderer2, private viewContainer: ViewContainerRef) {\r\n\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        if (!this.templates || !this.defaultTemplates || !this.item) return;\r\n        const promise = this.item.value instanceof Promise ? this.item.value : Promise.resolve(this.item.value);\r\n        promise.then(value => {\r\n            this.item.value = value;\r\n            this.path = ObjectUtils.isNullOrUndefined(this.path) ? \"\" : this.path.toString();\r\n            this.isArray = ObjectUtils.isArray(this.data);\r\n            this.isObject = ObjectUtils.isObject(this.data);\r\n            this.valueIsArray = ObjectUtils.isArray(this.item.value);\r\n            this.valueIsObject = ObjectUtils.isObject(this.item.value);\r\n            this.valueType = ObjectUtils.getType(this.item.value);\r\n            const context: any = this;\r\n            const template = this.templates.find(t => t.type == this.type && ObjectUtils.evaluate(t.selector, context)) || this.defaultTemplates[this.type];\r\n            // Set view\r\n            this.viewContainer.clear();\r\n            this.viewContainer.createEmbeddedView(template, context);\r\n            // Set classes\r\n            if (this.type !== \"item\") return;\r\n            this.item.classList = [];\r\n            this.isClass(\"is-array\", this.valueIsArray);\r\n            this.isClass(\"is-object\", this.valueIsObject);\r\n            this.isClass(\"is-value\", !this.valueIsObject && !this.valueIsArray);\r\n            this.isClass(`type-${this.valueType}`);\r\n            this.isClass(`path-${this.path.replace(/\\./g, \"-\")}`);\r\n            this.isClass(`key-${this.item.key}`);\r\n        }, reason => {\r\n            console.log(\"Can't handle promise rejection\", reason);\r\n        });\r\n    }\r\n\r\n    private isClass(className: string, value: boolean = true): void {\r\n        if (!value) return;\r\n        this.item.classList.push(className);\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/directives/unordered-list-template.directive.mjs

@@ -0,0 +1,26 @@
+import { Directive, ElementRef, Input, TemplateRef } from "@angular/core";
+import { UnorederedListTemplate } from "../common-types";
+import * as i0 from "@angular/core";
+export class UnorderedListTemplateDirective extends UnorederedListTemplate {
+    constructor(elementRef, templateRef) {
+        super();
+        this.elementRef = elementRef;
+        this.templateRef = templateRef;
+    }
+    createEmbeddedView(context) {
+        return this.templateRef.createEmbeddedView(context);
+    }
+}
+UnorderedListTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UnorderedListTemplateDirective, deps: [{ token: i0.ElementRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+UnorderedListTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: UnorderedListTemplateDirective, selector: "ng-template[type][selector]", inputs: { type: "type", selector: "selector" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UnorderedListTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "ng-template[type][selector]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.TemplateRef }]; }, propDecorators: { type: [{
+                type: Input
+            }], selector: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5vcmRlcmVkLWxpc3QtdGVtcGxhdGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL25neC11dGlscy9kaXJlY3RpdmVzL3Vub3JkZXJlZC1saXN0LXRlbXBsYXRlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLFVBQVUsRUFBbUIsS0FBSyxFQUFFLFdBQVcsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN6RixPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQzs7QUFNdkQsTUFBTSxPQUFPLDhCQUErQixTQUFRLHNCQUFzQjtJQUt0RSxZQUFtQixVQUFzQixFQUFTLFdBQTZCO1FBQzNFLEtBQUssRUFBRSxDQUFDO1FBRE8sZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUFTLGdCQUFXLEdBQVgsV0FBVyxDQUFrQjtJQUUvRSxDQUFDO0lBRUQsa0JBQWtCLENBQUMsT0FBWTtRQUMzQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsa0JBQWtCLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDeEQsQ0FBQzs7MkhBWFEsOEJBQThCOytHQUE5Qiw4QkFBOEI7MkZBQTlCLDhCQUE4QjtrQkFKMUMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsNkJBQTZCO2lCQUMxQzsySEFJWSxJQUFJO3NCQUFaLEtBQUs7Z0JBQ0csUUFBUTtzQkFBaEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlLCBFbGVtZW50UmVmLCBFbWJlZGRlZFZpZXdSZWYsIElucHV0LCBUZW1wbGF0ZVJlZn0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtVbm9yZWRlcmVkTGlzdFRlbXBsYXRlfSBmcm9tIFwiLi4vY29tbW9uLXR5cGVzXCI7XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuICAgIHNlbGVjdG9yOiBcIm5nLXRlbXBsYXRlW3R5cGVdW3NlbGVjdG9yXVwiXHJcbn0pXHJcblxyXG5leHBvcnQgY2xhc3MgVW5vcmRlcmVkTGlzdFRlbXBsYXRlRGlyZWN0aXZlIGV4dGVuZHMgVW5vcmVkZXJlZExpc3RUZW1wbGF0ZSB7XHJcblxyXG4gICAgQElucHV0KCkgdHlwZTogc3RyaW5nO1xyXG4gICAgQElucHV0KCkgc2VsZWN0b3I6IHN0cmluZztcclxuXHJcbiAgICBjb25zdHJ1Y3RvcihwdWJsaWMgZWxlbWVudFJlZjogRWxlbWVudFJlZiwgcHVibGljIHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjxhbnk+KSB7XHJcbiAgICAgICAgc3VwZXIoKTtcclxuICAgIH1cclxuXHJcbiAgICBjcmVhdGVFbWJlZGRlZFZpZXcoY29udGV4dDogYW55KTogRW1iZWRkZWRWaWV3UmVmPGFueT4ge1xyXG4gICAgICAgIHJldHVybiB0aGlzLnRlbXBsYXRlUmVmLmNyZWF0ZUVtYmVkZGVkVmlldyhjb250ZXh0KTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2020/ngx-utils/ngx-utils.imports.mjs

@@ -0,0 +1,165 @@
+import { ErrorHandler } from "@angular/core";
+import { EVENT_MANAGER_PLUGINS } from "@angular/platform-browser";
+import { UrlSerializer } from "@angular/router";
+import { DeviceDetectorService } from "ngx-device-detector";
+import { AuthGuard } from "./utils/auth.guard";
+import { AclService } from "./services/acl.service";
+import { ApiService } from "./services/api.service";
+import { StaticAuthService } from "./services/auth.service";
+import { BaseHttpClient } from "./services/base-http.client";
+import { BaseHttpService } from "./services/base-http.service";
+import { ConfigService } from "./services/config.service";
+import { ErrorHandlerService } from "./services/error-handler.service";
+import { EventsService } from "./services/events.service";
+import { FormatterService } from "./services/formatter.service";
+import { GlobalTemplateService } from "./services/global-template.service";
+import { IconService } from "./services/icon.service";
+import { LanguageService } from "./services/language.service";
+import { PromiseService } from "./services/promise.service";
+import { OpenApiService } from "./services/open-api.service";
+import { StateService } from "./services/state.service";
+import { StaticLanguageService } from "./services/static-language.service";
+import { StorageService } from "./services/storage.service";
+import { ConsoleToasterService } from "./services/toaster.service";
+import { TranslatedUrlSerializer } from "./services/translated-url.serializer";
+import { UniversalService } from "./services/universal.service";
+import { ResizeEventPlugin } from "./plugins/resize-event.plugin";
+import { ScrollEventPlugin } from "./plugins/scroll-event.plugin";
+import { AsyncMethodBase } from "./directives/async-method.base";
+import { AsyncMethodDirective } from "./directives/async-method.directive";
+import { BackgroundDirective } from "./directives/background.directive";
+import { DynamicTableTemplateDirective } from "./directives/dynamic-table-template.directive";
+import { GlobalTemplateDirective } from "./directives/global-template.directive";
+import { IconDirective } from "./directives/icon.directive";
+import { NgxTemplateOutletDirective } from "./directives/ngx-template-outlet.directive";
+import { PaginationDirective } from "./directives/pagination.directive";
+import { PaginationItemDirective } from "./directives/pagination-item.directive";
+import { ResourceIfDirective } from "./directives/resource-if.directive";
+import { StickyDirective } from "./directives/sticky.directive";
+import { StickyClassDirective } from "./directives/sticky-class.directive";
+import { UnorderedListItemDirective } from "./directives/unordered-list-item.directive";
+import { UnorderedListTemplateDirective } from "./directives/unordered-list-template.directive";
+import { ChunkPipe } from "./pipes/chunk.pipe";
+import { EntriesPipe } from "./pipes/entries.pipe";
+import { ExtraItemPropertiesPipe } from "./pipes/extra-item-properties.pipe";
+import { FilterPipe } from "./pipes/filter.pipe";
+import { FindPipe } from "./pipes/find.pipe";
+import { FormatNumberPipe } from "./pipes/format-number.pipe";
+import { GetOffsetPipe } from "./pipes/get-offset.pipe";
+import { GetTypePipe } from "./pipes/get-type.pipe";
+import { GlobalTemplatePipe } from "./pipes/global-template.pipe";
+import { GroupByPipe } from "./pipes/group-by.pipe";
+import { IsTypePipe } from "./pipes/is-type.pipe";
+import { JoinPipe } from "./pipes/join.pipe";
+import { KeysPipe } from "./pipes/keys.pipe";
+import { MapPipe } from "./pipes/map.pipe";
+import { MaxPipe } from "./pipes/max.pipe";
+import { MinPipe } from "./pipes/min.pipe";
+import { ReducePipe } from "./pipes/reduce.pipe";
+import { RemapPipe } from "./pipes/remap.pipe";
+import { ReplacePipe } from "./pipes/replace.pipe";
+import { ReversePipe } from "./pipes/reverse.pipe";
+import { RoundPipe } from "./pipes/round.pipe";
+import { SafeHtmlPipe } from "./pipes/safe-html.pipe";
+import { TranslatePipe } from "./pipes/translate.pipe";
+import { ValuesPipe } from "./pipes/values.pipe";
+import { DynamicTableComponent } from "./components/dynamic-table/dynamic-table.component";
+import { PaginationMenuComponent } from "./components/pagination-menu/pagination-menu.component";
+import { UnorderedListComponent } from "./components/unordered-list/unordered-list.component";
+// --- Pipes ---
+export const pipes = [
+    ChunkPipe,
+    EntriesPipe,
+    ExtraItemPropertiesPipe,
+    FilterPipe,
+    FindPipe,
+    FormatNumberPipe,
+    GetOffsetPipe,
+    GetTypePipe,
+    GlobalTemplatePipe,
+    GroupByPipe,
+    IsTypePipe,
+    JoinPipe,
+    KeysPipe,
+    MapPipe,
+    MaxPipe,
+    MinPipe,
+    ReducePipe,
+    RemapPipe,
+    ReplacePipe,
+    ReversePipe,
+    RoundPipe,
+    SafeHtmlPipe,
+    TranslatePipe,
+    ValuesPipe
+];
+// --- Directives ---
+export const directives = [
+    AsyncMethodBase,
+    AsyncMethodDirective,
+    BackgroundDirective,
+    DynamicTableTemplateDirective,
+    GlobalTemplateDirective,
+    IconDirective,
+    NgxTemplateOutletDirective,
+    PaginationDirective,
+    PaginationItemDirective,
+    ResourceIfDirective,
+    StickyDirective,
+    StickyClassDirective,
+    UnorderedListItemDirective,
+    UnorderedListTemplateDirective
+];
+// --- Components ---
+export const components = [
+    DynamicTableComponent,
+    PaginationMenuComponent,
+    UnorderedListComponent
+];
+export const providers = [
+    ...pipes,
+    BaseHttpClient,
+    BaseHttpService,
+    AuthGuard,
+    AclService,
+    ApiService,
+    StaticAuthService,
+    ConfigService,
+    ErrorHandlerService,
+    EventsService,
+    FormatterService,
+    GlobalTemplateService,
+    IconService,
+    LanguageService,
+    OpenApiService,
+    PromiseService,
+    StateService,
+    StaticLanguageService,
+    StorageService,
+    ConsoleToasterService,
+    TranslatedUrlSerializer,
+    UniversalService,
+    DeviceDetectorService,
+    {
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: ResizeEventPlugin,
+        multi: true
+    },
+    {
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: ScrollEventPlugin,
+        multi: true
+    },
+    {
+        provide: UrlSerializer,
+        useExisting: TranslatedUrlSerializer
+    },
+    {
+        provide: ErrorHandler,
+        useExisting: ErrorHandlerService
+    }
+];
+export function loadConfig(config) {
+    return config.load;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-utils.imports.js","sourceRoot":"","sources":["../../../src/ngx-utils/ngx-utils.imports.ts"],"names":[],"mappings":"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","sourcesContent":["import {ErrorHandler} from \"@angular/core\";\r\nimport {EVENT_MANAGER_PLUGINS} from \"@angular/platform-browser\";\r\nimport {UrlSerializer} from \"@angular/router\";\r\nimport {DeviceDetectorService} from \"ngx-device-detector\";\r\n\r\nimport {IConfigService} from \"./common-types\";\r\n\r\nimport {AuthGuard} from \"./utils/auth.guard\";\r\nimport {AclService} from \"./services/acl.service\";\r\nimport {ApiService} from \"./services/api.service\";\r\nimport {StaticAuthService} from \"./services/auth.service\";\r\nimport {BaseHttpClient} from \"./services/base-http.client\";\r\nimport {BaseHttpService} from \"./services/base-http.service\";\r\nimport {ConfigService} from \"./services/config.service\";\r\nimport {ErrorHandlerService} from \"./services/error-handler.service\";\r\nimport {EventsService} from \"./services/events.service\";\r\nimport {FormatterService} from \"./services/formatter.service\";\r\nimport {GlobalTemplateService} from \"./services/global-template.service\";\r\nimport {IconService} from \"./services/icon.service\";\r\nimport {LanguageService} from \"./services/language.service\";\r\nimport {PromiseService} from \"./services/promise.service\";\r\nimport {OpenApiService} from \"./services/open-api.service\";\r\nimport {StateService} from \"./services/state.service\";\r\nimport {StaticLanguageService} from \"./services/static-language.service\";\r\nimport {StorageService} from \"./services/storage.service\";\r\nimport {ConsoleToasterService} from \"./services/toaster.service\";\r\nimport {TranslatedUrlSerializer} from \"./services/translated-url.serializer\";\r\nimport {UniversalService} from \"./services/universal.service\";\r\nimport {ResizeEventPlugin} from \"./plugins/resize-event.plugin\";\r\nimport {ScrollEventPlugin} from \"./plugins/scroll-event.plugin\";\r\nimport {AsyncMethodBase} from \"./directives/async-method.base\";\r\nimport {AsyncMethodDirective} from \"./directives/async-method.directive\";\r\nimport {BackgroundDirective} from \"./directives/background.directive\";\r\nimport {DynamicTableTemplateDirective} from \"./directives/dynamic-table-template.directive\";\r\nimport {GlobalTemplateDirective} from \"./directives/global-template.directive\";\r\nimport {IconDirective} from \"./directives/icon.directive\";\r\nimport {NgxTemplateOutletDirective} from \"./directives/ngx-template-outlet.directive\";\r\nimport {PaginationDirective} from \"./directives/pagination.directive\";\r\nimport {PaginationItemDirective} from \"./directives/pagination-item.directive\";\r\nimport {ResourceIfDirective} from \"./directives/resource-if.directive\";\r\nimport {StickyDirective} from \"./directives/sticky.directive\";\r\nimport {StickyClassDirective} from \"./directives/sticky-class.directive\";\r\nimport {UnorderedListItemDirective} from \"./directives/unordered-list-item.directive\";\r\nimport {UnorderedListTemplateDirective} from \"./directives/unordered-list-template.directive\";\r\n\r\nimport {ChunkPipe} from \"./pipes/chunk.pipe\";\r\nimport {EntriesPipe} from \"./pipes/entries.pipe\";\r\nimport {ExtraItemPropertiesPipe} from \"./pipes/extra-item-properties.pipe\";\r\nimport {FilterPipe} from \"./pipes/filter.pipe\";\r\nimport {FindPipe} from \"./pipes/find.pipe\";\r\nimport {FormatNumberPipe} from \"./pipes/format-number.pipe\";\r\nimport {GetOffsetPipe} from \"./pipes/get-offset.pipe\";\r\nimport {GetTypePipe} from \"./pipes/get-type.pipe\";\r\nimport {GlobalTemplatePipe} from \"./pipes/global-template.pipe\";\r\nimport {GroupByPipe} from \"./pipes/group-by.pipe\";\r\nimport {IsTypePipe} from \"./pipes/is-type.pipe\";\r\nimport {JoinPipe} from \"./pipes/join.pipe\";\r\nimport {KeysPipe} from \"./pipes/keys.pipe\";\r\nimport {MapPipe} from \"./pipes/map.pipe\";\r\nimport {MaxPipe} from \"./pipes/max.pipe\";\r\nimport {MinPipe} from \"./pipes/min.pipe\";\r\nimport {ReducePipe} from \"./pipes/reduce.pipe\";\r\nimport {RemapPipe} from \"./pipes/remap.pipe\";\r\nimport {ReplacePipe} from \"./pipes/replace.pipe\";\r\nimport {ReversePipe} from \"./pipes/reverse.pipe\";\r\nimport {RoundPipe} from \"./pipes/round.pipe\";\r\nimport {SafeHtmlPipe} from \"./pipes/safe-html.pipe\";\r\nimport {TranslatePipe} from \"./pipes/translate.pipe\";\r\nimport {ValuesPipe} from \"./pipes/values.pipe\";\r\n\r\nimport {DynamicTableComponent} from \"./components/dynamic-table/dynamic-table.component\";\r\nimport {PaginationMenuComponent} from \"./components/pagination-menu/pagination-menu.component\";\r\nimport {UnorderedListComponent} from \"./components/unordered-list/unordered-list.component\";\r\n\r\n// --- Pipes ---\r\nexport const pipes = [\r\n    ChunkPipe,\r\n    EntriesPipe,\r\n    ExtraItemPropertiesPipe,\r\n    FilterPipe,\r\n    FindPipe,\r\n    FormatNumberPipe,\r\n    GetOffsetPipe,\r\n    GetTypePipe,\r\n    GlobalTemplatePipe,\r\n    GroupByPipe,\r\n    IsTypePipe,\r\n    JoinPipe,\r\n    KeysPipe,\r\n    MapPipe,\r\n    MaxPipe,\r\n    MinPipe,\r\n    ReducePipe,\r\n    RemapPipe,\r\n    ReplacePipe,\r\n    ReversePipe,\r\n    RoundPipe,\r\n    SafeHtmlPipe,\r\n    TranslatePipe,\r\n    ValuesPipe\r\n];\r\n\r\n// --- Directives ---\r\nexport const directives = [\r\n    AsyncMethodBase,\r\n    AsyncMethodDirective,\r\n    BackgroundDirective,\r\n    DynamicTableTemplateDirective,\r\n    GlobalTemplateDirective,\r\n    IconDirective,\r\n    NgxTemplateOutletDirective,\r\n    PaginationDirective,\r\n    PaginationItemDirective,\r\n    ResourceIfDirective,\r\n    StickyDirective,\r\n    StickyClassDirective,\r\n    UnorderedListItemDirective,\r\n    UnorderedListTemplateDirective\r\n];\r\n\r\n// --- Components ---\r\nexport const components = [\r\n    DynamicTableComponent,\r\n    PaginationMenuComponent,\r\n    UnorderedListComponent\r\n];\r\n\r\nexport const providers = [\r\n    ...pipes,\r\n    BaseHttpClient,\r\n    BaseHttpService,\r\n    AuthGuard,\r\n    AclService,\r\n    ApiService,\r\n    StaticAuthService,\r\n    ConfigService,\r\n    ErrorHandlerService,\r\n    EventsService,\r\n    FormatterService,\r\n    GlobalTemplateService,\r\n    IconService,\r\n    LanguageService,\r\n    OpenApiService,\r\n    PromiseService,\r\n    StateService,\r\n    StaticLanguageService,\r\n    StorageService,\r\n    ConsoleToasterService,\r\n    TranslatedUrlSerializer,\r\n    UniversalService,\r\n    DeviceDetectorService,\r\n    {\r\n        provide: EVENT_MANAGER_PLUGINS,\r\n        useClass: ResizeEventPlugin,\r\n        multi: true\r\n    },\r\n    {\r\n        provide: EVENT_MANAGER_PLUGINS,\r\n        useClass: ScrollEventPlugin,\r\n        multi: true\r\n    },\r\n    {\r\n        provide: UrlSerializer,\r\n        useExisting: TranslatedUrlSerializer\r\n    },\r\n    {\r\n        provide: ErrorHandler,\r\n        useExisting: ErrorHandlerService\r\n    }\r\n\r\n];\r\n\r\nexport function loadConfig(config: IConfigService): any {\r\n    return config.load;\r\n}\r\n"]}

package/esm2020/ngx-utils/ngx-utils.module.mjs

@@ -0,0 +1,178 @@
+import { APP_INITIALIZER, Injector, NgModule } from "@angular/core";
+import { APP_BASE_HREF, CommonModule } from "@angular/common";
+import { FormsModule } from "@angular/forms";
+import { API_SERVICE, APP_BASE_URL, AUTH_SERVICE, CONFIG_SERVICE, GLOBAL_TEMPLATES, ICON_SERVICE, LANGUAGE_SERVICE, PROMISE_SERVICE, ROOT_ELEMENT, TOASTER_SERVICE } from "./common-types";
+import { components, directives, loadConfig, pipes, providers } from "./ngx-utils.imports";
+import { ApiService } from "./services/api.service";
+import { StaticAuthService } from "./services/auth.service";
+import { IconService } from "./services/icon.service";
+import { StaticLanguageService } from "./services/static-language.service";
+import { ConsoleToasterService } from "./services/toaster.service";
+import { PromiseService } from "./services/promise.service";
+import { ConfigService } from "./services/config.service";
+import { GlobalTemplateService } from "./services/global-template.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./pipes/chunk.pipe";
+import * as i2 from "./pipes/entries.pipe";
+import * as i3 from "./pipes/extra-item-properties.pipe";
+import * as i4 from "./pipes/filter.pipe";
+import * as i5 from "./pipes/find.pipe";
+import * as i6 from "./pipes/format-number.pipe";
+import * as i7 from "./pipes/get-offset.pipe";
+import * as i8 from "./pipes/get-type.pipe";
+import * as i9 from "./pipes/global-template.pipe";
+import * as i10 from "./pipes/group-by.pipe";
+import * as i11 from "./pipes/is-type.pipe";
+import * as i12 from "./pipes/join.pipe";
+import * as i13 from "./pipes/keys.pipe";
+import * as i14 from "./pipes/map.pipe";
+import * as i15 from "./pipes/max.pipe";
+import * as i16 from "./pipes/min.pipe";
+import * as i17 from "./pipes/reduce.pipe";
+import * as i18 from "./pipes/remap.pipe";
+import * as i19 from "./pipes/replace.pipe";
+import * as i20 from "./pipes/reverse.pipe";
+import * as i21 from "./pipes/round.pipe";
+import * as i22 from "./pipes/safe-html.pipe";
+import * as i23 from "./pipes/translate.pipe";
+import * as i24 from "./pipes/values.pipe";
+import * as i25 from "./directives/async-method.base";
+import * as i26 from "./directives/async-method.directive";
+import * as i27 from "./directives/background.directive";
+import * as i28 from "./directives/dynamic-table-template.directive";
+import * as i29 from "./directives/global-template.directive";
+import * as i30 from "./directives/icon.directive";
+import * as i31 from "./directives/ngx-template-outlet.directive";
+import * as i32 from "./directives/pagination.directive";
+import * as i33 from "./directives/pagination-item.directive";
+import * as i34 from "./directives/resource-if.directive";
+import * as i35 from "./directives/sticky.directive";
+import * as i36 from "./directives/sticky-class.directive";
+import * as i37 from "./directives/unordered-list-item.directive";
+import * as i38 from "./directives/unordered-list-template.directive";
+import * as i39 from "./components/dynamic-table/dynamic-table.component";
+import * as i40 from "./components/pagination-menu/pagination-menu.component";
+import * as i41 from "./components/unordered-list/unordered-list.component";
+export function loadBaseUrl() {
+    if (typeof (document) === "undefined" || typeof (location) === "undefined")
+        return "/";
+    const currentScript = document.currentScript;
+    if (!currentScript) {
+        try {
+            // noinspection ExceptionCaughtLocallyJS
+            throw new Error();
+        }
+        catch (e) {
+            const qualifiedUrl = location.protocol + "//" + location.host;
+            const stack = (e.stack || "");
+            const srcUrl = (stack.match(new RegExp(qualifiedUrl + ".*?\\.js", "g")) || stack.match(/http([A-Z:\/\-.]+)\.js/gi)).shift();
+            const lastIndex = srcUrl.lastIndexOf("/");
+            return lastIndex < 0 ? "/" : srcUrl.substring(0, lastIndex + 1);
+        }
+    }
+    const scriptSrc = currentScript.src;
+    const lastIndex = scriptSrc.lastIndexOf("/");
+    return lastIndex < 0 ? "/" : scriptSrc.substring(0, lastIndex + 1);
+}
+export function loadBaseHref(baseUrl) {
+    try {
+        return new URL(baseUrl).pathname;
+    }
+    catch (e) {
+        console.log(e);
+        return "/";
+    }
+}
+export class NgxUtilsModule {
+    constructor() {
+    }
+    static forRoot(config) {
+        return {
+            ngModule: NgxUtilsModule,
+            providers: [
+                ...providers,
+                {
+                    provide: API_SERVICE,
+                    useExisting: (!config ? null : config.apiService) || ApiService
+                },
+                {
+                    provide: AUTH_SERVICE,
+                    useExisting: (!config ? null : config.authService) || StaticAuthService
+                },
+                {
+                    provide: ICON_SERVICE,
+                    useExisting: (!config ? null : config.iconService) || IconService
+                },
+                {
+                    provide: LANGUAGE_SERVICE,
+                    useExisting: (!config ? null : config.languageService) || StaticLanguageService
+                },
+                {
+                    provide: TOASTER_SERVICE,
+                    useExisting: (!config ? null : config.toasterService) || ConsoleToasterService
+                },
+                {
+                    provide: PROMISE_SERVICE,
+                    useExisting: (!config ? null : config.promiseService) || PromiseService
+                },
+                {
+                    provide: CONFIG_SERVICE,
+                    useExisting: (!config ? null : config.configService) || ConfigService
+                },
+                {
+                    provide: GLOBAL_TEMPLATES,
+                    useExisting: (!config ? null : config.globalTemplates) || GlobalTemplateService
+                },
+                {
+                    provide: APP_BASE_URL,
+                    useFactory: (!config ? null : config.baseUrl) || loadBaseUrl,
+                    deps: [Injector]
+                },
+                {
+                    provide: ROOT_ELEMENT,
+                    useValue: null
+                },
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: (!config ? null : config.initializeApp) || loadConfig,
+                    multi: true,
+                    deps: [(!config ? null : config.initializeApp) ? Injector : CONFIG_SERVICE]
+                },
+                {
+                    provide: APP_BASE_HREF,
+                    useFactory: loadBaseHref,
+                    deps: [APP_BASE_URL]
+                }
+            ]
+        };
+    }
+}
+NgxUtilsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxUtilsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxUtilsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxUtilsModule, declarations: [i1.ChunkPipe, i2.EntriesPipe, i3.ExtraItemPropertiesPipe, i4.FilterPipe, i5.FindPipe, i6.FormatNumberPipe, i7.GetOffsetPipe, i8.GetTypePipe, i9.GlobalTemplatePipe, i10.GroupByPipe, i11.IsTypePipe, i12.JoinPipe, i13.KeysPipe, i14.MapPipe, i15.MaxPipe, i16.MinPipe, i17.ReducePipe, i18.RemapPipe, i19.ReplacePipe, i20.ReversePipe, i21.RoundPipe, i22.SafeHtmlPipe, i23.TranslatePipe, i24.ValuesPipe, i25.AsyncMethodBase, i26.AsyncMethodDirective, i27.BackgroundDirective, i28.DynamicTableTemplateDirective, i29.GlobalTemplateDirective, i30.IconDirective, i31.NgxTemplateOutletDirective, i32.PaginationDirective, i33.PaginationItemDirective, i34.ResourceIfDirective, i35.StickyDirective, i36.StickyClassDirective, i37.UnorderedListItemDirective, i38.UnorderedListTemplateDirective, i39.DynamicTableComponent, i40.PaginationMenuComponent, i41.UnorderedListComponent], imports: [CommonModule,
+        FormsModule], exports: [i1.ChunkPipe, i2.EntriesPipe, i3.ExtraItemPropertiesPipe, i4.FilterPipe, i5.FindPipe, i6.FormatNumberPipe, i7.GetOffsetPipe, i8.GetTypePipe, i9.GlobalTemplatePipe, i10.GroupByPipe, i11.IsTypePipe, i12.JoinPipe, i13.KeysPipe, i14.MapPipe, i15.MaxPipe, i16.MinPipe, i17.ReducePipe, i18.RemapPipe, i19.ReplacePipe, i20.ReversePipe, i21.RoundPipe, i22.SafeHtmlPipe, i23.TranslatePipe, i24.ValuesPipe, i25.AsyncMethodBase, i26.AsyncMethodDirective, i27.BackgroundDirective, i28.DynamicTableTemplateDirective, i29.GlobalTemplateDirective, i30.IconDirective, i31.NgxTemplateOutletDirective, i32.PaginationDirective, i33.PaginationItemDirective, i34.ResourceIfDirective, i35.StickyDirective, i36.StickyClassDirective, i37.UnorderedListItemDirective, i38.UnorderedListTemplateDirective, i39.DynamicTableComponent, i40.PaginationMenuComponent, i41.UnorderedListComponent, FormsModule] });
+NgxUtilsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxUtilsModule, providers: pipes, imports: [[
+            CommonModule,
+            FormsModule
+        ], FormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxUtilsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...pipes,
+                        ...directives,
+                        ...components
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule
+                    ],
+                    exports: [
+                        ...pipes,
+                        ...directives,
+                        ...components,
+                        FormsModule
+                    ],
+                    providers: pipes
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-utils.module.js","sourceRoot":"","sources":["../../../src/ngx-utils/ngx-utils.module.ts"],"names":[],"mappings":"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","sourcesContent":["import {APP_INITIALIZER, Injector, ModuleWithProviders, NgModule} from \"@angular/core\";\r\nimport {APP_BASE_HREF, CommonModule} from \"@angular/common\";\r\nimport {FormsModule} from \"@angular/forms\";\r\nimport {\r\n    API_SERVICE,\r\n    APP_BASE_URL,\r\n    AUTH_SERVICE,\r\n    CONFIG_SERVICE,\r\n    GLOBAL_TEMPLATES,\r\n    ICON_SERVICE,\r\n    IModuleConfig,\r\n    LANGUAGE_SERVICE,\r\n    PROMISE_SERVICE,\r\n    ROOT_ELEMENT,\r\n    TOASTER_SERVICE\r\n} from \"./common-types\";\r\nimport {components, directives, loadConfig, pipes, providers} from \"./ngx-utils.imports\";\r\nimport {ApiService} from \"./services/api.service\";\r\nimport {StaticAuthService} from \"./services/auth.service\";\r\nimport {IconService} from \"./services/icon.service\";\r\nimport {StaticLanguageService} from \"./services/static-language.service\";\r\nimport {ConsoleToasterService} from \"./services/toaster.service\";\r\nimport {PromiseService} from \"./services/promise.service\";\r\nimport {ConfigService} from \"./services/config.service\";\r\nimport {GlobalTemplateService} from \"./services/global-template.service\";\r\n\r\nexport function loadBaseUrl(): string {\r\n    if (typeof (document) === \"undefined\" || typeof (location) === \"undefined\") return \"/\";\r\n    const currentScript = (document.currentScript as HTMLScriptElement);\r\n    if (!currentScript) {\r\n        try {\r\n            // noinspection ExceptionCaughtLocallyJS\r\n            throw new Error();\r\n        } catch (e) {\r\n            const qualifiedUrl = location.protocol + \"//\" + location.host;\r\n            const stack = (e.stack || \"\") as string;\r\n            const srcUrl = (stack.match(new RegExp(qualifiedUrl + \".*?\\\\.js\", \"g\")) || stack.match(/http([A-Z:\\/\\-.]+)\\.js/gi)).shift();\r\n            const lastIndex = srcUrl.lastIndexOf(\"/\");\r\n            return lastIndex < 0 ? \"/\" : srcUrl.substring(0, lastIndex + 1);\r\n        }\r\n    }\r\n    const scriptSrc = currentScript.src;\r\n    const lastIndex = scriptSrc.lastIndexOf(\"/\");\r\n    return lastIndex < 0 ? \"/\" : scriptSrc.substring(0, lastIndex + 1);\r\n}\r\n\r\nexport function loadBaseHref(baseUrl: string): string {\r\n    try {\r\n        return new URL(baseUrl).pathname;\r\n    } catch (e) {\r\n        console.log(e);\r\n        return \"/\";\r\n    }\r\n}\r\n\r\n@NgModule({\r\n    declarations: [\r\n        ...pipes,\r\n        ...directives,\r\n        ...components\r\n    ],\r\n    imports: [\r\n        CommonModule,\r\n        FormsModule\r\n    ],\r\n    exports: [\r\n        ...pipes,\r\n        ...directives,\r\n        ...components,\r\n        FormsModule\r\n    ],\r\n    providers: pipes\r\n})\r\nexport class NgxUtilsModule {\r\n\r\n    static forRoot(config?: IModuleConfig): ModuleWithProviders<NgxUtilsModule> {\r\n        return {\r\n            ngModule: NgxUtilsModule,\r\n            providers: [\r\n                ...providers,\r\n                {\r\n                    provide: API_SERVICE,\r\n                    useExisting: (!config ? null : config.apiService) || ApiService\r\n                },\r\n                {\r\n                    provide: AUTH_SERVICE,\r\n                    useExisting: (!config ? null : config.authService) || StaticAuthService\r\n                },\r\n                {\r\n                    provide: ICON_SERVICE,\r\n                    useExisting: (!config ? null : config.iconService) || IconService\r\n                },\r\n                {\r\n                    provide: LANGUAGE_SERVICE,\r\n                    useExisting: (!config ? null : config.languageService) || StaticLanguageService\r\n                },\r\n                {\r\n                    provide: TOASTER_SERVICE,\r\n                    useExisting: (!config ? null : config.toasterService) || ConsoleToasterService\r\n                },\r\n                {\r\n                    provide: PROMISE_SERVICE,\r\n                    useExisting: (!config ? null : config.promiseService) || PromiseService\r\n                },\r\n                {\r\n                    provide: CONFIG_SERVICE,\r\n                    useExisting: (!config ? null : config.configService) || ConfigService\r\n                },\r\n                {\r\n                    provide: GLOBAL_TEMPLATES,\r\n                    useExisting: (!config ? null : config.globalTemplates) || GlobalTemplateService\r\n                },\r\n                {\r\n                    provide: APP_BASE_URL,\r\n                    useFactory: (!config ? null : config.baseUrl) || loadBaseUrl,\r\n                    deps: [Injector]\r\n                },\r\n                {\r\n                    provide: ROOT_ELEMENT,\r\n                    useValue: null\r\n                },\r\n                {\r\n                    provide: APP_INITIALIZER,\r\n                    useFactory: (!config ? null : config.initializeApp) || loadConfig,\r\n                    multi: true,\r\n                    deps: [(!config ? null : config.initializeApp) ? Injector : CONFIG_SERVICE]\r\n                },\r\n                {\r\n                    provide: APP_BASE_HREF,\r\n                    useFactory: loadBaseHref,\r\n                    deps: [APP_BASE_URL]\r\n                }\r\n            ]\r\n        };\r\n    }\r\n\r\n    constructor() {\r\n\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/pipes/chunk.pipe.mjs

@@ -0,0 +1,25 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+export class ChunkPipe {
+    transform(items, count) {
+        const result = [];
+        let subResult = null;
+        items.forEach((item, index) => {
+            if (index % count == 0) {
+                subResult = [];
+                result.push(subResult);
+            }
+            subResult.push(item);
+        });
+        return result;
+    }
+}
+ChunkPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ChunkPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ChunkPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ChunkPipe, name: "chunk" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ChunkPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "chunk"
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2h1bmsucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9uZ3gtdXRpbHMvcGlwZXMvY2h1bmsucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsSUFBSSxFQUFnQixNQUFNLGVBQWUsQ0FBQzs7QUFLbEQsTUFBTSxPQUFPLFNBQVM7SUFDbEIsU0FBUyxDQUFDLEtBQVksRUFBRSxLQUFhO1FBQ2pDLE1BQU0sTUFBTSxHQUFVLEVBQUUsQ0FBQztRQUN6QixJQUFJLFNBQVMsR0FBVSxJQUFJLENBQUM7UUFDNUIsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsRUFBRTtZQUMxQixJQUFJLEtBQUssR0FBRyxLQUFLLElBQUksQ0FBQyxFQUFFO2dCQUNwQixTQUFTLEdBQUcsRUFBRSxDQUFDO2dCQUNmLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7YUFDMUI7WUFDRCxTQUFTLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3pCLENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxNQUFNLENBQUM7SUFDbEIsQ0FBQzs7c0dBWlEsU0FBUztvR0FBVCxTQUFTOzJGQUFULFNBQVM7a0JBSHJCLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFFLE9BQU87aUJBQ2hCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtQaXBlLCBQaXBlVHJhbnNmb3JtfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuQFBpcGUoe1xyXG4gICAgbmFtZTogXCJjaHVua1wiXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDaHVua1BpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuICAgIHRyYW5zZm9ybShpdGVtczogYW55W10sIGNvdW50OiBudW1iZXIpOiBhbnlbXSB7XHJcbiAgICAgICAgY29uc3QgcmVzdWx0OiBhbnlbXSA9IFtdO1xyXG4gICAgICAgIGxldCBzdWJSZXN1bHQ6IGFueVtdID0gbnVsbDtcclxuICAgICAgICBpdGVtcy5mb3JFYWNoKChpdGVtLCBpbmRleCkgPT4ge1xyXG4gICAgICAgICAgICBpZiAoaW5kZXggJSBjb3VudCA9PSAwKSB7XHJcbiAgICAgICAgICAgICAgICBzdWJSZXN1bHQgPSBbXTtcclxuICAgICAgICAgICAgICAgIHJlc3VsdC5wdXNoKHN1YlJlc3VsdCk7XHJcbiAgICAgICAgICAgIH1cclxuICAgICAgICAgICAgc3ViUmVzdWx0LnB1c2goaXRlbSk7XHJcbiAgICAgICAgfSk7XHJcbiAgICAgICAgcmV0dXJuIHJlc3VsdDtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2020/ngx-utils/pipes/entries.pipe.mjs

@@ -0,0 +1,28 @@
+import { Pipe } from "@angular/core";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+const emptyEntries = [];
+export class EntriesPipe {
+    transform(value) {
+        if (!value)
+            return emptyEntries;
+        const entries = [];
+        ObjectUtils.iterate(value, (val, key) => {
+            entries.push({
+                key: key,
+                value: val,
+                index: entries.length
+            });
+        });
+        return entries;
+    }
+}
+EntriesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: EntriesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+EntriesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: EntriesPipe, name: "entries" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: EntriesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "entries"
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50cmllcy5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL25neC11dGlscy9waXBlcy9lbnRyaWVzLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLElBQUksRUFBZ0IsTUFBTSxlQUFlLENBQUM7QUFDbEQsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLHVCQUF1QixDQUFDOztBQVFsRCxNQUFNLFlBQVksR0FBYSxFQUFFLENBQUM7QUFLbEMsTUFBTSxPQUFPLFdBQVc7SUFFcEIsU0FBUyxDQUFDLEtBQVU7UUFDaEIsSUFBSSxDQUFDLEtBQUs7WUFBRSxPQUFPLFlBQVksQ0FBQztRQUNoQyxNQUFNLE9BQU8sR0FBYSxFQUFFLENBQUM7UUFDN0IsV0FBVyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEVBQUU7WUFDcEMsT0FBTyxDQUFDLElBQUksQ0FBQztnQkFDVCxHQUFHLEVBQUUsR0FBRztnQkFDUixLQUFLLEVBQUUsR0FBRztnQkFDVixLQUFLLEVBQUUsT0FBTyxDQUFDLE1BQU07YUFDeEIsQ0FBQyxDQUFDO1FBQ1AsQ0FBQyxDQUFDLENBQUM7UUFDSCxPQUFPLE9BQU8sQ0FBQztJQUNuQixDQUFDOzt3R0FiUSxXQUFXO3NHQUFYLFdBQVc7MkZBQVgsV0FBVztrQkFIdkIsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsU0FBUztpQkFDbEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1BpcGUsIFBpcGVUcmFuc2Zvcm19IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7T2JqZWN0VXRpbHN9IGZyb20gXCIuLi91dGlscy9vYmplY3QudXRpbHNcIjtcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgSUVudHJ5IHtcclxuICAgIGtleTogc3RyaW5nO1xyXG4gICAgdmFsdWU6IGFueTtcclxuICAgIGluZGV4OiBudW1iZXI7XHJcbn1cclxuXHJcbmNvbnN0IGVtcHR5RW50cmllczogSUVudHJ5W10gPSBbXTtcclxuXHJcbkBQaXBlKHtcclxuICAgIG5hbWU6IFwiZW50cmllc1wiXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBFbnRyaWVzUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG5cclxuICAgIHRyYW5zZm9ybSh2YWx1ZTogYW55KTogSUVudHJ5W10ge1xyXG4gICAgICAgIGlmICghdmFsdWUpIHJldHVybiBlbXB0eUVudHJpZXM7XHJcbiAgICAgICAgY29uc3QgZW50cmllczogSUVudHJ5W10gPSBbXTtcclxuICAgICAgICBPYmplY3RVdGlscy5pdGVyYXRlKHZhbHVlLCAodmFsLCBrZXkpID0+IHtcclxuICAgICAgICAgICAgZW50cmllcy5wdXNoKHtcclxuICAgICAgICAgICAgICAgIGtleToga2V5LFxyXG4gICAgICAgICAgICAgICAgdmFsdWU6IHZhbCxcclxuICAgICAgICAgICAgICAgIGluZGV4OiBlbnRyaWVzLmxlbmd0aFxyXG4gICAgICAgICAgICB9KTtcclxuICAgICAgICB9KTtcclxuICAgICAgICByZXR1cm4gZW50cmllcztcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2020/ngx-utils/pipes/extra-item-properties.pipe.mjs

@@ -0,0 +1,31 @@
+import { Pipe } from "@angular/core";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+export class ExtraItemPropertiesPipe {
+    transform(items, properties, params = {}) {
+        const keys = Object.keys(properties);
+        keys.forEach(key => {
+            const value = properties[key];
+            properties[key] = ObjectUtils.isFunction(value) ? value : (item, index, params) => {
+                return ObjectUtils.evaluate(value, {
+                    item: item,
+                    index: index,
+                    params: params
+                });
+            };
+        });
+        return (items || []).map((item, index) => keys.reduce((result, key) => {
+            result[key] = properties[key](item, index, params);
+            return result;
+        }, { ...item }));
+    }
+}
+ExtraItemPropertiesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ExtraItemPropertiesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ExtraItemPropertiesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ExtraItemPropertiesPipe, name: "extraItemProperties" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ExtraItemPropertiesPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "extraItemProperties"
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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