@stemy/ngx-utils 12.1.3 → 13.0.2

package/esm2020/ngx-utils/common-types.mjs

@@ -0,0 +1,116 @@
+import { InjectionToken, TemplateRef } from "@angular/core";
+import { ReflectUtils } from "./utils/reflect.utils";
+import { ObjectUtils } from "./utils/object.utils";
+export class CanvasColor {
+    constructor(r, g, b, a = 255) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+}
+export const ICON_SERVICE = new InjectionToken("icon-service");
+export const LANGUAGE_SERVICE = new InjectionToken("language-service");
+export const AUTH_SERVICE = new InjectionToken("auth-service");
+// --- Storage Service ---
+export var StorageMode;
+(function (StorageMode) {
+    StorageMode[StorageMode["Local"] = 0] = "Local";
+    StorageMode[StorageMode["Session"] = 1] = "Session";
+})(StorageMode || (StorageMode = {}));
+export const TOASTER_SERVICE = new InjectionToken("toaster-service");
+export const PROMISE_SERVICE = new InjectionToken("promise-service");
+// --- Unordered list ---
+export class UnorederedListTemplate extends TemplateRef {
+}
+// --- Reflect utils ---
+export function FactoryDependencies(...dependencies) {
+    return function (target, method) {
+        ReflectUtils.defineMetadata("factoryDependencies", dependencies, target, method);
+    };
+}
+export class PaginationItemContext {
+    constructor(item, parallelItem, count, index, dataIndex) {
+        this.item = item;
+        this.parallelItem = parallelItem;
+        this.count = count;
+        this.index = index;
+        this.dataIndex = dataIndex;
+    }
+    get first() {
+        return this.index === 0;
+    }
+    get last() {
+        return this.index === this.count - 1;
+    }
+    get even() {
+        return this.index % 2 === 0;
+    }
+    get odd() {
+        return !this.even;
+    }
+    // Support for old dynamic table implementation
+    get row() {
+        console.log("DynamicTable row is deprecated use item instead");
+        return this.item;
+    }
+    // Support for old dynamic table implementation
+    get parallelRow() {
+        console.log("DynamicTable parallelRow is deprecated use parallelItem instead");
+        return this.parallelItem;
+    }
+    filter(filterRx) {
+        const keys = Object.keys(this.item);
+        for (const key of keys) {
+            const value = this.item[key];
+            if (ObjectUtils.isNullOrUndefined(value) || ObjectUtils.isObject(value))
+                continue;
+            const testValue = ObjectUtils.isString(value) ? value : value.toString();
+            if (testValue.match(filterRx))
+                return true;
+        }
+        return false;
+    }
+}
+export class HttpPromise extends Promise {
+    constructor(rejectHandler, executor) {
+        super(executor);
+        this.rejectHandler = rejectHandler;
+        this.attachCount = 0;
+        this.runCount = 0;
+    }
+    then(onFulfilled, onRejected) {
+        this.attachCount++;
+        return super.then(value => {
+            this.runCount++;
+            return onFulfilled ? onFulfilled(value) : null;
+        }, (reason) => {
+            const result = onRejected ? onRejected(reason) : null;
+            this.hasRejectHandler = this.hasRejectHandler || (onRejected && result !== false);
+            this.runCount++;
+            this.rejectHandler(this.runCount == this.attachCount && !this.hasRejectHandler ? reason : null);
+            return result;
+        });
+    }
+    catch(onRejected) {
+        return this.then(null, onRejected);
+    }
+}
+export const EXPRESS_REQUEST = new InjectionToken("express-request");
+export const API_SERVICE = new InjectionToken("api-service");
+// --- Resource if ---
+export class ResourceIfContext {
+}
+// --- ConfigService ---
+export class IConfiguration {
+}
+export const CONFIG_SERVICE = new InjectionToken("config-service");
+export const BASE_CONFIG = new InjectionToken("base-config");
+export const SCRIPT_PARAMS = new InjectionToken("script-params");
+export const ROOT_ELEMENT = new InjectionToken("app-root-element");
+export const ERROR_HANDLER = new InjectionToken("error-handler-callback");
+export const GLOBAL_TEMPLATES = new InjectionToken("global-templates");
+// --- Valued promise ---
+export class ValuedPromise extends Promise {
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../../../src/ngx-utils/common-types.ts"],"names":[],"mappings":"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","sourcesContent":["import {EventEmitter, InjectionToken, Injector, NgZone, Provider, TemplateRef, Type} from \"@angular/core\";\r\nimport {HttpClient, HttpErrorResponse, HttpHeaders} from \"@angular/common/http\";\r\nimport {ActivatedRouteSnapshot, Data, Route, UrlTree} from \"@angular/router\";\r\nimport {Request} from \"express\";\r\nimport {ReflectUtils} from \"./utils/reflect.utils\";\r\nimport {ObjectUtils} from \"./utils/object.utils\";\r\n\r\n// --- Utils\r\nexport interface IResolveFactory {\r\n    func: Function;\r\n    type?: any;\r\n    params?: any[];\r\n}\r\n\r\nexport class CanvasColor {\r\n    constructor(public r: number, public g: number, public b: number, public a: number = 255) {\r\n\r\n    }\r\n}\r\n\r\n// --- Icon service ---\r\nexport interface IIconService {\r\n    isDisabled: boolean;\r\n    iconsLoaded: EventEmitter<any>;\r\n    getIcon(icon: string, activeIcon: string, active: boolean): Promise<string>;\r\n}\r\n\r\nexport const ICON_SERVICE: InjectionToken<IIconService> = new InjectionToken<IIconService>(\"icon-service\");\r\n\r\n// --- Language service ---\r\nexport interface ITranslation {\r\n    lang: string;\r\n    translation: string;\r\n}\r\n\r\nexport interface ITranslations {\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface ILanguageSettings {\r\n    languages: string[];\r\n    devLanguages: string[];\r\n    defaultLanguage: string;\r\n    settings?: any;\r\n}\r\n\r\nexport interface ILanguageService {\r\n    currentLanguage: string;\r\n    editLanguage: string;\r\n    disableTranslations: boolean;\r\n    defaultLanguage: string;\r\n    dictionary: ITranslations;\r\n    readonly languages: ReadonlyArray<string>;\r\n    readonly httpClient: HttpClient;\r\n    replaceLanguages(languages: string[]): void;\r\n    addLanguages(languages: string[]): void;\r\n    getTranslationSync(key: string, params?: any): string;\r\n    getTranslation(key: string, params?: any): Promise<string>;\r\n    getTranslations(...keys: string[]): Promise<ITranslations>;\r\n    getTranslationFromObject(translations: ITranslations, params?: any, lang?: string): string;\r\n    getTranslationFromArray(translations: ITranslation[], params?: any, lang?: string): string;\r\n}\r\n\r\nexport const LANGUAGE_SERVICE: InjectionToken<ILanguageService> = new InjectionToken<ILanguageService>(\"language-service\");\r\n\r\n// --- Auth Service ---\r\nexport interface IAuthService {\r\n    isAuthenticated: boolean;\r\n    userChanged: EventEmitter<any>;\r\n    checkAuthenticated(): Promise<boolean>;\r\n}\r\n\r\nexport type RouteValidator = (auth: IAuthService, route?: IRoute, next?: ActivatedRouteSnapshot) => Promise<boolean>;\r\n\r\nexport interface IRouteData extends Data {\r\n    returnState?: string[];\r\n    guards?: Array<IResolveFactory | RouteValidator>;\r\n}\r\n\r\nexport interface IRoute extends Route {\r\n    data?: IRouteData;\r\n}\r\n\r\nexport const AUTH_SERVICE: InjectionToken<IAuthService> = new InjectionToken<IAuthService>(\"auth-service\");\r\n\r\n// --- Acl Service ---\r\nexport interface IAclComponent {\r\n    onUserInitialized(): void;\r\n    onUserChanged(): void;\r\n}\r\n\r\nexport interface IRouteStateInfo {\r\n    route: IRoute;\r\n    guard: any;\r\n    dirty: boolean;\r\n    first: boolean;\r\n    component?: any;\r\n}\r\n\r\n// --- State Service ---\r\nexport type NavigationUrlParam = any[] | string | UrlTree;\r\n\r\n// --- Storage Service ---\r\nexport enum StorageMode {\r\n    Local,\r\n    Session\r\n}\r\n\r\n// --- Toaster Service ---\r\nexport interface IToasterService {\r\n    error(message: string, params?: any, title?: string): void;\r\n    info(message: string, params?: any, title?: string): void;\r\n    success(message: string, params?: any, title?: string): void;\r\n    warning(message: string, params?: any, title?: string): void;\r\n}\r\n\r\nexport const TOASTER_SERVICE: InjectionToken<IToasterService> = new InjectionToken<IToasterService>(\"toaster-service\");\r\n\r\n// --- Promise Service ---\r\n\r\nexport interface IPromiseService {\r\n    zone: NgZone;\r\n    count: number;\r\n    onChanged: EventEmitter<number>;\r\n    create<T>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;\r\n    all(promises: Promise<any>[]): Promise<any>;\r\n    resolve<T>(value: T | PromiseLike<T>): Promise<T>;\r\n    reject<T>(value: T | PromiseLike<T>): Promise<T>;\r\n}\r\n\r\nexport const PROMISE_SERVICE = new InjectionToken<IPromiseService>(\"promise-service\");\r\n\r\n// --- Async method ---\r\nexport interface IAsyncMessage {\r\n    message: string;\r\n    context?: any;\r\n}\r\n\r\nexport type AsyncMethod = (context?: any) => Promise<IAsyncMessage>;\r\n\r\n// --- Unordered list ---\r\nexport abstract class UnorederedListTemplate extends TemplateRef<any> {\r\n    abstract type: string;\r\n    abstract selector: string;\r\n}\r\n\r\nexport interface UnorderedListTemplates {\r\n    [type: string]: TemplateRef<any>;\r\n}\r\n\r\nexport type UnorderedListStyle = \"table\" | \"list\";\r\n\r\n// --- Ajax request  ---\r\nexport interface IAjaxRequestDetails {\r\n    request: XMLHttpRequest,\r\n    method: string;\r\n    url: string;\r\n}\r\n\r\nexport type AjaxRequestCallback = (details: IAjaxRequestDetails, params: any) => void;\r\n\r\n// --- Loader utils ---\r\nexport interface IScriptPromises {\r\n    [src: string]: Promise<HTMLScriptElement>;\r\n}\r\nexport interface IStylePromises {\r\n    [src: string]: Promise<HTMLLinkElement>;\r\n}\r\n\r\n// --- Observable utils ---\r\nexport interface ISearchObservable {\r\n    search: string;\r\n    getSearchResults(token: string): Promise<any[]>;\r\n}\r\n\r\n// --- Reflect utils ---\r\nexport function FactoryDependencies(...dependencies: Array<InjectionToken<any> | Provider>): MethodDecorator {\r\n    return function (target: any, method: string): void {\r\n        ReflectUtils.defineMetadata(\"factoryDependencies\", dependencies, target, method);\r\n    };\r\n}\r\n\r\n// --- Timer utils ---\r\nexport interface ITimer {\r\n    id?: any;\r\n    func?: Function;\r\n    time?: number;\r\n    run?: () => void;\r\n    set?: (func: Function, time: number) => void;\r\n    clear?: () => void;\r\n}\r\n\r\n// --- ExtraItemProperties ---\r\nexport interface IExtraProperties {\r\n    [prop: string]: any;\r\n}\r\n\r\n// --- Group by ---\r\nexport interface IGroupMap {\r\n    [column: string]: any;\r\n}\r\n\r\n// --- Translate ---\r\nexport type TranslationQuery = string | ITranslations | ITranslation[];\r\n\r\n// --- Pagination ---\r\nexport interface IPageInfo {\r\n    text: string;\r\n    number: number;\r\n    active: boolean;\r\n}\r\n\r\nexport interface IPaginationData {\r\n    total: number;\r\n    items: any[];\r\n    meta?: any;\r\n}\r\n\r\nexport type PaginationDataLoader = (page: number, itemsPerPage: number) => Promise<IPaginationData>;\r\n\r\nexport class PaginationItemContext {\r\n\r\n    constructor(public item: any, public parallelItem: any, public count: number, public index: number, public dataIndex: number) {\r\n    }\r\n\r\n    get first(): boolean {\r\n        return this.index === 0;\r\n    }\r\n\r\n    get last(): boolean {\r\n        return this.index === this.count - 1;\r\n    }\r\n\r\n    get even(): boolean {\r\n        return this.index % 2 === 0;\r\n    }\r\n\r\n    get odd(): boolean {\r\n        return !this.even;\r\n    }\r\n\r\n    // Support for old dynamic table implementation\r\n    get row(): any {\r\n        console.log(\"DynamicTable row is deprecated use item instead\");\r\n        return this.item;\r\n    }\r\n\r\n    // Support for old dynamic table implementation\r\n    get parallelRow(): any {\r\n        console.log(\"DynamicTable parallelRow is deprecated use parallelItem instead\");\r\n        return this.parallelItem;\r\n    }\r\n\r\n    filter(filterRx: RegExp): boolean {\r\n        const keys = Object.keys(this.item);\r\n        for (const key of keys) {\r\n            const value = this.item[key];\r\n            if (ObjectUtils.isNullOrUndefined(value) || ObjectUtils.isObject(value)) continue;\r\n            const testValue = ObjectUtils.isString(value) ? value : value.toString();\r\n            if (testValue.match(filterRx)) return true;\r\n        }\r\n        return false;\r\n    }\r\n}\r\n\r\n// --- Http service ---\r\nexport interface IHttpHeaders {\r\n    [header: string]: string | string[];\r\n}\r\n\r\nexport interface IHttpParams {\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface IRequestOptions {\r\n    method?: string;\r\n    body?: any;\r\n    headers?: IHttpHeaders | HttpHeaders;\r\n    originalHeaders?: IHttpHeaders;\r\n    params?: IHttpParams;\r\n    observe?: \"body\" | \"response\";\r\n    reportProgress?: boolean;\r\n    responseType?: \"arraybuffer\" | \"blob\" | \"json\" | \"text\";\r\n    withCredentials?: boolean;\r\n    timeout?: number;\r\n}\r\n\r\nexport interface IIssueContext {\r\n    url: string;\r\n}\r\n\r\nexport interface IProgress {\r\n    percentage?: number;\r\n    loaded?: number;\r\n    total?: number;\r\n}\r\n\r\nexport type ProgressListener = (progress: IProgress) => void;\r\n\r\nexport type PromiseExecutor = (resolve: (value?: any | PromiseLike<any>) => void, reject: (reason?: any) => void) => void;\r\n\r\nexport class HttpPromise extends Promise<any> {\r\n\r\n    protected rejectHandler: (reason?: HttpErrorResponse) => void;\r\n    protected hasRejectHandler: boolean;\r\n    protected attachCount: number;\r\n    protected runCount: number;\r\n\r\n    constructor(rejectHandler: (reason?: HttpErrorResponse) => void, executor: PromiseExecutor) {\r\n        super(executor);\r\n        this.rejectHandler = rejectHandler;\r\n        this.attachCount = 0;\r\n        this.runCount = 0;\r\n    }\r\n\r\n    then<TResult1, TResult2>(onFulfilled?: ((value: any) => (PromiseLike<TResult1> | TResult1)) | null | undefined,\r\n                             onRejected?: ((reason: HttpErrorResponse) => (PromiseLike<TResult2> | TResult2)) | null | undefined): Promise<TResult1 | TResult2> {\r\n        this.attachCount++;\r\n        return super.then(value => {\r\n            this.runCount++;\r\n            return onFulfilled ? onFulfilled(value) : null;\r\n        }, (reason: HttpErrorResponse) => {\r\n            const result: any = onRejected ? onRejected(reason) : null;\r\n            this.hasRejectHandler = this.hasRejectHandler || (onRejected && result !== false);\r\n            this.runCount++;\r\n            this.rejectHandler(this.runCount == this.attachCount && !this.hasRejectHandler ? reason : null);\r\n            return result;\r\n        });\r\n    }\r\n\r\n    catch<TResult = never>(onRejected?: ((reason: HttpErrorResponse) => (PromiseLike<TResult> | TResult)) | null | undefined): Promise<any | TResult> {\r\n        return this.then(null, onRejected);\r\n    }\r\n}\r\n\r\nexport interface IHttpService {\r\n    language: ILanguageService;\r\n    url(url: string): string;\r\n    makeListParams(page: number, itemsPerPage: number, orderBy?: string, orderDescending?: boolean, filter?: string): IHttpParams;\r\n}\r\n\r\nexport const EXPRESS_REQUEST = new InjectionToken<Request>(\"express-request\");\r\n\r\n// --- Api service ---\r\n\r\nexport interface IApiService extends IHttpService {\r\n    cache: any;\r\n    client: HttpClient;\r\n    get(url: string, options?: IRequestOptions): Promise<any>;\r\n    delete(url: string, options?: IRequestOptions): Promise<any>;\r\n    post(url: string, body?: any, options?: IRequestOptions): Promise<any>;\r\n    put(url: string, body?: any, options?: IRequestOptions): Promise<any>;\r\n    patch(url: string, body?: any, options?: IRequestOptions): Promise<any>;\r\n    upload(url: string, body: any, listener?: ProgressListener, options?: IRequestOptions): Promise<any>;\r\n    list(url: string, params: IHttpParams): Promise<IPaginationData>;\r\n}\r\n\r\nexport const API_SERVICE: InjectionToken<IApiService> = new InjectionToken<IApiService>(\"api-service\");\r\n\r\n// --- OpenApi service ---\r\nexport interface IOpenApiSchemaProperty {\r\n    id: string;\r\n    type?: string;\r\n    format?: string;\r\n    column?: boolean;\r\n    additionalProperties?: any;\r\n    $ref?: string;\r\n    items?: IOpenApiSchemaProperty;\r\n    enum?: string[];\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface IOpenApiSchema {\r\n    properties: {\r\n        [name: string]: IOpenApiSchemaProperty;\r\n    };\r\n    required: string[];\r\n}\r\n\r\nexport interface IOpenApiSchemas {\r\n    [name: string]: IOpenApiSchema;\r\n}\r\n\r\n// --- Dynamic table ---\r\nexport interface ITableColumns {\r\n    [column: string]: string;\r\n}\r\n\r\nexport interface ITableTemplate {\r\n    column: string | string[];\r\n    pure: boolean;\r\n    ref: TemplateRef<any>;\r\n}\r\n\r\nexport interface ITableTemplates {\r\n    [column: string]: ITableTemplate;\r\n}\r\n\r\nexport type TableDataLoader = (page: number, rowsPerPage: number, orderBy: string, orderDescending: boolean, filter: string) => Promise<IPaginationData>;\r\n\r\n// --- Resource if ---\r\nexport class ResourceIfContext {\r\n    resource: string;\r\n    url: string;\r\n}\r\n\r\n// --- ConfigService ---\r\nexport class IConfiguration {\r\n    baseUrl?: string;\r\n    baseDomain?: string;\r\n    translationUrl?: string;\r\n    [key: string]: any;\r\n}\r\n\r\nexport interface IConfigService {\r\n    config: IConfiguration;\r\n    readonly load: () => Promise<IConfiguration>;\r\n    prepareUrl(url: string, ending: string): string;\r\n    getConfigValue(key: string): any;\r\n    getQueryParameter(name: string, url?: string): string;\r\n}\r\n\r\nexport const CONFIG_SERVICE = new InjectionToken<IConfigService>(\"config-service\");\r\n\r\nexport const BASE_CONFIG = new InjectionToken<IConfiguration>(\"base-config\");\r\n\r\nexport const SCRIPT_PARAMS = new InjectionToken<any>(\"script-params\");\r\n\r\nexport const ROOT_ELEMENT: InjectionToken<HTMLElement> = new InjectionToken<HTMLElement>(\"app-root-element\");\r\n\r\n// --- Error handler service ---\r\nexport type ErrorHandlerCallback = (error: string) => any;\r\n\r\nexport const ERROR_HANDLER = new InjectionToken<ErrorHandlerCallback>(\"error-handler-callback\");\r\n\r\n// --- Global templates service\r\n\r\nexport type GlobalComponentModifier = (component: any) => any;\r\n\r\nexport interface IGlobalTemplates {\r\n    readonly templatesUpdated: EventEmitter<void>;\r\n    get(id: string, component?: any): TemplateRef<any>;\r\n    add(id: string, template: TemplateRef<any>): void;\r\n    remove(id: string): void;\r\n    addComponentModifier(id: string, modifier: GlobalComponentModifier): void;\r\n}\r\n\r\nexport const GLOBAL_TEMPLATES = new InjectionToken<ErrorHandlerCallback>(\"global-templates\");\r\n\r\n// --- Module ---\r\nexport type AppInitializerFunc = () => Promise<void> | void;\r\n\r\nexport interface IModuleConfig {\r\n    apiService?: Type<IApiService>\r\n    authService?: Type<IAuthService>;\r\n    iconService?: Type<IIconService>;\r\n    languageService?: Type<ILanguageService>;\r\n    toasterService?: Type<IToasterService>;\r\n    promiseService?: Type<IPromiseService>;\r\n    configService?: Type<IConfigService>;\r\n    globalTemplates?: Type<IGlobalTemplates>;\r\n    initializeApp?: (injector: Injector) => AppInitializerFunc;\r\n}\r\n\r\n// --- Valued promise ---\r\nexport class ValuedPromise<T> extends Promise<T> {\r\n    value: T;\r\n}\r\n"]}

