@tstdl/base 0.85.23 → 0.85.25

package/decorators/log.js

@@ -22,22 +22,29 @@ __export(log_exports, {
 });
 module.exports = __toCommonJS(log_exports);
 var import_log = require("../function/log.js");
-var import_registry = require("../reflection/registry.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 logWrapped = Symbol("logged wrapped");
+const wrappedStaticMethods = /* @__PURE__ */ new WeakMap();
+const wrappedInstanceMethods = /* @__PURE__ */ new WeakMap();
+function isWrapped(constructor, property, isStatic) {
+  return (isStatic ? wrappedStaticMethods : wrappedInstanceMethods).get(constructor)?.has(property) ?? false;
+}
+function setWrapped(constructor, property, isStatic) {
+  const map = isStatic ? wrappedStaticMethods : wrappedInstanceMethods;
+  if (!map.has(constructor)) {
+    map.set(constructor, /* @__PURE__ */ new Set());
+  }
+  map.get(constructor).add(property);
+}
 function Log() {
-  return (0, import_utils.createDecorator)({ class: true, method: true }, (data, metadata) => {
-    if (metadata.data.has(logWrapped)) {
-      return void 0;
-    }
-    metadata.data.set(logWrapped, true);
+  return (0, import_utils.createDecorator)({ class: true, method: true }, (data) => {
     if (data.type == "method") {
+      setWrapped(data.constructor, data.methodKey, data.static);
       return { value: (0, import_log.wrapLog)(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]) && !(import_registry.reflectionRegistry.getMetadata(data.constructor)?.staticMethods.get(property)?.data.has(logWrapped) ?? false));
-    const instanceProperties = (0, import_object.objectKeys)(data.prototype).filter((property) => property != "constructor" && (0, import_type_guards.isFunction)(data.prototype[property]) && !(import_registry.reflectionRegistry.getMetadata(data.constructor)?.methods.get(property)?.data.has(logWrapped) ?? false));
+    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, true));
+    const instanceProperties = (0, import_object.objectKeys)(data.prototype).filter((property) => property != "constructor" && (0, import_type_guards.isFunction)(data.prototype[property]) && !isWrapped(data.constructor, property, false));
     for (const property of staticProperties) {
       data.constructor[property] = (0, import_log.wrapLog)(data.constructor[property], property);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.85.23",
+  "version": "0.85.25",
   "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();