lombok-typescript 0.6.0 → 0.8.0

package/dist/legacy/index.cjs

@@ -84,7 +84,12 @@ var MetadataKeys = {
   // Class-level (GoF)
   SINGLETON: `${PREFIX}singleton`,
   FACTORY: `${PREFIX}factory`,
+  ABSTRACT_FACTORY: `${PREFIX}abstractFactory`,
   PROTOTYPE: `${PREFIX}prototype`,
+  COMPOSITE: `${PREFIX}composite`,
+  WRAPS: `${PREFIX}wraps`,
+  FLYWEIGHT: `${PREFIX}flyweight`,
+  PROXY: `${PREFIX}proxy`,
   CHAIN_OF_RESPONSIBILITY: `${PREFIX}chainOfResponsibility`,
   COMMAND: `${PREFIX}command`,
   ITERABLE: `${PREFIX}iterable`,
@@ -92,6 +97,9 @@ var MetadataKeys = {
   MEMENTO_EXCLUDE: `${PREFIX}memento:exclude`,
   STATE: `${PREFIX}state`,
   STRATEGY: `${PREFIX}strategy`,
+  TEMPLATE_METHOD: `${PREFIX}templateMethod`,
+  VISITABLE: `${PREFIX}visitable`,
+  VISITOR: `${PREFIX}visitor`,
   // Field-level
   GETTER: `${PREFIX}getter`,
   SETTER: `${PREFIX}setter`,
@@ -104,6 +112,7 @@ var MetadataKeys = {
   MEMOIZE: `${PREFIX}memoize`,
   HANDLER: `${PREFIX}handler`,
   TRANSITION: `${PREFIX}transition`,
+  HOOK: `${PREFIX}hook`,
   // Parameter-level
   NON_NULL_PARAM: `${PREFIX}nonNull:param`};
 
@@ -849,6 +858,198 @@ function iterateOverFieldLegacy(backend, targetPrototype, propertyKey) {
   registerLegacyIterateField(targetPrototype, propertyKey);
 }
 
+// src/decorators/shared/flyweight.ts
+var pools = /* @__PURE__ */ new WeakMap();
+function getPool(ctor) {
+  let pool = pools.get(ctor);
+  if (!pool) {
+    pool = /* @__PURE__ */ new Map();
+    pools.set(ctor, pool);
+  }
+  return pool;
+}
+function wrapFlyweightClass(target, options) {
+  const pool = getPool(target);
+  const FlyweightClass = class extends target {
+    constructor(...args) {
+      const key = options.key(...args);
+      const existing = pool.get(key);
+      if (existing) {
+        return existing;
+      }
+      super(...args);
+      pool.set(key, this);
+    }
+  };
+  return FlyweightClass;
+}
+function flyweightClassLegacy(backend, target, options) {
+  if (typeof options?.key !== "function") {
+    throw new Error("@Flyweight requires a `key` function in options");
+  }
+  backend.metadata.set(MetadataKeys.FLYWEIGHT, target, void 0, options);
+  return wrapFlyweightClass(target, options);
+}
+
+// src/decorators/shared/composite.ts
+var CHILDREN = /* @__PURE__ */ Symbol("lombok-ts:composite-children");
+function getChildren(instance) {
+  const bag = instance;
+  if (!bag[CHILDREN]) {
+    bag[CHILDREN] = [];
+  }
+  return bag[CHILDREN];
+}
+function wrapCompositeClass(target) {
+  const CompositeClass = class extends target {
+    add(child) {
+      getChildren(this).push(child);
+    }
+    remove(child) {
+      const children = getChildren(this);
+      const index = children.indexOf(child);
+      if (index >= 0) {
+        children.splice(index, 1);
+      }
+    }
+    getChild(index) {
+      const children = getChildren(this);
+      const child = children[index];
+      if (child === void 0) {
+        throw new RangeError(`@Composite: no child at index ${index}`);
+      }
+      return child;
+    }
+    getChildren() {
+      return [...getChildren(this)];
+    }
+    traverse(callback) {
+      const visit = (node) => {
+        callback(node);
+        for (const child of getChildren(node)) {
+          visit(child);
+        }
+      };
+      visit(this);
+    }
+    *[Symbol.iterator]() {
+      yield* getChildren(this);
+    }
+  };
+  return CompositeClass;
+}
+function compositeClassLegacy(backend, target) {
+  backend.metadata.set(MetadataKeys.COMPOSITE, target, void 0, true);
+  return wrapCompositeClass(target);
+}
+
+// src/decorators/shared/proxy.ts
+function isMethod(key, value) {
+  return typeof key === "string" && key !== "constructor" && typeof value === "function";
+}
+function wrapProxyInstance(instance, hooks) {
+  const proto = Object.getPrototypeOf(instance);
+  return new Proxy(instance, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (!isMethod(prop, value)) {
+        return value;
+      }
+      const original = Object.getOwnPropertyDescriptor(proto, prop)?.value ?? value;
+      return (...args) => {
+        const methodName = String(prop);
+        hooks.before?.(methodName, args);
+        const result = original.apply(target, args);
+        hooks.after?.(methodName, result);
+        return result;
+      };
+    }
+  });
+}
+function wrapProxyClass(target, hooks) {
+  const ProxyClass = class extends target {
+    constructor(...args) {
+      super(...args);
+      return wrapProxyInstance(this, hooks);
+    }
+  };
+  return ProxyClass;
+}
+function proxyClassLegacy(backend, target, hooks = {}) {
+  backend.metadata.set(MetadataKeys.PROXY, target, void 0, hooks);
+  return wrapProxyClass(target, hooks);
+}
+
+// src/decorators/shared/wraps.ts
+var INNER = /* @__PURE__ */ Symbol("lombok-ts:wraps-inner");
+function wrapWrapsClass(target, InnerClass) {
+  if (typeof InnerClass !== "function") {
+    throw new TypeError("@Wraps requires a constructor function");
+  }
+  const WrapsClass = class extends target {
+    inner;
+    constructor(...args) {
+      super();
+      const inner = args[0];
+      if (inner === void 0 || !(inner instanceof InnerClass)) {
+        throw new TypeError(`@Wraps(${InnerClass.name}) expects an instance as the first argument`);
+      }
+      this.inner = inner;
+      this[INNER] = inner;
+    }
+  };
+  return WrapsClass;
+}
+function wrapsClassLegacy(backend, target, InnerClass) {
+  backend.metadata.set(MetadataKeys.WRAPS, target, void 0, InnerClass);
+  return wrapWrapsClass(target, InnerClass);
+}
+
+// src/decorators/shared/template-method.ts
+function templateMethodClassLegacy(backend, target, options) {
+  if (!Array.isArray(options?.steps) || options.steps.length === 0) {
+    throw new Error("@TemplateMethod requires a non-empty `steps` array");
+  }
+  backend.metadata.set(MetadataKeys.TEMPLATE_METHOD, target, void 0, options);
+}
+
+// src/decorators/shared/hook.ts
+function hookMethodLegacy(backend, targetPrototype, propertyKey, options) {
+  backend.metadata.set(MetadataKeys.HOOK, targetPrototype, propertyKey, options);
+}
+
+// src/decorators/shared/abstract-factory.ts
+function normalizeProducts(productsOrOptions) {
+  const products = Array.isArray(productsOrOptions) ? productsOrOptions : productsOrOptions.products;
+  if (!Array.isArray(products) || products.length === 0) {
+    throw new Error("@AbstractFactory requires a non-empty product list");
+  }
+  return products;
+}
+function abstractFactoryClassLegacy(backend, target, productsOrOptions) {
+  const products = normalizeProducts(productsOrOptions);
+  backend.metadata.set(MetadataKeys.ABSTRACT_FACTORY, target, void 0, { products });
+}
+
+// src/decorators/shared/visitor.ts
+var visitableRegistry = /* @__PURE__ */ new Map();
+function registerVisitable(name, ctor) {
+  visitableRegistry.set(name, ctor);
+}
+function getVisitableRegistry() {
+  return visitableRegistry;
+}
+function visitorClassLegacy(backend, target, options) {
+  if (!options?.visitMethods || typeof options.visitMethods !== "object") {
+    throw new Error("@Visitor requires a `visitMethods` map");
+  }
+  backend.metadata.set(MetadataKeys.VISITOR, target, void 0, options);
+}
+function visitableClassLegacy(backend, target, options = {}) {
+  backend.metadata.set(MetadataKeys.VISITABLE, target, void 0, options);
+  registerVisitable(target.name, target);
+}
+
 // src/decorators/legacy/index.ts
 var NonNull = defineFieldDecorator(nonNullFieldLegacy);
 function NonNullParam() {
@@ -954,20 +1155,54 @@ function Handler(options) {
 }
 var Iterable = defineClassDecorator(iterableClassLegacy);
 var IterateOver = defineFieldDecorator(iterateOverFieldLegacy);
+function Flyweight(options) {
+  return defineClassDecorator((backend, target) => flyweightClassLegacy(backend, target, options));
+}
+var Composite = defineClassDecorator(compositeClassLegacy);
+function Proxy2(hooks = {}) {
+  return defineClassDecorator((backend, target) => proxyClassLegacy(backend, target, hooks));
+}
+function Wraps(InnerClass) {
+  return defineClassDecorator((backend, target) => wrapsClassLegacy(backend, target, InnerClass));
+}
+function TemplateMethod(options) {
+  return defineClassDecorator(
+    (backend, target) => templateMethodClassLegacy(backend, target, options)
+  );
+}
+function Hook(options) {
+  return defineMethodDecorator((backend, target, key) => {
+    const name = options?.name ?? String(key);
+    hookMethodLegacy(backend, target, key, { name });
+  });
+}
+function AbstractFactory(products) {
+  return defineClassDecorator(
+    (backend, target) => abstractFactoryClassLegacy(backend, target, products)
+  );
+}
+function Visitor(options) {
+  return defineClassDecorator((backend, target) => visitorClassLegacy(backend, target, options));
+}
+var Visitable = defineClassDecorator(visitableClassLegacy);
 
+exports.AbstractFactory = AbstractFactory;
 exports.Accessors = Accessors;
 exports.Builder = Builder;
 exports.ChainOfResponsibility = ChainOfResponsibility;
 exports.Command = Command;
 exports.CommandHistory = CommandHistory;
+exports.Composite = Composite;
 exports.Data = Data;
 exports.Delegate = Delegate;
 exports.Equals = Equals;
 exports.EqualsExclude = EqualsExclude;
 exports.Factory = Factory;
 exports.FieldDefaults = FieldDefaults;
+exports.Flyweight = Flyweight;
 exports.Getter = Getter;
 exports.Handler = Handler;
+exports.Hook = Hook;
 exports.Iterable = Iterable;
 exports.IterateOver = IterateOver;
 exports.LegacyBackend = LegacyBackend;
@@ -979,16 +1214,21 @@ exports.NonNullParam = NonNullParam;
 exports.Observable = Observable;
 exports.Observer = Observer;
 exports.Prototype = Prototype;
+exports.Proxy = Proxy2;
 exports.Setter = Setter;
 exports.Singleton = Singleton;
 exports.State = State;
 exports.Strategy = Strategy;
 exports.StrategyRegistry = StrategyRegistry;
+exports.TemplateMethod = TemplateMethod;
 exports.ToString = ToString;
 exports.Transition = Transition;
 exports.UtilityClass = UtilityClass;
 exports.Value = Value;
+exports.Visitable = Visitable;
+exports.Visitor = Visitor;
 exports.With = With;
+exports.Wraps = Wraps;
 exports.createFromFactory = createFromFactory;
 exports.defineClassDecorator = defineClassDecorator;
 exports.defineFieldDecorator = defineFieldDecorator;
@@ -997,6 +1237,7 @@ exports.defineParameterDecorator = defineParameterDecorator;
 exports.getFactoryRegistry = getFactoryRegistry;
 exports.getStrategyFromRegistry = getStrategyFromRegistry;
 exports.getStrategyRegistry = getStrategyRegistry;
+exports.getVisitableRegistry = getVisitableRegistry;
 exports.legacyBackend = legacyBackend;
 exports.listStrategies = listStrategies;
 exports.registerFactory = registerFactory;