lombok-typescript 0.1.0 → 0.2.0

package/dist/codegen/index.js

@@ -69,31 +69,190 @@ function toParameterInfo(param) {
     decorators: param.getDecorators().map(toDecoratorInfo)
   };
 }
+
+// src/decorators/shared/composition.ts
+var CONFLICTING_CLASS_DECORATOR_PAIRS = [
+  ["Data", "Value"]
+];
+function classHasDecorator(info, name) {
+  return info.decorators.some((d) => d.name === name);
+}
+function validateClassComposition(info) {
+  for (const [a, b] of CONFLICTING_CLASS_DECORATOR_PAIRS) {
+    if (classHasDecorator(info, a) && classHasDecorator(info, b)) {
+      throw new Error(`Class "${info.name}": @${a} and @${b} cannot be used together.`);
+    }
+  }
+}
+function validateAllClassCompositions(classes) {
+  for (const info of classes) {
+    validateClassComposition(info);
+  }
+}
 function toImportPath(sourcePath, fromDir) {
   let rel = relative(fromDir, sourcePath).replace(/\\/g, "/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return rel.replace(/\.tsx?$/u, ".js");
 }
+var CODEGEN_CLASS_DECORATORS = [
+  "Builder",
+  "Data",
+  "ToString",
+  "Value",
+  "Equals",
+  "With"
+];
 function hasCodegenClassDecorator(info) {
-  return hasClassDecorator(info, "Builder") || hasClassDecorator(info, "Data") || hasClassDecorator(info, "ToString");
+  return CODEGEN_CLASS_DECORATORS.some((name) => hasClassDecorator(info, name)) || info.fields.some(
+    (f) => fieldHasDecorator(f, "Getter") || fieldHasDecorator(f, "Setter") || fieldHasDecorator(f, "With") || fieldHasDecorator(f, "Delegate")
+  );
 }
 function hasClassDecorator(info, name) {
   return info.decorators.some((d) => d.name === name);
 }
+function fieldHasDecorator(field, name) {
+  return field.decorators.some((d) => d.name === name);
+}
 function fieldExcludesToString(field) {
   return field.decorators.some(
     (d) => d.name === "ToStringExclude" || d.name === "ToString.Exclude"
   );
 }
+function fieldExcludesEquals(field) {
+  return field.decorators.some((d) => d.name === "EqualsExclude" || d.name === "Equals.Exclude");
+}
 function visibleFields(info) {
-  if (hasClassDecorator(info, "ToString")) {
+  if (hasClassDecorator(info, "ToString") || hasClassDecorator(info, "Data") || hasClassDecorator(info, "Value")) {
     return info.fields.filter((f) => !fieldExcludesToString(f));
   }
   return info.fields;
 }
+function equalsFields(info) {
+  return info.fields.filter((f) => !fieldExcludesEquals(f));
+}
+function getterName(fieldName) {
+  return `get${fieldName.charAt(0).toUpperCase()}${fieldName.slice(1)}`;
+}
+function setterName(fieldName) {
+  return `set${fieldName.charAt(0).toUpperCase()}${fieldName.slice(1)}`;
+}
+function withMethodName(fieldName) {
+  return `with${fieldName.charAt(0).toUpperCase()}${fieldName.slice(1)}`;
+}
 function builderClassName(className) {
   return `${className}Builder`;
 }
+function hasDataOrValue(info) {
+  return hasClassDecorator(info, "Data") || hasClassDecorator(info, "Value");
+}
+function wantsWithMethods(info, field) {
+  return hasClassDecorator(info, "Value") || hasClassDecorator(info, "With") || fieldHasDecorator(field, "With");
+}
+function wantsGetter(info, field) {
+  return hasDataOrValue(info) || fieldHasDecorator(field, "Getter");
+}
+function wantsSetter(info, field) {
+  if (hasClassDecorator(info, "Value")) return false;
+  if (hasClassDecorator(info, "Data")) return !effectiveReadonly(info, field);
+  return fieldHasDecorator(field, "Setter");
+}
+function wantsEquals(info) {
+  return hasClassDecorator(info, "Data") || hasClassDecorator(info, "Value") || hasClassDecorator(info, "Equals");
+}
+function wantsToString(info) {
+  return hasClassDecorator(info, "ToString") || hasClassDecorator(info, "Data") || hasClassDecorator(info, "Value");
+}
+function effectiveReadonly(info, field) {
+  if (field.isReadonly) return true;
+  const defaults = getFieldDefaultsOptions(info);
+  return defaults?.makeFinal === true;
+}
+function getFieldDefaultsOptions(info) {
+  const dec = info.decorators.find((d) => d.name === "FieldDefaults");
+  if (!dec) return void 0;
+  const [first] = dec.arguments;
+  if (typeof first === "string" && first.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(first.replace(/(\w+):/g, '"$1":').replace(/'/g, '"'));
+      return {
+        level: parsed.level ?? "public",
+        makeFinal: parsed.makeFinal ?? false
+      };
+    } catch {
+      return { level: "public", makeFinal: false };
+    }
+  }
+  return { level: "public", makeFinal: false };
+}
+function hasFluentAccessors(info) {
+  const dec = info.decorators.find((d) => d.name === "Accessors");
+  if (!dec) return false;
+  const [first] = dec.arguments;
+  if (typeof first === "string") {
+    return first.includes("chain") || first.includes("fluent");
+  }
+  return false;
+}
+function getDelegateMethods(field) {
+  const dec = field.decorators.find((d) => d.name === "Delegate");
+  if (!dec || dec.arguments.length === 0) return [];
+  if (dec.arguments.length === 1 && String(dec.arguments[0]).startsWith("[")) {
+    try {
+      return JSON.parse(String(dec.arguments[0]).replace(/'/g, '"'));
+    } catch {
+      return [];
+    }
+  }
+  return dec.arguments.map((a) => String(a).replace(/^['"]|['"]$/g, ""));
+}
+
+// src/codegen/emitters/accessors-emit.ts
+function emitGetterFn(info, field) {
+  const g = getterName(field.name);
+  return `
+function ${info.name}_${g}(this: ${info.name}): ${field.type} {
+  return this.${field.name};
+}`.trim();
+}
+function emitSetterFn(info, field) {
+  const s = setterName(field.name);
+  const fluent = hasFluentAccessors(info);
+  const ret = fluent ? `return this;` : "";
+  const returnType = fluent ? info.name : "void";
+  return `
+function ${info.name}_${s}(this: ${info.name}, value: ${field.type}): ${returnType} {
+  this.${field.name} = value;
+  ${ret}
+}`.trim();
+}
+function emitAccessorFns(info) {
+  const fns = [];
+  for (const field of info.fields) {
+    if (wantsGetter(info, field)) {
+      fns.push(emitGetterFn(info, field));
+    }
+    if (wantsSetter(info, field)) {
+      fns.push(emitSetterFn(info, field));
+    }
+  }
+  return fns.join("\n\n");
+}
+function emitAccessorApplyAssignments(info) {
+  const assignments = [];
+  for (const field of info.fields) {
+    if (wantsGetter(info, field)) {
+      assignments.push(
+        `prototype.${getterName(field.name)} = ${info.name}_${getterName(field.name)};`
+      );
+    }
+    if (wantsSetter(info, field)) {
+      assignments.push(
+        `prototype.${setterName(field.name)} = ${info.name}_${setterName(field.name)};`
+      );
+    }
+  }
+  return assignments;
+}
 
 // src/codegen/emitters/builder.ts
 function emitBuilderClass(info) {
@@ -131,16 +290,8 @@ ${info.fields.map((f) => `    instance.${f.name} = this._${f.name}${f.isOptional
   }
 }`.trim();
 }
-function emitDeclarationShim(sourcePath, companionOutputPath, classes) {
-  const relSource = toImportPath(sourcePath, dirname(companionOutputPath));
-  const lines = [
-    "// Auto-generated type augmentation by lombok-typescript.",
-    "// Do not edit. Regenerate via `lombok-ts generate`.",
-    "",
-    "export {};",
-    "",
-    `declare module '${relSource}' {`
-  ];
+function emitDeclarationModuleBlock(relSource, classes) {
+  const lines = [`declare module '${relSource}' {`];
   for (const info of classes) {
     if (hasClassDecorator(info, "Builder")) {
       const builderName = builderClassName(info.name);
@@ -155,24 +306,33 @@ function emitDeclarationShim(sourcePath, companionOutputPath, classes) {
     }
     if (hasClassDecorator(info, "Builder")) {
       const builderName = builderClassName(info.name);
-      lines.push(`  export class ${info.name} {`);
-      lines.push(`    static builder(): ${builderName};`);
+      lines.push(`  namespace ${info.name} {`);
+      lines.push(`    export function builder(): ${builderName};`);
       lines.push("  }");
       lines.push("");
     }
     const augments = [];
-    if (hasClassDecorator(info, "Data")) {
-      for (const f of info.fields) {
-        const g = `get${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
-        augments.push(`    ${g}(): ${f.type};`);
-        if (!f.isReadonly) {
-          const s = `set${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
-          augments.push(`    ${s}(value: ${f.type}): void;`);
+    for (const f of info.fields) {
+      if (wantsGetter(info, f)) {
+        augments.push(`    ${getterName(f.name)}(): ${f.type};`);
+      }
+      if (wantsSetter(info, f)) {
+        const ret = hasClassDecorator(info, "Accessors") ? info.name : "void";
+        augments.push(`    ${setterName(f.name)}(value: ${f.type}): ${ret};`);
+      }
+      if (wantsWithMethods(info, f)) {
+        augments.push(`    ${withMethodName(f.name)}(value: ${f.type}): ${info.name};`);
+      }
+      if (fieldHasDecorator(f, "Delegate")) {
+        for (const method of getDelegateMethods(f)) {
+          augments.push(`    ${method}(...args: unknown[]): unknown;`);
         }
       }
+    }
+    if (wantsEquals(info)) {
       augments.push(`    equals(other: ${info.name} | null | undefined): boolean;`);
-      augments.push(`    toString(): string;`);
-    } else if (hasClassDecorator(info, "ToString")) {
+    }
+    if (wantsToString(info)) {
       augments.push("    toString(): string;");
     }
     if (augments.length > 0) {
@@ -180,11 +340,99 @@ function emitDeclarationShim(sourcePath, companionOutputPath, classes) {
       lines.push(...augments);
       lines.push("  }");
     }
+    if (hasClassDecorator(info, "Equals")) {
+      lines.push(`  namespace ${info.name} {`);
+      lines.push(
+        `    export function equals(a: ${info.name} | null | undefined, b: ${info.name} | null | undefined): boolean;`
+      );
+      lines.push("  }");
+      lines.push("");
+    }
   }
   lines.push("}");
-  lines.push("");
   return lines.join("\n");
 }
+function emitDeclarationShim(sourcePath, companionOutputPath, classes) {
+  const relSource = toImportPath(sourcePath, dirname(companionOutputPath));
+  const moduleBlock = emitDeclarationModuleBlock(relSource, classes);
+  return [
+    "// Auto-generated type augmentation by lombok-typescript.",
+    "// Do not edit. Regenerate via `lombok-ts generate`.",
+    "",
+    "export {};",
+    "",
+    moduleBlock,
+    ""
+  ].join("\n");
+}
+
+// src/codegen/emitters/delegate-emit.ts
+function emitDelegateFns(info) {
+  const fns = [];
+  for (const field of info.fields) {
+    if (!fieldHasDecorator(field, "Delegate")) continue;
+    const methods = getDelegateMethods(field);
+    for (const method of methods) {
+      fns.push(
+        `
+function ${info.name}_${method}(this: ${info.name}, ...args: unknown[]): unknown {
+  const target = this.${field.name} as { ${method}: (...a: unknown[]) => unknown };
+  return target.${method}(...args);
+}`.trim()
+      );
+    }
+  }
+  return fns.join("\n\n");
+}
+function emitDelegateApplyAssignments(info) {
+  const assignments = [];
+  for (const field of info.fields) {
+    if (!fieldHasDecorator(field, "Delegate")) continue;
+    for (const method of getDelegateMethods(field)) {
+      assignments.push(`prototype.${method} = ${info.name}_${method};`);
+    }
+  }
+  return assignments;
+}
+
+// src/codegen/emitters/equals-emit.ts
+function emitEqualsFn(info) {
+  if (!wantsEquals(info)) return "";
+  const fields = equalsFields(info);
+  const checks = fields.map((f) => `this.${f.name} === other.${f.name}`).join(" &&\n    ");
+  return `
+function ${info.name}_equals(this: ${info.name}, other: ${info.name} | null | undefined): boolean {
+  if (other === null || other === undefined) return false;
+  if (!(other instanceof (this.constructor as typeof ${info.name}))) return false;
+  return ${checks || "true"};
+}`.trim();
+}
+function emitEqualsStaticFn(info) {
+  if (!hasClassDecorator(info, "Equals")) return "";
+  return `
+function ${info.name}_equalsStatic(a: ${info.name} | null | undefined, b: ${info.name} | null | undefined): boolean {
+  if (a === b) return true;
+  if (a === null || a === undefined || b === null || b === undefined) return false;
+  return a.equals(b);
+}`.trim();
+}
+
+// src/codegen/emitters/with-emit.ts
+function emitSingleWithFn(info, field) {
+  const method = withMethodName(field.name);
+  return `
+function ${info.name}_${method}(this: ${info.name}, value: ${field.type}): ${info.name} {
+  const copy = Object.create(Object.getPrototypeOf(this)) as ${info.name};
+  Object.assign(copy, this);
+  copy.${field.name} = value;
+  return copy;
+}`.trim();
+}
+function emitWithFns(info) {
+  const fields = info.fields.filter((f) => wantsWithMethods(info, f));
+  if (fields.length === 0) return "";
+  return fields.map((f) => emitSingleWithFn(info, f)).join("\n\n");
+}
 
 // src/codegen/emitters/index.ts
 function emitImports(classes, importPath) {
@@ -195,7 +443,7 @@ function emitImports(classes, importPath) {
 `;
 }
 function emitToStringFn(info) {
-  if (!hasClassDecorator(info, "ToString") && !hasClassDecorator(info, "Data")) return "";
+  if (!wantsToString(info)) return "";
   const fields = visibleFields(info);
   const parts = fields.map((f) => `${f.name}=\${String(this.${f.name})}`).join(", ");
   return `
@@ -205,26 +453,32 @@ function ${info.name}_toString(this: ${info.name}): string {
 }
 function emitApplyMixin(info) {
   const assignments = [];
-  if (hasClassDecorator(info, "Data")) {
-    for (const f of info.fields) {
-      const g = `get${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
-      assignments.push(`prototype.${g} = ${info.name}_${g};`);
-      if (!f.isReadonly) {
-        const s = `set${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
-        assignments.push(`prototype.${s} = ${info.name}_${s};`);
-      }
-    }
+  assignments.push(...emitAccessorApplyAssignments(info));
+  assignments.push(...emitDelegateApplyAssignments(info));
+  if (wantsEquals(info)) {
     assignments.push(`prototype.equals = ${info.name}_equals;`);
-    assignments.push(`prototype.toString = ${info.name}_toString;`);
-  } else if (hasClassDecorator(info, "ToString")) {
+  }
+  if (wantsToString(info)) {
     assignments.push(`prototype.toString = ${info.name}_toString;`);
   }
+  for (const field of info.fields) {
+    if (wantsWithMethods(info, field)) {
+      assignments.push(
+        `prototype.${withMethodName(field.name)} = ${info.name}_${withMethodName(field.name)};`
+      );
+    }
+  }
   if (hasClassDecorator(info, "Builder")) {
     const bName = builderClassName(info.name);
     assignments.push(
       `(ctor as typeof ${info.name} & { builder(): ${bName} }).builder = ${info.name}_builder;`
     );
   }
+  if (hasClassDecorator(info, "Equals")) {
+    assignments.push(
+      `(ctor as typeof ${info.name} & { equals(a: ${info.name} | null | undefined, b: ${info.name} | null | undefined): boolean }).equals = ${info.name}_equalsStatic;`
+    );
+  }
   if (assignments.length === 0) return "";
   return `
 export function apply${info.name}Generated(ctor: typeof ${info.name}): void {
@@ -232,39 +486,6 @@ export function apply${info.name}Generated(ctor: typeof ${info.name}): void {
   ${assignments.join("\n  ")}
 }`.trim();
 }
-function emitDataFns(info) {
-  if (!hasClassDecorator(info, "Data")) return "";
-  const fns = [];
-  for (const f of info.fields) {
-    const g = `get${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
-    fns.push(
-      `
-function ${info.name}_${g}(this: ${info.name}): ${f.type} {
-  return this.${f.name};
-}`.trim()
-    );
-    if (!f.isReadonly) {
-      const s = `set${f.name.charAt(0).toUpperCase()}${f.name.slice(1)}`;
-      fns.push(
-        `
-function ${info.name}_${s}(this: ${info.name}, value: ${f.type}): void {
-  this.${f.name} = value;
-}`.trim()
-      );
-    }
-  }
-  const equalsBody = info.fields.map((f) => `this.${f.name} === other.${f.name}`).join(" &&\n    ");
-  fns.push(
-    `
-function ${info.name}_equals(this: ${info.name}, other: ${info.name} | null | undefined): boolean {
-  if (other === null || other === undefined) return false;
-  if (!(other instanceof (this.constructor as typeof ${info.name}))) return false;
-  return ${equalsBody || "true"};
-}`.trim()
-  );
-  fns.push(emitToStringFn(info));
-  return fns.filter(Boolean).join("\n\n");
-}
 function emitBuilderFn(info) {
   if (!hasClassDecorator(info, "Builder")) return "";
   const bName = builderClassName(info.name);
@@ -273,7 +494,30 @@ function ${info.name}_builder(): ${bName} {
   return ${bName}.builder();
 }`.trim();
 }
+function emitClassCompanionBlocks(info) {
+  const blocks = [];
+  const builder = emitBuilderClass(info);
+  if (builder) blocks.push(builder);
+  const accessors = emitAccessorFns(info);
+  if (accessors) blocks.push(accessors);
+  const withFns = emitWithFns(info);
+  if (withFns) blocks.push(withFns);
+  const equalsFn = emitEqualsFn(info);
+  if (equalsFn) blocks.push(equalsFn);
+  const equalsStatic = emitEqualsStaticFn(info);
+  if (equalsStatic) blocks.push(equalsStatic);
+  const toString = emitToStringFn(info);
+  if (toString) blocks.push(toString);
+  const delegate = emitDelegateFns(info);
+  if (delegate) blocks.push(delegate);
+  const builderFn = emitBuilderFn(info);
+  if (builderFn) blocks.push(builderFn);
+  const apply = emitApplyMixin(info);
+  if (apply) blocks.push(apply);
+  return blocks.filter(Boolean).join("\n\n");
+}
 function emitCompanionFile(sourcePath, companionOutputPath, classes, cwd) {
+  validateAllClassCompositions(classes);
   const header = [
     "// Auto-generated by lombok-typescript.",
     "// Source: " + relative(cwd, sourcePath).replace(/\\/g, "/"),
@@ -283,25 +527,16 @@ function emitCompanionFile(sourcePath, companionOutputPath, classes, cwd) {
   const importPath = toImportPath(sourcePath, dirname(companionOutputPath));
   const blocks = [];
   for (const info of classes) {
-    const builder = emitBuilderClass(info);
-    if (builder) blocks.push(builder);
-    if (hasClassDecorator(info, "Data")) {
-      blocks.push(emitDataFns(info));
-    } else {
-      const ts2 = emitToStringFn(info);
-      if (ts2) blocks.push(ts2);
-    }
-    const builderFn = emitBuilderFn(info);
-    if (builderFn) blocks.push(builderFn);
-    const apply = emitApplyMixin(info);
-    if (apply) blocks.push(apply);
+    const chunk = emitClassCompanionBlocks(info);
+    if (chunk) blocks.push(chunk);
   }
-  const applyAll = classes.filter((c) => emitApplyMixin(c)).length > 0 ? `
+  const classesWithApply = classes.filter((c) => emitApplyMixin(c).length > 0);
+  const applyAll = classesWithApply.length > 0 ? `
 
 export function applyAllGenerated(handlers: {
-${classes.filter((c) => emitApplyMixin(c)).map((c) => `  ${c.name}: typeof ${c.name};`).join("\n")}
+${classesWithApply.map((c) => `  ${c.name}: typeof ${c.name};`).join("\n")}
 }): void {
-${classes.filter((c) => emitApplyMixin(c)).map((c) => `  apply${c.name}Generated(handlers.${c.name});`).join("\n")}
+${classesWithApply.map((c) => `  apply${c.name}Generated(handlers.${c.name});`).join("\n")}
 }
 ` : "\nexport {};\n";
   const imports = emitImports(classes, importPath);
@@ -343,7 +578,7 @@ var CodeGenerator = class {
       const { ts, dts } = emitCompanionFile(sourcePath, outputPath, classes, process.cwd());
       const content = ts;
       this.writeOutput(outputPath, content);
-      this.writeOutput(outputPath.replace(/\.lombok\.ts$/u, ".lombok.d.ts"), dts);
+      this.writeOutput(outputPath.replace(/\.lombok\.ts$/u, ".lombok.augment.d.ts"), dts);
       generated.push({
         sourcePath,
         outputPath,
@@ -366,7 +601,7 @@ var CodeGenerator = class {
     const { ts, dts } = emitCompanionFile(filePath, outputPath, classes, process.cwd());
     const content = ts;
     this.writeOutput(outputPath, content);
-    this.writeOutput(outputPath.replace(/\.lombok\.ts$/u, ".lombok.d.ts"), dts);
+    this.writeOutput(outputPath.replace(/\.lombok\.ts$/u, ".lombok.augment.d.ts"), dts);
     return {
       sourcePath: filePath,
       outputPath,
@@ -374,13 +609,57 @@ var CodeGenerator = class {
       processedClasses: classes.map((c) => c.name)
     };
   }
-  /** Watch mode is not implemented yet. Re-run `lombok-ts generate` for now. */
-  async watch() {
-    throw new Error(
-      "Watch mode is not implemented yet. Re-run `lombok-ts generate` after changes."
-    );
+  /** Watch for source changes and regenerate companion files. */
+  async watch(options = {}) {
+    const log = options.log ?? ((msg) => console.info(msg));
+    const generated = await this.generate();
+    log(`Generated ${generated.length} companion file(s). Watching for changes\u2026`);
+    if (options.signal?.aborted) return;
+    const { watch } = await import('fs');
+    const watchers = [];
+    const debounceTimers = /* @__PURE__ */ new Map();
+    const project = this.createProject();
+    const paths = project.getSourceFiles().map((sf) => sf.getFilePath()).filter((p) => this.shouldProcess(p));
+    const scheduleRegenerate = (filePath) => {
+      const existing = debounceTimers.get(filePath);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(
+        filePath,
+        setTimeout(() => {
+          void this.generateForFile(filePath).then((result) => {
+            if (result) {
+              log(`Regenerated ${relative(process.cwd(), result.outputPath)}`);
+            }
+          });
+        }, 100)
+      );
+    };
+    for (const filePath of paths) {
+      try {
+        const watcher = watch(filePath, { persistent: true }, (event) => {
+          if (event === "change") scheduleRegenerate(filePath);
+        });
+        watchers.push(watcher);
+      } catch {
+      }
+    }
+    await new Promise((resolve2) => {
+      const onAbort = () => {
+        for (const w of watchers) w.close();
+        for (const t of debounceTimers.values()) clearTimeout(t);
+        resolve2();
+      };
+      if (options.signal) {
+        if (options.signal.aborted) {
+          onAbort();
+          return;
+        }
+        options.signal.addEventListener("abort", onAbort, { once: true });
+        return;
+      }
+    });
   }
-  // Internal helpers
+  // Internal helpers — previously threw for watch stub
   createProject() {
     const tsConfig = resolve(this.options.tsConfigPath);
     if (existsSync(tsConfig)) {