@stemy/ngx-utils 12.1.3 → 13.0.0

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,178 @@
+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 "../pagination-menu/pagination-menu.component";
+import * as i2 from "../../directives/pagination.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "../../directives/ngx-template-outlet.directive";
+import * as i6 from "../../directives/icon.directive";
+import * as i7 from "../../directives/pagination-item.directive";
+import * as i8 from "../../pipes/translate.pipe";
+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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DynamicTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicTableComponent, selector: "dynamic-table", 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" }, queries: [{ propertyName: "rowTemplate", first: true, predicate: ["rowTemplate"], descendants: true, static: true }, { propertyName: "wrapperTemplate", first: true, predicate: ["wrapperTemplate"], descendants: true, static: true }, { propertyName: "filterTemplate", first: true, predicate: ["filterTemplate"], descendants: true, static: true }, { propertyName: "templateDirectives", predicate: DynamicTableTemplateDirective }], viewQueries: [{ propertyName: "columnsTemplate", first: true, predicate: ["columnsTemplate"], descendants: true, static: true }, { propertyName: "defaultRowTemplate", first: true, predicate: ["defaultRowTemplate"], descendants: true, static: true }, { propertyName: "defaultWrapperTemplate", first: true, predicate: ["defaultWrapperTemplate"], descendants: true, static: true }, { propertyName: "defaultFilterTemplate", first: true, predicate: ["defaultFilterTemplate"], descendants: true, static: true }, { propertyName: "pagination", first: true, predicate: ["pagination"], descendants: true }], usesOnChanges: true, ngImport: i0, 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", components: [{ type: i1.PaginationMenuComponent, selector: "pagination-menu", inputs: ["maxSize", "urlParam", "directionLinks", "boundaryLinks"] }], directives: [{ type: i2.PaginationDirective, selector: "[pagination]", inputs: ["pagination", "page", "itemsPerPage", "updateTime", "waitFor"], outputs: ["pageChange", "onRefresh"], exportAs: ["pagination"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i5.NgxTemplateOutletDirective, selector: "[ngxTemplateOutlet]", inputs: ["context", "additionalContext", "ngxTemplateOutlet"] }, { type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i6.IconDirective, selector: "[icon]", inputs: ["icon", "activeIcon", "active"], outputs: ["activeChange"] }, { type: i7.PaginationItemDirective, selector: "[paginationItem]" }], pipes: { "translate": i8.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicTableComponent, decorators: [{
+            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" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { 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"]}

package/esm2020/ngx-utils/components/pagination-menu/pagination-menu.component.mjs

@@ -0,0 +1,101 @@
+import { Component, Inject, Input } from "@angular/core";
+import { ObjectUtils } from "../../utils/object.utils";
+import { StateService } from "../../services/state.service";
+import { PaginationDirective } from "../../directives/pagination.directive";
+import { ICON_SERVICE } from "../../common-types";
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/state.service";
+import * as i2 from "../../directives/pagination.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "../../pipes/safe-html.pipe";
+export class PaginationMenuComponent {
+    constructor(state, pagination, icons) {
+        this.state = state;
+        this.pagination = pagination;
+        this.icons = icons;
+        this.maxSize = 5;
+        this.directionLinks = true;
+        this.boundaryLinks = true;
+        this.firstLabel = `<<`;
+        this.prevLabel = `<`;
+        this.nextLabel = `>`;
+        this.lastLabel = `>>`;
+    }
+    get hasPrev() {
+        return this.pagination.page > 1;
+    }
+    get hasNext() {
+        return this.pagination.page < this.pagination.maxPage;
+    }
+    ngOnInit() {
+        this.onRefresh = this.pagination.onRefresh.subscribe(() => this.setPages());
+        this.setIcon("firstLabel", "first-page");
+        this.setIcon("prevLabel", "prev-page");
+        this.setIcon("nextLabel", "next-page");
+        this.setIcon("lastLabel", "last-page");
+    }
+    ngOnDestroy() {
+        if (!this.onRefresh)
+            return;
+        this.onRefresh.unsubscribe();
+    }
+    ngOnChanges(changes) {
+        this.maxSize = isNaN(this.maxSize) || this.maxSize <= 0 ? 5 : this.maxSize;
+        this.directionLinks = ObjectUtils.isBoolean(this.directionLinks) ? this.directionLinks : true;
+        this.boundaryLinks = ObjectUtils.isBoolean(this.boundaryLinks) ? this.boundaryLinks : true;
+        this.setPages();
+    }
+    paginate(page) {
+        if (this.pagination.page == page || this.pagination.maxPage < page || page < 1)
+            return;
+        if (!this.urlParam) {
+            this.pagination.paginate(page);
+            return;
+        }
+        const params = Object.assign({}, this.state.params);
+        params[this.urlParam] = page.toString();
+        const path = StateService.toPath(this.state.route, params);
+        this.state.navigateByUrl(path);
+    }
+    setIcon(labelName, icon) {
+        this.icons.getIcon(icon, icon, false).then(i => {
+            if (i == icon)
+                return;
+            this[labelName] = i;
+        });
+    }
+    setPages() {
+        if (!this.pagination)
+            return;
+        const totalPages = this.pagination.maxPage;
+        let startPage = Math.max(this.pagination.page - Math.floor(this.maxSize / 2), 1);
+        let endPage = startPage + this.maxSize - 1;
+        if (endPage > totalPages) {
+            endPage = totalPages;
+            startPage = Math.max(endPage - this.maxSize + 1, 1);
+        }
+        const pages = [];
+        for (let num = startPage; num <= endPage; num++) {
+            pages.push(num);
+        }
+        this.pages = pages;
+    }
+}
+PaginationMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PaginationMenuComponent, deps: [{ token: i1.StateService }, { token: i2.PaginationDirective }, { token: ICON_SERVICE }], target: i0.ɵɵFactoryTarget.Component });
+PaginationMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: PaginationMenuComponent, selector: "pagination-menu", inputs: { maxSize: "maxSize", urlParam: "urlParam", directionLinks: "directionLinks", boundaryLinks: "boundaryLinks" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"pagination-menu\" *ngIf=\"pagination.total > pagination.itemsPerPage\">\r\n    <ul class=\"pagination\">\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasPrev}\" *ngIf=\"boundaryLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(1)\" [innerHTML]=\"firstLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasPrev}\" *ngIf=\"directionLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.page - 1)\" [innerHTML]=\"prevLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{active: pagination.page == page}\" *ngFor=\"let page of pages\">\r\n            <a class=\"page-link\" [ngClass]=\"{active: pagination.page == page}\" (click)=\"paginate(page)\">{{ page }}</a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasNext}\" *ngIf=\"directionLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.page + 1)\" [innerHTML]=\"nextLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasNext}\" *ngIf=\"boundaryLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.maxPage)\" [innerHTML]=\"lastLabel | safe\"></a>\r\n        </li>\r\n    </ul>\r\n</div>\r\n", directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "safe": i4.SafeHtmlPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PaginationMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "pagination-menu", template: "<div class=\"pagination-menu\" *ngIf=\"pagination.total > pagination.itemsPerPage\">\r\n    <ul class=\"pagination\">\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasPrev}\" *ngIf=\"boundaryLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(1)\" [innerHTML]=\"firstLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasPrev}\" *ngIf=\"directionLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.page - 1)\" [innerHTML]=\"prevLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{active: pagination.page == page}\" *ngFor=\"let page of pages\">\r\n            <a class=\"page-link\" [ngClass]=\"{active: pagination.page == page}\" (click)=\"paginate(page)\">{{ page }}</a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasNext}\" *ngIf=\"directionLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.page + 1)\" [innerHTML]=\"nextLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasNext}\" *ngIf=\"boundaryLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.maxPage)\" [innerHTML]=\"lastLabel | safe\"></a>\r\n        </li>\r\n    </ul>\r\n</div>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i1.StateService }, { type: i2.PaginationDirective }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ICON_SERVICE]
+                }] }]; }, propDecorators: { maxSize: [{
+                type: Input
+            }], urlParam: [{
+                type: Input
+            }], directionLinks: [{
+                type: Input
+            }], boundaryLinks: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination-menu.component.js","sourceRoot":"","sources":["../../../../../src/ngx-utils/components/pagination-menu/pagination-menu.component.ts","../../../../../src/ngx-utils/components/pagination-menu/pagination-menu.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAA8C,MAAM,eAAe,CAAC;AAEpG,OAAO,EAAC,WAAW,EAAC,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAC,YAAY,EAAC,MAAM,8BAA8B,CAAC;AAC1D,OAAO,EAAC,mBAAmB,EAAC,MAAM,uCAAuC,CAAC;AAC1E,OAAO,EAAC,YAAY,EAAe,MAAM,oBAAoB,CAAC;;;;;;AAM9D,MAAM,OAAO,uBAAuB;IAuBhC,YAAmB,KAAmB,EAAS,UAA+B,EAA+B,KAAmB;QAA7G,UAAK,GAAL,KAAK,CAAc;QAAS,eAAU,GAAV,UAAU,CAAqB;QAA+B,UAAK,GAAL,KAAK,CAAc;QAC5H,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QACjB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IAC1B,CAAC;IAlBD,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,GAAG,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAA;IACzD,CAAC;IAcD,QAAQ;QACJ,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC5E,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QACzC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IAC3C,CAAC;IAED,WAAW;QACP,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,OAAO;QAC5B,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;IACjC,CAAC;IAED,WAAW,CAAC,OAAsB;QAC9B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QAC3E,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9F,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3F,IAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC;IAED,QAAQ,CAAC,IAAY;QACjB,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,GAAG,IAAI,IAAI,IAAI,GAAG,CAAC;YAAE,OAAO;QACvF,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAChB,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC/B,OAAO;SACV;QACD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACpD,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QACxC,MAAM,IAAI,GAAG,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC3D,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAES,OAAO,CAAC,SAAiB,EAAE,IAAY;QAC7C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;YAC3C,IAAI,CAAC,IAAI,IAAI;gBAAE,OAAO;YACtB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;IACP,CAAC;IAES,QAAQ;QACd,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAO;QAC7B,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;QAC3C,IAAI,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACjF,IAAI,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QAC3C,IAAI,OAAO,GAAG,UAAU,EAAE;YACtB,OAAO,GAAG,UAAU,CAAC;YACrB,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;SACvD;QACD,MAAM,KAAK,GAAa,EAAE,CAAC;QAC3B,KAAK,IAAI,GAAG,GAAG,SAAS,EAAE,GAAG,IAAI,OAAO,EAAE,GAAG,EAAE,EAAE;YAC7C,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACnB;QACD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACvB,CAAC;;oHAtFQ,uBAAuB,iFAuBwD,YAAY;wGAvB3F,uBAAuB,oMCXpC,4xCAmBA;2FDRa,uBAAuB;kBAJnC,SAAS;+BACI,iBAAiB;;0BA0BsD,MAAM;2BAAC,YAAY;4CArB3F,OAAO;sBAAf,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,aAAa;sBAArB,KAAK","sourcesContent":["import {Component, Inject, Input, OnChanges, OnDestroy, OnInit, SimpleChanges} from \"@angular/core\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {ObjectUtils} from \"../../utils/object.utils\";\r\nimport {StateService} from \"../../services/state.service\";\r\nimport {PaginationDirective} from \"../../directives/pagination.directive\";\r\nimport {ICON_SERVICE, IIconService} from \"../../common-types\";\r\n\r\n@Component({\r\n    selector: \"pagination-menu\",\r\n    templateUrl: \"./pagination-menu.component.html\"\r\n})\r\nexport class PaginationMenuComponent implements OnInit, OnDestroy, OnChanges {\r\n\r\n    @Input() maxSize: number;\r\n    @Input() urlParam: string;\r\n    @Input() directionLinks: boolean;\r\n    @Input() boundaryLinks: boolean;\r\n\r\n    pages: number[];\r\n    firstLabel: string;\r\n    prevLabel: string;\r\n    nextLabel: string;\r\n    lastLabel: string;\r\n\r\n    get hasPrev(): boolean {\r\n        return this.pagination.page > 1;\r\n    }\r\n\r\n    get hasNext(): boolean {\r\n        return this.pagination.page < this.pagination.maxPage\r\n    }\r\n\r\n    private onRefresh: Subscription;\r\n\r\n    constructor(public state: StateService, public pagination: PaginationDirective, @Inject(ICON_SERVICE) public icons: IIconService) {\r\n        this.maxSize = 5;\r\n        this.directionLinks = true;\r\n        this.boundaryLinks = true;\r\n        this.firstLabel = `<<`;\r\n        this.prevLabel = `<`;\r\n        this.nextLabel = `>`;\r\n        this.lastLabel = `>>`;\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        this.onRefresh = this.pagination.onRefresh.subscribe(() => this.setPages());\r\n        this.setIcon(\"firstLabel\", \"first-page\");\r\n        this.setIcon(\"prevLabel\", \"prev-page\");\r\n        this.setIcon(\"nextLabel\", \"next-page\");\r\n        this.setIcon(\"lastLabel\", \"last-page\");\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        if (!this.onRefresh) return;\r\n        this.onRefresh.unsubscribe();\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        this.maxSize = isNaN(this.maxSize) || this.maxSize <= 0 ? 5 : this.maxSize;\r\n        this.directionLinks = ObjectUtils.isBoolean(this.directionLinks) ? this.directionLinks : true;\r\n        this.boundaryLinks = ObjectUtils.isBoolean(this.boundaryLinks) ? this.boundaryLinks : true;\r\n        this.setPages();\r\n    }\r\n\r\n    paginate(page: number): void {\r\n        if (this.pagination.page == page || this.pagination.maxPage < page || page < 1) return;\r\n        if (!this.urlParam) {\r\n            this.pagination.paginate(page);\r\n            return;\r\n        }\r\n        const params = Object.assign({}, this.state.params);\r\n        params[this.urlParam] = page.toString();\r\n        const path = StateService.toPath(this.state.route, params);\r\n        this.state.navigateByUrl(path);\r\n    }\r\n\r\n    protected setIcon(labelName: string, icon: string): void {\r\n        this.icons.getIcon(icon, icon, false).then(i => {\r\n            if (i == icon) return;\r\n            this[labelName] = i;\r\n        });\r\n    }\r\n\r\n    protected setPages(): number {\r\n        if (!this.pagination) return;\r\n        const totalPages = this.pagination.maxPage;\r\n        let startPage = Math.max(this.pagination.page - Math.floor(this.maxSize / 2), 1);\r\n        let endPage = startPage + this.maxSize - 1;\r\n        if (endPage > totalPages) {\r\n            endPage = totalPages;\r\n            startPage = Math.max(endPage - this.maxSize + 1, 1);\r\n        }\r\n        const pages: number[] = [];\r\n        for (let num = startPage; num <= endPage; num++) {\r\n            pages.push(num);\r\n        }\r\n        this.pages = pages;\r\n    }\r\n}\r\n","<div class=\"pagination-menu\" *ngIf=\"pagination.total > pagination.itemsPerPage\">\r\n    <ul class=\"pagination\">\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasPrev}\" *ngIf=\"boundaryLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(1)\" [innerHTML]=\"firstLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasPrev}\" *ngIf=\"directionLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.page - 1)\" [innerHTML]=\"prevLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{active: pagination.page == page}\" *ngFor=\"let page of pages\">\r\n            <a class=\"page-link\" [ngClass]=\"{active: pagination.page == page}\" (click)=\"paginate(page)\">{{ page }}</a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasNext}\" *ngIf=\"directionLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.page + 1)\" [innerHTML]=\"nextLabel | safe\"></a>\r\n        </li>\r\n        <li class=\"page-item\" [ngClass]=\"{disabled: !hasNext}\" *ngIf=\"boundaryLinks\">\r\n            <a class=\"page-link\" (click)=\"paginate(pagination.maxPage)\" [innerHTML]=\"lastLabel | safe\"></a>\r\n        </li>\r\n    </ul>\r\n</div>\r\n"]}