tnp-helpers 0.0.67 → 13.0.2

package/app.js

@@ -1 +1,2 @@
-//# sourceMappingURL=app.js.map
+//# sourceMappingURL=app.js.map
+// @fixed

package/browser/README.md

@@ -0,0 +1,24 @@
+# MyLib
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project my-lib` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project my-lib`.
+> Note: Don't forget to add `--project my-lib` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build my-lib` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build my-lib`, go to the dist folder `cd dist/my-lib` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test my-lib` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/browser/esm2020/lib/base-component.mjs

@@ -0,0 +1,48 @@
+import { Component, Input } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import * as i0 from "@angular/core";
+export class BaseComponent {
+    constructor() {
+        // @ts-ignore
+        this.model = {};
+        this.handlers = [];
+    }
+    ngOnDestroy() {
+        this.handlers.forEach(h => h.unsubscribe());
+        this.handlers.length = 0;
+    }
+}
+BaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: BaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BaseComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.4", type: BaseComponent, selector: "app-base-component-meta", inputs: { model: "model" }, ngImport: i0, template: '<div></div>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: BaseComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-base-component-meta',
+                    template: '<div></div>'
+                }]
+        }], propDecorators: { model: [{
+                type: Input
+            }] } });
+const isCalledNgInitAfterInternalRefresh = Symbol();
+export class BaseComponentForRouter extends BaseComponent {
+    constructor(__router) {
+        super();
+        this.__router = __router;
+        this[isCalledNgInitAfterInternalRefresh] = false;
+    }
+    isCalledNgInitAfterInternalRefresh() {
+        return !!this[isCalledNgInitAfterInternalRefresh];
+    }
+    reloadNgOninitOnUrlChange() {
+        this.handlers.push(this.__router.events.subscribe(event => {
+            if (event instanceof NavigationEnd && this['ngOnInit']) {
+                this[isCalledNgInitAfterInternalRefresh] = true;
+                this['ngOnInit']();
+                if (this[isCalledNgInitAfterInternalRefresh]) {
+                    this[isCalledNgInitAfterInternalRefresh] = false;
+                }
+            }
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/browser/esm2020/lib/base-formly-component.mjs

@@ -0,0 +1,123 @@
+import { FieldType } from '@ngx-formly/core';
+import { Component, Input, Output, } from '@angular/core';
+import { Log, Level } from 'ng2-logger/browser';
+import { DualComponentController } from './dual-component-ctrl';
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+const log = Log.create('base formly component', Level.__NOTHING);
+export class BaseFormlyComponent extends FieldType {
+    constructor() {
+        super(...arguments);
+        this.DualComponentController = DualComponentController;
+        this.ctrl = {};
+        this.change = new EventEmitter();
+        this.handlers = [];
+        this.__field = {
+            templateOptions: {}
+        };
+    }
+    // @ts-ignore
+    get mode() {
+        return this.ctrl.mode;
+    }
+    // @ts-ignore
+    set mode(v) {
+        this.ctrl.mode = v;
+    }
+    // @ts-ignore
+    set model(v) {
+        this.ctrl.model = v;
+    }
+    get model() {
+        return this.ctrl.model;
+    }
+    // @ts-ignore
+    set key(value) {
+        if (this.ctrl && this.ctrl.isFormlyMode) {
+            return;
+        }
+        this.path = value;
+    }
+    get key() {
+        if (this.ctrl && this.ctrl.isFormlyMode) {
+            return this.field.key;
+        }
+        return this.path;
+    }
+    ngOnDestroy() {
+        this.handlers.forEach(h => h.unsubscribe());
+        this.handlers.length = 0;
+    }
+    ngAfterViewInit() {
+    }
+    // _model: any;
+    ngOnInit() {
+        // console.log('model', this.model)
+        // console.log('ket', this.key)
+        const isFormlyMode = !!this.field;
+        log.i(`isFormlyMode: ${isFormlyMode}`);
+        if (!isFormlyMode) {
+            const that = this;
+            Object.defineProperty(this, 'field', {
+                get: function () {
+                    return that.__field;
+                },
+                set: function (v) {
+                    that.__field = v;
+                }
+            });
+        }
+        const existed = this.ctrl;
+        this.ctrl = new this.DualComponentController(this, isFormlyMode);
+        // @ts-ignore
+        Object.keys(existed).forEach(key => {
+            this.ctrl[key] = existed[key];
+        });
+        // if (!this.formControl) {
+        //   this.formControl = new FormControl({})
+        //   Object.defineProperty(this, 'field', {
+        //     get: () => {
+        //       return {
+        //         formControl: this.formControl
+        //       } as FormlyFieldConfig
+        //     }
+        //   })
+        //   //   this.formControl = new FormControl({})
+        // }
+        this.change.next(this.ctrl.value);
+    }
+}
+BaseFormlyComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: BaseFormlyComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+BaseFormlyComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.4", type: BaseFormlyComponent, selector: "app-base-formly-component-meta", inputs: { pizda: "pizda", mode: "mode", disabled: "disabled", required: "required", label: "label", placeholder: "placeholder", defaultValue: "defaultValue", model: "model", path: "path", key: "key", formControl: "formControl" }, outputs: { change: "change" }, usesInheritance: true, ngImport: i0, template: `<div></div>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: BaseFormlyComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-base-formly-component-meta',
+                    template: `<div></div>`
+                }]
+        }], propDecorators: { pizda: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], defaultValue: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], path: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }], key: [{
+                type: Input
+            }], formControl: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/browser/esm2020/lib/condition-wait.mjs

