@infrab4a/connect 4.0.1-beta.3 → 4.0.1

package/esm2020/utils/decorators/trace.method.decorator.mjs

@@ -0,0 +1,81 @@
+import { get } from 'lodash';
+import { DebugHelper } from '../helpers';
+const ASYNC_IDENTIFIER = 'async';
+export function Log(options = {}) {
+    return Trace({ level: 'log', ...options });
+}
+export function Trace(options = {}) {
+    return function (target, propertyKey, propertyDescriptor) {
+        const method = propertyDescriptor.value;
+        const isPromise = method.toString().includes(ASYNC_IDENTIFIER);
+        const args = {
+            options,
+            method,
+            target,
+            propertyKey,
+            propertyDescriptor,
+        };
+        propertyDescriptor.value = isPromise ? promiseTracer(args) : functionTracer(args);
+        return propertyDescriptor;
+    };
+}
+const traceCall = function ({ target, propertyKey, propertyDescriptor, args }) {
+    if (!target.debug)
+        target.debug = DebugHelper.for(target, propertyKey);
+    return target.debug.push(propertyKey).trace('called', { target, propertyKey, propertyDescriptor, args });
+};
+const promiseTracer = function ({ options, method, propertyKey, propertyDescriptor }) {
+    return function (...args) {
+        return new Promise((resolve, reject) => {
+            const debug = traceCall({ target: this, propertyDescriptor, propertyKey, args });
+            if (get(options, 'level', '') === 'log') {
+                debug.with('params').log(args);
+            }
+            return method
+                .apply(this, args)
+                .then((result) => {
+                if (options.callbackFn) {
+                    options.callbackFn({ target: this, result, args, namespace: [propertyKey] });
+                }
+                if (get(options, 'level', '') === 'log') {
+                    debug.with('returns').log(result === undefined ? 'void' : result);
+                }
+                return resolve(result);
+            })
+                .catch((error) => {
+                debug.error(error, ...args);
+                debug.with('stack').error(error.stack).pop();
+                return reject(error);
+            })
+                .finally(() => {
+                return debug.trace('finally', { args }).pop();
+            });
+        });
+    };
+};
+const functionTracer = function ({ options, target, method, propertyKey, propertyDescriptor, }) {
+    return function (...args) {
+        const debug = traceCall({ target: this || target, propertyDescriptor, propertyKey, args });
+        if (get(options, 'level', '') === 'log') {
+            debug.with('params').log(args);
+        }
+        let result;
+        try {
+            result = method.apply(this, args);
+            if (options.callbackFn)
+                options.callbackFn({ target: this, result, args, namespace: [propertyKey] });
+            if (get(options, 'level', '') === 'log') {
+                debug.with('returns').log(result === undefined ? 'void' : result);
+            }
+            return result;
+        }
+        catch (error) {
+            debug.error(error, ...args).pop();
+            throw error;
+        }
+        finally {
+            debug.trace('finally', { args }).pop();
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trace.method.decorator.js","sourceRoot":"","sources":["../../../../../projects/connect/src/utils/decorators/trace.method.decorator.ts"],"names":[],"mappings":"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","sourcesContent":["import { get } from 'lodash'\n\nimport { Debuggable, DebugHelper } from '../helpers'\n\nexport type CallbackFnArgs<T, Result> = {\n  target: T\n  result: Result\n  args: Array<any>\n  namespace?: Array<string>\n}\n\ntype CallbackFn<T, Result> = (opts: CallbackFnArgs<T, Result>) => void\n\ntype TraceOptions<T, Result> = {\n  callbackFn?: CallbackFn<T, Result>\n  level?: 'trace' | 'log'\n}\n\ntype Tracer<T, Result> = {\n  options: TraceOptions<T, Result>\n  method: any\n  target: T & Debuggable\n  propertyDescriptor: PropertyDescriptor\n  propertyKey: string\n}\n\ntype CallTracerArgs = {\n  target: any\n  propertyKey: string\n  propertyDescriptor: PropertyDescriptor\n  args: Array<any>\n}\n\nconst ASYNC_IDENTIFIER = 'async'\n\nexport function Log<T, Result>(options: TraceOptions<T, Result> = {}) {\n  return Trace<T, Result>({ level: 'log', ...options })\n}\n\nexport function Trace<T, Result>(options: TraceOptions<T, Result> = {}) {\n  return function (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) {\n    const method = propertyDescriptor.value\n    const isPromise = method.toString().includes(ASYNC_IDENTIFIER)\n    const args = {\n      options,\n      method,\n      target,\n      propertyKey,\n      propertyDescriptor,\n    }\n\n    propertyDescriptor.value = isPromise ? promiseTracer(args) : functionTracer(args)\n\n    return propertyDescriptor\n  }\n}\n\nconst traceCall = function ({ target, propertyKey, propertyDescriptor, args }: CallTracerArgs): DebugHelper {\n  if (!target.debug) target.debug = DebugHelper.for(target, propertyKey)\n\n  return target.debug.push(propertyKey).trace('called', { target, propertyKey, propertyDescriptor, args })\n}\n\nconst promiseTracer = function <T, Result>({ options, method, propertyKey, propertyDescriptor }: Tracer<T, Result>) {\n  return function (this: any, ...args: Array<any>): any {\n    return new Promise((resolve, reject) => {\n      const debug = traceCall({ target: this, propertyDescriptor, propertyKey, args })\n\n      if (get(options, 'level', '') === 'log') {\n        debug.with('params').log(args)\n      }\n\n      return method\n        .apply(this, args)\n        .then((result: any) => {\n          if (options.callbackFn) {\n            options.callbackFn({ target: this, result, args, namespace: [propertyKey] })\n          }\n\n          if (get(options, 'level', '') === 'log') {\n            debug.with('returns').log(result === undefined ? 'void' : result)\n          }\n\n          return resolve(result)\n        })\n        .catch((error: Error) => {\n          debug.error(error, ...args)\n          debug.with('stack').error(error.stack).pop()\n\n          return reject(error)\n        })\n        .finally(() => {\n          return debug.trace('finally', { args }).pop()\n        })\n    })\n  }\n}\n\nconst functionTracer = function <T, Result>({\n  options,\n  target,\n  method,\n  propertyKey,\n  propertyDescriptor,\n}: Tracer<T, Result>) {\n  return function (this: any, ...args: Array<any>): any {\n    const debug = traceCall({ target: this || target, propertyDescriptor, propertyKey, args })\n\n    if (get(options, 'level', '') === 'log') {\n      debug.with('params').log(args)\n    }\n\n    let result: any\n\n    try {\n      result = method.apply(this, args)\n\n      if (options.callbackFn) options.callbackFn({ target: this, result, args, namespace: [propertyKey] })\n\n      if (get(options, 'level', '') === 'log') {\n        debug.with('returns').log(result === undefined ? 'void' : result)\n      }\n\n      return result\n    } catch (error) {\n      debug.error(error, ...args).pop()\n\n      throw error\n    } finally {\n      debug.trace('finally', { args }).pop()\n    }\n  }\n}\n"]}

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":"AACA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAE9B,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAEtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAkBrD,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAW,EAAwB,EAAE;IAChE,OAAO,OAAO,IAAI,MAAM,CAAA;AAC1B,CAAC,CAAA;AAED,MAAM,OAAO,WAAW;IA+EtB,YAAY,GAAG,SAAwB;QACrC,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,EAAU,CAAA;QACnC,IAAI,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,CAAA;IACzB,CAAC;IA5ED,MAAM,CAAC,aAAa,CAAC,MAAc;QACjC,IAAI,KAAK,CAAC,MAAM,CAAC;YAAE,OAAO,EAAE,CAAA;QAE5B,MAAM,SAAS,GAAG,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAA;QACzE,MAAM,UAAU,GAAG,GAAG,CAAC,SAAS,EAAE,YAAY,EAAE,EAAE,CAAC,CAAA;QACnD,MAAM,IAAI,GAAG,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;QAEhE,OAAO,CAAC,GAAG,UAAU,EAAE,IAAI,CAAC,CAAA;IAC9B,CAAC;IAED,MAAM,CAAC,EAAE,CAAC,GAAG,UAAyB;QACpC,OAAO,IAAI,WAAW,CAAC,GAAG,UAAU,CAAC,CAAA;IACvC,CAAC;IAED,MAAM,CAAC,GAAG,CAAC,MAAc,EAAE,GAAG,UAAyB;QACrD,MAAM,gBAAgB,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAA;QAEnD,OAAO,IAAI,WAAW,CAAC,GAAG,gBAAgB,EAAE,GAAG,UAAU,CAAC,CAAA;IAC5D,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,MAAc,EAAE,GAAG,UAAyB;QACtD,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE;YAC7B,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAA;YAE1B,IAAI,UAAU;gBAAE,KAAK,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAA;YAEzC,OAAO,KAAK,CAAA;SACb;QAED,OAAO,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAA;IAC/C,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,MAAc,EAAE,GAAG,UAAyB;QAC5D,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE;YAC7B,UAAU,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;SACzC;aAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YACzB,UAAU,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAA;SAC/C;QAED,OAAO,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAA;IAC/C,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,MAAc,EAAE,GAAG,UAAyB;QACvD,IAAI,QAAqB,CAAA;QAEzB,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE;YAC7B,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAA;YACvB,UAAU,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAA;SACrC;QAED,OAAO;YACL,QAAQ;YACR,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC;SAC9C,CAAA;IACH,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,MAAW,EAAE,KAA4B;QACtD,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;YAAE,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,IAAI,CAAA;IAC1D,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,MAAc,EAAE,GAAG,UAAyB;QACtD,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,WAAW,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,CAAA;QAEpE,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAA;QAE5C,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAA;IAC5B,CAAC;IAYD,IAAI,OAAO;QACT,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC,CAAA;IAChD,CAAC;IAED,IAAI,SAAS;QACX,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACjD,CAAC;IAED,GAAG,CAAC,OAAa,EAAE,GAAG,IAAgB;QACpC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;QACvF,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA;QAEpE,OAAO,IAAI,CAAA;IACb,CAAC;IAED,KAAK,CAAC,OAAa,EAAE,GAAG,IAAgB;QACtC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAA;QAC3D,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA;QAEtE,OAAO,IAAI,CAAA;IACb,CAAC;IAED,KAAK,CAAC,KAAU,EAAE,GAAG,IAAgB;QACnC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;QACnH,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;QAEpE,OAAO,IAAI,CAAA;IACb,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,GAAG,GAAG,MAAM,CAAA;QAEjB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;YACjC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;YAC3C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;YAC3C,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;QACvC,CAAC,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAED,IAAI,CAAC,GAAG,SAAwB;QAC9B,OAAO,IAAI,WAAW,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAA;IACvD,CAAC;IAED,IAAI,CAAC,GAAG,SAAwB;QAC9B,IAAI,SAAS,EAAE;YACb,SAAS,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAA;SACvF;QAED,OAAO,IAAI,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED,OAAO,CAAC,GAAG,SAAwB;QACjC,IAAI,SAAS,EAAE;YACb,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAA;SACjD;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAED,KAAK,CAAC,GAAG,SAAwB;QAC/B,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;QAEtD,OAAO,IAAI,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED,SAAS,CAAC,GAAG,SAAwB;QACnC,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAA;QAE/B,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;QAEpE,OAAO,IAAI,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED,KAAK;QACH,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAA;QAEzB,IAAI,CAAC,KAAK,EAAE,CAAA;QAEZ,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAA;IAC5B,CAAC;IAED,GAAG;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAA;QAEzB,IAAI,CAAC,GAAG,EAAE,CAAA;QAEV,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAA;IAC5B,CAAC;IAED,KAAK;QACH,OAAO,IAAI,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED,MAAM,CAAC,GAAG,SAAwB;QAChC,IAAI,SAAS,EAAE;YACb,SAAS,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;SAC1F;QAED,OAAO,IAAI,CAAC,KAAK,EAAE,CAAA;IACrB,CAAC;IAED,IAAI,CAAC,GAAG,IAAmB;QACzB,OAAO,CAAC,IAAI,IAAI,CAAC,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACnD,CAAC;;AA9LM,iBAAK,GAAG,IAAI,OAAO,EAAY,CAAA;AAC/B,mBAAO,GAAG,IAAI,OAAO,EAAY,CAAA;AACjC,mBAAO,GAAG,IAAI,OAAO,EAAc,CAAA;AACnC,wBAAY,GAAG,YAAY,CAAA","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/{esm2015/utils/is-uuid.js → esm2020/utils/is-uuid.mjs}

@@ -1,3 +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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtdXVpZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2Nvbm5lY3Qvc3JjL3V0aWxzL2lzLXV1aWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFFBQVEsQ0FBQTtBQUVqQyxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsQ0FBQyxLQUFhLEVBQVcsRUFBRSxDQUMvQyxRQUFRLENBQUMsS0FBSyxDQUFDLElBQUksaUZBQWlGLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNTdHJpbmcgfSBmcm9tICdsb2Rhc2gnXHJcblxyXG5leHBvcnQgY29uc3QgaXNVVUlEID0gKHZhbHVlOiBzdHJpbmcpOiBib29sZWFuID0+XHJcbiAgaXNTdHJpbmcodmFsdWUpICYmIC9bMC05YS1mQS1GXXs4fVxcLVswLTlhLWZBLUZdezR9XFwtWzAtOWEtZkEtRl17NH1cXC1bMC05YS1mQS1GXXs0fVxcLVswLTlhLWZBLUZdezEyfS8udGVzdCh2YWx1ZSlcclxuIl19
+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/{esm2015/utils/mixins/base.mixin.js → esm2020/utils/mixins/base.mixin.mjs}

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

package/{esm2015/utils/mixins/index.js → esm2020/utils/mixins/index.mjs}

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

package/{esm2015/utils/mixins/merge-constructor-params.type.js → esm2020/utils/mixins/merge-constructor-params.type.mjs}

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

package/{esm2015/utils/mixins/mixin-ctor.type.js → esm2020/utils/mixins/mixin-ctor.type.mjs}

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