@acorex/core 3.0.21 → 3.0.25

package/fesm2015/acorex-core.js

@@ -0,0 +1,2057 @@
+import * as moment_ from 'jalali-moment';
+import { Subject } from 'rxjs';
+import { EventEmitter, InjectionToken, Injector, ɵɵdefineInjectable, ɵɵinject, INJECTOR, Injectable, NgModule, Pipe, ApplicationRef, ComponentFactoryResolver, ElementRef, Input, HostListener, Directive } from '@angular/core';
+import { __decorate, __metadata } from 'tslib';
+import { CommonModule } from '@angular/common';
+import { HttpHeaders, HttpParams, HttpClient, HttpClientModule } from '@angular/common/http';
+import merge from 'lodash-es/merge';
+import { Router } from '@angular/router';
+
+class AXColorUtil {
+    static hex2Rgb(hexColor) {
+        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexColor);
+        return result ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16)
+        } : null;
+    }
+    static rgb2Hex(r, g, b, a = 255) {
+        let alpha;
+        let hex = (r | 1 << 8).toString(16).slice(1) +
+            (g | 1 << 8).toString(16).slice(1) +
+            (b | 1 << 8).toString(16).slice(1);
+        if (a !== 255) {
+            alpha = a;
+        }
+        else {
+            alpha = 1;
+        }
+        alpha = Math.round(alpha * 100) / 100;
+        alpha = Math.round(alpha * 255);
+        const hexAlpha = (alpha + 0x10000).toString(16).substr(-2).toUpperCase();
+        return '#' + hex + (alpha == 255 ? '' : hexAlpha);
+    }
+    ;
+    static illuminance(hexColor) {
+        const rgbColor = AXColorUtil.hex2Rgb(hexColor);
+        if (!rgbColor) {
+            return -1;
+        }
+        const r = rgbColor.r;
+        const g = rgbColor.g;
+        const b = rgbColor.b;
+        const a = [r, g, b].map(v => {
+            v /= 255;
+            return (v <= 0.03928) ?
+                v / 12.92 :
+                Math.pow(((v + 0.055) / 1.055), 2.4);
+        });
+        return a[0] * 0.2126 + a[1] * 0.7152 + a[2] * 0.0722;
+    }
+    static contrastToWhite(hexColor) {
+        const whiteIlluminance = 1;
+        const illuminance = AXColorUtil.illuminance(hexColor);
+        return whiteIlluminance / illuminance;
+    }
+}
+
+// @dynamic
+class AXObjectUtil {
+    static deepJSONClone(obj) {
+        return obj ? JSON.parse(JSON.stringify(obj)) : null;
+    }
+    static deepCopy(obj) {
+        let copy;
+        // Handle the 3 simple types, and null or undefined
+        if (null == obj || 'object' !== typeof obj) {
+            return obj;
+        }
+        // Handle Date
+        if (obj instanceof Date) {
+            copy = new Date();
+            copy.setTime(obj.getTime());
+            return copy;
+        }
+        // Handle Array
+        if (obj instanceof Array) {
+            copy = [];
+            for (let i = 0, len = obj.length; i < len; i++) {
+                copy[i] = AXObjectUtil.deepCopy(obj[i]);
+            }
+            return copy;
+        }
+        // Handle Object
+        if (obj instanceof Object) {
+            copy = {};
+            for (const attr in obj) {
+                if (obj.hasOwnProperty(attr)) {
+                    copy[attr] = AXObjectUtil.deepCopy(obj[attr]);
+                }
+            }
+            return copy;
+        }
+        throw new Error('Unable to copy obj! Its type isn\'t supported.');
+    }
+}
+function AXFetchProp(obj, prop) {
+    if (typeof obj === 'undefined') {
+        return false;
+    }
+    const index = prop.indexOf('.');
+    if (index > -1) {
+        return AXFetchProp(obj[prop.substring(0, index)], prop.substr(index + 1));
+    }
+    return obj[prop];
+}
+function getPropByPath(obj, path, defaultVal) {
+    path = path
+        .replace(/\[/g, '.')
+        .replace(/]/g, '')
+        .split('.');
+    path.forEach((level) => {
+        if (obj) {
+            obj = obj[level];
+        }
+    });
+    if (obj === undefined) {
+        return defaultVal;
+    }
+    return obj;
+}
+function setPropByPath(obj, path, value) {
+    if (Object(obj) !== obj) {
+        return obj;
+    } // When obj is not an object
+    // If not yet an array, get the keys from the string-path
+    if (!Array.isArray(path)) {
+        path = path.toString().match(/[^.[\]]+/g) || [];
+    }
+    path.slice(0, -1).reduce((a, c, i) => // Iterate all of them except the last one
+     Object(a[c]) === a[c] // Does the key exist and is its value an object?
+        // Yes: then follow that path
+        ? a[c]
+        // No: create the key. Is the next key a potential array-index?
+        : a[c] = Math.abs(path[i + 1]) >> 0 === +path[i + 1]
+            ? [] // Yes: assign a new array object
+            : {}, // No: assign a new plain object
+    obj)[path[path.length - 1]] = value; // Finally assign the value to the last key
+    return obj; // Return the top-level object to allow chaining
+}
+
+// @dynamic
+class AXConfig {
+    static get onChange() {
+        return AXConfig.dataChangeSubject.asObservable();
+    }
+    static set(arg1, arg2) {
+        if (arg1 && typeof arg1 == 'string') {
+            setPropByPath(AXConfig.dataModel, arg1, arg2);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (arg1 && typeof arg1 == 'object') {
+            Object.assign(AXConfig.dataModel, arg1);
+            AXConfig.dataChangeSubject.next(AXConfig.dataModel);
+            return;
+        }
+        if (!arg1 && !arg2) {
+            return AXConfig.dataChangeSubject.asObservable();
+        }
+    }
+    static get(path) {
+        return getPropByPath(AXConfig.dataModel, path);
+    }
+}
+AXConfig.dataModel = {};
+AXConfig.dataChangeSubject = new Subject();
+
+const moment = moment_;
+class AXDateTime {
+    // private get _moment(): moment_.Moment {
+    //     const m = moment(this.date);
+    //     if (this.type === 'jalali') {
+    //         m.locale('fa');
+    //     }
+    //     return m;
+    // }
+    constructor(value = new Date(), type = AXConfig.get('dateTime.type') || 'gregorian') {
+        this.type = type;
+        if (value instanceof Date) {
+            this._date = value;
+        }
+        else {
+            this._date = new Date(value);
+        }
+        this._moment = moment(this.date);
+        if (this.type === 'jalali') {
+            this._moment.locale('fa');
+        }
+    }
+    static convert(value, type = AXConfig.get('dateTime.type') || 'gregorian') {
+        let date;
+        if (typeof value === 'string' || value instanceof String) {
+            date = new AXDateTime(value, type);
+        }
+        else if (value instanceof Date) {
+            date = new AXDateTime(value, type);
+        }
+        else if (value instanceof AXDateTime) {
+            date = value;
+        }
+        return date;
+    }
+    get date() {
+        return this._date;
+    }
+    resolveUnit(unit) {
+        return this.type === 'jalali' ? 'j' + unit : unit;
+    }
+    clone() {
+        return new AXDateTime(this.date, this.type);
+    }
+    get dayInMonth() {
+        return this._moment.date();
+    }
+    get dayOfYear() {
+        return this._moment.dayOfYear();
+    }
+    get dayInWeek() {
+        return this._moment.day();
+    }
+    get hour() {
+        return this._moment.hour();
+    }
+    get minute() {
+        return this._moment.minute();
+    }
+    get second() {
+        return this._moment.second();
+    }
+    get year() {
+        return this._moment.year();
+    }
+    get monthOfYear() {
+        return this._moment.month();
+    }
+    get month() {
+        return new AXCalendarMonth(this);
+    }
+    get firstDayOfWeek() {
+        const a = moment(this.date);
+        if (this.type === 'jalali') {
+            this._moment.locale('fa');
+        }
+        return new AXDateTime(a.startOf('w').toDate(), this.type);
+    }
+    get endDayOfWeek() {
+        const a = moment(this.date);
+        if (this.type === 'jalali') {
+            this._moment.locale('fa');
+        }
+        return new AXDateTime(moment(this.date).endOf('w').toDate(), this.type);
+    }
+    convertStringToJalali(date, format) {
+        return moment(date).locale('fa').format('YYYY/M/D');
+    }
+    convertStringToGregorian(date, format) {
+        return new Date((moment.from(date, 'fa', 'YYYY/MM/DD').format('YYYY/MM/DD')));
+    }
+    add(unit = 'day', amount) {
+        return new AXDateTime(moment(this.date).add(amount, this.resolveUnit(unit)).toDate(), this.type);
+    }
+    addDay(amount) {
+        return new AXDateTime(moment(this.date).add(amount, 'd').toDate(), this.type);
+    }
+    addMonth(amount) {
+        return new AXDateTime(moment(this.date).add(amount, 'months').toDate(), this.type);
+    }
+    addHour(amount) {
+        return new AXDateTime(moment(this.date).add(amount, 'hours').toDate(), this.type);
+    }
+    set(unit = 'day', value) {
+        return new AXDateTime(this._moment.set(unit, value).toDate(), this.type);
+    }
+    duration(end, unit = 'days') {
+        const duration = moment.duration(this._moment.diff(end._moment));
+        return Math.round(duration.as(unit));
+    }
+    startOf(unit = 'day') {
+        return new AXDateTime(moment(this.date).startOf(this.resolveUnit(unit)).toDate(), this.type);
+    }
+    endOf(unit = 'day') {
+        return new AXDateTime(moment(this.date).endOf(this.resolveUnit(unit)).toDate(), this.type);
+    }
+    format(format = AXConfig.get('dateTime.shortDateFormat') || (this.type === 'gregorian' ? 'DD-MM-YYYY' : 'YYYY-MM-DD')) {
+        if (format === 'P') {
+            return this._moment.fromNow();
+        }
+        return this._moment.format(format);
+    }
+    toString() {
+        return this.format();
+    }
+    equal(value, unit = 'day') {
+        if (!value) {
+            return false;
+        }
+        return this._moment.isSame(moment(value.date), this.resolveUnit(unit));
+    }
+    convertToJalaliDate(value) {
+        const options = {
+            numberingSystem: 'latn',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        };
+        const jDate = new Date(value).toLocaleDateString('fa-IR', options);
+        const item = {};
+        item.year = jDate.slice(0, 4);
+        item.month = jDate.slice(5, 7);
+        item.day = jDate.slice(8, 10);
+        item.hour = jDate.slice(13, 15);
+        item.minutes = jDate.slice(16, 18);
+        item.seconds = jDate.slice(19, 21);
+        return item;
+    }
+    toJalaliString(value) {
+        const date = this.convertToJalaliDate(value);
+        let str = '';
+        str = date.year + '-' + date.month + '-' + date.day + 'T' + date.hour + ':' + date.minutes + ':' + date.seconds;
+        return str;
+    }
+    convertToGregorianDate(value) {
+        const options = {
+            numberingSystem: 'latn',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit'
+        };
+        const date = new Date(value).toLocaleString('en-us', options);
+        const item = {};
+        item.year = date.slice(6, 10);
+        item.month = date.slice(0, 2);
+        item.day = date.slice(3, 5);
+        item.hour = date.slice(12, 14);
+        item.minutes = date.slice(15, 17);
+        item.seconds = date.slice(18, 20);
+        return item;
+    }
+    toGregorianString(value) {
+        const date = this.convertToGregorianDate(value);
+        let str = '';
+        str = date.year + '-' + date.month + '-' + date.day + 'T' + date.hour + ':' + date.minutes + ':' + date.seconds;
+        return str;
+    }
+    compaireNew(value, unit = 'YMD', type = 'jalali') {
+        const range = [0, 0];
+        let str1;
+        let str2;
+        if (type === 'jalali') {
+            str1 = this.toJalaliString(this.date);
+            str2 = this.toJalaliString(value.date ? value.date : value);
+        }
+        else {
+            str1 = this.toGregorianString(this.date);
+            str2 = this.toGregorianString(value.date ? value.date : value);
+        }
+        switch (unit) {
+            case 'YMDhms':
+                range[0] = 0;
+                range[1] = 19;
+                break;
+            case 'YMDhm':
+                range[0] = 0;
+                range[1] = 16;
+                break;
+            case 'YMDh':
+                range[0] = 0;
+                range[1] = 13;
+                break;
+            case 'YMD':
+                range[0] = 0;
+                range[1] = 10;
+                break;
+            case 'YM':
+                range[0] = 0;
+                range[1] = 7;
+                break;
+            case 'h':
+                range[0] = 11;
+                range[1] = 13;
+                break;
+            case 'm':
+                range[0] = 14;
+                range[1] = 16;
+                break;
+            case 's':
+                range[0] = 17;
+                range[1] = 19;
+                break;
+            case 'D':
+                range[0] = 8;
+                range[1] = 10;
+                break;
+            case 'M':
+                range[0] = 5;
+                range[1] = 7;
+                break;
+            case 'Y':
+                range[0] = 0;
+                range[1] = 4;
+                break;
+        }
+        if (str1.slice(range[0], range[1]) === str2.slice(range[0], range[1])) {
+            return 0;
+        }
+        else if (str1.slice(range[0], range[1]) > str2.slice(range[0], range[1])) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+    compaire(value, unit = 'day') {
+        if (this._moment.isSame(moment(value.date), this.resolveUnit(unit))) {
+            return 0;
+        }
+        else if (this._moment.isAfter(moment(value.date), this.resolveUnit(unit))) {
+            return 1;
+        }
+        else {
+            return -1;
+        }
+    }
+    toISOString() {
+        return this._date.toISOString();
+    }
+}
+class AXCalendarMonth {
+    constructor(date) {
+        this._moment = moment(date.date);
+        this.index = date.date.getMonth();
+        this.name = this._moment.format('MMMM');
+        this.range = new AXDateTimeRange(new AXDateTime(this._moment.startOf('month').toDate(), date.type), new AXDateTime(this._moment.endOf('month').toDate(), date.type));
+    }
+    get range() {
+        return this._range;
+    }
+    set range(v) {
+        this._range = v;
+    }
+}
+class AXDateTimeRange {
+    constructor(startTime, endTime) {
+        this.startTime = startTime;
+        this.endTime = endTime;
+    }
+    duration(unit = 'days') {
+        const duration = moment.duration(moment(this.startTime.date).diff(moment(this.endTime.date)));
+        return duration.as(unit);
+    }
+    enumurate(unit = 'day', type = AXConfig.get('dateTime.type') || 'jalali') {
+        const result = [];
+        for (let index = 0; this.startTime.add(unit, index).compaireNew(this.endTime, this.getViewCompaire(unit), type) <= 0; index++) {
+            result.push(this.startTime.add(unit, index));
+        }
+        return result;
+    }
+    includes(value, unit = 'day', type = 'jalali') {
+        return (value.compaireNew(this.startTime, this.getViewCompaire(unit), type) >= 0 &&
+            value.compaireNew(this.endTime, this.getViewCompaire(unit), type) <= 0);
+    }
+    getViewCompaire(view) {
+        switch (view) {
+            case 'day':
+                return 'YMD';
+            case 'month':
+                return 'YM';
+            case 'year':
+                return 'Y';
+        }
+    }
+}
+
+class AXBaseMenuItem {
+    constructor() {
+        this.uid = new Date().getTime().toString();
+        this.visible = true;
+        this.disable = false;
+        this.selected = false;
+        this.style = 'ax light';
+        this.orderIndex = 0;
+    }
+}
+class AXMenuItem extends AXBaseMenuItem {
+    constructor() {
+        super(...arguments);
+        this.divider = false;
+    }
+}
+class AXButtonItem extends AXBaseMenuItem {
+    constructor() {
+        super(...arguments);
+        this.dropdown = false;
+        this.submitBehavior = false;
+        this.cancelBehavior = false;
+    }
+}
+class AXCheckItem {
+}
+
+class AXPromise {
+    constructor(executor) {
+        this._executor = executor;
+        setTimeout(() => {
+            this._executor(this.thenAction);
+        }, 50);
+    }
+    static resolve(value) {
+        const r = new AXPromise(z => {
+            z(value);
+        }).then(() => { });
+        return r;
+    }
+    then(action) {
+        this.thenAction = action;
+        return this;
+    }
+}
+
+class AXSelectItem {
+}
+
+/**
+ * @deprecated Use AXBasePageComponent from @acorex/components
+ */
+class AXBasePageComponent {
+    constructor() {
+        this.onClosed = new EventEmitter();
+    }
+    close(data) {
+        this.onClosed.emit({
+            component: this,
+            data: data
+        });
+    }
+    onClosing(e) {
+    }
+    ngOnDestroy() {
+        this.onClosed.unsubscribe();
+    }
+}
+
+const AX_ERROR_DISPLAY_INTERCEPTOR = new InjectionToken('ax.error');
+let AXErrorService = class AXErrorService {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    handle(message) {
+        const instance = this.injector.get(AX_ERROR_DISPLAY_INTERCEPTOR);
+        if (instance) {
+            instance.show(message);
+        }
+    }
+};
+AXErrorService.ctorParameters = () => [
+    { type: Injector }
+];
+AXErrorService.ɵprov = ɵɵdefineInjectable({ factory: function AXErrorService_Factory() { return new AXErrorService(ɵɵinject(INJECTOR)); }, token: AXErrorService, providedIn: "root" });
+AXErrorService = __decorate([
+    Injectable({ providedIn: 'root' }),
+    __metadata("design:paramtypes", [Injector])
+], AXErrorService);
+
+let AXErrorModule = class AXErrorModule {
+};
+AXErrorModule = __decorate([
+    NgModule({
+        declarations: [],
+        imports: [CommonModule],
+        exports: [],
+        providers: [AXErrorService],
+    })
+], AXErrorModule);
+
+const AX_HTTP_EVENT_INTERCEPTOR = new InjectionToken('ax.http.events');
+
+class HttpResult {
+    constructor(executor) {
+        this._executor = executor;
+        setTimeout(() => {
+            this._executor(this.resultAction, this.errorAction, this.completeAction);
+        }, 50);
+    }
+    result(action) {
+        this.resultAction = action;
+        return this;
+    }
+    error(action) {
+        this.errorAction = action;
+        return this;
+    }
+    complete(action) {
+        this.completeAction = action;
+        return this;
+    }
+}
+
+// import { catchError, retry, retryWhen, mergeMap, delay, switchMap, scan, takeWhile, flatMap } from 'rxjs/operators';
+// import { of, concat, throwError } from 'rxjs';
+let AXHttpService = class AXHttpService {
+    constructor(http, injector) {
+        this.http = http;
+        this.injector = injector;
+        this.interceptor = this.injector.get(AX_HTTP_EVENT_INTERCEPTOR);
+    }
+    get(url, config = {}) {
+        config.url = url;
+        config.method = "get";
+        return this.request(config);
+    }
+    post(url, config = {}) {
+        config.url = url;
+        config.method = "post";
+        return this.request(config);
+    }
+    delete(url, config = {}) {
+        config.url = url;
+        config.method = "delete";
+        return this.request(config);
+    }
+    put(url, config = {}) {
+        config.url = url;
+        config.method = "put";
+        return this.request(config);
+    }
+    request(config) {
+        return new HttpResult((result, error, complete) => {
+            this.handleBegin(config).then(c => {
+                this.http
+                    .request(config.method, config.url, this.mapOptions(config))
+                    //.pipe(this.retry)
+                    .subscribe(data => {
+                    this.handleResult(data, result, complete, config);
+                }, c => {
+                    this.handleError(c, error, complete, config);
+                });
+            });
+        });
+    }
+    handleResult(data, result, complete, config) {
+        if (this.interceptor) {
+            this.interceptor.success(config, data).then(c => {
+                if (result)
+                    result(c);
+                this.handleComplete(complete, config);
+            });
+        }
+        else {
+            //
+            if (result)
+                result(data);
+            this.handleComplete(complete, config);
+        }
+    }
+    handleBegin(config) {
+        return new Promise((resolve) => {
+            if (!config.headers)
+                config.headers = {};
+            if (!config.params)
+                config.params = {};
+            //
+            if (this.interceptor) {
+                this.interceptor.begin(config).then(c => {
+                    resolve(c);
+                });
+            }
+            else {
+                resolve(config);
+            }
+        });
+    }
+    handleComplete(complete, config) {
+        if (complete)
+            complete();
+        if (this.interceptor)
+            this.interceptor.complete(config);
+    }
+    handleError(c, error, complete, config) {
+        var _a;
+        let r = {
+            message: c.message,
+            status: c.status,
+            code: (_a = c.status) === null || _a === void 0 ? void 0 : _a.toString(),
+            handled: false,
+            error: c.error
+        };
+        if (error) {
+            error(r);
+        }
+        if (!r.handled) {
+            if (this.interceptor)
+                this.interceptor.error(config, r);
+        }
+        this.handleComplete(complete, config);
+    }
+    mapOptions(options) {
+        let headers = new HttpHeaders();
+        for (const key in options.headers) {
+            if (options.headers.hasOwnProperty(key)) {
+                const value = options.headers[key];
+                headers = headers.set(key, value);
+            }
+        }
+        let params = new HttpParams();
+        for (const key in options.params) {
+            if (options.params.hasOwnProperty(key)) {
+                const value = options.params[key];
+                params = params.set(key, value);
+            }
+        }
+        return {
+            headers: headers,
+            params: params,
+            body: options.body,
+            responseType: options.responseType || 'json'
+        };
+        // if (options.method == "get") {
+        //     return {
+        //         headers: headers,
+        //         params: params
+        //     };
+        // }
+        // else {
+        //     return {
+        //         headers: headers,
+        //         params: params,
+        //         body: options.body
+        //     };
+        // }
+    }
+};
+AXHttpService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: Injector }
+];
+AXHttpService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [HttpClient, Injector])
+], AXHttpService);
+
+var AXHttpModule_1;
+let AXHttpModule = AXHttpModule_1 = class AXHttpModule {
+    static forRoot() {
+        return {
+            ngModule: AXHttpModule_1,
+            providers: [AXHttpService]
+        };
+    }
+};
+AXHttpModule = AXHttpModule_1 = __decorate([
+    NgModule({
+        declarations: [],
+        imports: [
+            CommonModule,
+            HttpClientModule
+        ],
+        exports: [HttpClientModule],
+        providers: [
+            AXHttpService
+        ]
+    })
+], AXHttpModule);
+
+let AXDateTimePipe = class AXDateTimePipe {
+    constructor() { }
+    transform(value, format) {
+        const date = AXDateTime.convert(value);
+        if (value == null) {
+            return '';
+        }
+        if (!format) {
+            return date.toString();
+        }
+        else {
+            return date.format(format);
+        }
+    }
+};
+AXDateTimePipe = __decorate([
+    Pipe({ name: 'dt' }),
+    __metadata("design:paramtypes", [])
+], AXDateTimePipe);
+
+let AXHtmlToTextPipe = class AXHtmlToTextPipe {
+    transform(value) {
+        if (value) {
+            const regexHtml = /<\/?[^>]+>/gi;
+            const regexNbsp = /&nbsp;/gi;
+            const regexAmp = /&amp;/gi;
+            return value
+                .replace(regexHtml, '')
+                .replace(regexNbsp, '')
+                .replace(regexAmp, '');
+        }
+        else {
+            return '';
+        }
+    }
+};
+AXHtmlToTextPipe = __decorate([
+    Pipe({ name: 'html2text' })
+], AXHtmlToTextPipe);
+
+let AXEventService = class AXEventService {
+    constructor() {
+        this.list = [];
+    }
+    broadcast(key, options) {
+        const d = this.list.find(c => c.key === key);
+        if (d) {
+            d.events.forEach(c => {
+                c(options);
+            });
+        }
+    }
+    on(key, callback) {
+        let d = this.list.find(c => c.key === key);
+        if (!d) {
+            d = { key, events: [] };
+            this.list.push(d);
+        }
+        d.events.push(callback);
+    }
+    destroy(key, callback) {
+        const d = this.list.find(c => c.key === key);
+        if (d) {
+            d.events = [];
+        }
+    }
+};
+AXEventService.ɵprov = ɵɵdefineInjectable({ factory: function AXEventService_Factory() { return new AXEventService(); }, token: AXEventService, providedIn: "root" });
+AXEventService = __decorate([
+    Injectable({ providedIn: 'root' })
+], AXEventService);
+
+let AXNavigator = class AXNavigator {
+};
+AXNavigator = __decorate([
+    Injectable()
+], AXNavigator);
+
+let AXStorageService = class AXStorageService {
+    get(key) {
+        return localStorage.getItem(key);
+    }
+    set(key, value) {
+        localStorage.setItem(key, value);
+    }
+};
+AXStorageService = __decorate([
+    Injectable()
+], AXStorageService);
+
+// @dynamic
+class AXTranslator {
+    static get onChange() {
+        return AXTranslator.dataChangeSubject.asObservable();
+    }
+    static load(lang, value) {
+        if (typeof value === 'object') {
+            if (!AXTranslator[`__data__${lang}`]) {
+                AXTranslator[`__data__${lang}`] = {};
+            }
+            AXTranslator[`__data__${lang}`] = merge(AXTranslator[`__data__${lang}`], value);
+        }
+    }
+    static use(lang) {
+        AXTranslator.lang = lang;
+    }
+    static get(key, lang) {
+        return getPropByPath(AXTranslator[`__data__${lang || AXTranslator.lang}`], key) || key;
+    }
+}
+AXTranslator.lang = 'en';
+AXTranslator.dataChangeSubject = new Subject();
+
+let AXTranslatorService = class AXTranslatorService {
+    load(lang, value) {
+        AXTranslator.load(lang, value);
+    }
+    use(lang) {
+        AXTranslator.use(lang);
+    }
+    get(key, lang) {
+        return AXTranslator.get(lang, lang);
+    }
+};
+AXTranslatorService.ɵprov = ɵɵdefineInjectable({ factory: function AXTranslatorService_Factory() { return new AXTranslatorService(); }, token: AXTranslatorService, providedIn: "platform" });
+AXTranslatorService = __decorate([
+    Injectable({ providedIn: 'platform' })
+], AXTranslatorService);
+
+let AXTranslatorPipe = class AXTranslatorPipe {
+    constructor() { }
+    // transform(value: string, lang?: string): Promise<string> {
+    //     return new Promise<string>((resolve, reject) => {
+    //         if (!value) {
+    //             resolve(value);
+    //         }
+    //         resolve(this.translate.get(value, lang));
+    //     });
+    // }
+    transform(value, lang) {
+        return AXTranslator.get(value, lang);
+    }
+};
+AXTranslatorPipe = __decorate([
+    Pipe({ name: 'trans', pure: true }),
+    __metadata("design:paramtypes", [])
+], AXTranslatorPipe);
+
+var common = {
+	search: "Search",
+	yes: "yes",
+	no: "No",
+	confirm: "Confirm",
+	okay: "Okay",
+	cancel: "Cancel",
+	remove: "Remove",
+	edit: "Edit",
+	configs: "Configs",
+	noDataFound: "No data found!",
+	searching: "searching ...",
+	save: "Save",
+	"save-as": "Save As...",
+	title: "Title",
+	description: "Description",
+	name: "Name",
+	uniquename: "Unique Name",
+	size: "Size",
+	"add-item": "Add Item",
+	color: "Color",
+	display: "Display",
+	"min-value": "Min Value",
+	value: "Value",
+	"max-value": "Max Value",
+	"refresh-rate": "Refresh Rate",
+	condition: "Condition"
+};
+var dateTime = {
+	weekdaysShort: {
+		sun: "Sun",
+		mon: "Mon",
+		tue: "Tue",
+		wed: "Wed",
+		thu: "Thu",
+		fri: "Fri",
+		sat: "Sat"
+	},
+	dayTime: {
+		am: "am",
+		pm: "pm",
+		m: "m",
+		a: "a",
+		p: "p"
+	},
+	today: "today",
+	duration: {
+		format_second: "{0} second(s)",
+		format_minute: "{0} minute(s)"
+	}
+};
+var queryBuilder = {
+	contains: "contains",
+	"start-with": "start-with",
+	"end-with": "end-with",
+	equal: "equal",
+	"not-equal": "not-equal",
+	"null": "null",
+	"not-null": "not-null",
+	"greater-than": "greater-than",
+	gt: "greater-than",
+	"greater-than-equal": "greater-than-equal",
+	gte: "greater-than-equal",
+	"less-than": "less-than",
+	lt: "less-than",
+	"less-than-equal": "less-than-equal",
+	lte: "less-than-equal",
+	"true": "true",
+	"false": "false",
+	empty: "empty"
+};
+var validation = {
+	messages: {
+		required: "This field is required!",
+		email: "Please enter a valid email address!",
+		phone: "Please enter a valid phone number!"
+	}
+};
+var dataGrid = {
+	page: "page",
+	more: "more",
+	to: "To",
+	of: "Of",
+	next: "next",
+	last: "last",
+	first: "first",
+	previous: "previous",
+	loadingOoo: "Loading...",
+	selectAll: "selectAll",
+	searchOoo: "Search...",
+	blanks: "blanks",
+	filterOoo: "Filter...",
+	equals: "Equals",
+	notEqual: "NotEqual",
+	lessThan: "LessThan",
+	greaterThan: "GreaterThan",
+	lessThanOrEqual: "LessThanOrEqual",
+	greaterThanOrEqual: "GreaterThanOrEqual",
+	inRange: "InRange",
+	inRangeStart: "To",
+	inRangeEnd: "From",
+	contains: "Contains",
+	notContains: "NotContains",
+	startsWith: "Starts with",
+	endsWith: "Ends with",
+	andCondition: "AND",
+	orCondition: "OR",
+	applyFilter: "Apply",
+	resetFilter: "Reset",
+	clearFilter: "Clear",
+	group: "Group",
+	columns: "Columns",
+	filters: "Filters",
+	groups: "Groups",
+	values: "Values",
+	enabled: "Enabled",
+	pinColumn: "Pin Column",
+	groupBy: "Group by",
+	ungroupBy: "UnGroup by",
+	resetColumns: "ResetColumns",
+	expandAll: "ExpandAll",
+	collapseAll: "CollapseAll",
+	toolPanel: "ToolPanel",
+	"export": "Exporto",
+	csvExport: "csv Export",
+	excelExport: "Excel Export (.xlsx)",
+	excelXmlExport: "Excel Exporto (.xml)",
+	chartRange: "Chart Range",
+	columnChart: "Column",
+	groupedColumn: "Grouped",
+	stackedColumn: "Stacked",
+	normalizedColumn: "normalized Column",
+	barChart: "bar Chart",
+	groupedBar: "Grouped",
+	stackedBar: "Stacked",
+	normalizedBar: "normalized Bar",
+	pie: "Pie",
+	doughnut: "Doughnut",
+	line: "Line",
+	xyChart: "X Y (Scatter)",
+	scatter: "Scatter",
+	bubble: "Bubble",
+	areaChart: "Area",
+	area: "Area",
+	stackedArea: "Stacked",
+	normalizedArea: "100% Stacked",
+	histogramChart: "Histogram",
+	pinLeft: "Pin Left",
+	pinRight: "Pin Right",
+	noPin: "Dont Pin",
+	sum: "Sum",
+	min: "Min",
+	max: "Max",
+	none: "None",
+	count: "Count",
+	avg: "Average",
+	filteredRows: "Filtered",
+	selectedRows: "Selected",
+	totalRows: "Total Rows",
+	totalAndFilteredRows: "Rows",
+	copy: "Copy",
+	copyWithHeaders: "Copy With Headers",
+	ctrlC: "Ctrl C",
+	paste: "Paste",
+	ctrlV: "Ctrl V",
+	pivotChartTitle: "Pivot Chart",
+	rangeChartTitle: "Range Chart",
+	settings: "Settings",
+	data: "Data",
+	format: "Format",
+	categories: "Categories",
+	series: "Series",
+	xyValues: "X Y Values",
+	paired: "Paired Mode",
+	axis: "Axis",
+	color: "Color",
+	thickness: "Thickness",
+	xType: "X Type",
+	automatic: "Automatic",
+	category: "Category",
+	number: "Number",
+	time: "Time",
+	xRotation: "X Rotation",
+	yRotation: "Y Rotation",
+	ticks: "Ticks",
+	width: "Width",
+	length: "Length",
+	padding: "Padding",
+	chart: "Chart",
+	title: "Title",
+	background: "Background",
+	font: "Font",
+	top: "Top",
+	right: "Right",
+	bottom: "Bottom",
+	left: "Left",
+	labels: "Labels",
+	size: "Size",
+	minSize: "Minimum Size",
+	maxSize: "Maximum Size",
+	legend: "Legend",
+	position: "Position",
+	markerSize: "Marker Size",
+	markerStroke: "Marker Stroke",
+	markerPadding: "Marker Padding",
+	itemPaddingX: "Item Padding X",
+	itemPaddingY: "Item Padding Y",
+	strokeWidth: "Stroke Width",
+	offset: "Offset",
+	offsets: "Offsets",
+	tooltips: "Tooltips",
+	callout: "Callout",
+	markers: "Markers",
+	shadow: "Shadow",
+	blur: "Blur",
+	xOffset: "X Offset",
+	yOffset: "Y Offset",
+	lineWidth: "Line Width",
+	normal: "Normal",
+	bold: "Bold",
+	italic: "Italic",
+	boldItalic: "Bold Italic",
+	predefined: "Predefined",
+	fillOpacity: "Fill Opacity",
+	strokeOpacity: "Line Opacity",
+	histogramBinCount: "Bin Count",
+	columnGroup: "Column",
+	barGroup: "Bar",
+	pieGroup: "Pie",
+	lineGroup: "Line",
+	scatterGroup: "Scatter",
+	areaGroup: "Area",
+	histogramGroup: "Histogram",
+	groupedColumnTooltip: "Grouped",
+	stackedColumnTooltip: "Stacked",
+	normalizedColumnTooltip: "100% Stacked",
+	groupedBarTooltip: "Grouped",
+	stackedBarTooltip: "Stacked",
+	pieTooltip: "Pie",
+	doughnutTooltip: "Doughnut",
+	lineTooltip: "Line",
+	groupedAreaTooltip: "Grouped",
+	stackedAreaTooltip: "Stacked",
+	scatterTooltip: "Scatter",
+	bubbleTooltip: "Bubble",
+	histogramTooltip: "Histogram"
+};
+var en = {
+	common: common,
+	dateTime: dateTime,
+	queryBuilder: queryBuilder,
+	validation: validation,
+	dataGrid: dataGrid
+};
+
+var en$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    common: common,
+    dateTime: dateTime,
+    queryBuilder: queryBuilder,
+    validation: validation,
+    dataGrid: dataGrid,
+    'default': en
+});
+
+var common$1 = {
+	search: "جستجو",
+	yes: "بله",
+	no: "خیر",
+	confirm: "تایید",
+	okay: "تایید",
+	cancel: "انصراف",
+	remove: "حذف",
+	edit: "ویرایش",
+	configs: "پیکربندی",
+	noDataFound: "موردی یافت نشد!",
+	searching: "درحال جستجو ...",
+	"save-as": "ذخیره به عنوان ...",
+	title: "عنوان",
+	description: "توضیحات",
+	name: "نام",
+	uniquename: "نام شناسه یکتا",
+	size: "اندازه",
+	"add-item": "افزودن",
+	color: "رنگ",
+	display: "نمایش",
+	value: "مقدار",
+	"min-value": "مقدار کمینه",
+	"max-value": "مقدار بیشینه",
+	"refresh-rate": "نرخ بروز رسانی",
+	condition: "شرط"
+};
+var dateTime$1 = {
+	weekdaysShort: {
+		sun: "ی",
+		mon: "د",
+		tue: "س",
+		wed: "چ",
+		thu: "پ",
+		fri: "ج",
+		sat: "ش"
+	},
+	dayTime: {
+		am: "ق ظ",
+		pm: "ب ظُ",
+		m: ".ظ",
+		a: "ق",
+		p: "ب"
+	},
+	today: "امروز",
+	duration: {
+		format_second: "{0} ثانیه",
+		format_minute: "{0} دقیقه"
+	}
+};
+var queryBuilder$1 = {
+	contains: "شامل",
+	"start-with": "شروع شود با",
+	"end-with": "پایان با",
+	equal: "برابر با",
+	"not-equal": "نا برابر با",
+	"null": " خالی باشد",
+	"not-null": "خالی نباشد",
+	"greater-than": "بزرگ تر",
+	gt: "بزرگ تر",
+	"greater-than-equal": "بزرگتر مساوی",
+	gte: "بزرگتر مساوی",
+	"less-than": "کوچکتر",
+	lt: "کوچکتر",
+	"less-than-equal": "کوچکتر مساوی",
+	lte: "کوچکتر مساوی",
+	"true": "true",
+	"false": "false"
+};
+var validation$1 = {
+	messages: {
+		required: "مقدار این فیلد  الزامی می باشد!",
+		email: "این آدرس ایمیل معتبر نمی باشد!",
+		phone: "این شماره تلفن معتبر نمی باشد!"
+	}
+};
+var dataGrid$1 = {
+	page: "صفحه",
+	more: "بیشتر",
+	to: "تا",
+	of: "از",
+	next: "بعدی",
+	last: "آخرین",
+	first: "اولین",
+	previous: "قبلی",
+	loadingOoo: "... لطفا منتظر بمانید",
+	selectAll: "انتخاب همه",
+	searchOoo: "جستجو ...",
+	blanks: "جای خالی",
+	filterOoo: "فیلتر ...",
+	equals: "برابر",
+	notEqual: "نابرابر",
+	lessThan: "کوچکتر از",
+	greaterThan: "بزرگتر از",
+	lessThanOrEqual: "کوچکتر مساوی",
+	greaterThanOrEqual: "بزرکتر مساوی",
+	inRange: "در محدوده",
+	inRangeStart: "تا",
+	inRangeEnd: "از",
+	contains: "شامل",
+	notContains: "شامل نمی شود",
+	startsWith: "شروع شود با",
+	endsWith: "پایان با",
+	andCondition: "و",
+	orCondition: "یا",
+	applyFilter: "اعمال",
+	resetFilter: "تنظیم مجدد فیلتر",
+	clearFilter: "پاک کردن فیلتر",
+	group: "گروه",
+	columns: "ستون ها",
+	filters: "فیاتر ها",
+	groups: "گروه ها ",
+	values: "مقدار ها",
+	enabled: "فعال شده",
+	pinColumn: "سنجاق",
+	groupBy: "دسته بندی بر اساس",
+	ungroupBy: "حذف دسته بندی",
+	resetColumns: "تنظیم مجدد ستون ها",
+	expandAll: "باز کردن همه",
+	collapseAll: "بستن همه",
+	toolPanel: "پنل ابزار",
+	"export": "خروجی",
+	csvExport: "csv خروجی",
+	excelExport: "خروجی اکسل (.xlsx)",
+	excelXmlExport: "خروجی اکسل (.xml)",
+	chartRange: "محدوده نمودار",
+	columnChart: "ستون",
+	groupedColumn: "دسته بندی شده",
+	stackedColumn: "انباشته",
+	normalizedColumn: "ستون نرمال",
+	barChart: "نمودار میله ای",
+	groupedBar: "دسته بندی شده",
+	stackedBar: "انباشته",
+	normalizedBar: "نوار ",
+	pie: "پای",
+	doughnut: "Doughnut",
+	line: "خط",
+	xyChart: "X Y (پراکندگی)",
+	scatter: "پراکندگی",
+	bubble: "حباب",
+	areaChart: "حوزه",
+	area: "حوزه",
+	stackedArea: "انباشته ",
+	normalizedArea: "100% انباشته",
+	histogramChart: "هیستوگرام",
+	pinLeft: "سنجاق چپ",
+	pinRight: "سنجاق راست",
+	noPin: "حذف سنجاق",
+	sum: "مجموع",
+	min: "مینیمم",
+	max: "ماکزیمم",
+	none: "هیچ",
+	count: "شمردن",
+	avg: "میانگین",
+	filteredRows: "فیلتر شده",
+	selectedRows: "انتخاب شده",
+	totalRows: "مجموع ردیف ها",
+	totalAndFilteredRows: "سطر ها",
+	copy: "کپی",
+	copyWithHeaders: "کپی با هدر ها",
+	ctrlC: "Ctrl C",
+	paste: "جایگزینی",
+	ctrlV: "Ctrl V",
+	pivotChartTitle: "نمودار محوری",
+	rangeChartTitle: "نمودار محدوده",
+	settings: "تنظیمات",
+	data: "تاریخ",
+	format: "قالب",
+	categories: "دسته بندی ها",
+	series: "Series",
+	xyValues: "X Y مقادیر",
+	paired: "حالت زوج",
+	axis: "محور",
+	color: "رنگ",
+	thickness: "ضخامت",
+	xType: "X Type",
+	automatic: "خودکار",
+	category: "دسته بندی",
+	number: "عدد",
+	time: "زمان",
+	xRotation: "X چرخش",
+	yRotation: "Y چرخش",
+	ticks: "نمادها",
+	width: "عرض",
+	length: "طول",
+	padding: "لایه گزاری",
+	chart: "جدول",
+	title: "عنوان",
+	background: "زمینه",
+	font: "فونت",
+	top: "بالا",
+	right: "راست",
+	bottom: "پایین",
+	left: "چپ",
+	labels: "برچسب",
+	size: "اندازه",
+	minSize: "حداقل اندازه",
+	maxSize: "بیشترین اندازه",
+	position: "موقعیت",
+	markerSize: "اندازه نشانگر",
+	callout: "فراخوان",
+	markers: "نشانه گرها",
+	shadow: "سایه",
+	blur: "محو شدن",
+	xOffset: "X انحراف",
+	yOffset: "Y انحراف",
+	lineWidth: "عرض خط",
+	normal: "نرمال",
+	italic: "Italic",
+	boldItalic: "Bold Italic",
+	predefined: "Predefined",
+	fillOpacity: "Fill Opacity",
+	strokeOpacity: "Line Opacity",
+	histogramBinCount: "Bin Count",
+	columnGroup: "ستون",
+	barGroup: "Bar",
+	pieGroup: "Pie",
+	lineGroup: "خط",
+	areaGroup: "حوزه",
+	histogramGroup: "هیستوگرام",
+	groupedColumnTooltip: "دسته بندی شده",
+	stackedColumnTooltip: "Stacked",
+	normalizedColumnTooltip: "100% Stacked",
+	groupedBarTooltip: "دسته بندی شده",
+	stackedBarTooltip: "Stacked",
+	pieTooltip: "Pie",
+	doughnutTooltip: "Doughnut",
+	lineTooltip: "خط",
+	groupedAreaTooltip: "گروه بندی شده",
+	stackedAreaTooltip: "Stacked",
+	scatterTooltip: "Scatter",
+	bubbleTooltip: "حباب",
+	histogramTooltip: "هیستوگرام",
+	autosizeThiscolumn: "تنظیم اندازه ستون ",
+	autosizeAllColumns: "تنظیم اندازه همه ستون ها"
+};
+var fa = {
+	common: common$1,
+	dateTime: dateTime$1,
+	queryBuilder: queryBuilder$1,
+	validation: validation$1,
+	dataGrid: dataGrid$1
+};
+
+var fa$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    common: common$1,
+    dateTime: dateTime$1,
+    queryBuilder: queryBuilder$1,
+    validation: validation$1,
+    dataGrid: dataGrid$1,
+    'default': fa
+});
+
+let AXTranslatorModule = class AXTranslatorModule {
+    constructor() {
+        AXTranslator.load('en', en$1);
+        AXTranslator.load('fa', fa$1);
+    }
+};
+AXTranslatorModule = __decorate([
+    NgModule({
+        imports: [],
+        exports: [AXTranslatorPipe],
+        declarations: [AXTranslatorPipe],
+        providers: [],
+    }),
+    __metadata("design:paramtypes", [])
+], AXTranslatorModule);
+
+// @dynamic
+class AXArrayUtil {
+    static pickRandom(array) {
+        return array[Math.floor(Math.random() * array.length)];
+    }
+    static insert(array, index, ...rest) {
+        array.splice.apply(array, [index, 0].concat(Array.prototype.slice.call(rest, 1)));
+        return array;
+    }
+    static range(min, max) {
+        return new Array(max - min).fill(1).map((d, i) => i);
+    }
+    static filter(array, filters) {
+        if (filters == null || filters.length === 0) {
+            return array;
+        }
+        const lamda = (item) => {
+            let result = true;
+            for (const key in filters) {
+                if (filters.hasOwnProperty(key)) {
+                    const f = filters[key];
+                    if (f !== 'AND') {
+                        const vals = [];
+                        const mt = f.field.match(/\[\:(.*?)\]/);
+                        if (mt && mt.length > 1) {
+                            const p1 = f.field.replace(mt[0], '');
+                            const p2 = mt[1];
+                            const prop = AXFetchProp(item, p1);
+                            if (prop instanceof Array && prop.length) {
+                                vals.push(...prop.map(m => (AXFetchProp(m, p2))));
+                            }
+                            else {
+                                result = false;
+                            }
+                        }
+                        else {
+                            vals.push(AXFetchProp(item, f.field));
+                        }
+                        for (const j in vals) {
+                            if (vals.hasOwnProperty(j)) {
+                                let v1 = vals[j];
+                                const v2 = f.value;
+                                if (f.dataType === 'string') {
+                                    v1 = v1.toString();
+                                    switch (f.condition) {
+                                        case 'equal':
+                                            result = (v1 && v2) && v1.toLowerCase() === v2.toLowerCase();
+                                            break;
+                                        case 'not-equal':
+                                            result = !((v1 && v2) && v1.toLowerCase() === v2.toLowerCase());
+                                            break;
+                                        case 'contains':
+                                            result = ((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));
+                                            break;
+                                        case 'not-contains':
+                                            result = !((v1 && v2) && (v1.toLowerCase().includes(v2.toLowerCase())));
+                                            break;
+                                        case 'start-with':
+                                            result = ((v1 && v2) && (v1.toLowerCase().startsWith(v2.toLowerCase())));
+                                            break;
+                                        case 'end-with':
+                                            result = ((v1 && v2) && (v1.toLowerCase().endsWith(v2.toLowerCase())));
+                                            break;
+                                        case 'is-empty':
+                                            result = v1 == null || v1 === undefined;
+                                            break;
+                                        case 'is-not-empty':
+                                            result = !(v1 == null || v1 === undefined);
+                                            break;
+                                        default:
+                                            console.error('The condition is not defined');
+                                            result = false;
+                                    }
+                                }
+                                else if (f.dataType === 'date') {
+                                }
+                                else if (f.dataType === 'number') {
+                                    v1 = Number(v1);
+                                    switch (f.condition) {
+                                        case 'equal':
+                                            result = v1 === v2;
+                                            break;
+                                        case 'not-equal':
+                                            result = v1 !== v2;
+                                            break;
+                                        case 'contains':
+                                            result = v2 && v2 instanceof Array && v2.includes(v1);
+                                            break;
+                                        case 'less-than':
+                                            result = v1 < v2;
+                                            break;
+                                        case 'less-than-equal':
+                                            result = v1 <= v2;
+                                            break;
+                                        case 'greater-than':
+                                            result = v1 > v2;
+                                            break;
+                                        case 'greater-than-equal':
+                                            result = v1 >= v2;
+                                            break;
+                                        case 'is-empty':
+                                            result = v1 == null || v1 === undefined;
+                                            break;
+                                        case 'is-not-empty':
+                                            result = !(v1 == null || v1 === undefined);
+                                            break;
+                                        default:
+                                            console.error('The condition is not defined');
+                                            result = false;
+                                    }
+                                }
+                                else {
+                                    console.error('The datatype is not supported');
+                                    result = false;
+                                }
+                                if (result) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!result) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        };
+        return array.filter(lamda);
+    }
+}
+
+class AXMathUtil {
+    static randomRange(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+}
+
+class AXPoint {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+}
+class AXClientRec {
+    constructor(rec) {
+        this._left = rec.left;
+        this._top = rec.top;
+        this._width = rec.width;
+        this._height = rec.height;
+        this._right = this._left + this._width;
+        this._bottom = this._top + this._height;
+    }
+    get left() {
+        return this._left;
+    }
+    set left(v) {
+        this._left = v;
+    }
+    get top() {
+        return this._top;
+    }
+    set top(v) {
+        this._top = v;
+    }
+    get right() {
+        return this._right;
+    }
+    set right(v) {
+        this._right = v;
+    }
+    get bottom() {
+        return this._bottom;
+    }
+    set bottom(v) {
+        this._bottom = v;
+    }
+    get width() {
+        return this._width;
+    }
+    set width(v) {
+        this._width = v;
+    }
+    get height() {
+        return this._height;
+    }
+    set height(v) {
+        this._height = v;
+    }
+    intersect(rec) {
+        return (this.left < rec.left + rec.width &&
+            this.left + this.width > rec.left &&
+            this.top < rec.top + rec.height &&
+            this.top + this.height > rec.top);
+    }
+}
+// @dynamic
+class AXHtmlUtil {
+    static getBoundingRectPoint(el, placement) {
+        const rec = el.getBoundingClientRect();
+        const width = el.offsetWidth;
+        const height = el.offsetHeight;
+        switch (placement) {
+            case 'top-start':
+                return new AXPoint(rec.left, rec.top);
+            case 'top-middle':
+                return new AXPoint(rec.left + (width / 2), rec.top);
+            case 'top-end':
+                return new AXPoint(rec.left + (width), rec.top);
+            case 'center-end':
+                return new AXPoint(rec.left + (width), rec.top + (height / 2));
+            case 'bottom-end':
+                return new AXPoint(rec.left + (width), rec.top + (height));
+            case 'bottom-middle':
+                return new AXPoint(rec.left + (width / 2), rec.top + (height));
+            case 'bottom-start':
+                return new AXPoint(rec.left, rec.top + (height));
+            case 'center-start':
+                return new AXPoint(rec.left, rec.top + (height / 2));
+            default:
+                return new AXPoint(rec.left + (width / 2), rec.top + (height));
+        }
+    }
+    static isInRecPoint(pos, rec) {
+        return pos.x >= rec.left && pos.x <= (rec.left + rec.width) && pos.y >= rec.top && (pos.y <= (rec.top + rec.height));
+    }
+    // static isOverLap(rec1: AXClientRecCtor, rec2: AXClientRecCtor): boolean {
+    //   const r1: AXClientRec = new AXClientRec(rec1);
+    //   const r2: AXClientRec = new AXClientRec(rec2);
+    //   return ;
+    // }
+    static isInElementBound(pos, element) {
+        const elBound = element.getBoundingClientRect();
+        return AXHtmlUtil.isInRecPoint(pos, {
+            left: elBound.left,
+            width: elBound.width,
+            top: elBound.top,
+            height: elBound.height
+        });
+    }
+    static getDimensions() {
+        let winW = 630;
+        let winH = 460;
+        if (document.body && document.body.offsetWidth) {
+            winW = document.body.offsetWidth;
+            winH = document.body.offsetHeight;
+        }
+        if (document.compatMode === 'CSS1Compat' && document.documentElement && document.documentElement.offsetWidth) {
+            winW = document.documentElement.offsetWidth;
+            winH = document.documentElement.offsetHeight;
+        }
+        if (window.innerWidth && window.innerHeight) {
+            winW = window.innerWidth;
+            winH = window.innerHeight;
+        }
+        return { width: winW, height: winH };
+    }
+    static getOffsetRight(elem) {
+        let element = elem;
+        const width = element.offsetWidth;
+        let right = 0;
+        while (element.offsetParent) {
+            right += element.offsetLeft;
+            element = element.offsetParent;
+        }
+        right += element.offsetLeft;
+        right = AXHtmlUtil.getDimensions().width - right;
+        right -= width;
+        return right;
+    }
+    static getUID() {
+        return 'el-' + AXMathUtil.randomRange(1000000000, 9999999999).toString();
+    }
+    static getRelatedPosition(source, placement, target, alignment) {
+        const result = { x: 0, y: 0 };
+        const sourcePos = AXHtmlUtil.getBoundingRectPoint(source, placement);
+        let top = 0;
+        let left = 0;
+        switch (alignment) {
+            case 'top-start':
+                top = sourcePos.y;
+                left = sourcePos.x;
+                break;
+            case 'top-middle':
+                top = sourcePos.y;
+                left = sourcePos.x - target.offsetWidth / 2;
+                break;
+            case 'top-end':
+                top = sourcePos.y;
+                left = sourcePos.x - target.offsetWidth;
+                break;
+            case 'center-end':
+                top = sourcePos.y - target.offsetHeight / 2;
+                left = sourcePos.x - target.offsetWidth;
+                break;
+            case 'bottom-end':
+                top = sourcePos.y - target.offsetHeight;
+                left = sourcePos.x - target.offsetWidth;
+                break;
+            case 'bottom-middle':
+                top = sourcePos.y - target.offsetHeight;
+                left = sourcePos.x - target.offsetWidth / 2;
+                break;
+            case 'bottom-start':
+                top = sourcePos.y - target.offsetHeight;
+                left = sourcePos.x;
+                break;
+            case 'center-start':
+                top = sourcePos.y - target.offsetHeight / 2;
+                left = sourcePos.x;
+                break;
+        }
+        result.y = top;
+        result.x = left;
+        return result;
+    }
+    static collision(a, b) {
+        const ac = a.getBoundingClientRect();
+        const bc = b.getBoundingClientRect();
+        if (ac.left < bc.left + bc.width && ac.left + ac.width > bc.left &&
+            ac.top < bc.top + bc.height && ac.top + ac.height > bc.top) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}
+
+let AXHtmlModule = class AXHtmlModule {
+};
+AXHtmlModule = __decorate([
+    NgModule({
+        declarations: [AXHtmlToTextPipe],
+        imports: [CommonModule],
+        exports: [AXHtmlToTextPipe],
+        providers: []
+    })
+], AXHtmlModule);
+
+let AXOnDemandPreloadService = class AXOnDemandPreloadService {
+    constructor() {
+        this.subject = new Subject();
+        this.tmp = AXHtmlUtil.getUID();
+    }
+    startPreload(routePath) {
+        const slices = [];
+        this.subject.next(routePath);
+        //console.log('ss', this.tmp);
+    }
+};
+AXOnDemandPreloadService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [])
+], AXOnDemandPreloadService);
+
+let AXRenderService = class AXRenderService {
+    constructor(appRef, router, componentFactoryResolver, modulePreloadService, injector) {
+        this.appRef = appRef;
+        this.router = router;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.modulePreloadService = modulePreloadService;
+        this.injector = injector;
+    }
+    appendComponent(componentClass, options = {}, location) {
+        const componentFactory = this.componentFactoryResolver.resolveComponentFactory(componentClass);
+        const componentRef = componentFactory.create(this.injector);
+        this.appRef.attachView(componentRef.hostView);
+        Object.assign(componentRef.instance, options);
+        //
+        const domElem = componentRef.hostView.rootNodes[0];
+        componentRef.onDestroy(() => {
+            this.appRef.detachView(componentRef.hostView);
+        });
+        if (location) {
+            location.appendChild(domElem);
+        }
+        else {
+            document.body.appendChild(domElem);
+        }
+        setTimeout(() => {
+            componentRef.changeDetectorRef.detectChanges();
+        }, 0);
+        return componentRef;
+    }
+    findLoadedComponentByRoute(path, timeoutTime = 10) {
+        const delay = 200;
+        const loop = timeoutTime * 1000 / delay;
+        return new Promise((resolve, reject) => {
+            let found = null;
+            let preload = false;
+            const theLoop = (i) => {
+                setTimeout(() => {
+                    found = this._findLoadedComponentByRoute(path);
+                    if (--i && found == null) {
+                        if (!preload) {
+                            this.modulePreloadService.startPreload(path);
+                            preload = true;
+                        }
+                        theLoop(i);
+                    }
+                    else if (found) {
+                        resolve(found);
+                    }
+                    else {
+                        reject();
+                    }
+                }, delay);
+            };
+            theLoop(loop);
+        });
+    }
+    _findLoadedComponentByRoute(search) {
+        let found = null;
+        const f = (list, path) => {
+            for (const p in list) {
+                if (list.hasOwnProperty(p)) {
+                    const route = list[p];
+                    const pp = (route.path != '' && route.path != null) ? path + '/' + route.path : path;
+                    if (pp == search && !route._loadedConfig && route.component) {
+                        found = route;
+                        break;
+                    }
+                    else if (route._loadedConfig) {
+                        f(route._loadedConfig.routes, pp);
+                    }
+                }
+            }
+        };
+        for (const p in this.router.config) {
+            if (this.router.config.hasOwnProperty(p)) {
+                const route = this.router.config[p];
+                if (route.path === search && route.component) {
+                    found = route;
+                }
+                else if (route['_loadedConfig']) {
+                    f(route['_loadedConfig'].routes, route.path);
+                }
+            }
+        }
+        return found;
+    }
+};
+AXRenderService.ctorParameters = () => [
+    { type: ApplicationRef },
+    { type: Router },
+    { type: ComponentFactoryResolver },
+    { type: AXOnDemandPreloadService },
+    { type: Injector }
+];
+AXRenderService.ɵprov = ɵɵdefineInjectable({ factory: function AXRenderService_Factory() { return new AXRenderService(ɵɵinject(ApplicationRef), ɵɵinject(Router), ɵɵinject(ComponentFactoryResolver), ɵɵinject(AXOnDemandPreloadService), ɵɵinject(INJECTOR)); }, token: AXRenderService, providedIn: "root" });
+AXRenderService = __decorate([
+    Injectable({ providedIn: 'root' }),
+    __metadata("design:paramtypes", [ApplicationRef,
+        Router,
+        ComponentFactoryResolver,
+        AXOnDemandPreloadService,
+        Injector])
+], AXRenderService);
+
+// @dynamic
+function getOnDemandPreloadServiceFactory() {
+    return new AXOnDemandPreloadService();
+}
+let AXRenderingModule = class AXRenderingModule {
+};
+AXRenderingModule = __decorate([
+    NgModule({
+        imports: [],
+        exports: [],
+        declarations: [],
+        providers: [
+            {
+                provide: AXOnDemandPreloadService,
+                useFactory: getOnDemandPreloadServiceFactory
+            },
+            AXRenderService
+        ],
+    })
+], AXRenderingModule);
+
+let AXHorizontalScrollDirective = class AXHorizontalScrollDirective {
+    constructor(el) {
+        this.el = el;
+        this.scrollValue = 40;
+    }
+    onMouseWheel(e) {
+        const delta = Math.max(-1, Math.min(1, e.wheelDelta || -e.detail));
+        this.el.nativeElement.scrollLeft -= delta * this.scrollValue;
+    }
+};
+AXHorizontalScrollDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+__decorate([
+    Input('horizontalScroll'),
+    __metadata("design:type", Object)
+], AXHorizontalScrollDirective.prototype, "scrollValue", void 0);
+__decorate([
+    HostListener('wheel', ['$event']),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], AXHorizontalScrollDirective.prototype, "onMouseWheel", null);
+AXHorizontalScrollDirective = __decorate([
+    Directive({
+        // tslint:disable-next-line: directive-selector
+        selector: '[horizontalScroll]'
+    }),
+    __metadata("design:paramtypes", [ElementRef])
+], AXHorizontalScrollDirective);
+let AXVerticalScrollDirective = class AXVerticalScrollDirective {
+    constructor(el) {
+        this.el = el;
+        this.scrollValue = 40;
+    }
+    onMouseWheel(e) {
+        const delta = Math.max(-1, Math.min(1, e.wheelDelta || -e.detail));
+        this.el.nativeElement.scrollTop -= delta * this.scrollValue;
+    }
+};
+AXVerticalScrollDirective.ctorParameters = () => [
+    { type: ElementRef }
+];
+__decorate([
+    Input('verticalScroll'),
+    __metadata("design:type", Object)
+], AXVerticalScrollDirective.prototype, "scrollValue", void 0);
+__decorate([
+    HostListener('wheel', ['$event']),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], AXVerticalScrollDirective.prototype, "onMouseWheel", null);
+AXVerticalScrollDirective = __decorate([
+    Directive({
+        // tslint:disable-next-line: directive-selector
+        selector: '[verticalScroll]'
+    }),
+    __metadata("design:paramtypes", [ElementRef])
+], AXVerticalScrollDirective);
+
+let AXScrollModule = class AXScrollModule {
+};
+AXScrollModule = __decorate([
+    NgModule({
+        declarations: [AXHorizontalScrollDirective, AXVerticalScrollDirective],
+        imports: [CommonModule],
+        exports: [AXHorizontalScrollDirective, AXVerticalScrollDirective],
+        providers: []
+    })
+], AXScrollModule);
+
+let AXSeparatorPipe = class AXSeparatorPipe {
+    transform(value) {
+        if (value) {
+            return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+        }
+        else {
+            return '0';
+        }
+    }
+};
+AXSeparatorPipe.ɵprov = ɵɵdefineInjectable({ factory: function AXSeparatorPipe_Factory() { return new AXSeparatorPipe(); }, token: AXSeparatorPipe, providedIn: "root" });
+AXSeparatorPipe = __decorate([
+    Pipe({ name: 'separator' }),
+    Injectable({
+        providedIn: 'root'
+    })
+], AXSeparatorPipe);
+
+let AXSeparatorModule = class AXSeparatorModule {
+};
+AXSeparatorModule = __decorate([
+    NgModule({
+        declarations: [AXSeparatorPipe],
+        imports: [CommonModule],
+        exports: [AXSeparatorPipe],
+        providers: []
+    })
+], AXSeparatorModule);
+
+const PIPES = [AXDateTimePipe];
+const MODULES = [AXScrollModule, AXTranslatorModule];
+const SERVICES = [AXEventService,
+    AXStorageService
+];
+let AXCoreModule = class AXCoreModule {
+};
+AXCoreModule = __decorate([
+    NgModule({
+        declarations: [...PIPES],
+        imports: [...MODULES],
+        exports: [...PIPES],
+        providers: [...SERVICES]
+    })
+], AXCoreModule);
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXArrayUtil, AXBaseMenuItem, AXBasePageComponent, AXButtonItem, AXCalendarMonth, AXCheckItem, AXClientRec, AXColorUtil, AXConfig, AXCoreModule, AXDateTime, AXDateTimePipe, AXDateTimeRange, AXErrorModule, AXErrorService, AXEventService, AXFetchProp, AXHorizontalScrollDirective, AXHtmlModule, AXHtmlToTextPipe, AXHtmlUtil, AXHttpModule, AXHttpService, AXMathUtil, AXMenuItem, AXNavigator, AXObjectUtil, AXOnDemandPreloadService, AXPoint, AXPromise, AXRenderService, AXRenderingModule, AXScrollModule, AXSelectItem, AXSeparatorModule, AXSeparatorPipe, AXStorageService, AXTranslator, AXTranslatorModule, AXTranslatorPipe, AXTranslatorService, AXVerticalScrollDirective, AX_ERROR_DISPLAY_INTERCEPTOR, AX_HTTP_EVENT_INTERCEPTOR, HttpResult, getOnDemandPreloadServiceFactory, getPropByPath, setPropByPath };
+//# sourceMappingURL=acorex-core.js.map