package/esm2020/ngx-utils/components/dynamic-table/dynamic-table.component.mjs

@@ -0,0 +1,407 @@
+import { Component, ContentChild, ContentChildren, Input, QueryList, TemplateRef, ViewChild } from "@angular/core";
+import { PaginationItemContext } from "../../common-types";
+import { ObjectUtils } from "../../utils/object.utils";
+import { DynamicTableTemplateDirective } from "../../directives/dynamic-table-template.directive";
+import { PaginationDirective } from "../../directives/pagination.directive";
+import { UniqueUtils } from "../../utils/unique.utils";
+import * as i0 from "@angular/core";
+import * as i1 from "../../directives/pagination.directive";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "../../directives/ngx-template-outlet.directive";
+import * as i5 from "../pagination-menu/pagination-menu.component";
+import * as i6 from "../../directives/icon.directive";
+import * as i7 from "../../directives/pagination-item.directive";
+import * as i8 from "../../pipes/translate.pipe";
+const _c0 = ["rowTemplate"];
+const _c1 = ["wrapperTemplate"];
+const _c2 = ["filterTemplate"];
+const _c3 = ["columnsTemplate"];
+const _c4 = ["defaultRowTemplate"];
+const _c5 = ["defaultWrapperTemplate"];
+const _c6 = ["defaultFilterTemplate"];
+const _c7 = ["pagination"];
+function DynamicTableComponent_ng_template_2_div_0_label_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "label");
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r13 = i0.ɵɵnextContext(3);
+    i0.ɵɵattribute("for", ctx_r13.tableId);
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(2, 2, ctx_r13.label));
+} }
+function DynamicTableComponent_ng_template_2_div_0_Template(rf, ctx) { if (rf & 1) {
+    const _r16 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "div", 11);
+    i0.ɵɵtemplate(1, DynamicTableComponent_ng_template_2_div_0_label_1_Template, 3, 4, "label", 12);
+    i0.ɵɵelementStart(2, "input", 13);
+    i0.ɵɵlistener("ngModelChange", function DynamicTableComponent_ng_template_2_div_0_Template_input_ngModelChange_2_listener($event) { i0.ɵɵrestoreView(_r16); const table_r11 = i0.ɵɵnextContext().$implicit; return table_r11.setFilter($event); });
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const table_r11 = i0.ɵɵnextContext().$implicit;
+    const ctx_r12 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r12.label);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("placeholder", i0.ɵɵpipeBind1(3, 4, ctx_r12.placeholder))("ngModel", table_r11.filter);
+    i0.ɵɵattribute("id", ctx_r12.tableId);
+} }
+function DynamicTableComponent_ng_template_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, DynamicTableComponent_ng_template_2_div_0_Template, 4, 6, "div", 10);
+} if (rf & 2) {
+    const table_r11 = ctx.$implicit;
+    i0.ɵɵproperty("ngIf", table_r11.showFilter);
+} }
+function DynamicTableComponent_ng_template_7_ng_template_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span");
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const column_r26 = ctx.column;
+    const item_r27 = ctx.item;
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(item_r27[column_r26] == undefined || item_r27[column_r26] == null ? "-" : item_r27[column_r26]);
+} }
+function DynamicTableComponent_ng_template_7_ng_template_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0, 3);
+} if (rf & 2) {
+    const ctx_r28 = i0.ɵɵnextContext();
+    const template_r20 = ctx_r28.template;
+    const context_r18 = ctx_r28.$implicit;
+    i0.ɵɵproperty("ngxTemplateOutlet", template_r20.ref)("context", context_r18);
+} }
+function DynamicTableComponent_ng_template_7_td_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "td", 17);
+    i0.ɵɵelementContainer(1, 3);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r29 = i0.ɵɵnextContext();
+    const column_r19 = ctx_r29.column;
+    const template_r20 = ctx_r29.template;
+    const context_r18 = ctx_r29.$implicit;
+    const _r21 = i0.ɵɵreference(1);
+    i0.ɵɵproperty("ngClass", "column-" + column_r19);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngxTemplateOutlet", !template_r20 ? _r21 : template_r20.ref)("context", context_r18);
+} }
+function DynamicTableComponent_ng_template_7_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, DynamicTableComponent_ng_template_7_ng_template_0_Template, 2, 1, "ng-template", null, 14, i0.ɵɵtemplateRefExtractor);
+    i0.ɵɵtemplate(2, DynamicTableComponent_ng_template_7_ng_template_2_Template, 1, 2, "ng-template", null, 15, i0.ɵɵtemplateRefExtractor);
+    i0.ɵɵtemplate(4, DynamicTableComponent_ng_template_7_td_4_Template, 2, 3, "td", 16);
+} if (rf & 2) {
+    const template_r20 = ctx.template;
+    const _r23 = i0.ɵɵreference(3);
+    i0.ɵɵadvance(4);
+    i0.ɵɵproperty("ngIf", !template_r20 || !template_r20.pure)("ngIfElse", _r23);
+} }
+const _c8 = function (a0, a1) { return { template: a0, column: a1 }; };
+function DynamicTableComponent_ng_template_9_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0, 19);
+} if (rf & 2) {
+    const column_r32 = ctx.$implicit;
+    const context_r30 = i0.ɵɵnextContext().$implicit;
+    const ctx_r31 = i0.ɵɵnextContext();
+    const _r3 = i0.ɵɵreference(8);
+    i0.ɵɵproperty("ngxTemplateOutlet", _r3)("context", context_r30)("additionalContext", i0.ɵɵpureFunction2(3, _c8, ctx_r31.templates[column_r32], column_r32));
+} }
+function DynamicTableComponent_ng_template_9_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵtemplate(0, DynamicTableComponent_ng_template_9_ng_container_0_Template, 1, 6, "ng-container", 18);
+} if (rf & 2) {
+    const ctx_r6 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("ngForOf", ctx_r6.cols);
+} }
+function DynamicTableComponent_ng_template_11_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "tr");
+    i0.ɵɵelementContainer(1, 3);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const context_r34 = ctx.$implicit;
+    i0.ɵɵnextContext();
+    const _r5 = i0.ɵɵreference(10);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngxTemplateOutlet", _r5)("context", context_r34);
+} }
+function DynamicTableComponent_ng_template_13_th_3_a_1_i_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "i", 26);
+} if (rf & 2) {
+    const column_r37 = i0.ɵɵnextContext(2).$implicit;
+    const ctx_r40 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("icon", ctx_r40.orderDescending ? "sort-desc" : "sort-asc")("ngClass", ctx_r40.orderBy == column_r37 ? ctx_r40.orderDescending ? "sort-desc" : "sort-asc" : "");
+} }
+function DynamicTableComponent_ng_template_13_th_3_a_1_Template(rf, ctx) { if (rf & 1) {
+    const _r44 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "a", 24);
+    i0.ɵɵlistener("click", function DynamicTableComponent_ng_template_13_th_3_a_1_Template_a_click_0_listener() { i0.ɵɵrestoreView(_r44); const column_r37 = i0.ɵɵnextContext().$implicit; const ctx_r42 = i0.ɵɵnextContext(2); return ctx_r42.setOrder(column_r37); });
+    i0.ɵɵelementStart(1, "span");
+    i0.ɵɵtext(2);
+    i0.ɵɵpipe(3, "translate");
+    i0.ɵɵelementEnd();
+    i0.ɵɵtemplate(4, DynamicTableComponent_ng_template_13_th_3_a_1_i_4_Template, 1, 2, "i", 25);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const column_r37 = i0.ɵɵnextContext().$implicit;
+    const ctx_r38 = i0.ɵɵnextContext(2);
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(3, 2, "label." + column_r37));
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("ngIf", ctx_r38.orderBy == column_r37);
+} }
+function DynamicTableComponent_ng_template_13_th_3_span_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "span");
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const column_r37 = i0.ɵɵnextContext().$implicit;
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(i0.ɵɵpipeBind1(2, 1, "label." + column_r37));
+} }
+function DynamicTableComponent_ng_template_13_th_3_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "th", 17);
+    i0.ɵɵtemplate(1, DynamicTableComponent_ng_template_13_th_3_a_1_Template, 5, 4, "a", 23);
+    i0.ɵɵtemplate(2, DynamicTableComponent_ng_template_13_th_3_span_2_Template, 3, 3, "span", 12);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const column_r37 = ctx.$implicit;
+    const ctx_r35 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("ngClass", "column-" + column_r37);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r35.orders[column_r37]);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", !ctx_r35.orders[column_r37]);
+} }
+function DynamicTableComponent_ng_template_13_ng_container_5_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0, 19);
+} if (rf & 2) {
+    const context_r47 = ctx.$implicit;
+    const ctx_r36 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("ngxTemplateOutlet", ctx_r36.rowTemplate)("context", context_r47)("additionalContext", ctx_r36);
+} }
+function DynamicTableComponent_ng_template_13_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "table", 20)(1, "thead")(2, "tr");
+    i0.ɵɵtemplate(3, DynamicTableComponent_ng_template_13_th_3_Template, 3, 3, "th", 21);
+    i0.ɵɵelementEnd()();
+    i0.ɵɵelementStart(4, "tbody");
+    i0.ɵɵtemplate(5, DynamicTableComponent_ng_template_13_ng_container_5_Template, 1, 3, "ng-container", 22);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const ctx_r10 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(3);
+    i0.ɵɵproperty("ngForOf", ctx_r10.cols);
+} }
+export class DynamicTableComponent {
+    constructor() {
+        this.loadData = (page, itemsPerPage) => {
+            const orderBy = this.orders[this.orderBy];
+            return this.dataLoader(page, itemsPerPage, orderBy, this.orderDescending, this.filter);
+        };
+        this.dataLoader = this.loadLocalData;
+        this.placeholder = "";
+        this.tableId = UniqueUtils.uuid();
+        this.templates = {};
+        this.filter = "";
+        this.orders = {};
+    }
+    get items() {
+        return !this.pagination ? [] : this.pagination.items;
+    }
+    static compare(orderBy, a, b) {
+        a = a.item ? a.item[orderBy] : null;
+        b = b.item ? b.item[orderBy] : null;
+        return ObjectUtils.compare(a, b);
+    }
+    ngAfterContentInit() {
+        this.templates = this.templateDirectives.reduce((result, directive) => {
+            if (ObjectUtils.isArray(directive.column)) {
+                directive.column.forEach(column => {
+                    result[column] = directive;
+                });
+                return result;
+            }
+            if (!ObjectUtils.isString(directive.column) || directive.column.length == 0)
+                return result;
+            result[directive.column] = directive;
+            return result;
+        }, {});
+    }
+    ngAfterViewInit() {
+        this.rowTemplate = this.rowTemplate || this.defaultRowTemplate;
+        this.filterTemplate = this.filterTemplate || this.defaultFilterTemplate;
+    }
+    ngOnChanges(changes) {
+        if (changes.columns) {
+            const columns = changes.columns.currentValue || [];
+            this.orders = ObjectUtils.isArray(columns) ? columns.reduce((result, column) => {
+                result[column] = column;
+                return result;
+            }, {}) : columns;
+            this.cols = Object.keys(this.orders);
+            this.orderBy = this.orderBy in this.orders ? this.orderBy : this.columns[0];
+        }
+        if (changes.orderBy && this.orders) {
+            this.orderBy = this.orderBy in this.orders ? this.orderBy : this.columns[0];
+        }
+        if (!changes.data && !changes.parallelData && !changes.itemsPerPage && !changes.orderBy && !changes.orderDescending)
+            return;
+        this.refresh();
+    }
+    refresh() {
+        if (!this.pagination)
+            return;
+        this.pagination.refresh();
+    }
+    setFilter(filter) {
+        this.filter = filter;
+        this.refresh();
+    }
+    setOrder(column) {
+        this.orderDescending = column == this.orderBy && !this.orderDescending;
+        this.orderBy = column;
+        this.refresh();
+    }
+    loadLocalData(page, rowsPerPage, orderBy, orderDescending, filter) {
+        if (!this.data) {
+            return Promise.resolve({
+                total: 0,
+                items: []
+            });
+        }
+        const compare = orderDescending
+            ? (a, b) => DynamicTableComponent.compare(orderBy, b, a)
+            : (a, b) => DynamicTableComponent.compare(orderBy, a, b);
+        const from = (page - 1) * rowsPerPage;
+        const dataLength = this.data.length;
+        const length = Math.min(rowsPerPage, dataLength - from);
+        const parallelData = this.parallelData || [];
+        let data = this.data.map((item, ix) => {
+            return new PaginationItemContext(item, parallelData[ix] || {}, dataLength, ix, ix);
+        });
+        if (ObjectUtils.isString(filter) && filter.length > 0) {
+            const filterRx = new RegExp(filter, "gi");
+            data = data.filter(c => c.filter(filterRx));
+        }
+        const items = orderBy ? data.sort(compare).splice(from, length) : data.splice(from, length);
+        items.forEach((context, ix) => {
+            context.index = from + ix;
+        });
+        return Promise.resolve({
+            total: dataLength,
+            items: items
+        });
+    }
+}
+DynamicTableComponent.ɵfac = function DynamicTableComponent_Factory(t) { return new (t || DynamicTableComponent)(); };
+DynamicTableComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: DynamicTableComponent, selectors: [["dynamic-table"]], contentQueries: function DynamicTableComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+        i0.ɵɵcontentQuery(dirIndex, _c0, 7);
+        i0.ɵɵcontentQuery(dirIndex, _c1, 7);
+        i0.ɵɵcontentQuery(dirIndex, _c2, 7);
+        i0.ɵɵcontentQuery(dirIndex, DynamicTableTemplateDirective, 4);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.rowTemplate = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.wrapperTemplate = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.filterTemplate = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.templateDirectives = _t);
+    } }, viewQuery: function DynamicTableComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c3, 7);
+        i0.ɵɵviewQuery(_c4, 7);
+        i0.ɵɵviewQuery(_c5, 7);
+        i0.ɵɵviewQuery(_c6, 7);
+        i0.ɵɵviewQuery(_c7, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.columnsTemplate = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.defaultRowTemplate = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.defaultWrapperTemplate = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.defaultFilterTemplate = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.pagination = _t.first);
+    } }, inputs: { label: "label", placeholder: "placeholder", dataLoader: "dataLoader", data: "data", parallelData: "parallelData", columns: "columns", showFilter: "showFilter", itemsPerPage: "itemsPerPage", updateTime: "updateTime", maxPages: "maxPages", directionLinks: "directionLinks", boundaryLinks: "boundaryLinks", orderBy: "orderBy", orderDescending: "orderDescending" }, features: [i0.ɵɵNgOnChangesFeature], decls: 17, vars: 13, consts: [[1, "dynamic-table", 3, "pagination", "itemsPerPage", "updateTime"], ["pagination", "pagination"], ["defaultFilterTemplate", ""], [3, "ngxTemplateOutlet", "context"], [3, "maxSize", "directionLinks", "boundaryLinks"], [1, "table-responsive"], ["columnTemplate", ""], ["columnsTemplate", ""], ["defaultRowTemplate", ""], ["defaultWrapperTemplate", ""], ["class", "table-search", 4, "ngIf"], [1, "table-search"], [4, "ngIf"], ["type", "text", 1, "form-control", 3, "placeholder", "ngModel", "ngModelChange"], ["defaultTemplate", ""], ["pureTemplate", ""], [3, "ngClass", 4, "ngIf", "ngIfElse"], [3, "ngClass"], [3, "ngxTemplateOutlet", "context", "additionalContext", 4, "ngFor", "ngForOf"], [3, "ngxTemplateOutlet", "context", "additionalContext"], [1, "table", "table-striped"], [3, "ngClass", 4, "ngFor", "ngForOf"], [3, "ngxTemplateOutlet", "context", "additionalContext", 4, "paginationItem"], [3, "click", 4, "ngIf"], [3, "click"], [3, "icon", "ngClass", 4, "ngIf"], [3, "icon", "ngClass"]], template: function DynamicTableComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0, 1);
+        i0.ɵɵtemplate(2, DynamicTableComponent_ng_template_2_Template, 1, 1, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵelementContainer(4, 3);
+        i0.ɵɵelement(5, "pagination-menu", 4);
+        i0.ɵɵelementStart(6, "div", 5);
+        i0.ɵɵtemplate(7, DynamicTableComponent_ng_template_7_Template, 5, 2, "ng-template", null, 6, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵtemplate(9, DynamicTableComponent_ng_template_9_Template, 1, 1, "ng-template", null, 7, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵtemplate(11, DynamicTableComponent_ng_template_11_Template, 2, 2, "ng-template", null, 8, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵtemplate(13, DynamicTableComponent_ng_template_13_Template, 6, 1, "ng-template", null, 9, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵelementContainer(15, 3);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelement(16, "pagination-menu", 4);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        const _r1 = i0.ɵɵreference(3);
+        const _r9 = i0.ɵɵreference(14);
+        i0.ɵɵproperty("pagination", ctx.loadData)("itemsPerPage", ctx.itemsPerPage)("updateTime", ctx.updateTime);
+        i0.ɵɵadvance(4);
+        i0.ɵɵproperty("ngxTemplateOutlet", ctx.filterTemplate || _r1)("context", ctx);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("maxSize", ctx.maxPages)("directionLinks", ctx.directionLinks)("boundaryLinks", ctx.boundaryLinks);
+        i0.ɵɵadvance(10);
+        i0.ɵɵproperty("ngxTemplateOutlet", ctx.wrapperTemplate || _r9)("context", ctx);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("maxSize", ctx.maxPages)("directionLinks", ctx.directionLinks)("boundaryLinks", ctx.boundaryLinks);
+    } }, directives: [i1.PaginationDirective, i2.NgIf, i3.DefaultValueAccessor, i3.NgControlStatus, i3.NgModel, i4.NgxTemplateOutletDirective, i5.PaginationMenuComponent, i2.NgClass, i2.NgForOf, i6.IconDirective, i7.PaginationItemDirective], pipes: [i8.TranslatePipe], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DynamicTableComponent, [{
+        type: Component,
+        args: [{ selector: "dynamic-table", template: "<div class=\"dynamic-table\" #pagination=\"pagination\" [pagination]=\"loadData\" [itemsPerPage]=\"itemsPerPage\" [updateTime]=\"updateTime\">\r\n    <ng-template #defaultFilterTemplate let-table>\r\n        <div class=\"table-search\" *ngIf=\"table.showFilter\">\r\n            <label *ngIf=\"label\" [attr.for]=\"tableId\">{{ label | translate }}</label>\r\n            <input type=\"text\"\r\n                   class=\"form-control\"\r\n                   [attr.id]=\"tableId\"\r\n                   [placeholder]=\"placeholder | translate\"\r\n                   [ngModel]=\"table.filter\"\r\n                   (ngModelChange)=\"table.setFilter($event)\"/>\r\n        </div>\r\n    </ng-template>\r\n    <ng-container [ngxTemplateOutlet]=\"filterTemplate || defaultFilterTemplate\" [context]=\"this\"></ng-container>\r\n    <pagination-menu [maxSize]=\"maxPages\" [directionLinks]=\"directionLinks\" [boundaryLinks]=\"boundaryLinks\"></pagination-menu>\r\n    <div class=\"table-responsive\">\r\n\r\n        <ng-template #columnTemplate let-context let-column=\"column\" let-template=\"template\">\r\n            <ng-template #defaultTemplate let-column=\"column\" let-item=\"item\">\r\n                <span>{{ item[column] == undefined || item[column] == null ? '-' : item[column] }}</span>\r\n            </ng-template>\r\n            <ng-template #pureTemplate>\r\n                <ng-container [ngxTemplateOutlet]=\"template.ref\" [context]=\"context\"></ng-container>\r\n            </ng-template>\r\n            <td [ngClass]=\"'column-' + column\" *ngIf=\"!template || !template.pure; else pureTemplate\">\r\n                <ng-container [ngxTemplateOutlet]=\"!template ? defaultTemplate : template.ref\" [context]=\"context\"></ng-container>\r\n            </td>\r\n        </ng-template>\r\n\r\n        <ng-template #columnsTemplate let-context>\r\n            <ng-container *ngFor=\"let column of cols\"\r\n                          [ngxTemplateOutlet]=\"columnTemplate\"\r\n                          [context]=\"context\"\r\n                          [additionalContext]=\"{\r\n                            template: templates[column],\r\n                            column: column\r\n                          }\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template #defaultRowTemplate let-context>\r\n            <tr>\r\n                <ng-container [ngxTemplateOutlet]=\"columnsTemplate\" [context]=\"context\"></ng-container>\r\n            </tr>\r\n        </ng-template>\r\n\r\n        <ng-template #defaultWrapperTemplate>\r\n            <table class=\"table table-striped\">\r\n                <thead>\r\n                <tr>\r\n                    <th *ngFor=\"let column of cols\" [ngClass]=\"'column-' + column\">\r\n                        <a *ngIf=\"orders[column]\" (click)=\"setOrder(column)\">\r\n                            <span>{{ 'label.' + column | translate }}</span>\r\n                            <i *ngIf=\"orderBy == column\"\r\n                               [icon]=\"orderDescending ? 'sort-desc' : 'sort-asc'\"\r\n                               [ngClass]=\"orderBy == column ? (orderDescending ? 'sort-desc': 'sort-asc') : ''\"></i>\r\n                        </a>\r\n                        <span *ngIf=\"!orders[column]\">{{ 'label.' + column | translate }}</span>\r\n                    </th>\r\n                </tr>\r\n                </thead>\r\n                <tbody>\r\n                <ng-container *paginationItem=\"let context\"\r\n                              [ngxTemplateOutlet]=\"rowTemplate\"\r\n                              [context]=\"context\"\r\n                              [additionalContext]=\"this\"></ng-container>\r\n                </tbody>\r\n            </table>\r\n        </ng-template>\r\n\r\n        <ng-container [ngxTemplateOutlet]=\"wrapperTemplate || defaultWrapperTemplate\"\r\n                      [context]=\"this\"></ng-container>\r\n    </div>\r\n    <pagination-menu [maxSize]=\"maxPages\" [directionLinks]=\"directionLinks\" [boundaryLinks]=\"boundaryLinks\"></pagination-menu>\r\n</div>\r\n" }]
+    }], function () { return []; }, { label: [{
+            type: Input
+        }], placeholder: [{
+            type: Input
+        }], dataLoader: [{
+            type: Input
+        }], data: [{
+            type: Input
+        }], parallelData: [{
+            type: Input
+        }], columns: [{
+            type: Input
+        }], showFilter: [{
+            type: Input
+        }], itemsPerPage: [{
+            type: Input
+        }], updateTime: [{
+            type: Input
+        }], maxPages: [{
+            type: Input
+        }], directionLinks: [{
+            type: Input
+        }], boundaryLinks: [{
+            type: Input
+        }], orderBy: [{
+            type: Input
+        }], orderDescending: [{
+            type: Input
+        }], rowTemplate: [{
+            type: ContentChild,
+            args: ["rowTemplate", { static: true }]
+        }], wrapperTemplate: [{
+            type: ContentChild,
+            args: ["wrapperTemplate", { static: true }]
+        }], filterTemplate: [{
+            type: ContentChild,
+            args: ["filterTemplate", { static: true }]
+        }], columnsTemplate: [{
+            type: ViewChild,
+            args: ["columnsTemplate", { static: true }]
+        }], defaultRowTemplate: [{
+            type: ViewChild,
+            args: ["defaultRowTemplate", { static: true }]
+        }], defaultWrapperTemplate: [{
+            type: ViewChild,
+            args: ["defaultWrapperTemplate", { static: true }]
+        }], defaultFilterTemplate: [{
+            type: ViewChild,
+            args: ["defaultFilterTemplate", { static: true }]
+        }], pagination: [{
+            type: ViewChild,
+            args: ["pagination"]
+        }], templateDirectives: [{
+            type: ContentChildren,
+            args: [DynamicTableTemplateDirective]
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-table.component.js","sourceRoot":"","sources":["../../../../../src/ngx-utils/components/dynamic-table/dynamic-table.component.ts","../../../../../src/ngx-utils/components/dynamic-table/dynamic-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    AfterContentInit, AfterViewInit,\r\n    Component,\r\n    ContentChild,\r\n    ContentChildren,\r\n    Input,\r\n    OnChanges,\r\n    QueryList,\r\n    SimpleChanges,\r\n    TemplateRef,\r\n    ViewChild\r\n} from \"@angular/core\";\r\nimport {\r\n    IPaginationData,\r\n    ITableColumns,\r\n    ITableTemplates,\r\n    PaginationItemContext,\r\n    TableDataLoader\r\n} from \"../../common-types\";\r\nimport {ObjectUtils} from \"../../utils/object.utils\";\r\nimport {DynamicTableTemplateDirective} from \"../../directives/dynamic-table-template.directive\";\r\nimport {PaginationDirective} from \"../../directives/pagination.directive\";\r\nimport {UniqueUtils} from \"../../utils/unique.utils\";\r\n\r\n@Component({\r\n    selector: \"dynamic-table\",\r\n    templateUrl: \"./dynamic-table.component.html\",\r\n})\r\nexport class DynamicTableComponent implements AfterContentInit, AfterViewInit, OnChanges {\r\n\r\n    @Input() label: string;\r\n    @Input() placeholder: string;\r\n    @Input() dataLoader: TableDataLoader;\r\n    @Input() data: any[];\r\n    @Input() parallelData: any[];\r\n    @Input() columns: ITableColumns | string[];\r\n    @Input() showFilter: boolean;\r\n    @Input() itemsPerPage: number;\r\n    @Input() updateTime: number;\r\n    @Input() maxPages: number;\r\n    @Input() directionLinks: boolean;\r\n    @Input() boundaryLinks: boolean;\r\n    @Input() orderBy: string;\r\n    @Input() orderDescending: boolean;\r\n\r\n    tableId: string;\r\n    templates: ITableTemplates;\r\n    filter: string;\r\n    orders: ITableColumns;\r\n    cols: string[];\r\n\r\n    get items(): any[] {\r\n        return !this.pagination ? [] : this.pagination.items;\r\n    }\r\n\r\n    @ContentChild(\"rowTemplate\", {static: true})\r\n    rowTemplate: TemplateRef<any>;\r\n\r\n    @ContentChild(\"wrapperTemplate\", {static: true})\r\n    wrapperTemplate: TemplateRef<any>;\r\n\r\n    @ContentChild(\"filterTemplate\", {static: true})\r\n    filterTemplate: TemplateRef<any>;\r\n\r\n    @ViewChild(\"columnsTemplate\", {static: true})\r\n    columnsTemplate: TemplateRef<any>;\r\n\r\n    @ViewChild(\"defaultRowTemplate\", {static: true})\r\n    defaultRowTemplate: TemplateRef<any>;\r\n\r\n    @ViewChild(\"defaultWrapperTemplate\", {static: true})\r\n    defaultWrapperTemplate: TemplateRef<any>;\r\n\r\n    @ViewChild(\"defaultFilterTemplate\", {static: true})\r\n    defaultFilterTemplate: TemplateRef<any>;\r\n\r\n    @ViewChild(\"pagination\")\r\n    private pagination: PaginationDirective;\r\n\r\n    @ContentChildren(DynamicTableTemplateDirective)\r\n    private templateDirectives: QueryList<DynamicTableTemplateDirective>;\r\n\r\n    private static compare(orderBy: string, a: PaginationItemContext, b: PaginationItemContext): number {\r\n        a = a.item ? a.item[orderBy] : null;\r\n        b = b.item ? b.item[orderBy] : null;\r\n        return ObjectUtils.compare(a, b);\r\n    }\r\n\r\n    constructor() {\r\n        this.dataLoader = this.loadLocalData;\r\n        this.placeholder = \"\";\r\n        this.tableId = UniqueUtils.uuid();\r\n        this.templates = {};\r\n        this.filter = \"\";\r\n        this.orders = {};\r\n    }\r\n\r\n    ngAfterContentInit(): void {\r\n        this.templates = this.templateDirectives.reduce((result, directive) => {\r\n            if (ObjectUtils.isArray(directive.column)) {\r\n                directive.column.forEach(column => {\r\n                    result[column] = directive;\r\n                });\r\n                return result;\r\n            }\r\n            if (!ObjectUtils.isString(directive.column) || directive.column.length == 0) return result;\r\n            result[directive.column] = directive;\r\n            return result;\r\n        }, {});\r\n    }\r\n\r\n    ngAfterViewInit(): void {\r\n        this.rowTemplate = this.rowTemplate || this.defaultRowTemplate;\r\n        this.filterTemplate = this.filterTemplate || this.defaultFilterTemplate;\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        if (changes.columns) {\r\n            const columns = changes.columns.currentValue || [];\r\n            this.orders = ObjectUtils.isArray(columns) ? columns.reduce((result, column) => {\r\n                result[column] = column;\r\n                return result;\r\n            }, {}) : columns;\r\n            this.cols = Object.keys(this.orders);\r\n            this.orderBy = this.orderBy in this.orders ? this.orderBy : this.columns[0];\r\n        }\r\n        if (changes.orderBy && this.orders) {\r\n            this.orderBy = this.orderBy in this.orders ? this.orderBy : this.columns[0];\r\n        }\r\n        if (!changes.data && !changes.parallelData && !changes.itemsPerPage && !changes.orderBy && !changes.orderDescending) return;\r\n        this.refresh();\r\n    }\r\n\r\n    refresh(): void {\r\n        if (!this.pagination) return;\r\n        this.pagination.refresh();\r\n    }\r\n\r\n    setFilter(filter: string): void {\r\n        this.filter = filter;\r\n        this.refresh();\r\n    }\r\n\r\n    setOrder(column: string): void {\r\n        this.orderDescending = column == this.orderBy && !this.orderDescending;\r\n        this.orderBy = column;\r\n        this.refresh();\r\n    }\r\n\r\n    loadData = (page: number, itemsPerPage: number): Promise<IPaginationData> => {\r\n        const orderBy = this.orders[this.orderBy];\r\n        return this.dataLoader(page, itemsPerPage, orderBy, this.orderDescending, this.filter);\r\n    };\r\n\r\n    private loadLocalData(page: number, rowsPerPage: number, orderBy: string, orderDescending: boolean, filter: string): Promise<IPaginationData> {\r\n        if (!this.data) {\r\n            return Promise.resolve({\r\n                total: 0,\r\n                items: []\r\n            });\r\n        }\r\n        const compare: (a: any, b: any) => number = orderDescending\r\n            ? (a, b) => DynamicTableComponent.compare(orderBy, b, a)\r\n            : (a, b) => DynamicTableComponent.compare(orderBy, a, b);\r\n        const from = (page - 1) * rowsPerPage;\r\n        const dataLength = this.data.length;\r\n        const length = Math.min(rowsPerPage, dataLength - from);\r\n        const parallelData = this.parallelData || [];\r\n        let data = this.data.map((item, ix) => {\r\n            return new PaginationItemContext(item, parallelData[ix] || {}, dataLength, ix, ix);\r\n        });\r\n        if (ObjectUtils.isString(filter) && filter.length > 0) {\r\n            const filterRx = new RegExp(filter, \"gi\");\r\n            data = data.filter(c => c.filter(filterRx));\r\n        }\r\n        const items = orderBy ? data.sort(compare).splice(from, length) : data.splice(from, length);\r\n        items.forEach((context, ix) => {\r\n            context.index = from + ix;\r\n        });\r\n        return Promise.resolve({\r\n            total: dataLength,\r\n            items: items\r\n        });\r\n    }\r\n}\r\n","<div class=\"dynamic-table\" #pagination=\"pagination\" [pagination]=\"loadData\" [itemsPerPage]=\"itemsPerPage\" [updateTime]=\"updateTime\">\r\n    <ng-template #defaultFilterTemplate let-table>\r\n        <div class=\"table-search\" *ngIf=\"table.showFilter\">\r\n            <label *ngIf=\"label\" [attr.for]=\"tableId\">{{ label | translate }}</label>\r\n            <input type=\"text\"\r\n                   class=\"form-control\"\r\n                   [attr.id]=\"tableId\"\r\n                   [placeholder]=\"placeholder | translate\"\r\n                   [ngModel]=\"table.filter\"\r\n                   (ngModelChange)=\"table.setFilter($event)\"/>\r\n        </div>\r\n    </ng-template>\r\n    <ng-container [ngxTemplateOutlet]=\"filterTemplate || defaultFilterTemplate\" [context]=\"this\"></ng-container>\r\n    <pagination-menu [maxSize]=\"maxPages\" [directionLinks]=\"directionLinks\" [boundaryLinks]=\"boundaryLinks\"></pagination-menu>\r\n    <div class=\"table-responsive\">\r\n\r\n        <ng-template #columnTemplate let-context let-column=\"column\" let-template=\"template\">\r\n            <ng-template #defaultTemplate let-column=\"column\" let-item=\"item\">\r\n                <span>{{ item[column] == undefined || item[column] == null ? '-' : item[column] }}</span>\r\n            </ng-template>\r\n            <ng-template #pureTemplate>\r\n                <ng-container [ngxTemplateOutlet]=\"template.ref\" [context]=\"context\"></ng-container>\r\n            </ng-template>\r\n            <td [ngClass]=\"'column-' + column\" *ngIf=\"!template || !template.pure; else pureTemplate\">\r\n                <ng-container [ngxTemplateOutlet]=\"!template ? defaultTemplate : template.ref\" [context]=\"context\"></ng-container>\r\n            </td>\r\n        </ng-template>\r\n\r\n        <ng-template #columnsTemplate let-context>\r\n            <ng-container *ngFor=\"let column of cols\"\r\n                          [ngxTemplateOutlet]=\"columnTemplate\"\r\n                          [context]=\"context\"\r\n                          [additionalContext]=\"{\r\n                            template: templates[column],\r\n                            column: column\r\n                          }\"></ng-container>\r\n        </ng-template>\r\n\r\n        <ng-template #defaultRowTemplate let-context>\r\n            <tr>\r\n                <ng-container [ngxTemplateOutlet]=\"columnsTemplate\" [context]=\"context\"></ng-container>\r\n            </tr>\r\n        </ng-template>\r\n\r\n        <ng-template #defaultWrapperTemplate>\r\n            <table class=\"table table-striped\">\r\n                <thead>\r\n                <tr>\r\n                    <th *ngFor=\"let column of cols\" [ngClass]=\"'column-' + column\">\r\n                        <a *ngIf=\"orders[column]\" (click)=\"setOrder(column)\">\r\n                            <span>{{ 'label.' + column | translate }}</span>\r\n                            <i *ngIf=\"orderBy == column\"\r\n                               [icon]=\"orderDescending ? 'sort-desc' : 'sort-asc'\"\r\n                               [ngClass]=\"orderBy == column ? (orderDescending ? 'sort-desc': 'sort-asc') : ''\"></i>\r\n                        </a>\r\n                        <span *ngIf=\"!orders[column]\">{{ 'label.' + column | translate }}</span>\r\n                    </th>\r\n                </tr>\r\n                </thead>\r\n                <tbody>\r\n                <ng-container *paginationItem=\"let context\"\r\n                              [ngxTemplateOutlet]=\"rowTemplate\"\r\n                              [context]=\"context\"\r\n                              [additionalContext]=\"this\"></ng-container>\r\n                </tbody>\r\n            </table>\r\n        </ng-template>\r\n\r\n        <ng-container [ngxTemplateOutlet]=\"wrapperTemplate || defaultWrapperTemplate\"\r\n                      [context]=\"this\"></ng-container>\r\n    </div>\r\n    <pagination-menu [maxSize]=\"maxPages\" [directionLinks]=\"directionLinks\" [boundaryLinks]=\"boundaryLinks\"></pagination-menu>\r\n</div>\r\n"]}