lombok-typescript 0.6.0 → 0.8.0

package/README.md

@@ -2,18 +2,24 @@
 
 TypeScript decorators inspired by Project Lombok and common design patterns. Supports legacy `experimentalDecorators` and Stage 3 decorators via separate entry points.
 
-[![npm latest](https://img.shields.io/npm/v/lombok-typescript/latest?label=latest&logo=npm&color=CB3837)](https://www.npmjs.com/package/lombok-typescript)
-[![npm preview](https://img.shields.io/npm/v/lombok-typescript/preview?label=preview&logo=npm&color=CB3837)](https://www.npmjs.com/package/lombok-typescript/v/preview)
-[![TypeScript](https://img.shields.io/badge/TypeScript-%E2%89%A56.0-blue?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
-[![Node](https://img.shields.io/badge/node-%E2%89%A522-brightgreen&logo=node.js&logoColor=white)](https://nodejs.org/)
-[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![version](https://img.shields.io/badge/npm-0.8.0-007ec6?logo=npm&label=version)](https://www.npmjs.com/package/lombok-typescript/v/0.8.0)
+[![preview](https://img.shields.io/npm/v/lombok-typescript/preview?label=preview&logo=npm&color=007ec6)](https://www.npmjs.com/package/lombok-typescript/v/preview)
+
+[![TypeScript](https://img.shields.io/badge/TypeScript-6.0+-3178c6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-22+-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![License](https://img.shields.io/badge/License-MIT-007ec6.svg)](https://opensource.org/licenses/MIT)
+
+[![bundle size](https://img.shields.io/bundlephobia/minzip/lombok-typescript@0.8.0?label=bundle%20size&color=007ec6)](https://bundlephobia.com/package/lombok-typescript@0.8.0)
+[![deps.dev](https://img.shields.io/badge/deps.dev-package-007ec6?logo=googlechrome)](https://deps.dev/npm/lombok-typescript/0.8.0)
+[![Socket](https://img.shields.io/badge/Socket-Supply%20Chain%2078-007ec6?logo=socket)](https://socket.dev/npm/package/lombok-typescript)
+[![Snyk](https://img.shields.io/snyk/vulnerabilities/npm/lombok-typescript?label=snyk&color=007ec6)](https://snyk.io/advisor/npm-package/lombok-typescript)
 
 ## Install
 
 Install this release:
 
 ```bash
-npm install lombok-typescript@0.6.0
+npm install lombok-typescript@0.8.0
 ```
 
 Install the current `latest` tag (stable release):
@@ -52,6 +58,7 @@ npm install lombok-typescript@preview
 - @Singleton
 - @Prototype
 - @Factory
+- @AbstractFactory
 
 ### Behavioral patterns
 
@@ -62,6 +69,17 @@ npm install lombok-typescript@preview
 - @Observable
 - @ChainOfResponsibility
 - @Iterable
+- @Visitor
+- @Visitable
+- @Hook
+
+### Structural patterns
+
+- @Flyweight
+- @Proxy
+- @Composite
+- @Wraps
+- @TemplateMethod
 
 ### TypeScript utilities
 

package/dist/cli/index.cjs

@@ -110,7 +110,10 @@ var CODEGEN_CLASS_DECORATORS = [
   "ToString",
   "Value",
   "Equals",
-  "With"
+  "With",
+  "TemplateMethod",
+  "AbstractFactory",
+  "Visitable"
 ];
 function hasCodegenClassDecorator(info) {
   return CODEGEN_CLASS_DECORATORS.some((name) => hasClassDecorator(info, name)) || info.fields.some(
@@ -215,6 +218,54 @@ function getDelegateMethods(field) {
   }
   return dec.arguments.map((a) => String(a).replace(/^['"]|['"]$/g, ""));
 }
+function parseDecoratorObjectArg(dec) {
+  if (!dec || dec.arguments.length === 0) return {};
+  const [first] = dec.arguments;
+  if (typeof first !== "string" || !first.startsWith("{")) return {};
+  try {
+    return JSON.parse(first.replace(/(\w+):/g, '"$1":').replace(/'/g, '"'));
+  } catch {
+    return {};
+  }
+}
+function parseDecoratorArrayArg(dec) {
+  if (!dec || dec.arguments.length === 0) return [];
+  const [first] = dec.arguments;
+  const text = String(first);
+  if (!text.startsWith("[")) return [];
+  try {
+    return JSON.parse(text.replace(/'/g, '"'));
+  } catch {
+    return [];
+  }
+}
+function getAbstractFactoryProducts(info) {
+  const dec = info.decorators.find((d) => d.name === "AbstractFactory");
+  const fromArray = parseDecoratorArrayArg(dec);
+  if (fromArray.length > 0) return fromArray;
+  const obj = parseDecoratorObjectArg(dec);
+  return Array.isArray(obj.products) ? obj.products : [];
+}
+function getTemplateMethodSteps(info) {
+  const dec = info.decorators.find((d) => d.name === "TemplateMethod");
+  const obj = parseDecoratorObjectArg(dec);
+  return Array.isArray(obj.steps) ? obj.steps : [];
+}
+function getTemplateMethodName(info) {
+  const dec = info.decorators.find((d) => d.name === "TemplateMethod");
+  const obj = parseDecoratorObjectArg(dec);
+  return typeof obj.template === "string" ? obj.template : "execute";
+}
+function getHookMethodNames(info) {
+  return info.methods.filter((m) => m.decorators.some((d) => d.name === "Hook")).map((m) => {
+    const hookDec = m.decorators.find((d) => d.name === "Hook");
+    const opts = parseDecoratorObjectArg(hookDec);
+    return typeof opts.name === "string" ? opts.name : m.name;
+  });
+}
+function visitMethodName(className) {
+  return `visit${className}`;
+}
 
 // src/codegen/emitters/accessors-emit.ts
 function emitGetterFn(info, field) {
@@ -264,6 +315,23 @@ function emitAccessorApplyAssignments(info) {
   return assignments;
 }
 
+// src/codegen/emitters/abstract-factory-emit.ts
+function emitAbstractFactoryMixin(info) {
+  if (!hasClassDecorator(info, "AbstractFactory")) return "";
+  const products = getAbstractFactoryProducts(info);
+  if (products.length === 0) {
+    throw new Error(`@AbstractFactory on ${info.name}: product list is empty`);
+  }
+  const methods = products.map((product) => {
+    const methodName = `create${product}`;
+    return `  abstract ${methodName}(): ${product};`;
+  }).join("\n");
+  return `
+export abstract class ${info.name}Mixin {
+${methods}
+}`.trim();
+}
+
 // src/codegen/emitters/builder.ts
 function emitBuilderClass(info) {
   if (!hasClassDecorator(info, "Builder")) {
@@ -363,6 +431,25 @@ function emitDeclarationModuleBlock(relSource, classes) {
     if (hasClassDecorator(info, "Iterable")) {
       augments.push("    [Symbol.iterator](): IterableIterator<unknown>;");
     }
+    if (hasClassDecorator(info, "Composite")) {
+      augments.push("    add(child: object): void;");
+      augments.push("    remove(child: object): void;");
+      augments.push("    getChild(index: number): object;");
+      augments.push("    getChildren(): readonly object[];");
+      augments.push("    traverse(callback: (node: object) => void): void;");
+      augments.push("    [Symbol.iterator](): IterableIterator<object>;");
+    }
+    if (hasClassDecorator(info, "Wraps")) {
+      const dec = info.decorators.find((d) => d.name === "Wraps");
+      const innerName = dec?.arguments[0] ? String(dec.arguments[0]) : "unknown";
+      augments.push(`    protected inner: ${innerName};`);
+    }
+    if (hasClassDecorator(info, "Visitable")) {
+      augments.push("    accept(visitor: unknown): unknown;");
+    }
+    if (hasClassDecorator(info, "TemplateMethod")) {
+      augments.push(`    ${getTemplateMethodName(info)}(): void;`);
+    }
     if (augments.length > 0) {
       lines.push(`  interface ${info.name} {`);
       lines.push(...augments);
@@ -462,13 +549,68 @@ function emitWithFns(info) {
   return fields.map((f) => emitSingleWithFn(info, f)).join("\n\n");
 }
 
+// src/codegen/emitters/template-method-emit.ts
+function emitTemplateMethodFn(info) {
+  if (!hasClassDecorator(info, "TemplateMethod")) return "";
+  const templateName = getTemplateMethodName(info);
+  const steps = getTemplateMethodSteps(info);
+  const hookNames = getHookMethodNames(info);
+  for (const step of steps) {
+    if (!hookNames.includes(step)) {
+      throw new Error(`@TemplateMethod on ${info.name}: missing @Hook method for step "${step}"`);
+    }
+  }
+  const calls = steps.map((step) => `this.${step}();`).join(" ");
+  return `
+function ${info.name}_${templateName}(this: ${info.name}): void {
+  ${calls}
+}`.trim();
+}
+function emitTemplateMethodApplyAssignment(info) {
+  if (!hasClassDecorator(info, "TemplateMethod")) return void 0;
+  const templateName = getTemplateMethodName(info);
+  return `prototype.${templateName} = ${info.name}_${templateName};`;
+}
+
+// src/codegen/emitters/visitor-emit.ts
+function emitVisitableAcceptFn(info) {
+  if (!hasClassDecorator(info, "Visitable")) return "";
+  const methodName = visitMethodName(info.name);
+  return `
+function ${info.name}_accept(this: ${info.name}, visitor: unknown): unknown {
+  const handler = (visitor as Record<string, unknown>)['${methodName}'];
+  if (typeof handler !== 'function') {
+    throw new Error(\`Visitor missing ${methodName} for ${info.name}\`);
+  }
+  return handler.call(visitor, this);
+}`.trim();
+}
+function emitVisitableAcceptApplyAssignment(info) {
+  if (!hasClassDecorator(info, "Visitable")) return void 0;
+  return `prototype.accept = ${info.name}_accept;`;
+}
+
 // src/codegen/emitters/index.ts
 function emitImports(classes, importPath) {
   const names = classes.filter(hasCodegenClassDecorator).map((c) => c.name);
-  if (names.length === 0) return "";
-  return `import { ${names.join(", ")} } from '${importPath}';
-
-`;
+  const productTypes = /* @__PURE__ */ new Set();
+  for (const info of classes) {
+    if (hasClassDecorator(info, "AbstractFactory")) {
+      for (const product of getAbstractFactoryProducts(info)) {
+        productTypes.add(product);
+      }
+    }
+  }
+  const importLines = [];
+  if (names.length > 0) {
+    importLines.push(`import { ${names.join(", ")} } from '${importPath}';`);
+  }
+  const extraProducts = [...productTypes].filter((p) => !names.includes(p));
+  if (extraProducts.length > 0) {
+    importLines.push(`import type { ${extraProducts.join(", ")} } from '${importPath}';`);
+  }
+  if (importLines.length === 0) return "";
+  return importLines.join("\n") + "\n\n";
 }
 function emitToStringFn(info) {
   if (!wantsToString(info)) return "";
@@ -507,6 +649,10 @@ function emitApplyMixin(info) {
       `(ctor as typeof ${info.name} & { equals(a: ${info.name} | null | undefined, b: ${info.name} | null | undefined): boolean }).equals = ${info.name}_equalsStatic;`
     );
   }
+  const templateApply = emitTemplateMethodApplyAssignment(info);
+  if (templateApply) assignments.push(templateApply);
+  const visitableApply = emitVisitableAcceptApplyAssignment(info);
+  if (visitableApply) assignments.push(visitableApply);
   if (assignments.length === 0) return "";
   return `
 export function apply${info.name}Generated(ctor: typeof ${info.name}): void {
@@ -540,6 +686,12 @@ function emitClassCompanionBlocks(info) {
   if (delegate) blocks.push(delegate);
   const builderFn = emitBuilderFn(info);
   if (builderFn) blocks.push(builderFn);
+  const templateMethod = emitTemplateMethodFn(info);
+  if (templateMethod) blocks.push(templateMethod);
+  const visitableAccept = emitVisitableAcceptFn(info);
+  if (visitableAccept) blocks.push(visitableAccept);
+  const abstractFactory = emitAbstractFactoryMixin(info);
+  if (abstractFactory) blocks.push(abstractFactory);
   const apply = emitApplyMixin(info);
   if (apply) blocks.push(apply);
   return blocks.filter(Boolean).join("\n\n");