tnp-helpers 0.0.67 → 13.0.2

package/client/fesm2015/tnp-helpers.mjs

@@ -0,0 +1,936 @@
+import { __awaiter } from 'tslib';
+import { _, CoreHelpers } from 'tnp-core/browser';
+import * as fuzzy from 'fuzzy';
+import { CLASS } from 'typescript-class-helpers/browser';
+import { Morphi } from 'morphi/browser';
+import { config } from 'tnp-config/browser';
+import * as i0 from '@angular/core';
+import { Component, Input, EventEmitter, Output, Injectable, Directive, HostBinding, HostListener } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { FieldType } from '@ngx-formly/core';
+import { Log, Level } from 'ng2-logger/browser';
+import * as elementResizeDetectorMaker from 'element-resize-detector';
+
+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 };
+    }
+}
+
+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}`)
+//       },
+//     }
+//   }
+// }
+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;
+        }
+    }
+}
+
+class HelpersStringsRegexes {
+    escapeStringForRegEx(s) {
+        return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+    matchExactOnce(s, regex) {
+        if (!_.isString(s) || !_.isRegExp(regex)) {
+            return void 0;
+        }
+        const result = s.match(regex);
+        if (_.isNil(result)) {
+            return void 0;
+        }
+        return result.length >= 1 ? _.first(result) : void 0;
+    }
+    get regex() {
+        return {
+            /**
+           * mathes
+           * xxx.xxx.xxx.xxx
+           * xxx.xxx.xxx.xxx:port
+           * http://xxx.xxx.xxx.xxx:port
+           * http://xxx.xxx.xxx.xxx
+           * https://xxx.xxx.xxx.xxx:port
+           * https://xxx.xxx.xxx.xxx   *
+           */
+            get forStringWithIpHost() {
+                const regex = /(http(s)?\:\/\/)?(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]?)(\:[0-9]+)?/;
+                return regex;
+            },
+            /**
+          * mathes
+          * http://domain.com:port
+          * http://domain.com
+          * http://domain:port
+          * http://domain
+          * https://domain.com:port
+          * https://domain.com
+          * https://domain:port
+          * https://domain
+          */
+            get forStringWithDomainHost() {
+                const regex = /(((http(s)?\:\/\/)?[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0-9](?:\.[a-zA-Z]{2,})+(\:[0-9]+)?)|((http(s)?\:\/\/)[a-zA-Z0-9-]{1,61}))/;
+                return regex;
+            }
+        };
+    }
+}
+
+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);
+    }
+}
+
+class HelpersStrings {
+    /**
+     * Example:
+     *
+     * const result = interpolateString("I'm {age} years old!")
+     * .withParameters({ age: 29 });
+     *
+     * const result = interpolateString("The {a} says {n}, {n}, {n}!")
+     * .withParameters({ a: 'cow', n: 'moo' });
+     *
+     *
+     * @param value string to interpolate
+     * @param parameters object with parametes
+     */
+    interpolateString(value) {
+        if (typeof value !== 'string') {
+            console.warn('[ss-logic][helper] Value for interpolation is not string: ', value);
+            return value;
+        }
+        return {
+            withParameters(parameters) {
+                if (typeof parameters !== 'object') {
+                    console.warn('[ss-logic][helper] Parameters are not a object: ', parameters);
+                    return value;
+                }
+                return value.replace(/{([^{}]*)}/g, function (a, b) {
+                    var r = parameters[b];
+                    return typeof r === 'string' || typeof r === 'number' ? r : a;
+                });
+            }
+        };
+    }
+    numValue(pixelsCss) {
+        // tslint:disable-next-line:radix
+        return parseInt(pixelsCss.replace('px', ''));
+    }
+    /**
+     * examples:
+     * 'aa bb bb' => ['aa','bb','cc'],
+     * 'aa' => ['aa']
+     * ['aa'] => ['aa']
+     */
+    splitIfNeed(stringOrArr) {
+        let res = [];
+        if (_.isArray(stringOrArr)) {
+            res = stringOrArr.map(s => {
+                return s.trim();
+            });
+        }
+        if (_.isString(stringOrArr)) {
+            res = stringOrArr.split(/\s*[\s,]\s*/);
+        }
+        return res.filter(f => !!f && (f.trim() !== ''));
+    }
+    removeDoubleOrMoreEmptyLines(s) {
+        s = s === null || s === void 0 ? void 0 : s.split('\n').map(f => f.trimRight()).join('\n');
+        return s === null || s === void 0 ? void 0 : s.replace(/(\r\n|\r|\n){2,}/g, '$1\n');
+    }
+}
+
+function conditionWait(conditionAndTimeout) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield waitFor(conditionAndTimeout);
+    });
+}
+function waitFor(arr, messageToShow = void 0) {
+    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        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 = yield Helpers.runSyncOrAsync(check.callback, check);
+            // console.log(`after: ${name}`)
+            if (resultTrue) {
+                // console.log(`timeout 1 is set to ${timeoutNext}`)
+                setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    // console.log(`timeout 1 is over`)
+                    yield 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(() => __awaiter(this, void 0, void 0, function* () {
+                    // console.log(`timeout 2 ${timeoutCheck} ovef`)
+                    yield waitFor(arr, check.errorMessage).then(() => {
+                        resolve(void 0);
+                    });
+                }), timeoutCheck);
+            }
+        }
+    }));
+}
+
+function applyMixins(derivedCtor, baseCtors) {
+    baseCtors.forEach(baseCtor => {
+        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
+            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
+        });
+    });
+}
+// @ts-ignore
+class HelpersTnp extends CoreHelpers {
+    constructor(arrays = new HelpersArrayObj(), strings = new HelpersStrings()) {
+        super();
+        this.arrays = arrays;
+        this.strings = strings;
+        this.conditionWait = conditionWait;
+        this.applyMixins = applyMixins;
+    }
+    static get Instance() {
+        if (!HelpersTnp._instance) {
+            HelpersTnp._instance = new HelpersTnp();
+        }
+        return HelpersTnp._instance;
+    }
+    CLIWRAP(f, name) {
+        CLASS.setName(f, name);
+        return f;
+    }
+    isElevated() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    mesureExectionInMs(description, functionToExecute, ...functionArguments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var start = new Date();
+            yield Helpers.runSyncOrAsync(functionToExecute, ...functionArguments);
+            //@ts-ignore
+            var end = new Date() - start;
+            if (Morphi.IsBrowser) {
+                Helpers.info(`Execution time: ${end.toString()}ms for "${description}"`);
+            }
+            return end;
+        });
+    }
+    mesureExectionInMsSync(description, functionToExecute) {
+        var start = new Date();
+        functionToExecute();
+        //@ts-ignore
+        var end = new Date() - start;
+        if (Morphi.IsBrowser) {
+            Helpers.info(`Execution time: ${end.toString()}ms for "${description}"`);
+        }
+        return end;
+    }
+    waitForCondition(conditionFn, howOfftenCheckInMs = 1000) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield Helpers.runSyncOrAsync(conditionFn);
+            if (result) {
+                resolve(void 0);
+            }
+            else {
+                setTimeout(() => {
+                    Helpers.waitForCondition(conditionFn, howOfftenCheckInMs).then(() => {
+                        resolve(void 0);
+                    });
+                }, howOfftenCheckInMs);
+            }
+        }));
+    }
+    getBrowserVerPath(moduleName) {
+    }
+    getMethodName(obj, method) {
+        var methodName = null;
+        Object.getOwnPropertyNames(obj).forEach(prop => {
+            if (obj[prop] === method) {
+                methodName = prop;
+            }
+        });
+        if (methodName !== null) {
+            return methodName;
+        }
+        var proto = Object.getPrototypeOf(obj);
+        if (proto) {
+            return Helpers.getMethodName(proto, method);
+        }
+        return null;
+    }
+    fixWebpackEnv(env) {
+        _.forIn(env, (v, k) => {
+            const value = v;
+            if (value === 'true')
+                env[k] = true;
+            if (value === 'false')
+                env[k] = false;
+        });
+    }
+}
+applyMixins(HelpersTnp, [
+    HelpersMessages,
+    HelpersStringsRegexes,
+    HelpersEnvironment,
+]);
+
+const BaselineSiteJoinprefix = '__';
+
+const Helpers$1 = HelpersTnp.Instance;
+class Project {
+    constructor() {
+        this.cache = {};
+        this.browser = {};
+    }
+    static typeFrom(location) {
+        return (void 0);
+    }
+    static unload(project) {
+        Project.projects = Project.projects.filter(f => f !== project);
+    }
+    static From(location) {
+        return (void 0);
+    }
+    static nearestTo(absoluteLocation, options) {
+        return (void 0);
+    }
+    static allProjectFrom(absoluteLocation, stopOnCwd = '/') {
+        return (void 0);
+    }
+    static DefaultPortByType(type) {
+        if (type === 'workspace') {
+            return 5000;
+        }
+        if (type === 'angular-client') {
+            return 4300;
+        }
+        if (type === 'angular-lib') {
+            return 4250;
+        }
+        if (type === 'electron-client') {
+            return 4350;
+        }
+        if (type === 'ionic-client') {
+            return 8080;
+        }
+        if (type === 'docker') {
+            return 5000;
+        }
+        if (type === 'isomorphic-lib') {
+            return 4000;
+        }
+        if (type === 'container' || type === 'unknow-npm-project') {
+            return;
+        }
+    }
+    static get isBundleMode() {
+        if (Helpers$1.isBrowser) {
+            return true;
+        }
+    }
+    static get Current() {
+        return (void 0);
+    }
+    static get Tnp() {
+        return (void 0);
+    }
+    static by(libraryType, version) {
+        return (void 0);
+    }
+    defineProperty(variableName, classFn) {
+        return (void 0);
+    }
+    setType(type) {
+        // @ts-ignore
+        this._type = type;
+    }
+    typeIs(...types) {
+        return this._type && types.includes(this._type);
+    }
+    typeIsNot(...types) {
+        return !this.typeIs(...types);
+    }
+    forEmptyStructure() {
+        return [
+            { relativePath: config.file.package_json, includeContent: true },
+            { relativePath: config.folder.src },
+        ];
+    }
+}
+Project.projects = [];
+/**
+ * To speed up checking folder I am keeping pathes for alterdy checked folder
+ * This may break things that are creating new projects
+ */
+Project.emptyLocations = [];
+
+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();
+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;
+                }
+            }
+        }));
+    }
+}
+
+const log$2 = Log.create(`DualComponentController`);
+class DualComponentController {
+    constructor(cmp, isFormlyMode = false) {
+        this.cmp = cmp;
+        this.isFormlyMode = isFormlyMode;
+    }
+    getValTemplateOptions(propertyName) {
+        var _a;
+        if (this.isFormlyMode) {
+            const res = (_a = this.cmp.field) === null || _a === void 0 ? void 0 : _a.templateOptions[propertyName];
+            if (res === void 0 && this.cmp[propertyName]) {
+                return this.cmp[propertyName];
+            }
+            return res;
+        }
+        return this.cmp[propertyName];
+    }
+    getValContext(propertyName) {
+        var _a;
+        if (this.isFormlyMode) {
+            const res = (_a = this.cmp) === null || _a === void 0 ? void 0 : _a.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$2.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;
+        }
+    }
+}
+
+const log$1 = Log.create('base formly component', Level.__NOTHING);
+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$1.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
+            }] } });
+
+class ResizeService {
+    constructor() {
+        this.resizeDetector = elementResizeDetectorMaker({ strategy: 'scroll' });
+    }
+    addResizeEventListener(element, handler) {
+        this.resizeDetector.listenTo(element, handler);
+    }
+    removeResizeEventListener(element) {
+        this.resizeDetector.uninstall(element);
+    }
+}
+ResizeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: ResizeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: ResizeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: ResizeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+
+const log = Log.create(`[tnp-helpers] long-press`, Level.__NOTHING);
+class LongPress {
+    constructor() {
+        this.pressDuration = 1000;
+        this.onLongPress = new EventEmitter();
+        this.onLongPressing = new EventEmitter();
+        this.onLongPressEnd = new EventEmitter();
+        this.mouseX = 0;
+        this.mouseY = 0;
+        this.allowTrigger = false;
+        this.triggerEnd = _.debounce(() => {
+            this.endPress();
+        }, 500);
+    }
+    get press() { return this.pressing; }
+    get longPress() { return this.longPressing; }
+    onMouseDown(event) {
+        // don't do right/middle clicks
+        log.d(`MOUSE DOWN `);
+        if (event.which !== 1)
+            return;
+        this.allowTrigger = true;
+        this.mouseX = event.clientX;
+        this.mouseY = event.clientY;
+        this.pressing = true;
+        this.longPressing = false;
+        this.timeout = setTimeout(() => {
+            if (this.allowTrigger) {
+                this.longPressing = true;
+                log.d(`long pressing start  pressDuration:${this.pressDuration} `);
+                this.onLongPress.emit(event);
+                this.loop(event);
+            }
+        }, this.pressDuration);
+        this.loop(event);
+    }
+    onMouseMove(event) {
+        if (this.pressing && !this.longPressing) {
+            const xThres = (event.clientX - this.mouseX) > 10;
+            const yThres = (event.clientY - this.mouseY) > 10;
+            if (xThres || yThres) {
+                this.endPress();
+            }
+        }
+    }
+    loop(event) {
+        if (this.longPressing) {
+            this.timeout = setTimeout(() => {
+                log.d(`emil longpressing`);
+                this.triggerEnd();
+                this.onLongPressing.emit(event);
+                this.loop(event);
+            }, 50);
+        }
+    }
+    endPress(emit = true) {
+        this.allowTrigger = false;
+        clearTimeout(this.timeout);
+        this.longPressing = false;
+        this.pressing = false;
+        if (emit) {
+            log.d(`EMIT END`);
+            this.onLongPressEnd.emit(true);
+        }
+        else {
+            log.d(`NOT EMIT END`);
+        }
+    }
+    onMouseUp() {
+        this.endPress(false);
+    }
+}
+LongPress.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: LongPress, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+LongPress.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.4", type: LongPress, selector: "[long-press]", inputs: { pressDuration: "pressDuration" }, outputs: { onLongPress: "onLongPress", onLongPressing: "onLongPressing", onLongPressEnd: "onLongPressEnd" }, host: { listeners: { "mousedown": "onMouseDown($event)", "mousemove": "onMouseMove($event)", "mouseup": "onMouseUp()" }, properties: { "class.press": "this.press", "class.longpress": "this.longPress" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: LongPress, decorators: [{
+            type: Directive,
+            args: [{ selector: '[long-press]' }]
+        }], propDecorators: { pressDuration: [{
+                type: Input
+            }], onLongPress: [{
+                type: Output
+            }], onLongPressing: [{
+                type: Output
+            }], onLongPressEnd: [{
+                type: Output
+            }], press: [{
+                type: HostBinding,
+                args: ['class.press']
+            }], longPress: [{
+                type: HostBinding,
+                args: ['class.longpress']
+            }], onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], onMouseMove: [{
+                type: HostListener,
+                args: ['mousemove', ['$event']]
+            }], onMouseUp: [{
+                type: HostListener,
+                args: ['mouseup']
+            }] } });
+
+// export * from './git-project';
+const Helpers = HelpersTnp.Instance;
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BaseComponent, BaseComponentForRouter, BaseFormlyComponent, BaselineSiteJoinprefix, DualComponentController, Helpers, LongPress, Project, ResizeService };
+//# sourceMappingURL=tnp-helpers.mjs.map