@infrab4a/connect 4.1.7-beta.0 → 4.2.0-beta.1

package/esm2020/utils/get.mjs

@@ -0,0 +1,3 @@
+import { get as getLodash } from 'lodash';
+export const get = (object, path, defaultValue) => getLodash(object, path, defaultValue);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY29ubmVjdC9zcmMvdXRpbHMvZ2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxHQUFHLElBQUksU0FBUyxFQUFFLE1BQU0sUUFBUSxDQUFBO0FBRXpDLE1BQU0sQ0FBQyxNQUFNLEdBQUcsR0FBRyxDQUFDLE1BQVcsRUFBRSxJQUFZLEVBQUUsWUFBa0IsRUFBRSxFQUFFLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxJQUFJLEVBQUUsWUFBWSxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBnZXQgYXMgZ2V0TG9kYXNoIH0gZnJvbSAnbG9kYXNoJ1xuXG5leHBvcnQgY29uc3QgZ2V0ID0gKG9iamVjdDogYW55LCBwYXRoOiBzdHJpbmcsIGRlZmF1bHRWYWx1ZT86IGFueSkgPT4gZ2V0TG9kYXNoKG9iamVjdCwgcGF0aCwgZGVmYXVsdFZhbHVlKVxuIl19

package/esm2020/utils/helpers/class-name.helper.mjs

