@tstdl/base 0.85.22 → 0.85.24

package/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './log.js';

package/decorators/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var decorators_exports = {};
+module.exports = __toCommonJS(decorators_exports);
+__reExport(decorators_exports, require("./log.js"), module.exports);

package/decorators/log.d.ts

@@ -0,0 +1,2 @@
+import type { Decorator } from '../reflection/types.js';
+export declare function Log(): Decorator<'class' | 'method'>;

package/decorators/log.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  Log: () => Log
+});
+module.exports = __toCommonJS(log_exports);
+var import_log = require("../function/log.js");
+var import_utils = require("../reflection/utils.js");
+var import_object = require("../utils/object/object.js");
+var import_type_guards = require("../utils/type-guards.js");
+const isLogWrapped = Symbol("log wrapped");
+function wrapLogTagged(fn, options) {
+  const wrapped = (0, import_log.wrapLog)(fn, options);
+  wrapped[isLogWrapped] = true;
+  return wrapped;
+}
+function isWrapped(fn) {
+  return fn[isLogWrapped] ?? false;
+}
+function Log() {
+  return (0, import_utils.createDecorator)({ class: true, method: true }, (data) => {
+    if (data.type == "method") {
+      return { value: wrapLogTagged(data.descriptor.value) };
+    }
+    const staticProperties = (0, import_object.objectKeys)(data.constructor).filter((property) => property != "length" && property != "name" && property != "prototype" && (0, import_type_guards.isFunction)(data.constructor[property]) && !isWrapped(data.constructor[property]));
+    const instanceProperties = (0, import_object.objectKeys)(data.prototype).filter((property) => property != "constructor" && (0, import_type_guards.isFunction)(data.prototype[property]) && !isWrapped(data.prototype[property]));
+    for (const property of staticProperties) {
+      data.constructor[property] = wrapLogTagged(data.constructor[property], property);
+    }
+    for (const property of instanceProperties) {
+      data.prototype[property] = wrapLogTagged(data.prototype[property], property);
+    }
+    return void 0;
+  });
+}

package/function/index.d.ts

@@ -0,0 +1 @@
+export * from './log.js';

package/function/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var function_exports = {};
+module.exports = __toCommonJS(function_exports);
+__reExport(function_exports, require("./log.js"), module.exports);

package/function/log.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from '../logger/logger.js';
+export type WrapLogOptions = {
+    fnName?: string;
+    logger?: Logger;
+};
+export declare function wrapLog(fn: Function, options?: WrapLogOptions): Function;

package/function/log.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  wrapLog: () => wrapLog
+});
+module.exports = __toCommonJS(log_exports);
+var import_type_guards = require("../utils/type-guards.js");
+var import_type_of = require("../utils/type-of.js");
+function wrapLog(fn, options) {
+  const fnName = options?.fnName ?? fn.name;
+  const log = options?.logger?.trace.bind(options.logger) ?? console.log.bind(console);
+  const wrapped = {
+    [fnName](...args) {
+      const argString = args.map((arg) => (0, import_type_guards.isPrimitive)(arg) ? arg : (0, import_type_of.typeOf)(arg)).join(", ");
+      log(`[call: ${fnName}(${argString})]`);
+      return Reflect.apply(fn, this, args);
+    }
+  };
+  return wrapped[fnName];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.85.22",
+  "version": "0.85.24",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/reflection/registry.d.ts

@@ -54,6 +54,5 @@ export declare class ReflectionRegistry {
      */
     unregister(type: AbstractConstructor): void;
     getOrInitializeMetadata(type: AbstractConstructor): TypeMetadata;
-    private initializeType;
 }
 export declare const reflectionRegistry: ReflectionRegistry;

package/reflection/registry.js

@@ -87,52 +87,51 @@ class ReflectionRegistry {
       throw new Error("Reflection data was accessed before registration was done.");
     }
     if (!this.metadataMap.has(type)) {
-      const metadata = this.initializeType(type);
+      const metadata = initializeType(type);
       this.metadataMap.set(type, metadata);
       return metadata;
     }
     return this.metadataMap.get(type);
   }
