x-tql-service 1.19.4

package/fesm2022/x-tql-service.mjs

@@ -0,0 +1,2232 @@
+import * as _ from 'lodash';
+import ___default, { isUndefined } from 'lodash';
+export { _ };
+import * as xml2js from 'xml2js';
+export { xml2js };
+import * as i0 from '@angular/core';
+import { InjectionToken, EventEmitter, Output, Directive, Injectable, Optional, Inject, provideAppInitializer, LOCALE_ID, inject, NgModule } from '@angular/core';
+import { Subscription, BehaviorSubject, Subject, throwError, skipWhile, first, Observable, catchError as catchError$1, of, map } from 'rxjs';
+import { LoadingBarService } from '@ngx-loading-bar/core';
+import * as i1 from '@angular/material/dialog';
+import { DatePipe, CommonModule } from '@angular/common';
+import * as i1$1 from '@angular/material/snack-bar';
+import * as i1$2 from '@angular/common/http';
+import { HttpHeaders } from '@angular/common/http';
+import { tap, catchError, timeout } from 'rxjs/operators';
+import * as i1$3 from '@ngx-translate/core';
+import { TranslateService, TranslateModule, MissingTranslationHandler, TranslateLoader } from '@ngx-translate/core';
+import { v4 } from 'uuid';
+
+// import * as moment from 'moment';
+const DATA_TYPE = {
+    DATE: 'date',
+    YES_NO: 'yes-no',
+};
+const TQL_LIBRARY_CONFIG = new InjectionToken('TQL Library Configuration');
+
+var ErrorStatusEnum;
+(function (ErrorStatusEnum) {
+    ErrorStatusEnum[ErrorStatusEnum["FORBIDDEN"] = 0] = "FORBIDDEN";
+    ErrorStatusEnum["SUCCESS"] = "Success";
+    ErrorStatusEnum["ERROR"] = "Error";
+})(ErrorStatusEnum || (ErrorStatusEnum = {}));
+
+const PRE_FIX = '';
+const KEY_CONSTANT = {
+    ALL: 'all',
+    LOCAL_STORAGE: {
+        USER: `${PRE_FIX}User`,
+        EXPIRE: `${PRE_FIX}expiry`,
+        SESSION_TOKEN: `${PRE_FIX}sessionToken`,
+        USER_TOKEN: `${PRE_FIX}userToken`,
+    },
+    SYS_ID: 'sysId',
+    STUDIO_KEY: 'x-atomiton-studio-key',
+    SESSION_KEY: 'x-atomiton-session-key',
+};
+
+const MAP_STYLES = [
+    {
+        featureType: 'administrative',
+        elementType: 'geometry',
+        stylers: [{ visibility: 'off' }],
+    },
+    { featureType: 'landscape.natural', elementType: 'geometry', stylers: [{ visibility: 'off' }] },
+    {
+        featureType: 'poi',
+        stylers: [{ visibility: 'off' }],
+    },
+    { featureType: 'road', elementType: 'geometry.fill', stylers: [{ color: '#c0c0c0' }] },
+    {
+        featureType: 'road',
+        elementType: 'labels.icon',
+        stylers: [{ visibility: 'off' }],
+    },
+    { featureType: 'road.highway', elementType: 'geometry.fill', stylers: [{ weight: 2 }] },
+    {
+        featureType: 'road.highway',
+        elementType: 'geometry.stroke',
+        stylers: [{ visibility: 'off' }],
+    },
+    { featureType: 'transit', stylers: [{ visibility: 'off' }] },
+];
+
+const LANGUAGES = {
+    EN: 'en-US',
+    PT: 'pt-BR',
+};
+const LANGUAGE_DEFAULT = LANGUAGES.EN;
+const KEY_LANGUAGES_LOCAL_STORAGE = 'TQL_language';
+const TYPE_LANGUAGES_HIGH_CHART = {
+    shortMonths: 'shortMonths',
+    months: 'months',
+    weekdays: 'weekdays',
+};
+const TRANSLATE_KEY = {
+    key: 'AIzaSyBxnsG8frZ9zX9_26LA5vkGb8CNUzh6AhA',
+};
+
+class DefaultModel {
+    /**
+     *
+     * @param _data
+     * @param idKey
+     * @param isAutoAssign
+     */
+    constructor(_data = {}, idKey = '', isAutoAssign = false, isAssignRawData = true) {
+        /**
+         * all keys are in lowercase
+         * @type {{}}
+         * @private
+         */
+        this._data = {};
+        /**
+         * all keys are raw
+         * @type {{}}
+         * @private
+         */
+        this._raw = {};
+        if (_data) {
+            // set raw
+            if (_data.hasOwnProperty('_raw')) {
+                delete _data['_raw'];
+            }
+            this._raw = _data;
+            // store data to new place
+            for (const key of Object.keys(_data)) {
+                this._data[key.toLowerCase()] = this._raw[key];
+            }
+            const self = this;
+            // setTimeout(() => {
+            if (isAutoAssign) {
+                if (isAssignRawData) {
+                    Object.assign(self, self._raw);
+                }
+                else {
+                    Object.assign(self, self._data);
+                }
+            }
+            // });
+        }
+        if (idKey) {
+            // set id key
+            this._idKey = idKey.toLowerCase();
+            this._id = this.getId();
+        }
+    }
+    /**
+     * get value of id
+     * @return {any}
+     */
+    getId() {
+        if (this._idKey && this._data[this._idKey]) {
+            return this._data[this._idKey];
+        }
+        return null;
+    }
+    setId(id) {
+        this._data[this._idKey] = id;
+        this._id = this.getId();
+    }
+    /**
+     * delete object property
+     * @param key: string
+     */
+    deleteProperty(key) {
+        const self = this;
+        if (!!self?.key) {
+            delete self[key];
+        }
+    }
+    /**
+     * get key of id
+     * @returns {string}
+     */
+    getIdKey() {
+        return this._idKey || '';
+    }
+    /**
+     * get value of _data by key
+     * @param key: string
+     * @returns {any}
+     */
+    getValue(key) {
+        return this._data[_.toLower(key)];
+    }
+    /**
+     * set value of _data by key & value of this object's attribute if existed
+     * @param key: string
+     * @param value: string
+     * @returns {any}
+     */
+    setValue(key, value) {
+        const self = this;
+        if (self.hasOwnProperty(key)) {
+            self[key] = value;
+        }
+        return (this._data[key.toLowerCase()] = value);
+    }
+    /**
+     * get raw value of _data by key
+     * @param key: string
+     * @returns {any}
+     */
+    getRawValue(key) {
+        return this._raw[key];
+    }
+    /**
+     * set value of _data by key
+     * @param key: string
+     * @param value: string
+     * @returns {any}
+     */
+    setRawValue(key, value) {
+        return (this._raw[key] = value);
+    }
+    /*STATIC*/
+    static describe(instance) {
+        return _.filter(Object.getOwnPropertyNames(instance), (x) => !_.startsWith(x, '_'));
+    }
+}
+
+class DefaultComponent {
+    /**
+     * pass injector into here if you want to check loading work
+     * ex: in child class
+     *      Constructor(private _Injector: Injector) {
+     *          super(_Injector)
+     *      }
+     */
+    constructor(_Injector) {
+        /**
+         * emit event trigger when all _promises called
+         * @type {EventEmitter<any>}
+         */
+        this.onPromise = new EventEmitter();
+        this._promises = [];
+        this._isLoading = false;
+        // when init, unsubscribe all
+        this.unsubscribeAll();
+        if (_Injector) {
+            this._LoadingBarService = _Injector.get(LoadingBarService);
+            this.addSubscribes(this._LoadingBarService.value$.subscribe((flat) => {
+                this._isLoading = !!flat;
+            }));
+        }
+    }
+    /**
+     * IMPORTANT
+     * when destroy, unsubscribe all
+     */
+    ngOnDestroy() {
+        this.unsubscribeAll();
+        // console.log('DESTROYED ' + this.constructor.name);
+    }
+    /**
+     * unsubscribe all subscription which add into the component
+     * it is important to prevent subscription still exist when component is destroyed
+     */
+    unsubscribeAll() {
+        if (this._subscriptionList) {
+            this._subscriptionList.unsubscribe();
+        }
+        this._subscriptionList = new Subscription();
+    }
+    /**
+     * add subscriptions to component storage
+     * @param subscriptions
+     */
+    addSubscribes(...subscriptions) {
+        subscriptions.forEach((el) => {
+            this._subscriptionList.add(el);
+        });
+    }
+    /**
+     * add promises into an array
+     * @param promises
+     */
+    addPromises(...promises) {
+        promises.forEach((el) => {
+            this._promises.push(el);
+        });
+        this.onPromise.emit(Promise.all(this._promises).then(() => {
+            this._promises = [];
+        }));
+    }
+    /**
+     * get list of current stored promises
+     * @returns {Promise<any>[]}
+     */
+    get promises() {
+        return this._promises;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DefaultComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.17", type: DefaultComponent, isStandalone: true, outputs: { onPromise: "onPromise" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DefaultComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { onPromise: [{
+                type: Output
+            }] } });
+
+class DefaultDirective extends DefaultComponent {
+    constructor() {
+        super();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DefaultDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.17", type: DefaultDirective, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DefaultDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+
+class DefaultDialogComponent extends DefaultComponent {
+    static { this.DEFAULT_WIDTH = '90vw'; }
+    static { this.DEFAULT_HEIGHT = 'auto'; }
+    constructor(dialogRef, _Injector, ...args) {
+        super(_Injector);
+        this.dialogRef = dialogRef;
+        this._Injector = _Injector;
+        if (!this.dialogRef.disableClose) {
+            this.dialogRef.backdropClick().subscribe(() => {
+                this.onCancel();
+            });
+        }
+    }
+    /**
+     *
+     * @param arg
+     */
+    onCancel(arg = false) {
+        this.dialogRef.close(arg);
+    }
+    /**
+     *
+     * @private
+     */
+    onClose() {
+        this.dialogRef.close(false);
+    }
+    /**
+     *
+     * @private
+     * @param arg
+     */
+    onOk(arg = true) {
+        this.dialogRef.close(arg);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DefaultDialogComponent, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.17", type: DefaultDialogComponent, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DefaultDialogComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.MatDialogRef }, { type: i0.Injector }, { type: undefined }] });
+(function (DefaultDialogComponent) {
+    let State;
+    (function (State) {
+        State[State["OPENING"] = 0] = "OPENING";
+        State[State["CLOSED"] = 1] = "CLOSED";
+    })(State = DefaultDialogComponent.State || (DefaultDialogComponent.State = {}));
+})(DefaultDialogComponent || (DefaultDialogComponent = {}));
+
+class DynamicDataModel {
+    constructor(component, data = null) {
+        this.component = component;
+        this.data = data;
+    }
+}
+
+class DefaultMapComponent extends DefaultComponent {
+    constructor() {
+        super();
+        this.DEFAULT_ZOOM = 13;
+        this.styles = MAP_STYLES;
+        this.zoom = this.DEFAULT_ZOOM;
+        if (typeof google !== 'undefined') {
+            this.center = new google.maps.LatLng(0, 0);
+        }
+        this.resetMapBounds();
+    }
+    /**
+     * reset map
+     */
+    resetMapBounds() {
+        if (typeof google !== 'undefined') {
+            this.bounds = new google.maps.LatLngBounds();
+        }
+    }
+    setMapBounds(map, points = [], minZoom = null) {
+        if (!(!!map && points.length)) {
+            return;
+        }
+        const self = this;
+        if (!self.bounds) {
+            this.resetMapBounds();
+        }
+        if (typeof google !== 'undefined' && map) {
+            for (let i = 0; i < points.length; i++) {
+                if (points[i]) {
+                    self.bounds.extend(points[i]);
+                }
+            }
+            map.fitBounds(self.bounds);
+            let listener = google.maps.event.addListener(map, 'idle', function () {
+                //TODO tmp disabled, nam, 12/02/2019
+                // if (map.getZoom() > self.DEFAULT_ZOOM) {
+                //   map.setZoom(self.DEFAULT_ZOOM);
+                // }
+                if (minZoom && map.getZoom() > minZoom) {
+                    map.setZoom(minZoom);
+                }
+                google.maps.event.removeListener(listener);
+            });
+        }
+    }
+    getCenterOfArray(points = []) {
+        if (!points.length || typeof google === 'undefined') {
+            return null;
+        }
+        const bounds = new google.maps.LatLngBounds();
+        points.map((el) => bounds.extend(el));
+        // console.log(bounds.getCenter());
+        const center = bounds.getCenter();
+        // console.log(new GeoPoint(center.lat(), center.lng()));
+        return { lat: center.lat(), lng: center.lng() };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DefaultMapComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.17", type: DefaultMapComponent, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: DefaultMapComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+
+class TqlUtilsService {
+    static { this._DatePipe = new DatePipe('en-US'); }
+    constructor() { }
+    /**
+     * replace all {find} inside {str} by {replace}
+     * @param text: string
+     * @param find: string
+     * @param replace: string
+     * @returns any
+     */
+    static replaceAll(text, find, replace) {
+        function escapeRegExp(str) {
+            return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1');
+        }
+        return text.replace(new RegExp(escapeRegExp(find), 'g'), replace);
+    }
+    /**
+     * replace all with params
+     * param format: {number}
+     * @param text
+     * @param params
+     * @returns {string}
+     */
+    static replaceWithParams(text, params) {
+        _.map(params, (x, index) => {
+            text = TqlUtilsService.replaceAll(text, `{${index}}`, x);
+        });
+        return text;
+    }
+    /**
+     * check if is array, if is not, return [value]
+     * @param value: string
+     * @returns any
+     */
+    static toArray(value) {
+        return _.isArray(value) ? value : !!value ? [value] : [];
+    }
+    /**
+     * parse string to object
+     * @param xmlString: string
+     * @param callback: function
+     * @returns Promise<any>
+     */
+    static parseXml(xmlString, callback = (rs) => { }) {
+        return new Promise((resolve, reject) => {
+            xml2js.parseString(xmlString, { explicitArray: false, mergeAttrs: true }, (error, result) => {
+                if (error) {
+                    reject(error);
+                    throw new Error(error);
+                }
+                else {
+                    resolve(result);
+                    callback(result);
+                }
+            });
+        });
+    }
+    /**
+     * Clean management response
+     * @param data: management response
+     * @returns any
+     */
+    static transferData(data) {
+        if (!!data['data'] &&
+            !!data['data']['Find'] &&
+            (data['data']['Find']['Status'] === 'Success' || data['data']['Status'] === 'Success') &&
+            !!data['data']['Find']['Result']) {
+            return data['data']['Find']['Result'];
+        }
+        if (data['data'] && data['data']['Status'] === 'Success') {
+            if (!!_.get(data, 'management.Save')) {
+                return _.get(data, 'management.Save');
+            }
+            return data['data'];
+        }
+        return null;
+    }
+    /**
+     * Check and convert management
+     * @param data: Data response
+     * @param modelType: Model type
+     * @param key: If model type of management response other than model type (optional)
+     * @returns Model[]
+     */
+    static convertData(data, modelType, key = null) {
+        data = TqlUtilsService.transferData(data);
+        return this.convert(data, modelType, key);
+    }
+    /**
+     * Convert management to Model Type
+     * ! { Model.name } is undefined in run build
+     * @param data: Data response
+     * @param modelType: Model type
+     * @param key: If model type of management response other than model type (optional)
+     * @returns Model[]
+     */
+    static convert(data, modelType, key) {
+        if (!data || TqlUtilsService.isEmpty(data)) {
+            return [];
+        }
+        return _.concat(data).map((d) => {
+            const model = new modelType();
+            key = key || modelType.name;
+            // Convert response management to management Model
+            // Convert key name to camelcase
+            _.forEach(_.keys(d[key]), (k) => {
+                return (model[`${k.charAt(0).toLowerCase()}${k.substring(1)}`] = d[key][k]);
+            });
+            return model;
+        });
+    }
+    static jsonToModel(data, modelType) {
+        return _.concat(data).map((d) => {
+            const model = new modelType(d);
+            // Convert response management to management Model
+            // Convert key name to camelcase
+            _.forEach(_.keys(d), (k) => {
+                return (model[`${k.charAt(0).toLowerCase()}${k.substring(1)}`] = d[k]);
+            });
+            return model;
+        });
+    }
+    static signData(data, model, keyRepresent, key) {
+        const obj = {};
+        const arr = this.convertData(data, model, key);
+        obj[keyRepresent] = arr ? arr[0] : null;
+        return obj;
+    }
+    /**
+     * Return true if response is successful
+     * @param data: management
+     * @param path: string
+     * @returns ({message: undefined, status: boolean} | boolean | {message: undefined, status: boolean})
+     */
+    static isSuccess(data, path = 'data') {
+        const paths = ['Save', 'Create', 'DeleteAll', 'Update'];
+        let pathResult = '';
+        for (const p of paths) {
+            if (!!_.get(data, `${path}.${p}`)) {
+                pathResult = `${path}.${p}`;
+            }
+        }
+        if (!!_.get(data, path) && !pathResult) {
+            pathResult = path;
+        }
+        if (_.get(data, `${pathResult}.Status`) === 'Success' || _.get(data, `${pathResult}.status`) === 'Success') {
+            return {
+                status: _.get(data, `${pathResult}.Status`) === 'Success',
+                message: _.get(data, `${pathResult}.Message`),
+            };
+        }
+        return false;
+    }
+    /**
+     * Return true if response is failed
+     * @param data: management
+     * @returns boolean
+     */
+    static isError(data) {
+        if (data && data['Result'] && data['Result']['Status'] === 'Error') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * check if management is empty
+     * @param data: string
+     * @returns boolean
+     */
+    static isEmpty(data) {
+        if (data['data'] && data['data']['Find'] && data['data']['Find']['Status'] === 'NoResult') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * get file extension
+     * @param fileName: string
+     * @returns any
+     */
+    static getFileExtension(fileName) {
+        return _.last(_.split(fileName, '.'));
+    }
+    /**
+     * set string to clipboard
+     * @param str: string
+     */
+    static copyStringToClipboard(str) {
+        // Create new element
+        const el = document.createElement('textarea');
+        // Set value (string to be copied)
+        el.value = str;
+        // Set non-editable to avoid focus and move outside of view
+        el.setAttribute('readonly', '');
+        document.body.appendChild(el);
+        // Select text inside element
+        el.select();
+        // Copy text to clipboard
+        document.execCommand('copy');
+        // Remove temporary element
+        document.body.removeChild(el);
+    }
+    /**
+     * get enum key by its value
+     * @param myEnum
+     * @param enumValue
+     * @param isCaseSensitive
+     * @return {null}
+     */
+    static getEnumKeyByEnumValue(myEnum, enumValue, isCaseSensitive = true) {
+        return (_.find(Object.keys(myEnum), (x) => isCaseSensitive
+            ? myEnum[x] === enumValue
+            : myEnum[x].toString().toLowerCase() === enumValue.toString().toLowerCase()) || null);
+    }
+    /**
+     * shorten number
+     * @param value
+     * @returns {any}
+     */
+    static abbreviateNumber(value) {
+        let newValue = value;
+        const suffixes = ['', 'kb', 'mb', 'b', 'tb'];
+        let suffixNum = 0;
+        while (newValue >= 1000 && suffixNum < _.size(suffixes)) {
+            newValue = (newValue / 1000).toFixed(1);
+            suffixNum++;
+            // for (let precision = 2; precision >= 1; precision--) {
+            //     shortValue = parseFloat((suffixNum !== 0 ? value / Math.pow(1000, suffixNum) : value).toPrecision(precision));
+            //     const dotLessShortValue = (shortValue + '').replace(/[^a-zA-Z 0-9]+/g, '');
+            //     if (dotLessShortValue.length <= 2) {
+            //         break;
+            //     }
+            // }
+            // if (shortValue % 1 !== 0) {
+            //     shortValue = shortValue.toFixed(1);
+            // }
+            // newValue = shortValue + suffixes[suffixNum];
+        }
+        return newValue + suffixes[suffixNum];
+    }
+    /**
+     * convert json to tree
+     * @param json
+     * @param key
+     * @returns {any}
+     */
+    static jsonToTree(data) {
+        if (TqlUtilsService.isObject(data)) {
+            const keys = Object.keys(data);
+            return _.map(keys, (x) => {
+                if (TqlUtilsService.isObject(data[x])) {
+                    return {
+                        title: x,
+                        children: TqlUtilsService.jsonToTree(data[x]),
+                    };
+                }
+                if (TqlUtilsService.isArray(data[x])) {
+                    return {
+                        title: x,
+                        children: _.flatten(TqlUtilsService.jsonToTree(data[x])),
+                    };
+                }
+                else {
+                    return {
+                        title: x,
+                        name: data[x],
+                    };
+                }
+            });
+        }
+        else if (TqlUtilsService.isArray(data)) {
+            return _.map(data, (x) => TqlUtilsService.jsonToTree(x));
+        }
+        else {
+            return {
+                name: data,
+            };
+        }
+    }
+    /**
+     * swap element in array
+     * @param array
+     * @param firstIndex
+     * @param secondIndex
+     */
+    static swap(array, firstIndex, secondIndex) {
+        if (!!array[firstIndex] && !!array[secondIndex]) {
+            const tmp = array[firstIndex];
+            array[firstIndex] = array[secondIndex];
+            array[secondIndex] = tmp;
+        }
+    }
+    static isObject(data) {
+        return data?.constructor === {}.constructor;
+    }
+    static isArray(data) {
+        return data?.constructor === [].constructor;
+    }
+    static buildTreeFromChild(child) {
+        let parent;
+        while (child?.parent) {
+            parent = child?.parent;
+            parent.children = [child];
+            child = parent;
+        }
+        return parent || child;
+    }
+    static traversalTree(list, callback, parent) {
+        _.map(list, (x) => {
+            if (!!x) {
+                x.parent = null;
+                if (!!parent) {
+                    x.parent = parent;
+                }
+                if (x?.children?.length) {
+                    TqlUtilsService.traversalTree(x.children, callback, x);
+                }
+                callback(x, parent);
+            }
+        });
+    }
+    static traversalTreeReverse(node, callback) {
+        callback(node);
+        if (!!node.parent) {
+            TqlUtilsService.traversalTreeReverse(node.parent, callback);
+        }
+    }
+    static findNodeOfTree(list, condition) {
+        let found = null;
+        for (let i = 0; i < list.length; i++) {
+            if (condition(list[i])) {
+                found = list[i];
+                break;
+            }
+            else if (list[i]?.children?.length) {
+                found = TqlUtilsService.findNodeOfTree(list[i].children, condition);
+                if (found) {
+                    break;
+                }
+            }
+        }
+        return found;
+    }
+    static filterNodeOfTree(list, condition) {
+        const foundList = [];
+        this.traversalTree(list, (x) => {
+            if (condition(x)) {
+                foundList.push(x);
+            }
+        });
+        return foundList;
+    }
+    /**
+     * get parent route when using in guard
+     * @param route
+     */
+    static getRedirectToRoute(route) {
+        return route.pathFromRoot
+            .filter((p) => p !== route && p.url !== null && p.url.length > 0)
+            .reduce((arr, p) => arr.concat(p.url.map((u) => u.path)), new Array());
+    }
+    static getResolvedUrl(route) {
+        return ('/' +
+            route.pathFromRoot
+                .filter((v) => v.url?.length)
+                .map((v) => v.url.map((segment) => segment.toString()).join('/'))
+                .join('/'));
+    }
+    static getUrlFromSegments(segments) {
+        if (!!segments) {
+            return encodeURI('/' +
+                _.join(_.map(segments, (x) => x?.path), '/'));
+        }
+        return '';
+    }
+    static clearLineBreakR(s) {
+        return _.replace(s, /(\r\n|\r)/g, '\n');
+    }
+    static transferToCapitalText(s, exceptions = {}) {
+        function capitalize(s) {
+            if (typeof s !== 'string') {
+                return '';
+            }
+            return s.charAt(0).toUpperCase() + s.slice(1);
+        }
+        s = capitalize(s);
+        return !!exceptions[s] ? exceptions[s] : s.replace(/([A-Z])/g, ' $1').trim();
+    }
+    static parsePayloadWithObject(query, dataObject) {
+        if (!Object.keys(dataObject).length) {
+            return query;
+        }
+        Object.keys(dataObject).forEach((k) => {
+            query = TqlUtilsService.replaceAll(query.toString(), `{${k}}`, dataObject[k]);
+        });
+        return query;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlUtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlUtilsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlUtilsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class SiteMap {
+    constructor(key, children = []) {
+        this.key = key;
+        this.children = children;
+    }
+    addChild(child) {
+        this.children.push(child);
+    }
+    set lazyLoading(value) {
+        this._lazyLoading = value;
+    }
+    get lazyLoading() {
+        return this._lazyLoading;
+    }
+    checkLazyLoading(compareClassName, siteMaps) {
+        let isMatch = false;
+        if (this.lazyLoading) {
+            // remove 'Routing' text then compare
+            if (TqlUtilsService.replaceAll(compareClassName, 'Routing', '') === this.lazyLoading) {
+                isMatch = true;
+                this.children = siteMaps;
+            }
+        }
+        return isMatch;
+    }
+}
+class TqlSiteMapControllerService {
+    static { this.SiteMap = SiteMap; }
+    constructor() {
+        this._siteMap = new Map();
+    }
+    async addRoutes(routes, appName, routingClassName) {
+        // console.log(appName);
+        // console.log(routingClassName);
+        // console.log(routes);
+        const newRoute = {
+            path: 'root',
+            children: routes,
+        };
+        const newSiteMap = await this.traversalRoute(newRoute);
+        const foundSiteMap = this._siteMap.get(appName);
+        if (newSiteMap) {
+            if (!!foundSiteMap) {
+                // existed
+                foundSiteMap.checkLazyLoading(routingClassName, newSiteMap.children);
+            }
+            else {
+                // new
+                this._siteMap.set(appName, newSiteMap);
+            }
+        }
+        // console.log(this._siteMap.get(appName));
+        // console.log('');
+        // this.print(newSiteMap);
+    }
+    async traversalRoute(route) {
+        if (isUndefined(route.path)) {
+            return;
+        }
+        const newSiteMap = new SiteMap(route.path);
+        // children
+        if (route.children) {
+            route.children.map(async (r, index) => {
+                const child = await this.traversalRoute(r);
+                if (child) {
+                    newSiteMap.addChild(child);
+                }
+            });
+        }
+        // lazy loading
+        if (route.loadChildren) {
+            try {
+                const fn = route?.loadChildren;
+                newSiteMap.lazyLoading = (await fn()).name;
+            }
+            catch (e) { }
+        }
+        return newSiteMap;
+    }
+    print(siteMap, index = 0) {
+        if (!!siteMap) {
+            index++;
+            const preFix = _.map(_.range(index), () => '_').join('');
+            console.log(preFix + siteMap.key);
+            _.map(siteMap.children, (x) => {
+                this.print(x, index);
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlSiteMapControllerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlSiteMapControllerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlSiteMapControllerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class TqlToastControllerService {
+    constructor(_MatSnackBar) {
+        this._MatSnackBar = _MatSnackBar;
+        this.X_BUTTON = 'Close';
+    }
+    openSimple(message, duration = TqlToastControllerService.DURATION.SHORT) {
+        this._MatSnackBar.open(message, this.X_BUTTON, { duration });
+    }
+    openSuccess(message, duration = TqlToastControllerService.DURATION.SHORT) {
+        // TODO
+        this._MatSnackBar.open(message, this.X_BUTTON, { duration });
+    }
+    openError(message, duration = TqlToastControllerService.DURATION.SHORT) {
+        // TODO
+        this._MatSnackBar.open(message, this.X_BUTTON, { duration });
+    }
+    openWarning(message, duration = TqlToastControllerService.DURATION.SHORT) {
+        // TODO
+        this._MatSnackBar.open(message, this.X_BUTTON, { duration });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlToastControllerService, deps: [{ token: i1$1.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlToastControllerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlToastControllerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$1.MatSnackBar }] });
+(function (TqlToastControllerService) {
+    let DURATION;
+    (function (DURATION) {
+        DURATION[DURATION["SHORT"] = 3000] = "SHORT";
+        DURATION[DURATION["LONG"] = 20000] = "LONG";
+    })(DURATION = TqlToastControllerService.DURATION || (TqlToastControllerService.DURATION = {}));
+})(TqlToastControllerService || (TqlToastControllerService = {}));
+
+class TqlDialogControllerService {
+    constructor(_MatDialog) {
+        this._MatDialog = _MatDialog;
+        this._openingDialogs = [];
+        this._Observable_Is_Opening_Dialogs = new BehaviorSubject(DefaultDialogComponent.State.CLOSED);
+    }
+    /**
+     * add dialog to storage to check opening status
+     * @param dialog
+     * @private
+     */
+    _addDialog(dialog) {
+        this._openingDialogs.push(dialog);
+        this._Observable_Is_Opening_Dialogs.next(this._openingDialogs.length > 0
+            ? DefaultDialogComponent.State.OPENING
+            : DefaultDialogComponent.State.CLOSED);
+    }
+    /**
+     * remove dialog to storage to check opening status
+     * @param dialog
+     * @private
+     */
+    _removeDialog(dialog) {
+        _.remove(this._openingDialogs, dialog);
+        this._Observable_Is_Opening_Dialogs.next(this._openingDialogs.length > 0
+            ? DefaultDialogComponent.State.OPENING
+            : DefaultDialogComponent.State.CLOSED);
+    }
+    open(classComp, data = {}, options = {}) {
+        // default not allow close when click backdrop
+        options['disableClose'] = true;
+        // width
+        options['width'] = classComp.DEFAULT_WIDTH;
+        options['height'] = classComp.DEFAULT_HEIGHT;
+        options['maxHeight'] = '80vh';
+        const dialog = this._MatDialog.open(classComp, {
+            ...options,
+            data: data,
+            autoFocus: false,
+        });
+        if (options['callback']) {
+            options['callback'](dialog);
+        }
+        // tmp store dialog
+        this._addDialog(dialog);
+        return new Promise((resolve, reject) => {
+            dialog.afterClosed().subscribe((result) => {
+                // remove dialog from the tmp stored
+                this._removeDialog(dialog);
+                resolve(result);
+            });
+        });
+    }
+    confirm(text) {
+        return confirm(text);
+    }
+    alert(text) {
+        alert(text);
+    }
+    prompt(text) {
+        return prompt(text);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlDialogControllerService, deps: [{ token: i1.MatDialog }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlDialogControllerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlDialogControllerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.MatDialog }] });
+
+class TqlRouteControllerService {
+    constructor() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlRouteControllerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlRouteControllerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlRouteControllerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class TqlTableControllerService {
+    constructor() {
+        this.filterGroup = {};
+    }
+    generateFilter(id) {
+        if (!this.filterGroup[id]) {
+            this.filterGroup[id] = {
+                onUpdate$: new Subject(),
+                onUpdateUI$: new Subject(),
+            };
+        }
+    }
+    getFilter(id) {
+        return this.filterGroup[id];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlTableControllerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlTableControllerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlTableControllerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+// import moment from 'moment';
+class TqlLoggerService {
+    constructor() {
+        this.log$ = new BehaviorSubject('');
+    }
+    /**
+     * log result
+     * @param data: any
+     */
+    _logResult(...data) {
+        // console.log(`[${this.constructor.name}]`, 'result \n', ...data);
+    }
+    /**
+     * log error
+     * @param error: any
+     */
+    _logError(...error) {
+        console.error(`[${this.constructor.name}]`, 'error \n', ...error);
+    }
+    /**
+     * log message
+     * @param message
+     */
+    log(message) {
+        // console.log(`${moment().format()} `, message);
+        this.log$.next(message + '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlLoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlLoggerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlLoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+// import {LoadingBarService} from '@ngx-loading-bar/core';
+class TqlErrorHandlerService extends TqlLoggerService {
+    constructor(_Injector) {
+        super();
+        if (_Injector) {
+            this._TqlToastControllerService = _Injector.get(TqlToastControllerService);
+        }
+    }
+    /**
+     *
+     * @param error
+     * @returns {EErrorStatus.FORBIDDEN | null}
+     */
+    handleHttpError(error) {
+        // if forbidden or un-authentication then return forbidden
+        if ([401, 403].includes(error.status)) {
+            return TqlErrorHandlerService.EErrorStatus.FORBIDDEN;
+        }
+        if (error.error instanceof ErrorEvent) {
+            // A client-side or network error occurred. Handle it accordingly.
+            this._logError('An error occurred: ', error.error.message);
+        }
+        else {
+            // The backend returned an unsuccessful response code.
+            // The response body may contain clues as to what went wrong,
+            this._logError(`Backend returned code ${error.status}, `, `message was: ${error.message}`);
+        }
+        // return an observable with a user-facing error message
+        throwError('Something bad happened; please try again later.');
+        return null;
+    }
+    /**
+     *
+     * @param response
+     * @returns {boolean}
+     */
+    handleSimpleResponse(response) {
+        const event = {
+            status: false,
+            message: 'Error',
+            data: response['data'],
+        };
+        if (response['data']['Response']) {
+            event.status = response['data']['Response']['Status'] === 'Success';
+            event.message = response['data']['Response']['Message'];
+        }
+        // print message
+        return this.handleStatusMessage(event);
+    }
+    /**
+     *
+     * @param response
+     * @returns {boolean}
+     */
+    handleAPIResponseMessage(response) {
+        const event = {
+            status: false,
+            message: 'Error',
+            data: response['data'],
+        };
+        if (response['data']['APIResponse']) {
+            event.status = response['data']['APIResponse']['Status'] === 'Success';
+            event.message = response['data']['APIResponse']['Message'];
+        }
+        // print message
+        return this.handleStatusMessage(event);
+    }
+    /**
+     *
+     * @param response
+     * @returns {boolean}
+     */
+    handleCreate(response) {
+        const event = {
+            status: false,
+            message: 'Error',
+            data: response['data'],
+        };
+        if (response['data']['Create']) {
+            event.status = response['data']['Create']['Status'] === 'Success';
+            event.message = 'Creation is successful';
+        }
+        else {
+            event.message = 'Creation occurs error';
+        }
+        // print message
+        return this.handleStatusMessage(event);
+    }
+    /**
+     *
+     * @param response
+     * @returns {boolean}
+     */
+    handleUpdate(response) {
+        const event = {
+            status: false,
+            message: 'Error',
+            data: response['data'],
+        };
+        if (response['data']['Save']) {
+            event.status = response['data']['Save']['Status'] === 'Success';
+            event.message = 'Update is successful';
+        }
+        else if (response['data']['Update']) {
+            event.status = response['data']['Update']['Status'] === 'Success';
+            event.message = 'Update is successful';
+        }
+        else {
+            event.message = 'Update occurs error';
+        }
+        // print message
+        return this.handleStatusMessage(event);
+    }
+    /**
+     * show message base on status
+     * @param event
+     * @return {boolean}
+     */
+    handleStatusMessage(event) {
+        if (event.status) {
+            this._showSuccessMessage(event.message);
+        }
+        else {
+            this._showErrorMessage(event.message);
+        }
+        return event.status;
+    }
+    /**
+     *
+     * @param message
+     */
+    _showSuccessMessage(message) {
+        this._TqlToastControllerService.openSuccess(message, TqlToastControllerService.DURATION.SHORT);
+    }
+    /**
+     *
+     * @param message
+     */
+    _showErrorMessage(message = 'Some error occur') {
+        this._TqlToastControllerService.openError(message, TqlToastControllerService.DURATION.LONG);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlErrorHandlerService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlErrorHandlerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlErrorHandlerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+(function (TqlErrorHandlerService) {
+    let EErrorStatus;
+    (function (EErrorStatus) {
+        EErrorStatus[EErrorStatus["FORBIDDEN"] = 0] = "FORBIDDEN";
+        EErrorStatus["SUCCESS"] = "Success";
+        EErrorStatus["ERROR"] = "Error";
+    })(EErrorStatus = TqlErrorHandlerService.EErrorStatus || (TqlErrorHandlerService.EErrorStatus = {}));
+})(TqlErrorHandlerService || (TqlErrorHandlerService = {}));
+
+class TqlApiLibService extends TqlLoggerService {
+    constructor(_HttpClient, _TqlErrorHandlerService) {
+        super();
+        this._HttpClient = _HttpClient;
+        this._TqlErrorHandlerService = _TqlErrorHandlerService;
+    }
+    /**
+     *
+     * @param url
+     */
+    initialize(url) {
+        this._default_url = url;
+    }
+    /**
+     * reset all subscription
+     */
+    reset() { }
+    /**
+     * get url
+     * @returns string
+     */
+    getUrl() {
+        return `${this._default_url}`;
+    }
+    /**
+     * Execute payload
+     * @param payload: Payload
+     * @param headers: Headers of query
+     * @param url: URL custom (optional)
+     * @returns {Promise<T | string>}
+     * @param params
+     * @param contentType
+     */
+    async execute(payload, params = [], headers = {}, url, contentType = 'text/plain') {
+        return await this.executeHttpClient(payload, params, headers, url, contentType)
+            .toPromise()
+            .then((data) => {
+            // this.checkPermission(data);
+            return data;
+        });
+    }
+    /**
+     * Execute http client
+     * @param payload: Payload
+     * @param headers: Headers of query
+     * @param url: URL custom (optional)
+     * @param params
+     * @param contentType
+     * @returns {Observable<T | string>}
+     */
+    executeHttpClient(payload, params = [], headers = {}, url, contentType = 'text/plain') {
+        return this._HttpClient
+            .post(url || this.getUrl(), payload.buildPayload(params), {
+            headers: new HttpHeaders({
+                'Content-Type': contentType,
+                ...headers,
+            }),
+            responseType: 'text',
+        })
+            .pipe(tap(this._TqlErrorHandlerService._logResult, this._TqlErrorHandlerService._logError), 
+        // then handle the error
+        catchError((err) => {
+            return this._TqlErrorHandlerService.handleHttpError(err);
+        }));
+    }
+    async get(url, contentType = 'text/plain', headers = {}) {
+        return await this._HttpClient
+            .get(url, {
+            headers: new HttpHeaders({
+                'Content-Type': contentType,
+                ...headers,
+            }),
+            responseType: 'text',
+        })
+            .toPromise();
+    }
+    /**
+     *
+     * @param payload
+     * @param params
+     * @param headers
+     * @param url
+     * @param contentType
+     * @return {Promise<{data: any[], raw: {}} | {data: any[], raw: {}}>}
+     */
+    async findRaw(payload, params = [], headers = {}, url, contentType) {
+        return await this.execute(payload, params, headers, url, contentType)
+            .then(async (data) => {
+            let json = {};
+            try {
+                json = {
+                    data: JSON.parse(data),
+                };
+            }
+            catch (e) {
+                json = TqlUtilsService.parseXml(`<data>${data}</data>`);
+            }
+            return json;
+        })
+            .then((json) => {
+            const pathRoot = 'data';
+            let array = [];
+            if (payload.objectPath !== null && payload.objectPath !== undefined) {
+                array = _.get(json, `${pathRoot}${payload.objectPath && '.' + payload.objectPath}`) || [];
+                array = TqlUtilsService.toArray(array);
+            }
+            array = payload.parse(array);
+            return {
+                raw: json,
+                data: array,
+            };
+        });
+    }
+    /**
+     * find management and convert to management model
+     * @param payload: Payload
+     * @param params: any
+     * @param headers: any
+     * @param url: string
+     * @param contentType
+     * @return {Promise<any[]>}
+     */
+    async find(payload, params = [], headers = {}, url, contentType) {
+        return await this.findRaw(payload, params, headers, url, contentType).then(({ raw, data }) => {
+            return data;
+        });
+    }
+    /**
+     *
+     * @param payload
+     * @param params
+     * @param headers
+     * @param url
+     * @param contentType
+     * @returns {Promise<{}>}
+     */
+    async post(payload, params = [], headers = {}, url, contentType) {
+        return await this.findRaw(payload, params, headers, url, contentType).then(({ raw, data }) => {
+            return raw;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlApiLibService, deps: [{ token: i1$2.HttpClient }, { token: TqlErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlApiLibService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlApiLibService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: TqlErrorHandlerService }] });
+
+class TqlWsService extends TqlLoggerService {
+    static { this.maxDefaultReconnectCount = 10; }
+    static { this.maxDefaultSameTimeApi = 100; }
+    constructor() {
+        super();
+        /**
+         * status
+         * @type {BehaviorSubject<TqlWsService.Status>}
+         */
+        this.status$ = new BehaviorSubject(new TqlWsService.Status());
+        /**
+         * message
+         * @type {BehaviorSubject<string>}
+         */
+        this.message$ = new BehaviorSubject('');
+        this.autoReconnect = false;
+        this.url = '';
+        this.pendingPayloads = [];
+        this.storedPayloads = [];
+        /**
+         * events
+         * @type {any}
+         */
+        this.events = {
+            open: TqlWsService.ENUM_TYPES.EMPTY,
+            close: TqlWsService.ENUM_TYPES.EMPTY,
+            error: TqlWsService.ENUM_TYPES.EMPTY,
+            message: TqlWsService.ENUM_TYPES.EMPTY,
+        };
+        /*options*/
+        this.options = {
+            max_reconnect_count: TqlWsService.maxDefaultReconnectCount,
+            max_same_time_api: TqlWsService.maxDefaultSameTimeApi,
+        };
+        this.handleMessage();
+    }
+    /**
+     * connect to url
+     * @param url
+     * @param autoReconnect
+     * @param options
+     */
+    connect(url, autoReconnect = false, options = {
+        max_reconnect_count: TqlWsService.maxDefaultReconnectCount,
+    }) {
+        // options
+        this.original_options = ___default.cloneDeep(options);
+        if (___default.isUndefined(this.original_options?.max_same_time_api)) {
+            this.original_options.max_same_time_api = TqlWsService.maxDefaultSameTimeApi;
+        }
+        // make sure options not empty
+        this.options = ___default.cloneDeep(this.original_options);
+        // reset
+        const $end = this.end(this.socket ? TqlWsService.ENUM_CODES.RESTART : TqlWsService.ENUM_CODES.START);
+        $end.then(() => {
+            //
+            this.autoReconnect = autoReconnect;
+            this.url = url;
+            // set events
+            this.setEvents();
+            // start socket
+            this.socket = new WebSocket(this.url);
+            this.socket.addEventListener('open', this.events.open);
+            this.socket.addEventListener('close', this.events.close);
+            this.socket.addEventListener('error', this.events.error);
+            this.socket.addEventListener('message', this.events.message);
+        });
+    }
+    /**
+     * reconnect
+     */
+    reconnect() {
+        this.log(`Socket reconnect.`);
+        if (this.url) {
+            this.options.max_reconnect_count--;
+            if (this.options.max_reconnect_count > 0) {
+                this.connect(this.url, this.autoReconnect, this.options);
+            }
+            else {
+                this.updateStatus(TqlWsService.ENUM_ACTIONS.DISCONNECT);
+            }
+        }
+    }
+    /**
+     * end the connection
+     * @param code
+     * @returns {Promise<boolean>}
+     */
+    end(code = TqlWsService.ENUM_CODES.END) {
+        return new Promise((resolve) => {
+            this.autoReconnect = false;
+            // remove events & close socket
+            if (this.socket) {
+                this.socket.close(TqlWsService.CODES[code].code, TqlWsService.CODES[code].message);
+                this.status$
+                    .pipe(skipWhile((x) => x.connected), first())
+                    .subscribe((rs) => {
+                    ___default.map(this.events, (x, k) => {
+                        if (x !== TqlWsService.ENUM_TYPES.EMPTY) {
+                            this.socket?.removeEventListener(k, x);
+                        }
+                    });
+                    // disconnect
+                    this.reset();
+                    // status
+                    this.updateStatus(TqlWsService.ENUM_ACTIONS.END);
+                    resolve(true);
+                });
+            }
+            else {
+                // disconnect
+                this.reset();
+                // status
+                this.updateStatus(TqlWsService.ENUM_ACTIONS.END);
+                resolve(false);
+            }
+        });
+    }
+    /**
+     * reset all values
+     */
+    reset() {
+        // reset
+        this.socket = null;
+        this.url = '';
+        this.events = {
+            open: TqlWsService.ENUM_TYPES.EMPTY,
+            close: TqlWsService.ENUM_TYPES.EMPTY,
+            error: TqlWsService.ENUM_TYPES.EMPTY,
+            message: TqlWsService.ENUM_TYPES.EMPTY,
+        };
+    }
+    /**
+     * call api
+     * @param payload
+     * @param isWaiver - not wait for response
+     * @returns {Promise<any>}
+     */
+    call(payload, isWaiver = false) {
+        if (this.socket) {
+            if (!isWaiver) {
+                // store if it is not waiver
+                this.storedPayloads.push(payload);
+                this.processPayload();
+            }
+            else {
+                // send if it is waiver
+                this.socket?.send(payload?.query);
+            }
+        }
+        return payload.$promise;
+    }
+    processPayload() {
+        while (this.storedPayloads?.length && this.pendingPayloads.length < (this.options?.max_same_time_api || 0)) {
+            const payload = this.storedPayloads.shift();
+            if (!!payload) {
+                this.pendingPayloads.push(payload);
+                this.socket?.send(payload?.query);
+            }
+        }
+    }
+    /**
+     * set event after connect
+     */
+    setEvents() {
+        this.events.open = () => {
+            this.log(`Socket connected.`);
+            // status
+            this.updateStatus(TqlWsService.ENUM_ACTIONS.CONNECT);
+            // options
+            this.options = ___default.cloneDeep(this.original_options);
+        };
+        this.events.close = () => {
+            this.log(`Socket closed.`);
+            // status
+            this.updateStatus(TqlWsService.ENUM_ACTIONS.DISCONNECT);
+            if (this.autoReconnect) {
+                this.reconnect();
+            }
+            else {
+                this.reset();
+            }
+        };
+        this.events.error = (event) => {
+            this.log(`Socket errored.`);
+            this.log(event);
+            // status
+            this.updateStatus(TqlWsService.ENUM_ACTIONS.DISCONNECT);
+            if (this.autoReconnect) {
+                this.reconnect();
+            }
+            else {
+                this.reset();
+            }
+        };
+        this.events.message = (event) => {
+            const data = event?.data;
+            if (data) {
+                this.log(`Socket has message come.`);
+                this.log(data);
+                this.message$.next(data);
+            }
+        };
+    }
+    /**
+     * handle coming message
+     */
+    handleMessage() {
+        this.message$
+            // .pipe(concatMap((data) => from(this.resolveMessage(data))))
+            .subscribe((data) => {
+            // console.log(this.pendingPayloads);
+            ___default.forEach(this.pendingPayloads, (x) => {
+                if (x.resolve(data)) {
+                    ___default.remove(this.pendingPayloads, x);
+                    this.processPayload();
+                    return false;
+                }
+                return true;
+            });
+            this.log('|||||||||||| Pending Payloads: ' + this.pendingPayloads?.length);
+            if (this.pendingPayloads?.length <= 10) {
+                this.log(this.pendingPayloads);
+            }
+        });
+    }
+    /**
+     * update status$
+     * @param action
+     */
+    updateStatus(action) {
+        const status = this.status$.value;
+        switch (action) {
+            case TqlWsService.ENUM_ACTIONS.CONNECT:
+                status.setConnect();
+                break;
+            case TqlWsService.ENUM_ACTIONS.DISCONNECT:
+                status.setDisconnect();
+                break;
+            case TqlWsService.ENUM_ACTIONS.END:
+                status.setEnd();
+                break;
+        }
+        status.setReconnectCount(this.options.max_reconnect_count);
+        this.status$.next(status);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlWsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlWsService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlWsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+(function (TqlWsService) {
+    let ENUM_TYPES;
+    (function (ENUM_TYPES) {
+        ENUM_TYPES[ENUM_TYPES["EMPTY"] = 0] = "EMPTY";
+    })(ENUM_TYPES = TqlWsService.ENUM_TYPES || (TqlWsService.ENUM_TYPES = {}));
+    let ENUM_CODES;
+    (function (ENUM_CODES) {
+        ENUM_CODES[ENUM_CODES["START"] = 0] = "START";
+        ENUM_CODES[ENUM_CODES["END"] = 1] = "END";
+        ENUM_CODES[ENUM_CODES["RESTART"] = 2] = "RESTART";
+    })(ENUM_CODES = TqlWsService.ENUM_CODES || (TqlWsService.ENUM_CODES = {}));
+    let ENUM_ACTIONS;
+    (function (ENUM_ACTIONS) {
+        ENUM_ACTIONS[ENUM_ACTIONS["CONNECT"] = 0] = "CONNECT";
+        ENUM_ACTIONS[ENUM_ACTIONS["DISCONNECT"] = 1] = "DISCONNECT";
+        ENUM_ACTIONS[ENUM_ACTIONS["END"] = 2] = "END";
+    })(ENUM_ACTIONS = TqlWsService.ENUM_ACTIONS || (TqlWsService.ENUM_ACTIONS = {}));
+    /*The value must be an integer: either 1000, or else a custom code of your choosing in the range 3000-4999.
+    If you specify a code value, you should also specify a reason value.*/
+    TqlWsService.CODES = {
+        [ENUM_CODES.START]: { code: 300, message: 'Socket started first time' },
+        [ENUM_CODES.END]: { code: 3001, message: 'Socket is ended' },
+        [ENUM_CODES.RESTART]: { code: 3002, message: 'Socket is restart' },
+    };
+    class Status {
+        get connected() {
+            return this._connected;
+        }
+        get reconnectCount() {
+            return this._reconnectCount;
+        }
+        get end() {
+            return this._end;
+        }
+        constructor() {
+            this.connectStartTime = 0;
+            this.connectEndTime = 0;
+            this._connected = false;
+            this._end = false;
+        }
+        setDisconnect() {
+            this._connected = false;
+            this.connectEndTime = new Date().getTime();
+        }
+        setConnect() {
+            this._connected = true;
+            this.connectStartTime = new Date().getTime();
+            this.connectEndTime = 0;
+        }
+        setEnd() {
+            this._connected = false;
+            this._end = true;
+            this.connectEndTime = new Date().getTime();
+        }
+        setReconnectCount(count) {
+            this._reconnectCount = count;
+        }
+    }
+    TqlWsService.Status = Status;
+})(TqlWsService || (TqlWsService = {}));
+
+class TqlTranslateService {
+    constructor(http, injector) {
+        this.http = http;
+        this.injector = injector;
+        this.translationDataLoaded$ = new BehaviorSubject(null);
+        this.translationData = [];
+    }
+    loaded$() {
+        this.translationData.push(this.translationDataLoaded$.value);
+        return this.translationDataLoaded$;
+    }
+    getDataTranslate(keyLang) {
+        const itemFind = this.translationData.find((x) => x.key === keyLang);
+        if (itemFind) {
+            return new Observable((x) => {
+                x.next(itemFind.data);
+                x.complete();
+            });
+        }
+        return new Observable((x) => {
+            const path = `config/language/${keyLang}.json`;
+            try {
+                this.http
+                    .get(path)
+                    .pipe(catchError$1((res) => {
+                    // console.error('Something went wrong for the following translation file:', path);
+                    // console.error(res.message);
+                    return of({});
+                }))
+                    .subscribe((rs) => {
+                    x.next(rs);
+                    x.complete();
+                    const data = ___default.assign({ ...TqlTranslateService.getJsonLocalStorage(keyLang) }, rs);
+                    this.translationDataLoaded$.next(data);
+                    this.translationData.push({
+                        key: keyLang,
+                        data: data,
+                    });
+                });
+            }
+            catch (e) { }
+        });
+    }
+    translateGG(text) {
+        const obj = new GoogleObj(text);
+        switch (this.getLanguage()) {
+            case LANGUAGES.PT: {
+                obj.target = 'pt';
+                break;
+            }
+            case LANGUAGES.EN: {
+                return new Observable((x) => {
+                    this.saveTextTranslate(text, text);
+                    x.next(text);
+                    x.complete();
+                });
+            }
+        }
+        return this.http
+            .post('https://translation.googleapis.com/language/translate/v2?key=' + TRANSLATE_KEY.key, obj)
+            .pipe(map((x) => {
+            if (x?.['data']?.translations?.[0]?.translatedText) {
+                this.saveTextTranslate(x?.['data']?.translations?.[0]?.translatedText, text);
+            }
+            return x?.['data']?.translations?.[0]?.translatedText ?? text;
+        }));
+    }
+    saveTextTranslate(rs, text) {
+        this.translationData[0].data;
+        this.translationData[0].data[text] = rs;
+        const object = {};
+        object[text] = rs;
+        TqlTranslateService.updateJsonDataLocalStorage(object);
+    }
+    static getDataLocalStorage() {
+        if (typeof window === 'undefined' || !window?.localStorage?.getItem(KEY_LANGUAGES_LOCAL_STORAGE)) {
+            return {};
+        }
+        try {
+            const data = JSON.parse(window?.localStorage?.getItem(KEY_LANGUAGES_LOCAL_STORAGE) ?? '{}');
+            return data ?? {};
+        }
+        catch (error) {
+            return {};
+        }
+    }
+    getLanguage() {
+        return TqlTranslateService.getLanguage();
+    }
+    static getLanguage() {
+        if (this.getDataLocalStorage()?.key) {
+            return this.getDataLocalStorage()?.key;
+        }
+        TqlTranslateService.updateKeyLanguage(LANGUAGE_DEFAULT);
+        return LANGUAGE_DEFAULT;
+    }
+    static getJsonLocalStorage(keyLang) {
+        return this.getDataLocalStorage()?.[keyLang ?? this.getLanguage()] ?? {};
+    }
+    static updateKeyLanguage(keyLang) {
+        const data = this.getDataLocalStorage();
+        data['key'] = keyLang;
+        if (typeof window !== 'undefined')
+            window?.localStorage.setItem(KEY_LANGUAGES_LOCAL_STORAGE, JSON.stringify(data));
+    }
+    static updateJsonDataLocalStorage(dataTranslate) {
+        const keyLang = TqlTranslateService.getLanguage();
+        const data = this.getDataLocalStorage();
+        data[keyLang] = ___default.assign({ ...TqlTranslateService.getJsonLocalStorage(keyLang) }, dataTranslate);
+        if (typeof window !== 'undefined')
+            window?.localStorage.setItem(KEY_LANGUAGES_LOCAL_STORAGE, JSON.stringify(data));
+    }
+    async instant(data) {
+        const translate = this.injector.get(TranslateService);
+        return await translate.stream(data).pipe(first()).toPromise();
+    }
+    static getTranslateHighCharts(type) {
+        const langue = this.getLanguage();
+        switch (type) {
+            case TYPE_LANGUAGES_HIGH_CHART.shortMonths: {
+                switch (langue) {
+                    case LANGUAGES.PT: {
+                        return [
+                            'Jan',
+                            'Fev',
+                            'Março',
+                            'Abril',
+                            'Maio',
+                            'Junho',
+                            'Julho',
+                            'Agosto',
+                            'Set',
+                            'Out',
+                            'Nov',
+                            'Dez',
+                        ];
+                    }
+                    default: {
+                        return ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+                    }
+                }
+            }
+            case TYPE_LANGUAGES_HIGH_CHART.months: {
+                switch (langue) {
+                    case LANGUAGES.PT: {
+                        return [
+                            'Janeiro',
+                            'Fevereiro',
+                            'Março',
+                            'Abril',
+                            'Maio',
+                            'Junho',
+                            'Julho',
+                            'Agosto',
+                            'Setembro',
+                            'Outubro',
+                            'Novembro',
+                            'Dezembro',
+                        ];
+                    }
+                    default: {
+                        return [
+                            'January',
+                            'February',
+                            'March',
+                            'April',
+                            'May',
+                            'June',
+                            'July',
+                            'August',
+                            'September',
+                            'October',
+                            'November',
+                            'December',
+                        ];
+                    }
+                }
+            }
+            case TYPE_LANGUAGES_HIGH_CHART.weekdays: {
+                switch (langue) {
+                    case LANGUAGES.PT: {
+                        return [
+                            'Domingo',
+                            'Segunda-feira',
+                            'Terça-feira',
+                            'Quarta-feira',
+                            'Quinta-feira',
+                            'Sexta-feira',
+                            'Sábado',
+                        ];
+                    }
+                    default: {
+                        return ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+                    }
+                }
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlTranslateService, deps: [{ token: i1$2.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlTranslateService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlTranslateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1$2.HttpClient }, { type: i0.Injector }] });
+(function (TqlTranslateService) {
+    class MyMissingTranslationHandler {
+        constructor(_TqlTranslateService) {
+            this._TqlTranslateService = _TqlTranslateService;
+        }
+        handle(params) {
+            const itemFind = this._TqlTranslateService.translationData[0]?.data?.[params?.key];
+            if (itemFind) {
+                return itemFind;
+            }
+            return this._TqlTranslateService.translateGG(params?.key);
+        }
+    }
+    TqlTranslateService.MyMissingTranslationHandler = MyMissingTranslationHandler;
+    function HandleMyMissing(_TqlTranslateService) {
+        return new MyMissingTranslationHandler(_TqlTranslateService);
+    }
+    TqlTranslateService.HandleMyMissing = HandleMyMissing;
+    // AoT requires an exported function for factories
+    function HttpLoaderFactory(_TqlTranslateService) {
+        return new MultiTranslateHttpLoader(_TqlTranslateService);
+    }
+    TqlTranslateService.HttpLoaderFactory = HttpLoaderFactory;
+    class MultiTranslateHttpLoader {
+        constructor(_TqlTranslateService) {
+            this._TqlTranslateService = _TqlTranslateService;
+        }
+        getTranslation() {
+            return new Observable((x) => {
+                x.next(this._TqlTranslateService.translationData[0].data);
+                x.complete();
+            });
+        }
+    }
+    TqlTranslateService.MultiTranslateHttpLoader = MultiTranslateHttpLoader;
+    function initializeTranslations(_TqlTranslateService) {
+        return async () => {
+            return _TqlTranslateService.getDataTranslate(_TqlTranslateService.getLanguage()).toPromise();
+        };
+    }
+    TqlTranslateService.initializeTranslations = initializeTranslations;
+    TqlTranslateService.languageHighChart = {
+        lang: {
+            thousandsSep: ',',
+            shortMonths: TqlTranslateService.getTranslateHighCharts('shortMonths'),
+            months: TqlTranslateService.getTranslateHighCharts('months'),
+            weekdays: TqlTranslateService.getTranslateHighCharts('weekdays'),
+        },
+    };
+})(TqlTranslateService || (TqlTranslateService = {}));
+class GoogleObj {
+    constructor(q) {
+        this.source = 'en';
+        this.target = 'pt';
+        this.format = 'text';
+        this.q = q;
+    }
+}
+
+class TqlGlobalConfigService {
+    constructor(externalConfig) {
+        this.externalConfig = externalConfig;
+        this.config = { spinTemplate: null };
+        console.log(externalConfig);
+        _.assign(this.config, externalConfig);
+    }
+    getConfig() {
+        return this.config;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlGlobalConfigService, deps: [{ token: TQL_LIBRARY_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlGlobalConfigService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlGlobalConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TQL_LIBRARY_CONFIG]
+                }] }] });
+
+class PayloadModel {
+    /**
+     *
+     * @param query
+     * @param objectName
+     * @param objectClass
+     * @param objectPath
+     */
+    constructor(query, objectName, objectPath, objectClass) {
+        this.query = query;
+        this.objectName = objectName;
+        this.objectPath = objectPath;
+        this.objectClass = objectClass;
+    }
+    /**
+     *
+     * @param params
+     * @returns {string}
+     */
+    buildPayload(params = []) {
+        let data = this.query.toString();
+        if (!params || !Object.keys(params).length) {
+            return data;
+        }
+        return _.reduce(params, (result, v, index) => TqlUtilsService.replaceAll(result.toString(), `{${index}}`, v), data);
+    }
+    /**
+     *
+     * @param dataObject
+     * @returns {string}
+     */
+    buildPayloadWithObject(dataObject) {
+        if (!Object.keys(dataObject).length) {
+            return this.query;
+        }
+        return _.reduce(Object.keys(dataObject), (result, v, k) => TqlUtilsService.replaceAll(result.toString(), `{${k}}`, dataObject[k]), this.query);
+    }
+    /**
+     *
+     * @param array
+     * @returns {any[]}
+     */
+    parse(array = []) {
+        if (_.isUndefined(this.objectClass) || _.isUndefined(this.objectName)) {
+            return array;
+        }
+        const data = [];
+        try {
+            for (let i = 0; i < array.length; i++) {
+                if (_.get(array, this.objectName ? [i, this.objectName] : [i])) {
+                    data.push(new this.objectClass(_.get(array, this.objectName ? [i, this.objectName] : [i])));
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return data;
+    }
+}
+
+class WSPayloadModel {
+    constructor(query, params = [], id) {
+        this.id = id || v4();
+        this.query = TqlUtilsService.replaceAll(query, '{mid}', this.id);
+        ___default.map(params, (x, k) => {
+            this.query = TqlUtilsService.replaceAll(this.query, `{${k}}`, x);
+        });
+        this.$promise = new Promise((resolve) => {
+            this.promiseResolve = resolve;
+        });
+    }
+    /**
+     *
+     * @param data
+     * @returns {boolean}
+     */
+    resolve(data) {
+        if (data.includes(this.id)) {
+            data = TqlUtilsService.replaceAll(data, '---Self---', `""`);
+            let json = data;
+            try {
+                json = JSON.parse(data);
+            }
+            catch (e) { }
+            this.promiseResolve(json);
+            return true;
+        }
+        return false;
+    }
+}
+
+/* default */
+
+class TqlApiInterceptor {
+    constructor() {
+    }
+    intercept(request, next) {
+        // timeout
+        let $timeout = 300000;
+        if (request.headers.has(TqlApiInterceptor.HEADER_KEYS.TIMEOUT)) {
+            $timeout = parseInt(request.headers.get(TqlApiInterceptor.HEADER_KEYS.TIMEOUT));
+            request = request.clone({
+                headers: request.headers.delete(TqlApiInterceptor.HEADER_KEYS.TIMEOUT)
+            });
+        }
+        // check token
+        if (request.headers.has(TqlApiInterceptor.HEADER_KEYS.NO_TOKEN) || request.headers.has(TqlApiInterceptor.HEADER_KEYS.REQUIRE_TOKEN)) {
+            request = request.clone({
+                headers: request.headers.delete(TqlApiInterceptor.HEADER_KEYS.NO_TOKEN).delete(TqlApiInterceptor.HEADER_KEYS.REQUIRE_TOKEN)
+            });
+            // check token
+        }
+        // console.log(request);
+        return next.handle(request)
+            .pipe(timeout($timeout));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlApiInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlApiInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlApiInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+(function (TqlApiInterceptor) {
+    let HEADER_KEYS;
+    (function (HEADER_KEYS) {
+        HEADER_KEYS["TIMEOUT"] = "timeout";
+        HEADER_KEYS["NO_TOKEN"] = "noToken";
+        HEADER_KEYS["REQUIRE_TOKEN"] = "requiteToken";
+        HEADER_KEYS["REQUIRE_USER_TOKEN"] = "requiteUserToken";
+    })(HEADER_KEYS = TqlApiInterceptor.HEADER_KEYS || (TqlApiInterceptor.HEADER_KEYS = {}));
+})(TqlApiInterceptor || (TqlApiInterceptor = {}));
+
+// export * from './api/tql-api-lib.service';
+
+class TqlServiceModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlServiceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.17", ngImport: i0, type: TqlServiceModule, imports: [CommonModule, i1$3.TranslateModule], exports: [TranslateModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlServiceModule, providers: [
+            TqlSiteMapControllerService,
+            TqlToastControllerService,
+            TqlDialogControllerService,
+            TqlRouteControllerService,
+            TqlApiLibService,
+            TqlErrorHandlerService,
+            TqlLoggerService,
+            TqlUtilsService,
+            TqlWsService,
+            TqlTranslateService,
+            provideAppInitializer(() => {
+                const translateService = inject(TqlTranslateService);
+                return TqlTranslateService.initializeTranslations(translateService)();
+            }),
+            {
+                provide: LOCALE_ID,
+                deps: [TqlTranslateService],
+                useFactory: (_TqlTranslateService) => _TqlTranslateService.getLanguage(),
+            },
+            { provide: TQL_LIBRARY_CONFIG, useValue: {} },
+        ], imports: [CommonModule,
+            TranslateModule.forRoot({
+                loader: {
+                    provide: TranslateLoader,
+                    useFactory: TqlTranslateService.HttpLoaderFactory,
+                    deps: [TqlTranslateService],
+                },
+                missingTranslationHandler: {
+                    provide: MissingTranslationHandler,
+                    useFactory: TqlTranslateService.HandleMyMissing,
+                    deps: [TqlTranslateService],
+                },
+                useDefaultLang: false,
+            }), TranslateModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: TqlServiceModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule,
+                        TranslateModule.forRoot({
+                            loader: {
+                                provide: TranslateLoader,
+                                useFactory: TqlTranslateService.HttpLoaderFactory,
+                                deps: [TqlTranslateService],
+                            },
+                            missingTranslationHandler: {
+                                provide: MissingTranslationHandler,
+                                useFactory: TqlTranslateService.HandleMyMissing,
+                                deps: [TqlTranslateService],
+                            },
+                            useDefaultLang: false,
+                        }),
+                    ],
+                    providers: [
+                        TqlSiteMapControllerService,
+                        TqlToastControllerService,
+                        TqlDialogControllerService,
+                        TqlRouteControllerService,
+                        TqlApiLibService,
+                        TqlErrorHandlerService,
+                        TqlLoggerService,
+                        TqlUtilsService,
+                        TqlWsService,
+                        TqlTranslateService,
+                        provideAppInitializer(() => {
+                            const translateService = inject(TqlTranslateService);
+                            return TqlTranslateService.initializeTranslations(translateService)();
+                        }),
+                        {
+                            provide: LOCALE_ID,
+                            deps: [TqlTranslateService],
+                            useFactory: (_TqlTranslateService) => _TqlTranslateService.getLanguage(),
+                        },
+                        { provide: TQL_LIBRARY_CONFIG, useValue: {} },
+                    ],
+                    exports: [TranslateModule],
+                }]
+        }] });
+
+/*
+ * Public API Surface of tql-service
+ */
+// controllers
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DATA_TYPE, DefaultComponent, DefaultDialogComponent, DefaultDirective, DefaultMapComponent, DefaultModel, DynamicDataModel, ErrorStatusEnum, GoogleObj, KEY_CONSTANT, KEY_LANGUAGES_LOCAL_STORAGE, LANGUAGES, LANGUAGE_DEFAULT, MAP_STYLES, PayloadModel, TQL_LIBRARY_CONFIG, TRANSLATE_KEY, TYPE_LANGUAGES_HIGH_CHART, TqlApiInterceptor, TqlApiLibService, TqlDialogControllerService, TqlErrorHandlerService, TqlGlobalConfigService, TqlLoggerService, TqlRouteControllerService, TqlServiceModule, TqlSiteMapControllerService, TqlTableControllerService, TqlToastControllerService, TqlTranslateService, TqlUtilsService, TqlWsService, WSPayloadModel };
+//# sourceMappingURL=x-tql-service.mjs.map