@@ -0,0 +1,15 @@
+import { compact, get } from 'lodash';
+export class ClassNameHelper {
+    static get(clazz) {
+        if (!clazz)
+            return null;
+        const prototype = Object.getPrototypeOf(clazz);
+        const names = compact([
+            get(clazz, 'constructor.name'),
+            get(prototype, 'constructor.name'),
+            get(prototype, '__proto__.constructor.name'),
+        ]);
+        return names.find((name) => name !== 'class_1');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3MtbmFtZS5oZWxwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy91dGlscy9oZWxwZXJzL2NsYXNzLW5hbWUuaGVscGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sUUFBUSxDQUFBO0FBRXJDLE1BQU0sT0FBTyxlQUFlO0lBQzFCLE1BQU0sQ0FBQyxHQUFHLENBQUMsS0FBVTtRQUNuQixJQUFJLENBQUMsS0FBSztZQUFFLE9BQU8sSUFBSSxDQUFBO1FBRXZCLE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDOUMsTUFBTSxLQUFLLEdBQUcsT0FBTyxDQUFDO1lBQ3BCLEdBQUcsQ0FBQyxLQUFLLEVBQUUsa0JBQWtCLENBQUM7WUFDOUIsR0FBRyxDQUFDLFNBQVMsRUFBRSxrQkFBa0IsQ0FBQztZQUNsQyxHQUFHLENBQUMsU0FBUyxFQUFFLDRCQUE0QixDQUFDO1NBQzdDLENBQUMsQ0FBQTtRQUVGLE9BQU8sS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsSUFBSSxLQUFLLFNBQVMsQ0FBQyxDQUFBO0lBQ2pELENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNvbXBhY3QsIGdldCB9IGZyb20gJ2xvZGFzaCdcblxuZXhwb3J0IGNsYXNzIENsYXNzTmFtZUhlbHBlciB7XG4gIHN0YXRpYyBnZXQoY2xheno6IGFueSk6IHN0cmluZyB7XG4gICAgaWYgKCFjbGF6eikgcmV0dXJuIG51bGxcblxuICAgIGNvbnN0IHByb3RvdHlwZSA9IE9iamVjdC5nZXRQcm90b3R5cGVPZihjbGF6eilcbiAgICBjb25zdCBuYW1lcyA9IGNvbXBhY3QoW1xuICAgICAgZ2V0KGNsYXp6LCAnY29uc3RydWN0b3IubmFtZScpLFxuICAgICAgZ2V0KHByb3RvdHlwZSwgJ2NvbnN0cnVjdG9yLm5hbWUnKSxcbiAgICAgIGdldChwcm90b3R5cGUsICdfX3Byb3RvX18uY29uc3RydWN0b3IubmFtZScpLFxuICAgIF0pXG5cbiAgICByZXR1cm4gbmFtZXMuZmluZCgobmFtZSkgPT4gbmFtZSAhPT0gJ2NsYXNzXzEnKVxuICB9XG59XG4iXX0=

package/esm2020/utils/helpers/debug-decorator.helper.mjs

@@ -0,0 +1,18 @@
+import { ReflectHelper } from './reflect.helper';
+export class DebugDecoratorHelper {
+    static set(target, options) {
+        ReflectHelper.add({
+            key: DebugDecoratorHelper.DebugNamingMetadataKey,
+            target,
+            value: options,
+        });
+    }
+    static get(target) {
+        return ReflectHelper.first({
+            key: DebugDecoratorHelper.DebugNamingMetadataKey,
+            target,
+        });
+    }
+}
+DebugDecoratorHelper.DebugNamingMetadataKey = 'model:naming:decorator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVidWctZGVjb3JhdG9yLmhlbHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL3V0aWxzL2hlbHBlcnMvZGVidWctZGVjb3JhdG9yLmhlbHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sa0JBQWtCLENBQUE7QUFPaEQsTUFBTSxPQUFPLG9CQUFvQjtJQUcvQixNQUFNLENBQUMsR0FBRyxDQUFDLE1BQWMsRUFBRSxPQUFxQjtRQUM5QyxhQUFhLENBQUMsR0FBRyxDQUFlO1lBQzlCLEdBQUcsRUFBRSxvQkFBb0IsQ0FBQyxzQkFBc0I7WUFDaEQsTUFBTTtZQUNOLEtBQUssRUFBRSxPQUFPO1NBQ2YsQ0FBQyxDQUFBO0lBQ0osQ0FBQztJQUVELE1BQU0sQ0FBQyxHQUFHLENBQUMsTUFBYztRQUN2QixPQUFPLGFBQWEsQ0FBQyxLQUFLLENBQWU7WUFDdkMsR0FBRyxFQUFFLG9CQUFvQixDQUFDLHNCQUFzQjtZQUNoRCxNQUFNO1NBQ1AsQ0FBQyxDQUFBO0lBQ0osQ0FBQzs7QUFmTSwyQ0FBc0IsR0FBRyx3QkFBd0IsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlZmxlY3RIZWxwZXIgfSBmcm9tICcuL3JlZmxlY3QuaGVscGVyJ1xuXG5leHBvcnQgdHlwZSBEZWJ1Z09wdGlvbnMgPSB7XG4gIG5hbWU/OiBzdHJpbmdcbiAgbmFtZXNwYWNlcz86IEFycmF5PHN0cmluZz5cbn1cblxuZXhwb3J0IGNsYXNzIERlYnVnRGVjb3JhdG9ySGVscGVyIHtcbiAgc3RhdGljIERlYnVnTmFtaW5nTWV0YWRhdGFLZXkgPSAnbW9kZWw6bmFtaW5nOmRlY29yYXRvcidcblxuICBzdGF0aWMgc2V0KHRhcmdldDogb2JqZWN0LCBvcHRpb25zOiBEZWJ1Z09wdGlvbnMpOiB2b2lkIHtcbiAgICBSZWZsZWN0SGVscGVyLmFkZDxEZWJ1Z09wdGlvbnM+KHtcbiAgICAgIGtleTogRGVidWdEZWNvcmF0b3JIZWxwZXIuRGVidWdOYW1pbmdNZXRhZGF0YUtleSxcbiAgICAgIHRhcmdldCxcbiAgICAgIHZhbHVlOiBvcHRpb25zLFxuICAgIH0pXG4gIH1cblxuICBzdGF0aWMgZ2V0KHRhcmdldDogb2JqZWN0KTogRGVidWdPcHRpb25zIHtcbiAgICByZXR1cm4gUmVmbGVjdEhlbHBlci5maXJzdDxEZWJ1Z09wdGlvbnM+KHtcbiAgICAgIGtleTogRGVidWdEZWNvcmF0b3JIZWxwZXIuRGVidWdOYW1pbmdNZXRhZGF0YUtleSxcbiAgICAgIHRhcmdldCxcbiAgICB9KVxuICB9XG59XG4iXX0=

package/esm2020/utils/helpers/debug.helper.mjs

@@ -0,0 +1,150 @@
+import { compact, flatten, get, isNil } from 'lodash';
+import { Subject } from 'rxjs';
+import { DebugNamespaces, Logger } from '../log.utils';
+import { DebugDecoratorHelper } from './debug-decorator.helper';
+import { ClassNameHelper } from './class-name.helper';
+export const isDebuggable = (object) => {
+    return 'debug' in object;
+};
+export class DebugHelper {
+    constructor(...namespace) {
+        this.namespaces = new Set();
+        this.push(...namespace);
+    }
+    static namespacesFor(target) {
+        if (isNil(target))
+            return [];
+        const decorator = DebugDecoratorHelper.get(Object.getPrototypeOf(target));
+        const namespaces = get(decorator, 'namespaces', []);
+        const name = get(decorator, 'name', ClassNameHelper.get(target));
+        return [...namespaces, name];
+    }
+    static as(...namespaces) {
+        return new DebugHelper(...namespaces);
+    }
+    static for(target, ...namespaces) {
+        const targetNamespaces = this.namespacesFor(target);
+        return new DebugHelper(...targetNamespaces, ...namespaces);
+    }
+    static from(target, ...namespaces) {
+        if (this.isDebuggable(target)) {
+            const debug = target.debug;
+            if (namespaces)
+                debug.push(...namespaces);
+            return debug;
+        }
+        return DebugHelper.for(target, ...namespaces);
+    }
+    static clonedFrom(target, ...namespaces) {
+        if (this.isDebuggable(target)) {
+            namespaces.push(...target.debug.entries);
+        }
+        else if (!isNil(target)) {
+            namespaces.push(...this.namespacesFor(target));
+        }
+        return DebugHelper.for(target, ...namespaces);
+    }
+    static clone(target, ...namespaces) {
+        let original;
+        if (this.isDebuggable(target)) {
+            original = target.debug;
+            namespaces.push(...original.entries);
+        }
+        return {
+            original,
+            debug: DebugHelper.for(target, ...namespaces),
+        };
+    }
+    static replace(target, attrs) {
+        if (this.isDebuggable(target))
+            target.debug = attrs.with;
+    }
+    static mock(target, ...namespaces) {
+        const { original, debug } = DebugHelper.clone(target, ...namespaces);
+        DebugHelper.replace(target, { with: debug });
+        return { original, debug };
+    }
+    get entries() {
+        return Array.from(get(this, 'namespaces', []));
+    }
+    get namespace() {
+        return compact(flatten(this.entries)).join(':');
+    }
+    log(message, ...args) {
+        this.logger(JSON.stringify(message), ...args.map((element) => JSON.stringify(element)));
+        DebugHelper.logs$.next({ namespace: this.namespace, message, args });
+        return this;
+    }
+    trace(message, ...args) {
+        this.logger.extend(DebugNamespaces.TRACE)(message, ...args);
+        DebugHelper.traces$.next({ namespace: this.namespace, message, args });
+        return this;
+    }
+    error(error, ...args) {
+        this.logger.extend(DebugNamespaces.ERROR)(JSON.stringify(error), ...args.map((element) => JSON.stringify(element)));
+        DebugHelper.errors$.next({ namespace: this.namespace, error, args });
+        return this;
+    }
+    build() {
+        this.logger = Logger;
+        this.tracer = Logger;
+        this.err = Logger;
+        this.entries.forEach((namespace) => {
+            this.logger = this.logger.extend(namespace);
+            this.tracer = this.tracer.extend(namespace);
+            this.err = this.err.extend(namespace);
+        });
+        return this;
+    }
+    with(...namespace) {
+        return new DebugHelper(...this.entries, ...namespace);
+    }
+    push(...namespace) {
+        if (namespace) {
+            namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.add(item));
+        }
+        return this.build();
+    }
+    unshift(...namespace) {
+        if (namespace) {
+            return this.reset(...namespace, ...this.entries);
+        }
+        return this;
+    }
+    reset(...namespace) {
+        this.namespaces = new Set(flatten(compact(namespace)));
+        return this.build();
+    }
+    startWith(...namespace) {
+        const current = this.namespaces;
+        this.namespaces = new Set(flatten([compact(namespace), ...current]));
+        return this.build();
+    }
+    shift() {
+        const list = this.entries;
+        list.shift();
+        return this.reset(...list);
+    }
+    pop() {
+        const list = this.entries;
+        list.pop();
+        return this.reset(...list);
+    }
+    clear() {
+        return this.reset();
+    }
+    remove(...namespace) {
+        if (namespace) {
+            namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.delete(item));
+        }
+        return this.build();
+    }
+    puts(...args) {
+        return [`[${this.namespace}]`, ...args].join(' ');
+    }
+}
+DebugHelper.logs$ = new Subject();
+DebugHelper.traces$ = new Subject();
+DebugHelper.errors$ = new Subject();
+DebugHelper.isDebuggable = isDebuggable;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"debug.helper.js","sourceRoot":"","sources":["../../../../../projects/connect/src/utils/helpers/debug.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Debugger } from 'debug'\nimport { compact, flatten, get, isNil } from 'lodash'\nimport { Subject } from 'rxjs'\n\nimport { DebugNamespaces, Logger } from '../log.utils'\n\nimport { DebugDecoratorHelper } from './debug-decorator.helper'\nimport { ClassNameHelper } from './class-name.helper'\n\nexport type Debuggable = {\n  debug: DebugHelper\n}\n\ntype DebugLog = {\n  namespace: string\n  message: string\n  args: Array<any>\n}\n\ntype DebugError = {\n  namespace: string\n  error: any\n  args: Array<any>\n}\n\nexport const isDebuggable = (object: any): object is Debuggable => {\n  return 'debug' in object\n}\n\nexport class DebugHelper {\n  static logs$ = new Subject<DebugLog>()\n  static traces$ = new Subject<DebugLog>()\n  static errors$ = new Subject<DebugError>()\n  static isDebuggable = isDebuggable\n\n  static namespacesFor(target: object): Array<string> {\n    if (isNil(target)) return []\n\n    const decorator = DebugDecoratorHelper.get(Object.getPrototypeOf(target))\n    const namespaces = get(decorator, 'namespaces', [])\n    const name = get(decorator, 'name', ClassNameHelper.get(target))\n\n    return [...namespaces, name]\n  }\n\n  static as(...namespaces: Array<string>): DebugHelper {\n    return new DebugHelper(...namespaces)\n  }\n\n  static for(target: object, ...namespaces: Array<string>): DebugHelper {\n    const targetNamespaces = this.namespacesFor(target)\n\n    return new DebugHelper(...targetNamespaces, ...namespaces)\n  }\n\n  static from(target: object, ...namespaces: Array<string>): DebugHelper {\n    if (this.isDebuggable(target)) {\n      const debug = target.debug\n\n      if (namespaces) debug.push(...namespaces)\n\n      return debug\n    }\n\n    return DebugHelper.for(target, ...namespaces)\n  }\n\n  static clonedFrom(target: object, ...namespaces: Array<string>): DebugHelper {\n    if (this.isDebuggable(target)) {\n      namespaces.push(...target.debug.entries)\n    } else if (!isNil(target)) {\n      namespaces.push(...this.namespacesFor(target))\n    }\n\n    return DebugHelper.for(target, ...namespaces)\n  }\n\n  static clone(target: object, ...namespaces: Array<string>): { original: DebugHelper; debug: DebugHelper } {\n    let original: DebugHelper\n\n    if (this.isDebuggable(target)) {\n      original = target.debug\n      namespaces.push(...original.entries)\n    }\n\n    return {\n      original,\n      debug: DebugHelper.for(target, ...namespaces),\n    }\n  }\n\n  static replace(target: any, attrs: { with: DebugHelper }): void {\n    if (this.isDebuggable(target)) target.debug = attrs.with\n  }\n\n  static mock(target: object, ...namespaces: Array<string>): { original: DebugHelper; debug: DebugHelper } {\n    const { original, debug } = DebugHelper.clone(target, ...namespaces)\n\n    DebugHelper.replace(target, { with: debug })\n\n    return { original, debug }\n  }\n\n  logger: Debugger\n  tracer: Debugger\n  err: Debugger\n  namespaces: Set<string>\n\n  constructor(...namespace: Array<string>) {\n    this.namespaces = new Set<string>()\n    this.push(...namespace)\n  }\n\n  get entries(): Array<string> {\n    return Array.from(get(this, 'namespaces', []))\n  }\n\n  get namespace(): string {\n    return compact(flatten(this.entries)).join(':')\n  }\n\n  log(message?: any, ...args: Array<any>): DebugHelper {\n    this.logger(JSON.stringify(message), ...args.map((element) => JSON.stringify(element)))\n    DebugHelper.logs$.next({ namespace: this.namespace, message, args })\n\n    return this\n  }\n\n  trace(message?: any, ...args: Array<any>): DebugHelper {\n    this.logger.extend(DebugNamespaces.TRACE)(message, ...args)\n    DebugHelper.traces$.next({ namespace: this.namespace, message, args })\n\n    return this\n  }\n\n  error(error: any, ...args: Array<any>): DebugHelper {\n    this.logger.extend(DebugNamespaces.ERROR)(JSON.stringify(error), ...args.map((element) => JSON.stringify(element)))\n    DebugHelper.errors$.next({ namespace: this.namespace, error, args })\n\n    return this\n  }\n\n  build(): DebugHelper {\n    this.logger = Logger\n    this.tracer = Logger\n    this.err = Logger\n\n    this.entries.forEach((namespace) => {\n      this.logger = this.logger.extend(namespace)\n      this.tracer = this.tracer.extend(namespace)\n      this.err = this.err.extend(namespace)\n    })\n\n    return this\n  }\n\n  with(...namespace: Array<string>): DebugHelper {\n    return new DebugHelper(...this.entries, ...namespace)\n  }\n\n  push(...namespace: Array<string>): DebugHelper {\n    if (namespace) {\n      namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.add(item))\n    }\n\n    return this.build()\n  }\n\n  unshift(...namespace: Array<string>): DebugHelper {\n    if (namespace) {\n      return this.reset(...namespace, ...this.entries)\n    }\n\n    return this\n  }\n\n  reset(...namespace: Array<string>): DebugHelper {\n    this.namespaces = new Set(flatten(compact(namespace)))\n\n    return this.build()\n  }\n\n  startWith(...namespace: Array<string>): DebugHelper {\n    const current = this.namespaces\n\n    this.namespaces = new Set(flatten([compact(namespace), ...current]))\n\n    return this.build()\n  }\n\n  shift(): DebugHelper {\n    const list = this.entries\n\n    list.shift()\n\n    return this.reset(...list)\n  }\n\n  pop(): DebugHelper {\n    const list = this.entries\n\n    list.pop()\n\n    return this.reset(...list)\n  }\n\n  clear(): DebugHelper {\n    return this.reset()\n  }\n\n  remove(...namespace: Array<string>): DebugHelper {\n    if (namespace) {\n      namespace.filter((item) => Boolean(item)).forEach((item) => this.namespaces.delete(item))\n    }\n\n    return this.build()\n  }\n\n  puts(...args: Array<string>): string {\n    return [`[${this.namespace}]`, ...args].join(' ')\n  }\n}\n"]}