@@ -0,0 +1,54 @@
+import { _ } from 'tnp-core/browser';
+import { Helpers } from './index';
+export async function conditionWait(conditionAndTimeout) {
+    await waitFor(conditionAndTimeout);
+}
+function waitFor(arr, messageToShow = void 0) {
+    return new Promise(async (resolve, reject) => {
+        if (arr.length === 0) {
+            resolve(void 0);
+        }
+        else {
+            // console.log(arr.length)
+            const check = arr.shift();
+            if (_.isUndefined(check.timeoutCheck)) {
+                check.timeoutCheck = 2000;
+            }
+            if (_.isUndefined(check.timeoutNext)) {
+                check.timeoutNext = 4000;
+            }
+            const { timeoutCheck, timeoutNext, name } = check;
+            // console.log(`timeoutCheck: ${timeoutCheck}`);
+            // console.log(`timeoutNext: ${timeoutNext}`);
+            // console.log(`Checking: ${name}`)
+            const resultTrue = await Helpers.runSyncOrAsync(check.callback, check);
+            // console.log(`after: ${name}`)
+            if (resultTrue) {
+                // console.log(`timeout 1 is set to ${timeoutNext}`)
+                setTimeout(async () => {
+                    // console.log(`timeout 1 is over`)
+                    await waitFor(arr).then(() => {
+                        resolve(void 0);
+                    });
+                }, timeoutNext);
+            }
+            else {
+                arr.unshift(check);
+                if (!messageToShow || check.errorMessage !== messageToShow) {
+                    Helpers.info(check.errorMessage);
+                }
+                else {
+                    // console.log(`dont show error  message ${check.errorMessage}`)
+                }
+                // console.log(`timeout 2 is set to ${timeoutCheck}, arr.length is ${arr.length}`)
+                setTimeout(async () => {
+                    // console.log(`timeout 2 ${timeoutCheck} ovef`)
+                    await waitFor(arr, check.errorMessage).then(() => {
+                        resolve(void 0);
+                    });
+                }, timeoutCheck);
+            }
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/browser/esm2020/lib/constants.mjs

@@ -0,0 +1,2 @@
+export const BaselineSiteJoinprefix = '__';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdG1wLWxpYnMtZm9yLWJ1bmRsZS90bnAtaGVscGVycy9wcm9qZWN0cy90bnAtaGVscGVycy9zcmMvbGliL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxJQUFJLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcblxuZXhwb3J0IGNvbnN0IEJhc2VsaW5lU2l0ZUpvaW5wcmVmaXggPSAnX18nO1xuIl19

package/browser/esm2020/lib/dual-component-ctrl.mjs

@@ -0,0 +1,116 @@
+import { _ } from 'tnp-core/browser';
+import { CLASS } from 'typescript-class-helpers/browser';
+import { Log } from 'ng2-logger/browser';
+const log = Log.create(`DualComponentController`);
+export class DualComponentController {
+    constructor(cmp, isFormlyMode = false) {
+        this.cmp = cmp;
+        this.isFormlyMode = isFormlyMode;
+    }
+    getValTemplateOptions(propertyName) {
+        if (this.isFormlyMode) {
+            const res = this.cmp.field?.templateOptions[propertyName];
+            if (res === void 0 && this.cmp[propertyName]) {
+                return this.cmp[propertyName];
+            }
+            return res;
+        }
+        return this.cmp[propertyName];
+    }
+    getValContext(propertyName) {
+        if (this.isFormlyMode) {
+            const res = this.cmp?.field[propertyName];
+            if (res === void 0 && this.cmp[propertyName]) {
+                return this.cmp[propertyName];
+            }
+            return res;
+        }
+        return this.cmp[propertyName];
+    }
+    get disabled() {
+        return this.getValTemplateOptions('disabled');
+    }
+    get required() {
+        return this.getValTemplateOptions('required');
+    }
+    get type() {
+        if (!this.isFormlyMode) {
+            return CLASS.getNameFromObject(this.cmp);
+        }
+        return this.getValContext('type');
+    }
+    get label() {
+        return this.getValTemplateOptions('label');
+    }
+    get placeholder() {
+        return this.getValTemplateOptions('placeholder');
+    }
+    get defaultValue() {
+        return this.getValContext('defaultValue');
+    }
+    get formControl() {
+        return this.getValContext('formControl');
+    }
+    get key() {
+        return this.getValContext('key');
+    }
+    get path() {
+        return this.getValContext('path');
+    }
+    get model() {
+        if (this.isFormlyMode) {
+            return this.getValContext('model');
+        }
+        else {
+            return this.__model;
+        }
+    }
+    set model(v) {
+        if (this.isFormlyMode) {
+            log.w(`[DualComponentController] You can't set model in formly component mode`);
+        }
+        else {
+            this.__model = v;
+        }
+    }
+    get mode() {
+        if (this.isFormlyMode) {
+            return this.getValContext('mode');
+        }
+        else {
+            return this.__mode;
+        }
+    }
+    set mode(v) {
+        if (this.isFormlyMode) {
+            // this.cmp.field.mode =
+            // log.w(`[DualComponentController] You can't set mode in formly component mode`);
+        }
+        else {
+            this.__mode = v;
+        }
+    }
+    get value() {
+        if (this.isFormlyMode) {
+            return this.cmp.field.formControl.value;
+        }
+        if (_.isString(this.path)) {
+            return _.get(this.cmp.model, this.path);
+        }
+        return this.cmp.model;
+    }
+    set value(v) {
+        if (this.isFormlyMode) {
+            this.cmp.field.formControl.setValue(v);
+            this.cmp.change.next(v);
+            return;
+        }
+        if (_.isString(this.path)) {
+            _.set(this.cmp.model, this.path, v);
+        }
+        else {
+            this.cmp.model = v;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dual-component-ctrl.js","sourceRoot":"","sources":["../../../../tmp-libs-for-bundle/tnp-helpers/projects/tnp-helpers/src/lib/dual-component-ctrl.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,kBAAkB,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAKzD,OAAO,EAAE,GAAG,EAAS,MAAM,oBAAoB,CAAC;AAChD,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,yBAAyB,CAAC,CAAC;AAElD,MAAM,OAAgB,uBAAuB;IAE3C,YAAsB,GAAwB,EAAS,eAAe,KAAK;QAArD,QAAG,GAAH,GAAG,CAAqB;QAAS,iBAAY,GAAZ,YAAY,CAAQ;IAE3E,CAAC;IAES,qBAAqB,CAAC,YAAoB;QAClD,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,eAAe,CAAC,YAAY,CAAC,CAAA;YACzD,IAAI,GAAG,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBAC5C,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;aAC/B;YACD,OAAO,GAAG,CAAC;SACZ;QACD,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;IAC/B,CAAC;IAES,aAAa,CAAC,YAAoB;QAC1C,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,YAAY,CAAC,CAAA;YACzC,IAAI,GAAG,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE;gBAC5C,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;aAC/B;YACD,OAAO,GAAG,CAAC;SACZ;QACD,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAA;IAC/B,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAY,CAAC;IAC3D,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAY,CAAC;IAC3D,CAAC;IAED,IAAI,IAAI;QACN,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACtB,OAAO,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;SACzC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAY,CAAC;IAC/C,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAW,CAAC;IACvD,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAW,CAAC;IAC7D,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC,cAAc,CAAQ,CAAC;IACnD,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,aAAa,CAAQ,CAAC;IAClD,CAAC;IAED,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAW,CAAC;IAC7C,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAW,CAAC;IAC9C,CAAC;IAGD,IAAI,KAAK;QACP,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,OAAO,IAAI,CAAC,aAAa,CAAC,OAAO,CAAW,CAAC;SAC9C;aAAM;YACL,OAAO,IAAI,CAAC,OAAO,CAAC;SACrB;IACH,CAAC;IAED,IAAI,KAAK,CAAC,CAAC;QACT,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,GAAG,CAAC,CAAC,CAAC,wEAAwE,CAAC,CAAC;SACjF;aAAM;YACL,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;SAClB;IACH,CAAC;IAGD,IAAI,IAAI;QACN,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAW,CAAC;SAC7C;aAAM;YACL,OAAO,IAAI,CAAC,MAAM,CAAC;SACpB;IACH,CAAC;IAED,IAAI,IAAI,CAAC,CAAC;QACR,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,wBAAwB;YACxB,kFAAkF;SACnF;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;SACjB;IACH,CAAC;IAGD,IAAI,KAAK;QACP,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC;SACzC;QACD,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YACzB,OAAO,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;SACzC;QACD,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC;IACxB,CAAC;IAED,IAAI,KAAK,CAAC,CAAC;QACT,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACvC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACxB,OAAO;SACR;QACD,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YACzB,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;SACrC;aAAM;YACL,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC;SACpB;IACH,CAAC;CAGF","sourcesContent":["\n\nimport { _ } from 'tnp-core/browser';\nimport { BaseFormlyComponent } from './base-formly-component';\nimport { CLASS } from 'typescript-class-helpers/browser';\nimport {   Component, OnInit, Input, Output, AfterViewInit, } from '@angular/core';\n\nimport {   FormControl,   FormGroup } from '@angular/forms'\n\nimport { Log, Level } from 'ng2-logger/browser';\nconst log = Log.create(`DualComponentController`);\n\nexport abstract class DualComponentController<T = any> {\n\n  constructor(protected cmp: BaseFormlyComponent, public isFormlyMode = false) {\n\n  }\n\n  protected getValTemplateOptions(propertyName: string) {\n    if (this.isFormlyMode) {\n      const res = this.cmp.field?.templateOptions[propertyName]\n      if (res === void 0 && this.cmp[propertyName]) {\n        return this.cmp[propertyName];\n      }\n      return res;\n    }\n    return this.cmp[propertyName]\n  }\n\n  protected getValContext(propertyName: string) {\n    if (this.isFormlyMode) {\n      const res = this.cmp?.field[propertyName]\n      if (res === void 0 && this.cmp[propertyName]) {\n        return this.cmp[propertyName];\n      }\n      return res;\n    }\n    return this.cmp[propertyName]\n  }\n\n  get disabled() {\n    return this.getValTemplateOptions('disabled') as boolean;\n  }\n\n  get required() {\n    return this.getValTemplateOptions('required') as boolean;\n  }\n\n  get type() {\n    if (!this.isFormlyMode) {\n      return CLASS.getNameFromObject(this.cmp)\n    }\n    return this.getValContext('type') as boolean;\n  }\n\n  get label() {\n    return this.getValTemplateOptions('label') as string;\n  }\n\n  get placeholder() {\n    return this.getValTemplateOptions('placeholder') as string;\n  }\n\n  get defaultValue(): T {\n    return this.getValContext('defaultValue') as any;\n  }\n\n  get formControl(): FormControl {\n    return this.getValContext('formControl') as any;\n  }\n\n  get key() {\n    return this.getValContext('key') as string;\n  }\n\n  get path() {\n    return this.getValContext('path') as string;\n  }\n\n  __model: any;\n  get model(): any {\n    if (this.isFormlyMode) {\n      return this.getValContext('model') as string;\n    } else {\n      return this.__model;\n    }\n  }\n\n  set model(v) {\n    if (this.isFormlyMode) {\n      log.w(`[DualComponentController] You can't set model in formly component mode`);\n    } else {\n      this.__model = v;\n    }\n  }\n\n  __mode: any;\n  get mode(): any {\n    if (this.isFormlyMode) {\n      return this.getValContext('mode') as string;\n    } else {\n      return this.__mode;\n    }\n  }\n\n  set mode(v) {\n    if (this.isFormlyMode) {\n      // this.cmp.field.mode =\n      // log.w(`[DualComponentController] You can't set mode in formly component mode`);\n    } else {\n      this.__mode = v;\n    }\n  }\n\n\n  get value(): T {\n    if (this.isFormlyMode) {\n      return this.cmp.field.formControl.value;\n    }\n    if (_.isString(this.path)) {\n      return _.get(this.cmp.model, this.path);\n    }\n    return this.cmp.model;\n  }\n\n  set value(v) {\n    if (this.isFormlyMode) {\n      this.cmp.field.formControl.setValue(v);\n      this.cmp.change.next(v);\n      return;\n    }\n    if (_.isString(this.path)) {\n      _.set(this.cmp.model, this.path, v);\n    } else {\n      this.cmp.model = v;\n    }\n  }\n\n\n}\n"]}

package/browser/esm2020/lib/helpers-array-obj.mjs

@@ -0,0 +1,81 @@
+import { _ } from 'tnp-core/browser';
+import * as fuzzy from 'fuzzy';
+import { Helpers } from './index';
+export class HelpersArrayObj {
+    from(s) {
+        if (_.isArray(s)) {
+            return s;
+        }
+        if (_.isString(s)) {
+            return s.split(' ');
+        }
+    }
+    second(arr) {
+        if (!Array.isArray(arr) || arr.length < 2) {
+            return void 0;
+        }
+        return arr[1];
+    }
+    arrayMoveElementBefore(arr, a, b, prop) {
+        let indexA = prop ? arr.findIndex(elem => elem[prop] === a[prop]) : arr.indexOf(a);
+        _.pullAt(arr, indexA);
+        let indexB = prop ? arr.findIndex(elem => elem[prop] === b[prop]) : arr.indexOf(b);
+        if (indexB === 0) {
+            arr.unshift(a);
+        }
+        else {
+            arr.splice(indexB - 1, 0, a);
+        }
+        return arr;
+    }
+    arrayMoveElementAfterB(arr, a, b, prop) {
+        let indexA = prop ? arr.findIndex(elem => elem[prop] === a[prop]) : arr.indexOf(a);
+        _.pullAt(arr, indexA);
+        let indexB = prop ? arr.findIndex(elem => elem[prop] === b[prop]) : arr.indexOf(b);
+        if (indexB === arr.length - 1) {
+            arr.push(a);
+        }
+        else {
+            arr.splice(indexB + 1, 0, a);
+        }
+        return arr;
+    }
+    uniqArray(array, uniqueProperty) {
+        var seen = {};
+        return array
+            .filter(f => !!f)
+            .filter(function (item) {
+            return seen.hasOwnProperty(uniqueProperty ? item[uniqueProperty] : item) ? false
+                : (seen[uniqueProperty ? item[uniqueProperty] : item] = true);
+        });
+    }
+    sortKeys(obj) {
+        if (_.isArray(obj)) {
+            return obj.map(Helpers.arrays.sortKeys);
+        }
+        if (_.isObject(obj)) {
+            return _.fromPairs(_.keys(obj).sort().map(key => [key, Helpers.arrays.sortKeys(obj[key])]));
+        }
+        return obj;
+    }
+    ;
+    /**
+     * Fuzzy search
+     */
+    fuzzy(query, list, valueFn) {
+        const resultsFuzzy = fuzzy.filter(query, list.map(k => valueFn ? valueFn(k) : k));
+        const resultsFuzzyKebab = fuzzy.filter(_.kebabCase(query), list.map(k => _.kebabCase((valueFn ? valueFn(k) : k))));
+        const matches = resultsFuzzy.map((el) => el.string);
+        const matchesKebab = resultsFuzzyKebab.map((el) => el.string);
+        const results = (resultsFuzzy.length === 0) ? [] : list.filter(k => {
+            return matches.includes((valueFn ? valueFn(k) : k));
+        });
+        if (matches.length === 0 && matchesKebab.length > 0) {
+            const m = list.find(k => _.kebabCase((valueFn ? valueFn(k) : k)) === _.first(matchesKebab));
+            results.push(m);
+            matches.push((valueFn ? valueFn(m) : m));
+        }
+        return { matches, results };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers-array-obj.js","sourceRoot":"","sources":["../../../../tmp-libs-for-bundle/tnp-helpers/projects/tnp-helpers/src/lib/helpers-array-obj.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,kBAAkB,CAAC;AACrC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC,MAAM,OAAO,eAAe;IAE1B,IAAI,CAAC,CAAoB;QACvB,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YAChB,OAAO,CAAC,CAAC;SACV;QACD,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;YACjB,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;SACpB;IACH,CAAC;IAED,MAAM,CAAC,GAAG;QACR,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;YACzC,OAAO,KAAK,CAAC,CAAC;SACf;QACD,OAAQ,GAAG,CAAC,CAAC,CAAC,CAAC;IACjB,CAAC;IAED,sBAAsB,CAAU,GAAU,EAAE,CAAM,EAAE,CAAM,EAAE,IAAc;QACxE,IAAI,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACnF,CAAC,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QACtB,IAAI,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACnF,IAAI,MAAM,KAAK,CAAC,EAAE;YAChB,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;SAChB;aAAM;YACL,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;SAC9B;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IACD,sBAAsB,CAAU,GAAU,EAAE,CAAM,EAAE,CAAM,EAAE,IAAc;QACxE,IAAI,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACnF,CAAC,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QACtB,IAAI,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACnF,IAAI,MAAM,KAAK,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;YAC7B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACb;aAAM;YACL,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;SAC9B;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,SAAS,CAAU,KAAY,EAAE,cAA0B;QACzD,IAAI,IAAI,GAAG,EAAE,CAAC;QACd,OAAO,KAAK;aACT,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAChB,MAAM,CAAC,UAAU,IAAI;YACpB,OAAO,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK;gBAC9E,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;IACP,CAAC;IAED,QAAQ,CAAC,GAAG;QACV,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YAClB,OAAO,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;SACzC;QACD,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACnB,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC7F;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAAA,CAAC;IAEF;;OAEG;IACH,KAAK,CAAU,KAAa,EAAE,IAAS,EAAE,OAAsC;QAC7E,MAAM,YAAY,GAAG,KAAK,CAAC,MAAM,CAC/B,KAAK,EACL,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CACxC,CAAA;QACD,MAAM,iBAAiB,GAAG,KAAK,CAAC,MAAM,CACpC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,EAClB,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAQ,CAAC,CAAC,CAC9D,CAAA;QACD,MAAM,OAAO,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;QACpD,MAAM,YAAY,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;QAE9D,MAAM,OAAO,GAAG,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;YACjE,OAAO,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAQ,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAA;QAEF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE;YACnD,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;YACnG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAChB,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAQ,CAAC,CAAC;SACjD;QAED,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;IAC9B,CAAC;CAEF","sourcesContent":["\n\nimport { _ } from 'tnp-core/browser';\nimport * as fuzzy from 'fuzzy';\nimport { Helpers } from './index';\n\nexport class HelpersArrayObj {\n\n  from(s: string | string[]): string[] {\n    if (_.isArray(s)) {\n      return s;\n    }\n    if (_.isString(s)) {\n      return s.split(' ')\n    }\n  }\n\n  second(arr) {\n    if (!Array.isArray(arr) || arr.length < 2) {\n      return void 0;\n    }\n    return  arr[1];\n  }\n\n  arrayMoveElementBefore<T = any>(arr: any[], a: any, b: any, prop?: keyof T) {\n    let indexA = prop ? arr.findIndex(elem => elem[prop] === a[prop]) : arr.indexOf(a);\n    _.pullAt(arr, indexA);\n    let indexB = prop ? arr.findIndex(elem => elem[prop] === b[prop]) : arr.indexOf(b);\n    if (indexB === 0) {\n      arr.unshift(a);\n    } else {\n      arr.splice(indexB - 1, 0, a);\n    }\n    return arr;\n  }\n  arrayMoveElementAfterB<T = any>(arr: any[], a: any, b: any, prop?: keyof T) {\n    let indexA = prop ? arr.findIndex(elem => elem[prop] === a[prop]) : arr.indexOf(a);\n    _.pullAt(arr, indexA);\n    let indexB = prop ? arr.findIndex(elem => elem[prop] === b[prop]) : arr.indexOf(b);\n    if (indexB === arr.length - 1) {\n      arr.push(a);\n    } else {\n      arr.splice(indexB + 1, 0, a);\n    }\n    return arr;\n  }\n\n  uniqArray<T = any>(array: any[], uniqueProperty?: (keyof T)) {\n    var seen = {};\n    return array\n      .filter(f => !!f)\n      .filter(function (item) {\n        return seen.hasOwnProperty(uniqueProperty ? item[uniqueProperty] : item) ? false\n          : (seen[uniqueProperty ? item[uniqueProperty] : item] = true);\n      });\n  }\n\n  sortKeys(obj) {\n    if (_.isArray(obj)) {\n      return obj.map(Helpers.arrays.sortKeys);\n    }\n    if (_.isObject(obj)) {\n      return _.fromPairs(_.keys(obj).sort().map(key => [key, Helpers.arrays.sortKeys(obj[key])]));\n    }\n    return obj;\n  };\n\n  /**\n   * Fuzzy search\n   */\n  fuzzy<T = any>(query: string, list: T[], valueFn?: (modelFromList: T) => string) {\n    const resultsFuzzy = fuzzy.filter(\n      query,\n      list.map(k => valueFn ? valueFn(k) : k),\n    )\n    const resultsFuzzyKebab = fuzzy.filter(\n      _.kebabCase(query),\n      list.map(k => _.kebabCase((valueFn ? valueFn(k) : k) as any)),\n    )\n    const matches = resultsFuzzy.map((el) => el.string);\n    const matchesKebab = resultsFuzzyKebab.map((el) => el.string);\n\n    const results = (resultsFuzzy.length === 0) ? [] : list.filter(k => {\n      return matches.includes((valueFn ? valueFn(k) : k) as any);\n    })\n\n    if (matches.length === 0 && matchesKebab.length > 0) {\n      const m = list.find(k => _.kebabCase((valueFn ? valueFn(k) : k) as any) === _.first(matchesKebab));\n      results.push(m);\n      matches.push((valueFn ? valueFn(m) : m) as any);\n    }\n\n    return { matches, results };\n  }\n\n}\n"]}

package/browser/esm2020/lib/helpers-environment.mjs

@@ -0,0 +1,21 @@
+import { _, } from 'tnp-core/browser';
+export class HelpersEnvironment {
+    environmentName(filename, local_env_name) {
+    }
+    isValidGitRepuUrl(url) {
+        const regex = /^([A-Za-z0-9]+@|http(|s)\:\/\/)([A-Za-z0-9.]+(:\d+)?)(?::|\/)([\d\/\w.-]+?)(\.git)?$/;
+        const res = regex.test(url);
+        return res;
+    }
+    isValidIp(ip) {
+        if (!_.isString(ip)) {
+            return false;
+        }
+        ip = ip.trim();
+        if (ip === 'localhost') {
+            return true;
+        }
+        return /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(ip);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy1lbnZpcm9ubWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RtcC1saWJzLWZvci1idW5kbGUvdG5wLWhlbHBlcnMvcHJvamVjdHMvdG5wLWhlbHBlcnMvc3JjL2xpYi9oZWxwZXJzLWVudmlyb25tZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBSSxDQUFDLEdBQUksTUFBTSxrQkFBa0IsQ0FBQztBQUd6QyxNQUFNLE9BQU8sa0JBQWtCO0lBRTdCLGVBQWUsQ0FBQyxRQUFRLEVBQUUsY0FBYztJQUV4QyxDQUFDO0lBRUQsaUJBQWlCLENBQUMsR0FBVztRQUMzQixNQUFNLEtBQUssR0FBRyxzRkFBc0YsQ0FBQztRQUNyRyxNQUFNLEdBQUcsR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQzVCLE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQztJQUVELFNBQVMsQ0FBQyxFQUFVO1FBQ2xCLElBQUksQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxFQUFFO1lBQ25CLE9BQU8sS0FBSyxDQUFDO1NBQ2Q7UUFDRCxFQUFFLEdBQUcsRUFBRSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ2YsSUFBSSxFQUFFLEtBQUssV0FBVyxFQUFFO1lBQ3RCLE9BQU8sSUFBSSxDQUFDO1NBQ2I7UUFDRCxPQUFPLGtLQUFrSyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUNwTCxDQUFDO0NBRUYiLCJzb3VyY2VzQ29udGVudCI6WyJcblxuaW1wb3J0IHsgICBfLCAgfSBmcm9tICd0bnAtY29yZS9icm93c2VyJztcblxuXG5leHBvcnQgY2xhc3MgSGVscGVyc0Vudmlyb25tZW50IHtcblxuICBlbnZpcm9ubWVudE5hbWUoZmlsZW5hbWUsIGxvY2FsX2Vudl9uYW1lKSB7XG5cbiAgfVxuXG4gIGlzVmFsaWRHaXRSZXB1VXJsKHVybDogc3RyaW5nKSB7XG4gICAgY29uc3QgcmVnZXggPSAvXihbQS1aYS16MC05XStAfGh0dHAofHMpXFw6XFwvXFwvKShbQS1aYS16MC05Ll0rKDpcXGQrKT8pKD86OnxcXC8pKFtcXGRcXC9cXHcuLV0rPykoXFwuZ2l0KT8kLztcbiAgICBjb25zdCByZXMgPSByZWdleC50ZXN0KHVybCk7XG4gICAgcmV0dXJuIHJlcztcbiAgfVxuXG4gIGlzVmFsaWRJcChpcDogc3RyaW5nKSB7XG4gICAgaWYgKCFfLmlzU3RyaW5nKGlwKSkge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cbiAgICBpcCA9IGlwLnRyaW0oKTtcbiAgICBpZiAoaXAgPT09ICdsb2NhbGhvc3QnKSB7XG4gICAgICByZXR1cm4gdHJ1ZTtcbiAgICB9XG4gICAgcmV0dXJuIC9eKDI1WzAtNV18MlswLTRdWzAtOV18WzAxXT9bMC05XVswLTldPylcXC4oMjVbMC01XXwyWzAtNF1bMC05XXxbMDFdP1swLTldWzAtOV0/KVxcLigyNVswLTVdfDJbMC00XVswLTldfFswMV0/WzAtOV1bMC05XT8pXFwuKDI1WzAtNV18MlswLTRdWzAtOV18WzAxXT9bMC05XVswLTldPykkLy50ZXN0KGlwKVxuICB9XG5cbn1cbiJdfQ==

package/browser/esm2020/lib/helpers-messages.mjs

@@ -0,0 +1,68 @@
+import { Helpers } from './index';
+const KEY = {
+    LAST_ERROR: Symbol(),
+    LAST_INFO: Symbol(),
+    LAST_WARN: Symbol(),
+    LAST_LOG: Symbol(),
+};
+// export class Log {
+//   private static _instance: Log;
+//   public Instance() {
+//     if (!Log._instance) {
+//       Log._instance = new Log();
+//     }
+//     return Log._instance;
+//   }
+//   create(name: string, level?: Level) {
+//     if (level === void 0) {
+//       level = Level.DATA;
+//     }
+//     return {
+//       d(details: string, debugLevel?: number) {
+//         return Helpers.log(`[${name}] ${details}`, debugLevel)
+//       },
+//       i(details: string) {
+//         return Helpers.info(`[${name}] ${details}`)
+//       },
+//       w(details: string, noExit = false, noTrace = false) {
+//         return Helpers.error(`[${name}] ${details}`, noExit, noTrace);
+//       },
+//       er(details: string, ) {
+//         return Helpers.info(`[${name}] ${details}`)
+//       },
+//     }
+//   }
+// }
+export class HelpersMessages {
+    msgCacheClear() {
+        global[KEY.LAST_LOG] = void 0;
+        global[KEY.LAST_WARN] = void 0;
+        global[KEY.LAST_ERROR] = void 0;
+        global[KEY.LAST_INFO] = void 0;
+    }
+    error(details, noExit = false, noTrace = false) {
+        if (Helpers.isBrowser) {
+            console.error(details);
+            return;
+        }
+    }
+    info(details) {
+        if (Helpers.isBrowser) {
+            console.info(details);
+            return;
+        }
+    }
+    log(details, debugLevel = 0) {
+        if (Helpers.isBrowser) {
+            console.log(details);
+            return;
+        }
+    }
+    warn(details, trace = false) {
+        if (Helpers.isBrowser) {
+            console.warn(details);
+            return;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy1tZXNzYWdlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RtcC1saWJzLWZvci1idW5kbGUvdG5wLWhlbHBlcnMvcHJvamVjdHMvdG5wLWhlbHBlcnMvc3JjL2xpYi9oZWxwZXJzLW1lc3NhZ2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFFbEMsTUFBTSxHQUFHLEdBQUc7SUFDVixVQUFVLEVBQUUsTUFBTSxFQUFFO0lBQ3BCLFNBQVMsRUFBRSxNQUFNLEVBQUU7SUFDbkIsU0FBUyxFQUFFLE1BQU0sRUFBRTtJQUNuQixRQUFRLEVBQUUsTUFBTSxFQUFFO0NBQ25CLENBQUE7QUFFRCxxQkFBcUI7QUFDckIsbUNBQW1DO0FBQ25DLHdCQUF3QjtBQUN4Qiw0QkFBNEI7QUFDNUIsbUNBQW1DO0FBQ25DLFFBQVE7QUFDUiw0QkFBNEI7QUFDNUIsTUFBTTtBQUVOLDBDQUEwQztBQUMxQyw4QkFBOEI7QUFDOUIsNEJBQTRCO0FBQzVCLFFBQVE7QUFDUixlQUFlO0FBQ2Ysa0RBQWtEO0FBQ2xELGlFQUFpRTtBQUNqRSxXQUFXO0FBQ1gsNkJBQTZCO0FBQzdCLHNEQUFzRDtBQUN0RCxXQUFXO0FBRVgsOERBQThEO0FBQzlELHlFQUF5RTtBQUN6RSxXQUFXO0FBQ1gsZ0NBQWdDO0FBQ2hDLHNEQUFzRDtBQUN0RCxXQUFXO0FBQ1gsUUFBUTtBQUNSLE1BQU07QUFFTixJQUFJO0FBRUosTUFBTSxPQUFPLGVBQWU7SUFFMUIsYUFBYTtRQUNYLE1BQU0sQ0FBQyxHQUFHLENBQUMsUUFBUSxDQUFDLEdBQUcsS0FBSyxDQUFDLENBQUM7UUFDOUIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsR0FBRyxLQUFLLENBQUMsQ0FBQztRQUMvQixNQUFNLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxHQUFHLEtBQUssQ0FBQyxDQUFDO1FBQ2hDLE1BQU0sQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLEdBQUcsS0FBSyxDQUFDLENBQUM7SUFDakMsQ0FBQztJQUVELEtBQUssQ0FBQyxPQUFZLEVBQUUsTUFBTSxHQUFHLEtBQUssRUFBRSxPQUFPLEdBQUcsS0FBSztRQUNqRCxJQUFJLE9BQU8sQ0FBQyxTQUFTLEVBQUU7WUFDckIsT0FBTyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtZQUN0QixPQUFPO1NBQ1I7SUFFSCxDQUFDO0lBRUQsSUFBSSxDQUFDLE9BQWU7UUFDbEIsSUFBSSxPQUFPLENBQUMsU0FBUyxFQUFFO1lBQ3JCLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDdEIsT0FBTztTQUNSO0lBRUgsQ0FBQztJQUVELEdBQUcsQ0FBQyxPQUFlLEVBQUUsVUFBVSxHQUFHLENBQUM7UUFDakMsSUFBSSxPQUFPLENBQUMsU0FBUyxFQUFFO1lBQ3JCLE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDckIsT0FBTztTQUNSO0lBRUgsQ0FBQztJQUVELElBQUksQ0FBQyxPQUFlLEVBQUUsS0FBSyxHQUFHLEtBQUs7UUFDakMsSUFBSSxPQUFPLENBQUMsU0FBUyxFQUFFO1lBQ3JCLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDdEIsT0FBTztTQUNSO0lBRUgsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiXG5cbmltcG9ydCB7IENvcmVDb25maWcgfSBmcm9tICd0bnAtY29yZS9icm93c2VyJztcbmltcG9ydCB7IFBST0dSRVNTX0RBVEEgfSBmcm9tICd0bnAtbW9kZWxzL2Jyb3dzZXInO1xuaW1wb3J0IHsgSGVscGVycyB9IGZyb20gJy4vaW5kZXgnO1xuXG5jb25zdCBLRVkgPSB7XG4gIExBU1RfRVJST1I6IFN5bWJvbCgpLFxuICBMQVNUX0lORk86IFN5bWJvbCgpLFxuICBMQVNUX1dBUk46IFN5bWJvbCgpLFxuICBMQVNUX0xPRzogU3ltYm9sKCksXG59XG5cbi8vIGV4cG9ydCBjbGFzcyBMb2cge1xuLy8gICBwcml2YXRlIHN0YXRpYyBfaW5zdGFuY2U6IExvZztcbi8vICAgcHVibGljIEluc3RhbmNlKCkge1xuLy8gICAgIGlmICghTG9nLl9pbnN0YW5jZSkge1xuLy8gICAgICAgTG9nLl9pbnN0YW5jZSA9IG5ldyBMb2coKTtcbi8vICAgICB9XG4vLyAgICAgcmV0dXJuIExvZy5faW5zdGFuY2U7XG4vLyAgIH1cblxuLy8gICBjcmVhdGUobmFtZTogc3RyaW5nLCBsZXZlbD86IExldmVsKSB7XG4vLyAgICAgaWYgKGxldmVsID09PSB2b2lkIDApIHtcbi8vICAgICAgIGxldmVsID0gTGV2ZWwuREFUQTtcbi8vICAgICB9XG4vLyAgICAgcmV0dXJuIHtcbi8vICAgICAgIGQoZGV0YWlsczogc3RyaW5nLCBkZWJ1Z0xldmVsPzogbnVtYmVyKSB7XG4vLyAgICAgICAgIHJldHVybiBIZWxwZXJzLmxvZyhgWyR7bmFtZX1dICR7ZGV0YWlsc31gLCBkZWJ1Z0xldmVsKVxuLy8gICAgICAgfSxcbi8vICAgICAgIGkoZGV0YWlsczogc3RyaW5nKSB7XG4vLyAgICAgICAgIHJldHVybiBIZWxwZXJzLmluZm8oYFske25hbWV9XSAke2RldGFpbHN9YClcbi8vICAgICAgIH0sXG5cbi8vICAgICAgIHcoZGV0YWlsczogc3RyaW5nLCBub0V4aXQgPSBmYWxzZSwgbm9UcmFjZSA9IGZhbHNlKSB7XG4vLyAgICAgICAgIHJldHVybiBIZWxwZXJzLmVycm9yKGBbJHtuYW1lfV0gJHtkZXRhaWxzfWAsIG5vRXhpdCwgbm9UcmFjZSk7XG4vLyAgICAgICB9LFxuLy8gICAgICAgZXIoZGV0YWlsczogc3RyaW5nLCApIHtcbi8vICAgICAgICAgcmV0dXJuIEhlbHBlcnMuaW5mbyhgWyR7bmFtZX1dICR7ZGV0YWlsc31gKVxuLy8gICAgICAgfSxcbi8vICAgICB9XG4vLyAgIH1cblxuLy8gfVxuXG5leHBvcnQgY2xhc3MgSGVscGVyc01lc3NhZ2VzIHtcblxuICBtc2dDYWNoZUNsZWFyKCkge1xuICAgIGdsb2JhbFtLRVkuTEFTVF9MT0ddID0gdm9pZCAwO1xuICAgIGdsb2JhbFtLRVkuTEFTVF9XQVJOXSA9IHZvaWQgMDtcbiAgICBnbG9iYWxbS0VZLkxBU1RfRVJST1JdID0gdm9pZCAwO1xuICAgIGdsb2JhbFtLRVkuTEFTVF9JTkZPXSA9IHZvaWQgMDtcbiAgfVxuXG4gIGVycm9yKGRldGFpbHM6IGFueSwgbm9FeGl0ID0gZmFsc2UsIG5vVHJhY2UgPSBmYWxzZSkge1xuICAgIGlmIChIZWxwZXJzLmlzQnJvd3Nlcikge1xuICAgICAgY29uc29sZS5lcnJvcihkZXRhaWxzKVxuICAgICAgcmV0dXJuO1xuICAgIH1cblxuICB9XG5cbiAgaW5mbyhkZXRhaWxzOiBzdHJpbmcpIHtcbiAgICBpZiAoSGVscGVycy5pc0Jyb3dzZXIpIHtcbiAgICAgIGNvbnNvbGUuaW5mbyhkZXRhaWxzKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgfVxuXG4gIGxvZyhkZXRhaWxzOiBzdHJpbmcsIGRlYnVnTGV2ZWwgPSAwKSB7XG4gICAgaWYgKEhlbHBlcnMuaXNCcm93c2VyKSB7XG4gICAgICBjb25zb2xlLmxvZyhkZXRhaWxzKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgfVxuXG4gIHdhcm4oZGV0YWlsczogc3RyaW5nLCB0cmFjZSA9IGZhbHNlKSB7XG4gICAgaWYgKEhlbHBlcnMuaXNCcm93c2VyKSB7XG4gICAgICBjb25zb2xlLndhcm4oZGV0YWlscyk7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gIH1cbn1cbiJdfQ==