-  // eslint-disable-next-line max-lines-per-function
-  initializeType(type) {
-    return (0, import_lazy_property.lazyObject)({
-      metadataType: "type",
-      constructor: (0, import_lazy_property.lazyObjectValue)(type),
-      parent: (0, import_lazy_property.lazyObjectValue)(Reflect.getPrototypeOf(type)),
-      parameters: {
-        initializer() {
-          const parametersTypes = (0, import_reflection.getParameterTypes)(type);
-          return parametersTypes?.map((parameterType, index) => ({ metadataType: "constructor-parameter", index, type: parameterType, data: new import_reflection_data_map.ReflectionDataMap() }));
+}
+function initializeType(type) {
+  return (0, import_lazy_property.lazyObject)({
+    metadataType: "type",
+    constructor: (0, import_lazy_property.lazyObjectValue)(type),
+    parent: (0, import_lazy_property.lazyObjectValue)(Reflect.getPrototypeOf(type)),
+    parameters: {
+      initializer() {
+        const parametersTypes = (0, import_reflection.getParameterTypes)(type);
+        return parametersTypes?.map((parameterType, index) => ({ metadataType: "constructor-parameter", index, type: parameterType, data: new import_reflection_data_map.ReflectionDataMap() }));
+      }
+    },
+    properties: {
+      initializer: () => new import_factory_map.FactoryMap((key) => ({ metadataType: "property", key, type: (0, import_reflection.getDesignType)(type.prototype, key), isAccessor: false, data: new import_reflection_data_map.ReflectionDataMap() }))
+    },
+    staticProperties: {
+      initializer: () => new import_factory_map.FactoryMap((key) => ({ metadataType: "property", key, type: (0, import_reflection.getDesignType)(type, key), isAccessor: false, data: new import_reflection_data_map.ReflectionDataMap() }))
+    },
+    methods: {
+      initializer: () => new import_factory_map.FactoryMap((key) => {
+        const parameters = (0, import_reflection.getParameterTypes)(type.prototype, key);
+        const returnType = (0, import_reflection.getReturnType)(type.prototype, key);
+        if ((0, import_type_guards.isUndefined)(parameters)) {
+          throw new Error(`Could not get parameters for method ${key.toString()} of type ${type.name}`);
         }
-      },
-      properties: {
-        initializer: () => new import_factory_map.FactoryMap((key) => ({ metadataType: "property", key, type: (0, import_reflection.getDesignType)(type.prototype, key), isAccessor: false, data: new import_reflection_data_map.ReflectionDataMap() }))
-      },
-      staticProperties: {
-        initializer: () => new import_factory_map.FactoryMap((key) => ({ metadataType: "property", key, type: (0, import_reflection.getDesignType)(type, key), isAccessor: false, data: new import_reflection_data_map.ReflectionDataMap() }))
-      },
-      methods: {
-        initializer: () => new import_factory_map.FactoryMap((key) => {
-          const parameters = (0, import_reflection.getParameterTypes)(type.prototype, key);
-          const returnType = (0, import_reflection.getReturnType)(type.prototype, key);
-          if ((0, import_type_guards.isUndefined)(parameters)) {
-            throw new Error(`Could not get parameters for method ${key.toString()} of type ${type.name}`);
-          }
-          return { metadataType: "method", parameters: parameters.map((parameter, index) => ({ metadataType: "method-parameter", index, type: parameter, data: new import_reflection_data_map.ReflectionDataMap() })), returnType, data: new import_reflection_data_map.ReflectionDataMap() };
-        })
-      },
-      staticMethods: {
-        initializer: () => new import_factory_map.FactoryMap((key) => {
-          const parameters = (0, import_reflection.getParameterTypes)(type, key);
-          const returnType = (0, import_reflection.getReturnType)(type, key);
-          if ((0, import_type_guards.isUndefined)(parameters)) {
-            throw new Error(`Could not get parameters for static method ${key.toString()} of type ${type.name}`);
-          }
-          return { metadataType: "method", parameters: parameters.map((parameter, index) => ({ metadataType: "method-parameter", index, type: parameter, data: new import_reflection_data_map.ReflectionDataMap() })), returnType, data: new import_reflection_data_map.ReflectionDataMap() };
-        })
-      },
-      data: { initializer: () => new import_reflection_data_map.ReflectionDataMap() }
-    });
-  }
+        return { metadataType: "method", parameters: parameters.map((parameter, index) => ({ metadataType: "method-parameter", index, type: parameter, data: new import_reflection_data_map.ReflectionDataMap() })), returnType, data: new import_reflection_data_map.ReflectionDataMap() };
+      })
+    },
+    staticMethods: {
+      initializer: () => new import_factory_map.FactoryMap((key) => {
+        const parameters = (0, import_reflection.getParameterTypes)(type, key);
+        const returnType = (0, import_reflection.getReturnType)(type, key);
+        if ((0, import_type_guards.isUndefined)(parameters)) {
+          throw new Error(`Could not get parameters for static method ${key.toString()} of type ${type.name}`);
+        }
+        return { metadataType: "method", parameters: parameters.map((parameter, index) => ({ metadataType: "method-parameter", index, type: parameter, data: new import_reflection_data_map.ReflectionDataMap() })), returnType, data: new import_reflection_data_map.ReflectionDataMap() };
+      })
+    },
+    data: { initializer: () => new import_reflection_data_map.ReflectionDataMap() }
+  });
 }
 const reflectionRegistry = new ReflectionRegistry();