package/esm2020/utils/helpers/index.mjs

@@ -0,0 +1,5 @@
+export * from './debug.helper';
+export * from './reflect.helper';
+export * from './class-name.helper';
+export * from './debug-decorator.helper';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy91dGlscy9oZWxwZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUE7QUFDOUIsY0FBYyxrQkFBa0IsQ0FBQTtBQUNoQyxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsMEJBQTBCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RlYnVnLmhlbHBlcidcbmV4cG9ydCAqIGZyb20gJy4vcmVmbGVjdC5oZWxwZXInXG5leHBvcnQgKiBmcm9tICcuL2NsYXNzLW5hbWUuaGVscGVyJ1xuZXhwb3J0ICogZnJvbSAnLi9kZWJ1Zy1kZWNvcmF0b3IuaGVscGVyJ1xuIl19

package/esm2020/utils/helpers/reflect.helper.mjs

@@ -0,0 +1,165 @@
+import { first, flatten, isArray, isNil, last } from 'lodash';
+import 'reflect-metadata';
+export class ReflectHelper {
+    static get items() {
+        return this._items;
+    }
+    static get keys() {
+        return Object.keys(ReflectHelper.items);
+    }
+    static has(key, target, property) {
+        return (!isNil(key) &&
+            !isNil(ReflectHelper.items[key]) &&
+            (isNil(target) ||
+                (!isNil(ReflectHelper.items[key][target]) &&
+                    (isNil(property) || !isNil(ReflectHelper.items[key][target][String(property)])))));
+    }
+    static get({ key, target, property, own = true }) {
+        try {
+            if (own) {
+                return Reflect.getOwnMetadata(key, target, property) || null;
+            }
+            else {
+                return Reflect.getMetadata(key, target, property) || null;
+            }
+        }
+        catch (_err) {
+            return null;
+        }
+    }
+    static first({ key, target, property, own = true }) {
+        const values = ReflectHelper.get({ key, target, property, own });
+        return isArray(values) ? first(values) : values;
+    }
+    static last({ key, target, property, own = true }) {
+        const values = ReflectHelper.get({ key, target, property, own });
+        return isArray(values) ? last(values) : values;
+    }
+    static set({ key, target, property, value, propertyDescriptor }) {
+        Reflect.defineMetadata(key, value, target, property);
+        ReflectHelper.put({ key, target, property, value, propertyDescriptor });
+    }
+    static add({ key, target, property, value, propertyDescriptor }) {
+        let values = ReflectHelper.get({ key, target, property }) || new Array();
+        if (!Array.isArray(values))
+            values = [values];
+        values.push(value);
+        ReflectHelper.set({ key, target, property, value: values, propertyDescriptor });
+    }
+    static all({ key }) {
+        const items = ReflectHelper.items[key] || {};
+        return flatten(Object.keys(items).map((item) => flatten(this.allFrom(key, items[item]))));
+    }
+    static allFrom(key, target) {
+        return Object.keys(target)
+            .filter((property) => property !== 'object')
+            .map((property) => this.allValuesFrom(key, target, property));
+    }
+    static allValuesFrom(key, target, property) {
+        const values = target[property];
+        let value = values.value;
+        const propertyDescriptor = values.propertyDescriptor;
+        if (!isArray(value))
+            value = [value];
+        return flatten(value.map((val) => {
+            return {
+                key,
+                target: target.object,
+                property,
+                value: val,
+                propertyDescriptor,
+            };
+        }));
+    }
+    static delete({ key, target, property }) {
+        Reflect.deleteMetadata(key, target, property);
+        return ReflectHelper.remove(key, target, property);
+    }
+    static clear(key) {
+        if (!key) {
+            ReflectHelper.keys.forEach((storedKey) => {
+                ReflectHelper.clear(storedKey);
+            });
+        }
+        else {
+            if (ReflectHelper.keys.includes(key)) {
+                Object.values(ReflectHelper.items[key]).forEach((target) => {
+                    if (ReflectHelper.has(key, target)) {
+                        Object.values(ReflectHelper.items[key][target.toString()]).forEach((property) => {
+                            ReflectHelper.delete({
+                                key,
+                                target: target.object,
+                                property: String(property),
+                            });
+                            ReflectHelper.remove(key, target, String(property));
+                        });
+                    }
+                    ReflectHelper.delete({ key, target: target.object });
+                    ReflectHelper.remove(key, target);
+                });
+            }
+        }
+    }
+    static getType({ target, propertyKey }) {
+        return Reflect.getMetadata('design:type', target, propertyKey);
+    }
+    static getReturntype({ target, propertyKey }) {
+        return Reflect.getMetadata('design:returntype', target, propertyKey);
+    }
+    static getAllMethods(target) {
+        const props = [];
+        let obj = target;
+        do {
+            props.push(...Object.getOwnPropertyNames(obj));
+        } while ((obj = Object.getPrototypeOf(obj)));
+        return props.sort().filter((e, i, arr) => {
+            if ([
+                '__defineGetter__',
+                '__defineSetter__',
+                '__lookupGetter__',
+                '__lookupSetter__',
+                'constructor',
+                'hasOwnProperty',
+                'isPrototypeOf',
+                'propertyIsEnumerable',
+                'toLocaleString',
+                'toString',
+                'valueOf',
+            ].includes(e))
+                return false;
+            if (e != arr[i + 1] && typeof target[e] === 'function')
+                return true;
+        });
+    }
+    static put({ key, target, property, value, propertyDescriptor }) {
+        const index = target.constructor.name;
+        ReflectHelper.items[key] = ReflectHelper.items[key] || {};
+        ReflectHelper.items[key][index] = ReflectHelper.items[key][index] || {};
+        ReflectHelper.items[key][index].object = target;
+        if (isNil(property)) {
+            ReflectHelper.items[key][index].value = {
+                value,
+                propertyDescriptor,
+            };
+        }
+        else {
+            ReflectHelper.items[key][index][String(property)] = ReflectHelper.items[key][index][String(property)] || {};
+            ReflectHelper.items[key][index][String(property)] = {
+                value,
+                propertyDescriptor,
+            };
+        }
+    }
+    static remove(key, target, property) {
+        if (ReflectHelper.has(key, target, property))
+            return delete ReflectHelper.items[key][target][String(property)];
+        else if (ReflectHelper.has(key, target))
+            return delete ReflectHelper.items[key][target];
+        else if (ReflectHelper.has(key))
+            return delete ReflectHelper.items[key];
+        else
+            return false;
+    }
+}
+ReflectHelper._items = {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reflect.helper.js","sourceRoot":"","sources":["../../../../../projects/connect/src/utils/helpers/reflect.helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { first, flatten, isArray, isNil, last } from 'lodash'\nimport 'reflect-metadata'\n\ntype Dictionary<T> = {\n  [key: string]: T\n}\nexport type MetaArgs = {\n  key: keyof MetaStorage | string\n  target: any\n  property?: string | symbol\n  own?: boolean\n  propertyDescriptor?: PropertyDescriptor\n}\nexport type MetaValueArgs<T = any> = MetaArgs & {\n  value: T\n}\ntype MetaProperties<T = any> = Dictionary<T>\ntype MetaTargets = Dictionary<MetaProperties>\ntype MetaKeys = Dictionary<MetaTargets>\ntype MetaStorage = {\n  value?: any\n  object?: any\n  values?: MetaKeys\n} & Record<string, any>\n\nexport class ReflectHelper {\n  static get items(): MetaStorage {\n    return this._items\n  }\n\n  static get keys(): Array<string> {\n    return Object.keys(ReflectHelper.items)\n  }\n\n  static has(key: keyof MetaStorage, target?: any, property?: string | symbol): boolean {\n    return (\n      !isNil(key) &&\n      !isNil(ReflectHelper.items[key]) &&\n      (isNil(target) ||\n        (!isNil(ReflectHelper.items[key][target]) &&\n          (isNil(property) || !isNil(ReflectHelper.items[key][target][String(property)]))))\n    )\n  }\n\n  static get<T = any>({ key, target, property, own = true }: MetaArgs): Array<T> {\n    try {\n      if (own) {\n        return Reflect.getOwnMetadata(key, target, property) || null\n      } else {\n        return Reflect.getMetadata(key, target, property) || null\n      }\n    } catch (_err) {\n      return null\n    }\n  }\n\n  static first<T = any>({ key, target, property, own = true }: MetaArgs): T {\n    const values = ReflectHelper.get<T>({ key, target, property, own })\n\n    return isArray(values) ? first(values) : values\n  }\n\n  static last<T = any>({ key, target, property, own = true }: MetaArgs): T {\n    const values = ReflectHelper.get<T>({ key, target, property, own })\n\n    return isArray(values) ? last(values) : values\n  }\n\n  static set<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {\n    Reflect.defineMetadata(key, value, target, property)\n\n    ReflectHelper.put<T>({ key, target, property, value, propertyDescriptor })\n  }\n\n  static add<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {\n    let values: Array<T> = ReflectHelper.get<T>({ key, target, property }) || new Array<T>()\n\n    if (!Array.isArray(values)) values = [values]\n\n    values.push(value)\n\n    ReflectHelper.set<Array<T>>({ key, target, property, value: values, propertyDescriptor })\n  }\n\n  static all<T = any>({ key }: Partial<MetaArgs>): Array<MetaValueArgs<T>> {\n    const items = ReflectHelper.items[key] || {}\n\n    return flatten(Object.keys(items).map((item) => flatten(this.allFrom(key, items[item]))))\n  }\n\n  static allFrom(key: string, target: any): any {\n    return Object.keys(target)\n      .filter((property) => property !== 'object')\n      .map((property) => this.allValuesFrom(key, target, property))\n  }\n\n  static allValuesFrom(key: string, target: any, property: any): any {\n    const values = target[property]\n    let value = values.value\n    const propertyDescriptor = values.propertyDescriptor\n\n    if (!isArray(value)) value = [value]\n\n    return flatten(\n      value.map((val: any) => {\n        return {\n          key,\n          target: target.object,\n          property,\n          value: val,\n          propertyDescriptor,\n        }\n      }),\n    )\n  }\n\n  static delete({ key, target, property }: MetaArgs): boolean {\n    Reflect.deleteMetadata(key, target, property)\n\n    return ReflectHelper.remove(key, target, property)\n  }\n\n  static clear(key?: string): void {\n    if (!key) {\n      ReflectHelper.keys.forEach((storedKey) => {\n        ReflectHelper.clear(storedKey)\n      })\n    } else {\n      if (ReflectHelper.keys.includes(key)) {\n        Object.values<MetaStorage>(ReflectHelper.items[key]).forEach((target) => {\n          if (ReflectHelper.has(key, target)) {\n            Object.values(ReflectHelper.items[key][target.toString()]).forEach((property) => {\n              ReflectHelper.delete({\n                key,\n                target: target.object,\n                property: String(property),\n              })\n              ReflectHelper.remove(key, target, String(property))\n            })\n          }\n\n          ReflectHelper.delete({ key, target: target.object })\n          ReflectHelper.remove(key, target)\n        })\n      }\n    }\n  }\n\n  static getType({ target, propertyKey }: { target: string; propertyKey: string }): any {\n    return Reflect.getMetadata('design:type', target, propertyKey)\n  }\n\n  static getReturntype({ target, propertyKey }: { target: string; propertyKey: string }): any {\n    return Reflect.getMetadata('design:returntype', target, propertyKey)\n  }\n\n  static getAllMethods(target: any): string[] {\n    const props = []\n    let obj = target\n\n    do {\n      props.push(...Object.getOwnPropertyNames(obj))\n    } while ((obj = Object.getPrototypeOf(obj)))\n\n    return props.sort().filter((e, i, arr) => {\n      if (\n        [\n          '__defineGetter__',\n          '__defineSetter__',\n          '__lookupGetter__',\n          '__lookupSetter__',\n          'constructor',\n          'hasOwnProperty',\n          'isPrototypeOf',\n          'propertyIsEnumerable',\n          'toLocaleString',\n          'toString',\n          'valueOf',\n        ].includes(e)\n      )\n        return false\n      if (e != arr[i + 1] && typeof target[e] === 'function') return true\n    })\n  }\n\n  private static _items: MetaStorage = {}\n\n  private static put<T = any>({ key, target, property, value, propertyDescriptor }: MetaValueArgs<T>): void {\n    const index = target.constructor.name\n\n    ReflectHelper.items[key] = ReflectHelper.items[key] || {}\n    ReflectHelper.items[key][index] = ReflectHelper.items[key][index] || {}\n    ReflectHelper.items[key][index].object = target\n\n    if (isNil(property)) {\n      ReflectHelper.items[key][index].value = {\n        value,\n        propertyDescriptor,\n      }\n    } else {\n      ReflectHelper.items[key][index][String(property)] = ReflectHelper.items[key][index][String(property)] || {}\n      ReflectHelper.items[key][index][String(property)] = {\n        value,\n        propertyDescriptor,\n      }\n    }\n  }\n\n  private static remove(key: string, target?: any, property?: string | symbol): boolean {\n    if (ReflectHelper.has(key, target, property)) return delete ReflectHelper.items[key][target][String(property)]\n    else if (ReflectHelper.has(key, target)) return delete ReflectHelper.items[key][target]\n    else if (ReflectHelper.has(key)) return delete ReflectHelper.items[key]\n    else return false\n  }\n}\n"]}

package/esm2020/utils/index.mjs

@@ -0,0 +1,13 @@
+import { add, addBusinessDays, addDays, addMonths, addYears, endOfDay, format, formatISO9075, parseISO, startOfDay, sub, } from 'date-fns';
+import { chunk, each, get, isBoolean, isDate, isEmpty, isInteger, isNaN, isNil, isNumber, isObject, isString, now, omit, pick, set, unset, } from 'lodash';
+export * from './decorators';
+export * from './get';
+export * from './helpers';
+export * from './is';
+export * from './is-uuid';
+export * from './log.utils';
+export * from './mixins';
+export * from './parse-datetime';
+export * from './types';
+export { add, addDays, addBusinessDays, addMonths, addYears, chunk, each, endOfDay, format, formatISO9075, get, isBoolean, isDate, isEmpty, isInteger, isNil, isNaN, isNumber, isObject, isString, parseISO, now, omit, pick, set, startOfDay, sub, unset, };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/is-uuid.mjs

@@ -0,0 +1,3 @@
+import { isString } from 'lodash';
+export const isUUID = (value) => isString(value) && /[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}/.test(value);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtdXVpZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL3V0aWxzL2lzLXV1aWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFFBQVEsQ0FBQTtBQUVqQyxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsQ0FBQyxLQUFhLEVBQVcsRUFBRSxDQUMvQyxRQUFRLENBQUMsS0FBSyxDQUFDLElBQUksaUZBQWlGLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNTdHJpbmcgfSBmcm9tICdsb2Rhc2gnXG5cbmV4cG9ydCBjb25zdCBpc1VVSUQgPSAodmFsdWU6IHN0cmluZyk6IGJvb2xlYW4gPT5cbiAgaXNTdHJpbmcodmFsdWUpICYmIC9bMC05YS1mQS1GXXs4fVxcLVswLTlhLWZBLUZdezR9XFwtWzAtOWEtZkEtRl17NH1cXC1bMC05YS1mQS1GXXs0fVxcLVswLTlhLWZBLUZdezEyfS8udGVzdCh2YWx1ZSlcbiJdfQ==

package/esm2020/utils/is.mjs

@@ -0,0 +1,4 @@
+export function is(value) {
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy91dGlscy9pcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUsRUFBRSxDQUFJLEtBQVU7SUFDOUIsT0FBTyxLQUFLLENBQUE7QUFDZCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGlzPFQ+KHZhbHVlOiBhbnkpOiBUIHtcbiAgcmV0dXJuIHZhbHVlXG59XG4iXX0=

package/esm2020/utils/log.utils.mjs

@@ -0,0 +1,9 @@
+import { debug } from 'debug';
+export var DebugNamespaces;
+(function (DebugNamespaces) {
+    DebugNamespaces["ROOT"] = "connect";
+    DebugNamespaces["TRACE"] = "trace";
+    DebugNamespaces["ERROR"] = "error";
+})(DebugNamespaces || (DebugNamespaces = {}));
+export const Logger = debug(DebugNamespaces.ROOT);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nLnV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY29ubmVjdC9zcmMvdXRpbHMvbG9nLnV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQVksTUFBTSxPQUFPLENBQUE7QUFFdkMsTUFBTSxDQUFOLElBQVksZUFJWDtBQUpELFdBQVksZUFBZTtJQUN6QixtQ0FBZ0IsQ0FBQTtJQUNoQixrQ0FBZSxDQUFBO0lBQ2Ysa0NBQWUsQ0FBQTtBQUNqQixDQUFDLEVBSlcsZUFBZSxLQUFmLGVBQWUsUUFJMUI7QUFFRCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQWEsS0FBSyxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlYnVnLCBEZWJ1Z2dlciB9IGZyb20gJ2RlYnVnJ1xuXG5leHBvcnQgZW51bSBEZWJ1Z05hbWVzcGFjZXMge1xuICBST09UID0gJ2Nvbm5lY3QnLFxuICBUUkFDRSA9ICd0cmFjZScsXG4gIEVSUk9SID0gJ2Vycm9yJyxcbn1cblxuZXhwb3J0IGNvbnN0IExvZ2dlcjogRGVidWdnZXIgPSBkZWJ1ZyhEZWJ1Z05hbWVzcGFjZXMuUk9PVClcbiJdfQ==

package/esm2020/utils/mixins/base.mixin.mjs

@@ -0,0 +1,6 @@
+export class Base {
+    constructor(...args) {
+        Object.assign(this, ...args);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5taXhpbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL3V0aWxzL21peGlucy9iYXNlLm1peGluLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxJQUFJO0lBQ2YsWUFBWSxHQUFHLElBQWdCO1FBQzdCLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLEdBQUcsSUFBSSxDQUFDLENBQUE7SUFDOUIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIEJhc2Uge1xuICBjb25zdHJ1Y3RvciguLi5hcmdzOiBBcnJheTxhbnk+KSB7XG4gICAgT2JqZWN0LmFzc2lnbih0aGlzLCAuLi5hcmdzKVxuICB9XG59XG4iXX0=

package/esm2020/utils/mixins/index.mjs

@@ -0,0 +1,4 @@
+export * from './mixin-ctor.type';
+export * from './base.mixin';
+export * from './merge-constructor-params.type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy91dGlscy9taXhpbnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLGlDQUFpQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9taXhpbi1jdG9yLnR5cGUnXG5leHBvcnQgKiBmcm9tICcuL2Jhc2UubWl4aW4nXG5leHBvcnQgKiBmcm9tICcuL21lcmdlLWNvbnN0cnVjdG9yLXBhcmFtcy50eXBlJ1xuIl19

package/esm2020/utils/mixins/merge-constructor-params.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVyZ2UtY29uc3RydWN0b3ItcGFyYW1zLnR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy91dGlscy9taXhpbnMvbWVyZ2UtY29uc3RydWN0b3ItcGFyYW1zLnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbInR5cGUgVGFpbDxUIGV4dGVuZHMgYW55W10+ID0gVCBleHRlbmRzIFthbnksIC4uLmluZmVyIFVdID8gVSA6IFtdXG5cbmV4cG9ydCB0eXBlIE1lcmdlQ29uc3RydWN0b3JQYXJhbXM8TmV3UGFyYW1zIGV4dGVuZHMgYW55W10sIEN1cnJlbnRQYXJhbXMgZXh0ZW5kcyBhbnlbXT4gPSBDdXJyZW50UGFyYW1zIGV4dGVuZHMgW11cbiAgPyBbLi4uTmV3UGFyYW1zLCAuLi5hbnldXG4gIDogQ3VycmVudFBhcmFtc1swXSBleHRlbmRzIG5ldmVyXG4gID8gWy4uLk5ld1BhcmFtcywgLi4uYW55XVxuICA6IFsuLi5OZXdQYXJhbXMsIC4uLlRhaWw8Q3VycmVudFBhcmFtcz5dXG4iXX0=

package/esm2020/utils/mixins/mixin-ctor.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWl4aW4tY3Rvci50eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29ubmVjdC9zcmMvdXRpbHMvbWl4aW5zL21peGluLWN0b3IudHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgTWl4aW5DdG9yPFQgPSBhbnksIEEgZXh0ZW5kcyBhbnlbXSA9IGFueVtdPiA9IG5ldyAoLi4uYXJnczogQSkgPT4gVFxuIl19

package/esm2020/utils/parse-datetime.mjs

@@ -0,0 +1,14 @@
+import { isString } from 'lodash';
+import { parseISO } from 'date-fns';
+export const parseDateTime = (value) => {
+    if (!isString(value))
+        return value;
+    if (!/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.test(value) &&
+        !/^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T\d{2}:\d{2}:\d{2}/.test(value))
+        return value;
+    const date = parseISO(value);
+    if (isNaN(date.getTime()))
+        return value;
+    return date;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2UtZGF0ZXRpbWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy91dGlscy9wYXJzZS1kYXRldGltZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sUUFBUSxDQUFBO0FBQ2pDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxVQUFVLENBQUE7QUFFbkMsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQUMsS0FBYSxFQUFpQixFQUFFO0lBQzVELElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDO1FBQUUsT0FBTyxLQUFLLENBQUE7SUFDbEMsSUFDRSxDQUFDLGtEQUFrRCxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDL0QsQ0FBQyxtRUFBbUUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO1FBRWhGLE9BQU8sS0FBSyxDQUFBO0lBRWQsTUFBTSxJQUFJLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBRTVCLElBQUksS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUFFLE9BQU8sS0FBSyxDQUFBO0lBRXZDLE9BQU8sSUFBSSxDQUFBO0FBQ2IsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNTdHJpbmcgfSBmcm9tICdsb2Rhc2gnXG5pbXBvcnQgeyBwYXJzZUlTTyB9IGZyb20gJ2RhdGUtZm5zJ1xuXG5leHBvcnQgY29uc3QgcGFyc2VEYXRlVGltZSA9ICh2YWx1ZTogc3RyaW5nKTogc3RyaW5nIHwgRGF0ZSA9PiB7XG4gIGlmICghaXNTdHJpbmcodmFsdWUpKSByZXR1cm4gdmFsdWVcbiAgaWYgKFxuICAgICEvXlxcZHs0fS0oMFsxLTldfDFbMC0yXSktKDBbMS05XXxbMTJdWzAtOV18M1swMV0pJC8udGVzdCh2YWx1ZSkgJiZcbiAgICAhL15cXGR7NH0tKDBbMS05XXwxWzAtMl0pLSgwWzEtOV18WzEyXVswLTldfDNbMDFdKVRcXGR7Mn06XFxkezJ9OlxcZHsyfS8udGVzdCh2YWx1ZSlcbiAgKVxuICAgIHJldHVybiB2YWx1ZVxuXG4gIGNvbnN0IGRhdGUgPSBwYXJzZUlTTyh2YWx1ZSlcblxuICBpZiAoaXNOYU4oZGF0ZS5nZXRUaW1lKCkpKSByZXR1cm4gdmFsdWVcblxuICByZXR1cm4gZGF0ZVxufVxuIl19

package/esm2020/utils/types/array-element.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktZWxlbWVudC50eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29ubmVjdC9zcmMvdXRpbHMvdHlwZXMvYXJyYXktZWxlbWVudC50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBBcnJheUVsZW1lbnQ8QXJyYXlUeXBlIGV4dGVuZHMgcmVhZG9ubHkgdW5rbm93bltdPiA9IEFycmF5VHlwZSBleHRlbmRzIHJlYWRvbmx5IChpbmZlciBFbGVtZW50VHlwZSlbXVxuICA/IEVsZW1lbnRUeXBlXG4gIDogbmV2ZXJcbiJdfQ==

package/esm2020/utils/types/index.mjs

@@ -0,0 +1,3 @@
+export * from './prop.type';
+export * from './array-element.type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0L3NyYy91dGlscy90eXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQTtBQUMzQixjQUFjLHNCQUFzQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wcm9wLnR5cGUnXG5leHBvcnQgKiBmcm9tICcuL2FycmF5LWVsZW1lbnQudHlwZSdcbiJdfQ==

package/esm2020/utils/types/prop.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcC50eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29ubmVjdC9zcmMvdXRpbHMvdHlwZXMvcHJvcC50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBQcm9wVHlwZTxUT2JqLCBUUHJvcCBleHRlbmRzIGtleW9mIFRPYmo+ID0gVE9ialtUUHJvcF1cbiJdfQ==