openapi-typesafe 0.0.0 → 1.0.0-rc.1

package/dist/adapters/terminal-logger/terminal-logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-logger.mjs","sources":["../../../src/adapters/terminal-logger/terminal-logger.ts"],"sourcesContent":["import colors from \"ansi-colors\";\nimport type { DebugGroup, Logger } from \"../../application/ports/logger.js\";\n\n/**\n * The Logger port on a terminal, with the original output format: ` ⚠  ` warnings, ` ✘  `\n * errors, and `openapi-ts:<group>` debug lines filtered by `DEBUG` (ENGINEERING_PLAN 4.5).\n */\n\n/** Where the lines go: `console` in production, a recording sink in tests. */\nexport interface TerminalSink {\n  debug(line: string): void;\n  warn(line: string): void;\n  error(line: string): void;\n}\n\nexport interface TerminalLoggerOptions {\n  /** Drop warnings (errors and debug lines are still written). */\n  readonly silent: boolean;\n  /** The value of `DEBUG`: `*`, `openapi-ts:*` or `openapi-ts:<group>` turn debug lines on. */\n  readonly debugFilter: string | undefined;\n  readonly useColors: boolean;\n  readonly sink: TerminalSink;\n}\n\ntype Colors = ReturnType<typeof colors.create>;\n\nconst MILLISECONDS_PER_SECOND = 1000;\nconst MILLISECONDS_PER_MINUTE = 60_000;\n\n/** A duration as the original prints it: one decimal, in ms, s or m. */\nexport function formatDuration(milliseconds: number): string {\n  if (milliseconds < MILLISECONDS_PER_SECOND) {\n    return `${Math.round(10 * milliseconds) / 10}ms`;\n  }\n  if (milliseconds < MILLISECONDS_PER_MINUTE) {\n    return `${Math.round(milliseconds / 100) / 10}s`;\n  }\n  return `${Math.round(milliseconds / 6000) / 10}m`;\n}\n\nfunction groupColor(palette: Colors, group: DebugGroup | undefined): (text: string) => string {\n  const byGroup: Readonly<Partial<Record<DebugGroup, (text: string) => string>>> = {\n    redoc: palette.cyanBright,\n    lint: palette.yellowBright,\n    bundle: palette.magentaBright,\n    ts: palette.blueBright,\n  };\n  return (group && byGroup[group]) || palette.whiteBright;\n}\n\n/** Whether `DEBUG` asks for this group (the original check, case-insensitive for the group). */\nexport function isDebugEnabled(filter: string | undefined, group: DebugGroup | undefined): boolean {\n  if (!filter) {\n    return false;\n  }\n  return (\n    !group ||\n    filter === \"*\" ||\n    filter === \"openapi-ts:*\" ||\n    filter.toLocaleLowerCase() === `openapi-ts:${group.toLocaleLowerCase()}`\n  );\n}\n\nclass TerminalLogger implements Logger {\n  readonly #options: TerminalLoggerOptions;\n  readonly #palette: Colors;\n\n  constructor(options: TerminalLoggerOptions) {\n    this.#options = options;\n    this.#palette = colors.create();\n    this.#palette.enabled = options.useColors;\n  }\n\n  debug(message: string, group?: DebugGroup, durationMs?: number): void {\n    if (!isDebugEnabled(this.#options.debugFilter, group)) {\n      return;\n    }\n    const name = groupColor(this.#palette, group)(`openapi-ts:${group ?? \"info\"}`);\n    const time =\n      durationMs === undefined ? \"\" : this.#palette.green(` ${formatDuration(durationMs)} `);\n    this.#options.sink.debug(`  ${this.#palette.bold(name)}${time}${message}`);\n  }\n\n  warn(message: string): void {\n    if (!this.#options.silent) {\n      this.#options.sink.warn(this.#palette.yellow(` ⚠  ${message}`));\n    }\n  }\n\n  error(message: string): void {\n    this.#options.sink.error(this.#palette.red(` ✘  ${message}`));\n  }\n}\n\n/** A Logger that writes to a terminal sink. */\nexport function createTerminalLogger(options: TerminalLoggerOptions): Logger {\n  return new TerminalLogger(options);\n}\n"],"names":[],"mappings":"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"}

package/dist/adapters/type-ast-bridge/footer-nodes.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const irToTypescript = require('./ir-to-typescript.cjs');
+
+function isTypeAliasNamed(ts, node, name) {
+  return ts.isTypeAliasDeclaration(node) && node.name.text === name;
+}
+function asInterfaceNamed(ts, node, name) {
+  return ts.isInterfaceDeclaration(node) && node.name.text === name ? node : null;
+}
+function appendMember(ts, node, member) {
+  node.members = ts.factory.createNodeArray([
+    ...node.members,
+    irToTypescript.toPropertySignature(ts, member)
+  ]);
+}
+
+exports.appendMember = appendMember;
+exports.asInterfaceNamed = asInterfaceNamed;
+exports.isTypeAliasNamed = isTypeAliasNamed;
+//# sourceMappingURL=footer-nodes.cjs.map

package/dist/adapters/type-ast-bridge/footer-nodes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer-nodes.cjs","sources":["../../../src/adapters/type-ast-bridge/footer-nodes.ts"],"sourcesContent":["import type ts from \"typescript\";\nimport type { IrPropertySignature } from \"../../domain/ir/nodes.js\";\nimport { toPropertySignature } from \"./ir-to-typescript.js\";\nimport type { TypeScriptModule } from \"./load-typescript.js\";\n\n/**\n * TypeScript nodes that user code adds to the footer (`ctx.injectFooter`). The generator's own\n * footer entries are IR; these functions are the only places that read or change a user's node.\n */\n\n/** Whether the node is a type alias with this name (the original's helper check). */\nexport function isTypeAliasNamed(ts: TypeScriptModule, node: ts.Node, name: string): boolean {\n  return ts.isTypeAliasDeclaration(node) && node.name.text === name;\n}\n\n/** The node as an interface with this name, or null. */\nexport function asInterfaceNamed(\n  ts: TypeScriptModule,\n  node: ts.Node,\n  name: string,\n): ts.InterfaceDeclaration | null {\n  return ts.isInterfaceDeclaration(node) && node.name.text === name ? node : null;\n}\n\n/**\n * Add a member to a user's interface in place, as the original `injectOperationObject` did:\n * other references to the node see the member.\n */\nexport function appendMember(\n  ts: TypeScriptModule,\n  node: ts.InterfaceDeclaration,\n  member: IrPropertySignature,\n): void {\n  (node as { members: ts.NodeArray<ts.TypeElement> }).members = ts.factory.createNodeArray([\n    ...node.members,\n    toPropertySignature(ts, member),\n  ]);\n}\n"],"names":["toPropertySignature"],"mappings":";;;;AAWO,SAAS,gBAAA,CAAiB,EAAA,EAAsB,IAAA,EAAe,IAAA,EAAuB;AAC3F,EAAA,OAAO,GAAG,sBAAA,CAAuB,IAAI,CAAA,IAAK,IAAA,CAAK,KAAK,IAAA,KAAS,IAAA;AAC/D;AAGO,SAAS,gBAAA,CACd,EAAA,EACA,IAAA,EACA,IAAA,EACgC;AAChC,EAAA,OAAO,EAAA,CAAG,uBAAuB,IAAI,CAAA,IAAK,KAAK,IAAA,CAAK,IAAA,KAAS,OAAO,IAAA,GAAO,IAAA;AAC7E;AAMO,SAAS,YAAA,CACd,EAAA,EACA,IAAA,EACA,MAAA,EACM;AACN,EAAC,IAAA,CAAmD,OAAA,GAAU,EAAA,CAAG,OAAA,CAAQ,eAAA,CAAgB;AAAA,IACvF,GAAG,IAAA,CAAK,OAAA;AAAA,IACRA,kCAAA,CAAoB,IAAI,MAAM;AAAA,GAC/B,CAAA;AACH;;;;"}

package/dist/adapters/type-ast-bridge/footer-nodes.mjs

@@ -0,0 +1,17 @@
+import { toPropertySignature } from './ir-to-typescript.mjs';
+
+function isTypeAliasNamed(ts, node, name) {
+  return ts.isTypeAliasDeclaration(node) && node.name.text === name;
+}
+function asInterfaceNamed(ts, node, name) {
+  return ts.isInterfaceDeclaration(node) && node.name.text === name ? node : null;
+}
+function appendMember(ts, node, member) {
+  node.members = ts.factory.createNodeArray([
+    ...node.members,
+    toPropertySignature(ts, member)
+  ]);
+}
+
+export { appendMember, asInterfaceNamed, isTypeAliasNamed };
+//# sourceMappingURL=footer-nodes.mjs.map

package/dist/adapters/type-ast-bridge/footer-nodes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer-nodes.mjs","sources":["../../../src/adapters/type-ast-bridge/footer-nodes.ts"],"sourcesContent":["import type ts from \"typescript\";\nimport type { IrPropertySignature } from \"../../domain/ir/nodes.js\";\nimport { toPropertySignature } from \"./ir-to-typescript.js\";\nimport type { TypeScriptModule } from \"./load-typescript.js\";\n\n/**\n * TypeScript nodes that user code adds to the footer (`ctx.injectFooter`). The generator's own\n * footer entries are IR; these functions are the only places that read or change a user's node.\n */\n\n/** Whether the node is a type alias with this name (the original's helper check). */\nexport function isTypeAliasNamed(ts: TypeScriptModule, node: ts.Node, name: string): boolean {\n  return ts.isTypeAliasDeclaration(node) && node.name.text === name;\n}\n\n/** The node as an interface with this name, or null. */\nexport function asInterfaceNamed(\n  ts: TypeScriptModule,\n  node: ts.Node,\n  name: string,\n): ts.InterfaceDeclaration | null {\n  return ts.isInterfaceDeclaration(node) && node.name.text === name ? node : null;\n}\n\n/**\n * Add a member to a user's interface in place, as the original `injectOperationObject` did:\n * other references to the node see the member.\n */\nexport function appendMember(\n  ts: TypeScriptModule,\n  node: ts.InterfaceDeclaration,\n  member: IrPropertySignature,\n): void {\n  (node as { members: ts.NodeArray<ts.TypeElement> }).members = ts.factory.createNodeArray([\n    ...node.members,\n    toPropertySignature(ts, member),\n  ]);\n}\n"],"names":[],"mappings":";;AAWO,SAAS,gBAAA,CAAiB,EAAA,EAAsB,IAAA,EAAe,IAAA,EAAuB;AAC3F,EAAA,OAAO,GAAG,sBAAA,CAAuB,IAAI,CAAA,IAAK,IAAA,CAAK,KAAK,IAAA,KAAS,IAAA;AAC/D;AAGO,SAAS,gBAAA,CACd,EAAA,EACA,IAAA,EACA,IAAA,EACgC;AAChC,EAAA,OAAO,EAAA,CAAG,uBAAuB,IAAI,CAAA,IAAK,KAAK,IAAA,CAAK,IAAA,KAAS,OAAO,IAAA,GAAO,IAAA;AAC7E;AAMO,SAAS,YAAA,CACd,EAAA,EACA,IAAA,EACA,MAAA,EACM;AACN,EAAC,IAAA,CAAmD,OAAA,GAAU,EAAA,CAAG,OAAA,CAAQ,eAAA,CAAgB;AAAA,IACvF,GAAG,IAAA,CAAK,OAAA;AAAA,IACR,mBAAA,CAAoB,IAAI,MAAM;AAAA,GAC/B,CAAA;AACH;;"}

package/dist/adapters/type-ast-bridge/ir-declarations-to-typescript.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+const assertNever = require('../../domain/assert-never.cjs');
+const irToTypescript = require('./ir-to-typescript.cjs');
+
+function exportModifiers(ts, isExported) {
+  return isExported ? [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)] : void 0;
+}
+function toConstArrayStatement(ts, declaration) {
+  const initializer = ts.factory.createArrayLiteralExpression(
+    declaration.values.map((value) => irToTypescript.toValueExpression(ts, value))
+  );
+  const variable = ts.factory.createVariableDeclaration(
+    declaration.name,
+    void 0,
+    irToTypescript.toTypeNode(ts, declaration.type),
+    initializer
+  );
+  const list = ts.factory.createVariableDeclarationList([variable], ts.NodeFlags.Const);
+  return ts.factory.createVariableStatement(exportModifiers(ts, declaration.isExported), list);
+}
+function parseStatements(ts, text) {
+  return ts.createSourceFile("raw.ts", text, ts.ScriptTarget.ESNext).statements;
+}
+function toStatements(ts, declaration) {
+  return declaration.kind === "rawDeclaration" ? [...parseStatements(ts, declaration.text)] : [toStatement(ts, declaration)];
+}
+function toEnumStatement(ts, declaration) {
+  const members = declaration.members.map(
+    (member) => irToTypescript.withComments(
+      ts,
+      ts.factory.createEnumMember(member.name, irToTypescript.toValueExpression(ts, member.value)),
+      member.comments
+    )
+  );
+  const modifiers = exportModifiers(ts, declaration.isExported);
+  return ts.factory.createEnumDeclaration(modifiers, declaration.name, members);
+}
+function toInterfaceStatement(ts, declaration) {
+  const members = declaration.members.map((member) => irToTypescript.toTypeElement(ts, member));
+  const modifiers = exportModifiers(ts, declaration.isExported);
+  return ts.factory.createInterfaceDeclaration(
+    modifiers,
+    declaration.name,
+    void 0,
+    void 0,
+    members
+  );
+}
+function toTypeAliasStatement(ts, declaration) {
+  const type = irToTypescript.toTypeNode(ts, declaration.type);
+  const modifiers = exportModifiers(ts, declaration.isExported);
+  return ts.factory.createTypeAliasDeclaration(modifiers, declaration.name, void 0, type);
+}
+function toStatement(ts, declaration) {
+  switch (declaration.kind) {
+    case "interface":
+      return irToTypescript.withComments(ts, toInterfaceStatement(ts, declaration), declaration.comments);
+    case "typeAlias":
+      return irToTypescript.withComments(ts, toTypeAliasStatement(ts, declaration), declaration.comments);
+    case "enum":
+      return irToTypescript.withComments(ts, toEnumStatement(ts, declaration), declaration.comments);
+    case "constArray":
+      return irToTypescript.withComments(ts, toConstArrayStatement(ts, declaration), declaration.comments);
+    case "rawDeclaration":
+      return parseStatements(ts, declaration.text)[0];
+    default:
+      return assertNever.assertNever(declaration);
+  }
+}
+
+exports.parseStatements = parseStatements;
+exports.toStatement = toStatement;
+exports.toStatements = toStatements;
+//# sourceMappingURL=ir-declarations-to-typescript.cjs.map

package/dist/adapters/type-ast-bridge/ir-declarations-to-typescript.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-declarations-to-typescript.cjs","sources":["../../../src/adapters/type-ast-bridge/ir-declarations-to-typescript.ts"],"sourcesContent":["import type ts from \"typescript\";\nimport { assertNever } from \"../../domain/assert-never.js\";\nimport type { IrDeclaration } from \"../../domain/ir/nodes.js\";\nimport { toTypeElement, toTypeNode, toValueExpression, withComments } from \"./ir-to-typescript.js\";\nimport type { TypeScriptModule } from \"./load-typescript.js\";\n\n/**\n * Convert IR declarations to TypeScript statements, with the factory calls the original makes\n * (see `ir-to-typescript.ts` for types and members).\n */\n\nfunction exportModifiers(ts: TypeScriptModule, isExported: boolean): ts.Modifier[] | undefined {\n  return isExported ? [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)] : undefined;\n}\n\nfunction toConstArrayStatement(\n  ts: TypeScriptModule,\n  declaration: Extract<IrDeclaration, { kind: \"constArray\" }>,\n): ts.Statement {\n  const initializer = ts.factory.createArrayLiteralExpression(\n    declaration.values.map((value) => toValueExpression(ts, value)),\n  );\n  const variable = ts.factory.createVariableDeclaration(\n    declaration.name,\n    undefined,\n    toTypeNode(ts, declaration.type),\n    initializer,\n  );\n  const list = ts.factory.createVariableDeclarationList([variable], ts.NodeFlags.Const);\n  return ts.factory.createVariableStatement(exportModifiers(ts, declaration.isExported), list);\n}\n\n/** Parse source text into statements, like the original's `stringToAST`. */\nexport function parseStatements(ts: TypeScriptModule, text: string): readonly ts.Statement[] {\n  return ts.createSourceFile(\"raw.ts\", text, ts.ScriptTarget.ESNext).statements;\n}\n\n/** Convert one IR declaration; a raw declaration gives every statement its text holds. */\nexport function toStatements(ts: TypeScriptModule, declaration: IrDeclaration): ts.Statement[] {\n  return declaration.kind === \"rawDeclaration\"\n    ? [...parseStatements(ts, declaration.text)]\n    : [toStatement(ts, declaration)];\n}\n\nfunction toEnumStatement(\n  ts: TypeScriptModule,\n  declaration: Extract<IrDeclaration, { kind: \"enum\" }>,\n): ts.Statement {\n  const members = declaration.members.map((member) =>\n    withComments(\n      ts,\n      ts.factory.createEnumMember(member.name, toValueExpression(ts, member.value)),\n      member.comments,\n    ),\n  );\n  const modifiers = exportModifiers(ts, declaration.isExported);\n  return ts.factory.createEnumDeclaration(modifiers, declaration.name, members);\n}\n\nfunction toInterfaceStatement(\n  ts: TypeScriptModule,\n  declaration: Extract<IrDeclaration, { kind: \"interface\" }>,\n): ts.Statement {\n  const members = declaration.members.map((member) => toTypeElement(ts, member));\n  const modifiers = exportModifiers(ts, declaration.isExported);\n  return ts.factory.createInterfaceDeclaration(\n    modifiers,\n    declaration.name,\n    undefined,\n    undefined,\n    members,\n  );\n}\n\nfunction toTypeAliasStatement(\n  ts: TypeScriptModule,\n  declaration: Extract<IrDeclaration, { kind: \"typeAlias\" }>,\n): ts.Statement {\n  const type = toTypeNode(ts, declaration.type);\n  const modifiers = exportModifiers(ts, declaration.isExported);\n  return ts.factory.createTypeAliasDeclaration(modifiers, declaration.name, undefined, type);\n}\n\n/** Convert one IR declaration. A raw declaration is parsed, like the original's `stringToAST`. */\nexport function toStatement(ts: TypeScriptModule, declaration: IrDeclaration): ts.Statement {\n  switch (declaration.kind) {\n    case \"interface\":\n      return withComments(ts, toInterfaceStatement(ts, declaration), declaration.comments);\n    case \"typeAlias\":\n      return withComments(ts, toTypeAliasStatement(ts, declaration), declaration.comments);\n    case \"enum\":\n      return withComments(ts, toEnumStatement(ts, declaration), declaration.comments);\n    case \"constArray\":\n      return withComments(ts, toConstArrayStatement(ts, declaration), declaration.comments);\n    case \"rawDeclaration\":\n      return parseStatements(ts, declaration.text)[0] as ts.Statement;\n    default:\n      return assertNever(declaration);\n  }\n}\n"],"names":["toValueExpression","toTypeNode","withComments","toTypeElement","assertNever"],"mappings":"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"}

package/dist/adapters/type-ast-bridge/ir-declarations-to-typescript.mjs

@@ -0,0 +1,71 @@
+import { assertNever } from '../../domain/assert-never.mjs';
+import { withComments, toValueExpression, toTypeNode, toTypeElement } from './ir-to-typescript.mjs';
+
+function exportModifiers(ts, isExported) {
+  return isExported ? [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)] : void 0;
+}
+function toConstArrayStatement(ts, declaration) {
+  const initializer = ts.factory.createArrayLiteralExpression(
+    declaration.values.map((value) => toValueExpression(ts, value))
+  );
+  const variable = ts.factory.createVariableDeclaration(
+    declaration.name,
+    void 0,
+    toTypeNode(ts, declaration.type),
+    initializer
+  );
+  const list = ts.factory.createVariableDeclarationList([variable], ts.NodeFlags.Const);
+  return ts.factory.createVariableStatement(exportModifiers(ts, declaration.isExported), list);
+}
+function parseStatements(ts, text) {
+  return ts.createSourceFile("raw.ts", text, ts.ScriptTarget.ESNext).statements;
+}
+function toStatements(ts, declaration) {
+  return declaration.kind === "rawDeclaration" ? [...parseStatements(ts, declaration.text)] : [toStatement(ts, declaration)];
+}
+function toEnumStatement(ts, declaration) {
+  const members = declaration.members.map(
+    (member) => withComments(
+      ts,
+      ts.factory.createEnumMember(member.name, toValueExpression(ts, member.value)),
+      member.comments
+    )
+  );
+  const modifiers = exportModifiers(ts, declaration.isExported);
+  return ts.factory.createEnumDeclaration(modifiers, declaration.name, members);
+}
+function toInterfaceStatement(ts, declaration) {
+  const members = declaration.members.map((member) => toTypeElement(ts, member));
+  const modifiers = exportModifiers(ts, declaration.isExported);
+  return ts.factory.createInterfaceDeclaration(
+    modifiers,
+    declaration.name,
+    void 0,
+    void 0,
+    members
+  );
+}
+function toTypeAliasStatement(ts, declaration) {
+  const type = toTypeNode(ts, declaration.type);
+  const modifiers = exportModifiers(ts, declaration.isExported);
+  return ts.factory.createTypeAliasDeclaration(modifiers, declaration.name, void 0, type);
+}
+function toStatement(ts, declaration) {
+  switch (declaration.kind) {
+    case "interface":
+      return withComments(ts, toInterfaceStatement(ts, declaration), declaration.comments);
+    case "typeAlias":
+      return withComments(ts, toTypeAliasStatement(ts, declaration), declaration.comments);
+    case "enum":
+      return withComments(ts, toEnumStatement(ts, declaration), declaration.comments);
+    case "constArray":
+      return withComments(ts, toConstArrayStatement(ts, declaration), declaration.comments);
+    case "rawDeclaration":
+      return parseStatements(ts, declaration.text)[0];
+    default:
+      return assertNever(declaration);
+  }
+}
+
+export { parseStatements, toStatement, toStatements };
+//# sourceMappingURL=ir-declarations-to-typescript.mjs.map

package/dist/adapters/type-ast-bridge/ir-declarations-to-typescript.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-declarations-to-typescript.mjs","sources":["../../../src/adapters/type-ast-bridge/ir-declarations-to-typescript.ts"],"sourcesContent":["import type ts from \"typescript\";\nimport { assertNever } from \"../../domain/assert-never.js\";\nimport type { IrDeclaration } from \"../../domain/ir/nodes.js\";\nimport { toTypeElement, toTypeNode, toValueExpression, withComments } from \"./ir-to-typescript.js\";\nimport type { TypeScriptModule } from \"./load-typescript.js\";\n\n/**\n * Convert IR declarations to TypeScript statements, with the factory calls the original makes\n * (see `ir-to-typescript.ts` for types and members).\n */\n\nfunction exportModifiers(ts: TypeScriptModule, isExported: boolean): ts.Modifier[] | undefined {\n  return isExported ? [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)] : undefined;\n}\n\nfunction toConstArrayStatement(\n  ts: TypeScriptModule,\n  declaration: Extract<IrDeclaration, { kind: \"constArray\" }>,\n): ts.Statement {\n  const initializer = ts.factory.createArrayLiteralExpression(\n    declaration.values.map((value) => toValueExpression(ts, value)),\n  );\n  const variable = ts.factory.createVariableDeclaration(\n    declaration.name,\n    undefined,\n    toTypeNode(ts, declaration.type),\n    initializer,\n  );\n  const list = ts.factory.createVariableDeclarationList([variable], ts.NodeFlags.Const);\n  return ts.factory.createVariableStatement(exportModifiers(ts, declaration.isExported), list);\n}\n\n/** Parse source text into statements, like the original's `stringToAST`. */\nexport function parseStatements(ts: TypeScriptModule, text: string): readonly ts.Statement[] {\n  return ts.createSourceFile(\"raw.ts\", text, ts.ScriptTarget.ESNext).statements;\n}\n\n/** Convert one IR declaration; a raw declaration gives every statement its text holds. */\nexport function toStatements(ts: TypeScriptModule, declaration: IrDeclaration): ts.Statement[] {\n  return declaration.kind === \"rawDeclaration\"\n    ? [...parseStatements(ts, declaration.text)]\n    : [toStatement(ts, declaration)];\n}\n\nfunction toEnumStatement(\n  ts: TypeScriptModule,\n  declaration: Extract<IrDeclaration, { kind: \"enum\" }>,\n): ts.Statement {\n  const members = declaration.members.map((member) =>\n    withComments(\n      ts,\n      ts.factory.createEnumMember(member.name, toValueExpression(ts, member.value)),\n      member.comments,\n    ),\n  );\n  const modifiers = exportModifiers(ts, declaration.isExported);\n  return ts.factory.createEnumDeclaration(modifiers, declaration.name, members);\n}\n\nfunction toInterfaceStatement(\n  ts: TypeScriptModule,\n  declaration: Extract<IrDeclaration, { kind: \"interface\" }>,\n): ts.Statement {\n  const members = declaration.members.map((member) => toTypeElement(ts, member));\n  const modifiers = exportModifiers(ts, declaration.isExported);\n  return ts.factory.createInterfaceDeclaration(\n    modifiers,\n    declaration.name,\n    undefined,\n    undefined,\n    members,\n  );\n}\n\nfunction toTypeAliasStatement(\n  ts: TypeScriptModule,\n  declaration: Extract<IrDeclaration, { kind: \"typeAlias\" }>,\n): ts.Statement {\n  const type = toTypeNode(ts, declaration.type);\n  const modifiers = exportModifiers(ts, declaration.isExported);\n  return ts.factory.createTypeAliasDeclaration(modifiers, declaration.name, undefined, type);\n}\n\n/** Convert one IR declaration. A raw declaration is parsed, like the original's `stringToAST`. */\nexport function toStatement(ts: TypeScriptModule, declaration: IrDeclaration): ts.Statement {\n  switch (declaration.kind) {\n    case \"interface\":\n      return withComments(ts, toInterfaceStatement(ts, declaration), declaration.comments);\n    case \"typeAlias\":\n      return withComments(ts, toTypeAliasStatement(ts, declaration), declaration.comments);\n    case \"enum\":\n      return withComments(ts, toEnumStatement(ts, declaration), declaration.comments);\n    case \"constArray\":\n      return withComments(ts, toConstArrayStatement(ts, declaration), declaration.comments);\n    case \"rawDeclaration\":\n      return parseStatements(ts, declaration.text)[0] as ts.Statement;\n    default:\n      return assertNever(declaration);\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/adapters/type-ast-bridge/ir-to-typescript.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+const assertNever = require('../../domain/assert-never.cjs');
+
+function keywordKind(ts, keyword) {
+  const kinds = {
+    string: ts.SyntaxKind.StringKeyword,
+    number: ts.SyntaxKind.NumberKeyword,
+    boolean: ts.SyntaxKind.BooleanKeyword,
+    undefined: ts.SyntaxKind.UndefinedKeyword,
+    unknown: ts.SyntaxKind.UnknownKeyword,
+    never: ts.SyntaxKind.NeverKeyword
+  };
+  return kinds[keyword];
+}
+function toKeywordType(ts, keyword) {
+  return keyword === "null" ? ts.factory.createLiteralTypeNode(ts.factory.createNull()) : ts.factory.createKeywordTypeNode(keywordKind(ts, keyword));
+}
+function toNumberExpression(ts, value) {
+  return value < 0 ? ts.factory.createPrefixUnaryExpression(
+    ts.SyntaxKind.MinusToken,
+    ts.factory.createNumericLiteral(Math.abs(value))
+  ) : ts.factory.createNumericLiteral(value);
+}
+function toValueExpression(ts, value) {
+  return typeof value === "number" ? toNumberExpression(ts, value) : ts.factory.createStringLiteral(value);
+}
+function toStringLiteralType(ts, value, encoding) {
+  return encoding === "json" ? ts.factory.createIdentifier(JSON.stringify(value)) : ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(value));
+}
+function toTupleElement(ts, element) {
+  const type = toTypeNode(ts, element.type);
+  if (element.isOptional) {
+    return ts.factory.createOptionalTypeNode(type);
+  }
+  return element.isRest ? ts.factory.createRestTypeNode(type) : type;
+}
+function toLeafTypeNode(ts, type) {
+  switch (type.kind) {
+    case "keyword":
+      return toKeywordType(ts, type.keyword);
+    case "stringLiteral":
+      return toStringLiteralType(ts, type.value, type.encoding);
+    case "numberLiteral":
+      return ts.factory.createLiteralTypeNode(toNumberExpression(ts, type.value));
+    case "booleanLiteral":
+      return ts.factory.createLiteralTypeNode(
+        type.value ? ts.factory.createTrue() : ts.factory.createFalse()
+      );
+    case "raw":
+      return type.origin ?? ts.factory.createIdentifier(type.text);
+    default:
+      return assertNever.assertNever(type);
+  }
+}
+function toReferenceNode(ts, type) {
+  const typeArguments = type.typeArguments.length > 0 ? type.typeArguments.map((argument) => toTypeNode(ts, argument)) : void 0;
+  return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(type.name), typeArguments);
+}
+function toTypeNode(ts, type) {
+  const convert = (inner) => toTypeNode(ts, inner);
+  const { factory } = ts;
+  switch (type.kind) {
+    case "keyword":
+    case "stringLiteral":
+    case "numberLiteral":
+    case "booleanLiteral":
+    case "raw":
+      return toLeafTypeNode(ts, type);
+    case "reference":
+      return toReferenceNode(ts, type);
+    case "array":
+      return factory.createArrayTypeNode(convert(type.element));
+    case "tuple":
+      return factory.createTupleTypeNode(
+        type.elements.map((element) => toTupleElement(ts, element))
+      );
+    case "union":
+      return factory.createUnionTypeNode(type.types.map(convert));
+    case "intersection":
+      return factory.createIntersectionTypeNode(type.types.map(convert));
+    case "object":
+      return factory.createTypeLiteralNode(type.members.map((member) => toTypeElement(ts, member)));
+    case "indexedAccess":
+      return factory.createIndexedAccessTypeNode(convert(type.object), convert(type.index));
+    case "readonly":
+      return factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, convert(type.type));
+    default:
+      return assertNever.assertNever(type);
+  }
+}
+function withComments(ts, node, comments) {
+  for (const comment of comments) {
+    const kind = comment.kind === "block" ? ts.SyntaxKind.MultiLineCommentTrivia : ts.SyntaxKind.SingleLineCommentTrivia;
+    ts.addSyntheticLeadingComment(node, kind, comment.text, true);
+  }
+  return node;
+}
+function toPropertyName(ts, name) {
+  switch (name.kind) {
+    case "identifier":
+      return ts.factory.createIdentifier(name.text);
+    case "string":
+      return ts.factory.createStringLiteral(name.value);
+    case "number":
+      return ts.factory.createNumericLiteral(name.text);
+    default:
+      return assertNever.assertNever(name);
+  }
+}
+function readonlyModifiers(ts, isReadonly) {
+  return isReadonly ? [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)] : void 0;
+}
+function toPropertySignature(ts, property) {
+  const questionToken = property.isOptional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : void 0;
+  const signature = ts.factory.createPropertySignature(
+    readonlyModifiers(ts, property.isReadonly),
+    toPropertyName(ts, property.name),
+    questionToken,
+    toTypeNode(ts, property.type)
+  );
+  return withComments(ts, signature, property.comments);
+}
+function toTypeElement(ts, member) {
+  if (member.kind === "property") {
+    return toPropertySignature(ts, member);
+  }
+  const parameter = ts.factory.createParameterDeclaration(
+    void 0,
+    void 0,
+    member.parameterName,
+    void 0,
+    toTypeNode(ts, member.parameterType)
+  );
+  const signature = ts.factory.createIndexSignature(
+    readonlyModifiers(ts, member.isReadonly),
+    [parameter],
+    toTypeNode(ts, member.type)
+  );
+  return withComments(ts, signature, member.comments);
+}
+
+exports.toPropertySignature = toPropertySignature;
+exports.toTypeElement = toTypeElement;
+exports.toTypeNode = toTypeNode;
+exports.toValueExpression = toValueExpression;
+exports.withComments = withComments;
+//# sourceMappingURL=ir-to-typescript.cjs.map

package/dist/adapters/type-ast-bridge/ir-to-typescript.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-to-typescript.cjs","sources":["../../../src/adapters/type-ast-bridge/ir-to-typescript.ts"],"sourcesContent":["import type ts from \"typescript\";\nimport { assertNever } from \"../../domain/assert-never.js\";\nimport type {\n  IrComment,\n  IrKeyword,\n  IrMember,\n  IrPropertyName,\n  IrPropertySignature,\n  IrTupleElement,\n  IrType,\n} from \"../../domain/ir/nodes.js\";\nimport type { TypeScriptModule } from \"./load-typescript.js\";\n\n/**\n * Convert IR to TypeScript AST nodes with the same factory calls the original generator makes.\n * Printing the result with the TypeScript printer gives the original output, which is how the\n * printer parity tests (ENGINEERING_PLAN 4.3) define \"byte-identical\". Every function takes the\n * TypeScript module to build with (ADR-004, decision 4): the nodes must come from the same module\n * that later reads or prints them.\n */\n\ntype KeywordName = Exclude<IrKeyword, \"null\">;\n\nfunction keywordKind(ts: TypeScriptModule, keyword: KeywordName): ts.KeywordTypeSyntaxKind {\n  const kinds: Readonly<Record<KeywordName, ts.KeywordTypeSyntaxKind>> = {\n    string: ts.SyntaxKind.StringKeyword,\n    number: ts.SyntaxKind.NumberKeyword,\n    boolean: ts.SyntaxKind.BooleanKeyword,\n    undefined: ts.SyntaxKind.UndefinedKeyword,\n    unknown: ts.SyntaxKind.UnknownKeyword,\n    never: ts.SyntaxKind.NeverKeyword,\n  };\n  return kinds[keyword];\n}\n\nfunction toKeywordType(ts: TypeScriptModule, keyword: IrKeyword): ts.TypeNode {\n  return keyword === \"null\"\n    ? ts.factory.createLiteralTypeNode(ts.factory.createNull())\n    : ts.factory.createKeywordTypeNode(keywordKind(ts, keyword));\n}\n\n/**\n * Numbers as the original writes them: a negative value is a prefix minus on its absolute value.\n */\nfunction toNumberExpression(\n  ts: TypeScriptModule,\n  value: number,\n): ts.PrefixUnaryExpression | ts.NumericLiteral {\n  return value < 0\n    ? ts.factory.createPrefixUnaryExpression(\n        ts.SyntaxKind.MinusToken,\n        ts.factory.createNumericLiteral(Math.abs(value)),\n      )\n    : ts.factory.createNumericLiteral(value);\n}\n\n/** An enum member or array element value, written as the original writes it. */\nexport function toValueExpression(ts: TypeScriptModule, value: string | number): ts.Expression {\n  return typeof value === \"number\"\n    ? toNumberExpression(ts, value)\n    : ts.factory.createStringLiteral(value);\n}\n\n/** The original writes JSON-encoded literal types as identifiers to keep UTF-8 readable. */\nfunction toStringLiteralType(\n  ts: TypeScriptModule,\n  value: string,\n  encoding: \"json\" | \"escaped\",\n): ts.TypeNode {\n  return encoding === \"json\"\n    ? (ts.factory.createIdentifier(JSON.stringify(value)) as unknown as ts.TypeNode)\n    : ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(value));\n}\n\nfunction toTupleElement(ts: TypeScriptModule, element: IrTupleElement): ts.TypeNode {\n  const type = toTypeNode(ts, element.type);\n  if (element.isOptional) {\n    return ts.factory.createOptionalTypeNode(type);\n  }\n  return element.isRest ? ts.factory.createRestTypeNode(type) : type;\n}\n\ntype LeafType = Extract<\n  IrType,\n  { kind: \"keyword\" | \"stringLiteral\" | \"numberLiteral\" | \"booleanLiteral\" | \"raw\" }\n>;\n\nfunction toLeafTypeNode(ts: TypeScriptModule, type: LeafType): ts.TypeNode {\n  switch (type.kind) {\n    case \"keyword\":\n      return toKeywordType(ts, type.keyword);\n    case \"stringLiteral\":\n      return toStringLiteralType(ts, type.value, type.encoding);\n    case \"numberLiteral\":\n      return ts.factory.createLiteralTypeNode(toNumberExpression(ts, type.value));\n    case \"booleanLiteral\":\n      return ts.factory.createLiteralTypeNode(\n        type.value ? ts.factory.createTrue() : ts.factory.createFalse(),\n      );\n    case \"raw\":\n      // A node read from TypeScript goes back as it was, so the TypeScript printer indents it.\n      return (\n        (type.origin as ts.TypeNode | undefined) ??\n        (ts.factory.createIdentifier(type.text) as unknown as ts.TypeNode)\n      );\n    default:\n      return assertNever(type);\n  }\n}\n\nfunction toReferenceNode(\n  ts: TypeScriptModule,\n  type: Extract<IrType, { kind: \"reference\" }>,\n): ts.TypeNode {\n  const typeArguments =\n    type.typeArguments.length > 0\n      ? type.typeArguments.map((argument) => toTypeNode(ts, argument))\n      : undefined;\n  return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(type.name), typeArguments);\n}\n\n/** Convert one IR type. */\nexport function toTypeNode(ts: TypeScriptModule, type: IrType): ts.TypeNode {\n  const convert = (inner: IrType) => toTypeNode(ts, inner);\n  const { factory } = ts;\n  switch (type.kind) {\n    case \"keyword\":\n    case \"stringLiteral\":\n    case \"numberLiteral\":\n    case \"booleanLiteral\":\n    case \"raw\":\n      return toLeafTypeNode(ts, type);\n    case \"reference\":\n      return toReferenceNode(ts, type);\n    case \"array\":\n      return factory.createArrayTypeNode(convert(type.element));\n    case \"tuple\":\n      return factory.createTupleTypeNode(\n        type.elements.map((element) => toTupleElement(ts, element)),\n      );\n    case \"union\":\n      return factory.createUnionTypeNode(type.types.map(convert));\n    case \"intersection\":\n      return factory.createIntersectionTypeNode(type.types.map(convert));\n    case \"object\":\n      return factory.createTypeLiteralNode(type.members.map((member) => toTypeElement(ts, member)));\n    case \"indexedAccess\":\n      return factory.createIndexedAccessTypeNode(convert(type.object), convert(type.index));\n    case \"readonly\":\n      return factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, convert(type.type));\n    default:\n      return assertNever(type);\n  }\n}\n\n/** Attach IR comments to a node as synthetic leading comments, as the original does. */\nexport function withComments<T extends ts.Node>(\n  ts: TypeScriptModule,\n  node: T,\n  comments: readonly IrComment[],\n): T {\n  for (const comment of comments) {\n    const kind =\n      comment.kind === \"block\"\n        ? ts.SyntaxKind.MultiLineCommentTrivia\n        : ts.SyntaxKind.SingleLineCommentTrivia;\n    ts.addSyntheticLeadingComment(node, kind, comment.text, true);\n  }\n  return node;\n}\n\nfunction toPropertyName(ts: TypeScriptModule, name: IrPropertyName): ts.PropertyName {\n  switch (name.kind) {\n    case \"identifier\":\n      return ts.factory.createIdentifier(name.text);\n    case \"string\":\n      return ts.factory.createStringLiteral(name.value);\n    case \"number\":\n      return ts.factory.createNumericLiteral(name.text);\n    default:\n      return assertNever(name);\n  }\n}\n\nfunction readonlyModifiers(ts: TypeScriptModule, isReadonly: boolean): ts.Modifier[] | undefined {\n  return isReadonly ? [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)] : undefined;\n}\n\n/** Convert one property signature (for callbacks that receive a `ts.PropertySignature`). */\nexport function toPropertySignature(\n  ts: TypeScriptModule,\n  property: IrPropertySignature,\n): ts.PropertySignature {\n  const questionToken = property.isOptional\n    ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)\n    : undefined;\n  const signature = ts.factory.createPropertySignature(\n    readonlyModifiers(ts, property.isReadonly),\n    toPropertyName(ts, property.name),\n    questionToken,\n    toTypeNode(ts, property.type),\n  );\n  return withComments(ts, signature, property.comments);\n}\n\nexport function toTypeElement(ts: TypeScriptModule, member: IrMember): ts.TypeElement {\n  if (member.kind === \"property\") {\n    return toPropertySignature(ts, member);\n  }\n  const parameter = ts.factory.createParameterDeclaration(\n    undefined,\n    undefined,\n    member.parameterName,\n    undefined,\n    toTypeNode(ts, member.parameterType),\n  );\n  const signature = ts.factory.createIndexSignature(\n    readonlyModifiers(ts, member.isReadonly),\n    [parameter],\n    toTypeNode(ts, member.type),\n  );\n  return withComments(ts, signature, member.comments);\n}\n"],"names":["assertNever"],"mappings":"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"}

package/dist/adapters/type-ast-bridge/ir-to-typescript.mjs

@@ -0,0 +1,142 @@
+import { assertNever } from '../../domain/assert-never.mjs';
+
+function keywordKind(ts, keyword) {
+  const kinds = {
+    string: ts.SyntaxKind.StringKeyword,
+    number: ts.SyntaxKind.NumberKeyword,
+    boolean: ts.SyntaxKind.BooleanKeyword,
+    undefined: ts.SyntaxKind.UndefinedKeyword,
+    unknown: ts.SyntaxKind.UnknownKeyword,
+    never: ts.SyntaxKind.NeverKeyword
+  };
+  return kinds[keyword];
+}
+function toKeywordType(ts, keyword) {
+  return keyword === "null" ? ts.factory.createLiteralTypeNode(ts.factory.createNull()) : ts.factory.createKeywordTypeNode(keywordKind(ts, keyword));
+}
+function toNumberExpression(ts, value) {
+  return value < 0 ? ts.factory.createPrefixUnaryExpression(
+    ts.SyntaxKind.MinusToken,
+    ts.factory.createNumericLiteral(Math.abs(value))
+  ) : ts.factory.createNumericLiteral(value);
+}
+function toValueExpression(ts, value) {
+  return typeof value === "number" ? toNumberExpression(ts, value) : ts.factory.createStringLiteral(value);
+}
+function toStringLiteralType(ts, value, encoding) {
+  return encoding === "json" ? ts.factory.createIdentifier(JSON.stringify(value)) : ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(value));
+}
+function toTupleElement(ts, element) {
+  const type = toTypeNode(ts, element.type);
+  if (element.isOptional) {
+    return ts.factory.createOptionalTypeNode(type);
+  }
+  return element.isRest ? ts.factory.createRestTypeNode(type) : type;
+}
+function toLeafTypeNode(ts, type) {
+  switch (type.kind) {
+    case "keyword":
+      return toKeywordType(ts, type.keyword);
+    case "stringLiteral":
+      return toStringLiteralType(ts, type.value, type.encoding);
+    case "numberLiteral":
+      return ts.factory.createLiteralTypeNode(toNumberExpression(ts, type.value));
+    case "booleanLiteral":
+      return ts.factory.createLiteralTypeNode(
+        type.value ? ts.factory.createTrue() : ts.factory.createFalse()
+      );
+    case "raw":
+      return type.origin ?? ts.factory.createIdentifier(type.text);
+    default:
+      return assertNever(type);
+  }
+}
+function toReferenceNode(ts, type) {
+  const typeArguments = type.typeArguments.length > 0 ? type.typeArguments.map((argument) => toTypeNode(ts, argument)) : void 0;
+  return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(type.name), typeArguments);
+}
+function toTypeNode(ts, type) {
+  const convert = (inner) => toTypeNode(ts, inner);
+  const { factory } = ts;
+  switch (type.kind) {
+    case "keyword":
+    case "stringLiteral":
+    case "numberLiteral":
+    case "booleanLiteral":
+    case "raw":
+      return toLeafTypeNode(ts, type);
+    case "reference":
+      return toReferenceNode(ts, type);
+    case "array":
+      return factory.createArrayTypeNode(convert(type.element));
+    case "tuple":
+      return factory.createTupleTypeNode(
+        type.elements.map((element) => toTupleElement(ts, element))
+      );
+    case "union":
+      return factory.createUnionTypeNode(type.types.map(convert));
+    case "intersection":
+      return factory.createIntersectionTypeNode(type.types.map(convert));
+    case "object":
+      return factory.createTypeLiteralNode(type.members.map((member) => toTypeElement(ts, member)));
+    case "indexedAccess":
+      return factory.createIndexedAccessTypeNode(convert(type.object), convert(type.index));
+    case "readonly":
+      return factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, convert(type.type));
+    default:
+      return assertNever(type);
+  }
+}
+function withComments(ts, node, comments) {
+  for (const comment of comments) {
+    const kind = comment.kind === "block" ? ts.SyntaxKind.MultiLineCommentTrivia : ts.SyntaxKind.SingleLineCommentTrivia;
+    ts.addSyntheticLeadingComment(node, kind, comment.text, true);
+  }
+  return node;
+}
+function toPropertyName(ts, name) {
+  switch (name.kind) {
+    case "identifier":
+      return ts.factory.createIdentifier(name.text);
+    case "string":
+      return ts.factory.createStringLiteral(name.value);
+    case "number":
+      return ts.factory.createNumericLiteral(name.text);
+    default:
+      return assertNever(name);
+  }
+}
+function readonlyModifiers(ts, isReadonly) {
+  return isReadonly ? [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)] : void 0;
+}
+function toPropertySignature(ts, property) {
+  const questionToken = property.isOptional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : void 0;
+  const signature = ts.factory.createPropertySignature(
+    readonlyModifiers(ts, property.isReadonly),
+    toPropertyName(ts, property.name),
+    questionToken,
+    toTypeNode(ts, property.type)
+  );
+  return withComments(ts, signature, property.comments);
+}
+function toTypeElement(ts, member) {
+  if (member.kind === "property") {
+    return toPropertySignature(ts, member);
+  }
+  const parameter = ts.factory.createParameterDeclaration(
+    void 0,
+    void 0,
+    member.parameterName,
+    void 0,
+    toTypeNode(ts, member.parameterType)
+  );
+  const signature = ts.factory.createIndexSignature(
+    readonlyModifiers(ts, member.isReadonly),
+    [parameter],
+    toTypeNode(ts, member.type)
+  );
+  return withComments(ts, signature, member.comments);
+}
+
+export { toPropertySignature, toTypeElement, toTypeNode, toValueExpression, withComments };
+//# sourceMappingURL=ir-to-typescript.mjs.map

package/dist/adapters/type-ast-bridge/ir-to-typescript.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-to-typescript.mjs","sources":["../../../src/adapters/type-ast-bridge/ir-to-typescript.ts"],"sourcesContent":["import type ts from \"typescript\";\nimport { assertNever } from \"../../domain/assert-never.js\";\nimport type {\n  IrComment,\n  IrKeyword,\n  IrMember,\n  IrPropertyName,\n  IrPropertySignature,\n  IrTupleElement,\n  IrType,\n} from \"../../domain/ir/nodes.js\";\nimport type { TypeScriptModule } from \"./load-typescript.js\";\n\n/**\n * Convert IR to TypeScript AST nodes with the same factory calls the original generator makes.\n * Printing the result with the TypeScript printer gives the original output, which is how the\n * printer parity tests (ENGINEERING_PLAN 4.3) define \"byte-identical\". Every function takes the\n * TypeScript module to build with (ADR-004, decision 4): the nodes must come from the same module\n * that later reads or prints them.\n */\n\ntype KeywordName = Exclude<IrKeyword, \"null\">;\n\nfunction keywordKind(ts: TypeScriptModule, keyword: KeywordName): ts.KeywordTypeSyntaxKind {\n  const kinds: Readonly<Record<KeywordName, ts.KeywordTypeSyntaxKind>> = {\n    string: ts.SyntaxKind.StringKeyword,\n    number: ts.SyntaxKind.NumberKeyword,\n    boolean: ts.SyntaxKind.BooleanKeyword,\n    undefined: ts.SyntaxKind.UndefinedKeyword,\n    unknown: ts.SyntaxKind.UnknownKeyword,\n    never: ts.SyntaxKind.NeverKeyword,\n  };\n  return kinds[keyword];\n}\n\nfunction toKeywordType(ts: TypeScriptModule, keyword: IrKeyword): ts.TypeNode {\n  return keyword === \"null\"\n    ? ts.factory.createLiteralTypeNode(ts.factory.createNull())\n    : ts.factory.createKeywordTypeNode(keywordKind(ts, keyword));\n}\n\n/**\n * Numbers as the original writes them: a negative value is a prefix minus on its absolute value.\n */\nfunction toNumberExpression(\n  ts: TypeScriptModule,\n  value: number,\n): ts.PrefixUnaryExpression | ts.NumericLiteral {\n  return value < 0\n    ? ts.factory.createPrefixUnaryExpression(\n        ts.SyntaxKind.MinusToken,\n        ts.factory.createNumericLiteral(Math.abs(value)),\n      )\n    : ts.factory.createNumericLiteral(value);\n}\n\n/** An enum member or array element value, written as the original writes it. */\nexport function toValueExpression(ts: TypeScriptModule, value: string | number): ts.Expression {\n  return typeof value === \"number\"\n    ? toNumberExpression(ts, value)\n    : ts.factory.createStringLiteral(value);\n}\n\n/** The original writes JSON-encoded literal types as identifiers to keep UTF-8 readable. */\nfunction toStringLiteralType(\n  ts: TypeScriptModule,\n  value: string,\n  encoding: \"json\" | \"escaped\",\n): ts.TypeNode {\n  return encoding === \"json\"\n    ? (ts.factory.createIdentifier(JSON.stringify(value)) as unknown as ts.TypeNode)\n    : ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(value));\n}\n\nfunction toTupleElement(ts: TypeScriptModule, element: IrTupleElement): ts.TypeNode {\n  const type = toTypeNode(ts, element.type);\n  if (element.isOptional) {\n    return ts.factory.createOptionalTypeNode(type);\n  }\n  return element.isRest ? ts.factory.createRestTypeNode(type) : type;\n}\n\ntype LeafType = Extract<\n  IrType,\n  { kind: \"keyword\" | \"stringLiteral\" | \"numberLiteral\" | \"booleanLiteral\" | \"raw\" }\n>;\n\nfunction toLeafTypeNode(ts: TypeScriptModule, type: LeafType): ts.TypeNode {\n  switch (type.kind) {\n    case \"keyword\":\n      return toKeywordType(ts, type.keyword);\n    case \"stringLiteral\":\n      return toStringLiteralType(ts, type.value, type.encoding);\n    case \"numberLiteral\":\n      return ts.factory.createLiteralTypeNode(toNumberExpression(ts, type.value));\n    case \"booleanLiteral\":\n      return ts.factory.createLiteralTypeNode(\n        type.value ? ts.factory.createTrue() : ts.factory.createFalse(),\n      );\n    case \"raw\":\n      // A node read from TypeScript goes back as it was, so the TypeScript printer indents it.\n      return (\n        (type.origin as ts.TypeNode | undefined) ??\n        (ts.factory.createIdentifier(type.text) as unknown as ts.TypeNode)\n      );\n    default:\n      return assertNever(type);\n  }\n}\n\nfunction toReferenceNode(\n  ts: TypeScriptModule,\n  type: Extract<IrType, { kind: \"reference\" }>,\n): ts.TypeNode {\n  const typeArguments =\n    type.typeArguments.length > 0\n      ? type.typeArguments.map((argument) => toTypeNode(ts, argument))\n      : undefined;\n  return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(type.name), typeArguments);\n}\n\n/** Convert one IR type. */\nexport function toTypeNode(ts: TypeScriptModule, type: IrType): ts.TypeNode {\n  const convert = (inner: IrType) => toTypeNode(ts, inner);\n  const { factory } = ts;\n  switch (type.kind) {\n    case \"keyword\":\n    case \"stringLiteral\":\n    case \"numberLiteral\":\n    case \"booleanLiteral\":\n    case \"raw\":\n      return toLeafTypeNode(ts, type);\n    case \"reference\":\n      return toReferenceNode(ts, type);\n    case \"array\":\n      return factory.createArrayTypeNode(convert(type.element));\n    case \"tuple\":\n      return factory.createTupleTypeNode(\n        type.elements.map((element) => toTupleElement(ts, element)),\n      );\n    case \"union\":\n      return factory.createUnionTypeNode(type.types.map(convert));\n    case \"intersection\":\n      return factory.createIntersectionTypeNode(type.types.map(convert));\n    case \"object\":\n      return factory.createTypeLiteralNode(type.members.map((member) => toTypeElement(ts, member)));\n    case \"indexedAccess\":\n      return factory.createIndexedAccessTypeNode(convert(type.object), convert(type.index));\n    case \"readonly\":\n      return factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, convert(type.type));\n    default:\n      return assertNever(type);\n  }\n}\n\n/** Attach IR comments to a node as synthetic leading comments, as the original does. */\nexport function withComments<T extends ts.Node>(\n  ts: TypeScriptModule,\n  node: T,\n  comments: readonly IrComment[],\n): T {\n  for (const comment of comments) {\n    const kind =\n      comment.kind === \"block\"\n        ? ts.SyntaxKind.MultiLineCommentTrivia\n        : ts.SyntaxKind.SingleLineCommentTrivia;\n    ts.addSyntheticLeadingComment(node, kind, comment.text, true);\n  }\n  return node;\n}\n\nfunction toPropertyName(ts: TypeScriptModule, name: IrPropertyName): ts.PropertyName {\n  switch (name.kind) {\n    case \"identifier\":\n      return ts.factory.createIdentifier(name.text);\n    case \"string\":\n      return ts.factory.createStringLiteral(name.value);\n    case \"number\":\n      return ts.factory.createNumericLiteral(name.text);\n    default:\n      return assertNever(name);\n  }\n}\n\nfunction readonlyModifiers(ts: TypeScriptModule, isReadonly: boolean): ts.Modifier[] | undefined {\n  return isReadonly ? [ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)] : undefined;\n}\n\n/** Convert one property signature (for callbacks that receive a `ts.PropertySignature`). */\nexport function toPropertySignature(\n  ts: TypeScriptModule,\n  property: IrPropertySignature,\n): ts.PropertySignature {\n  const questionToken = property.isOptional\n    ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)\n    : undefined;\n  const signature = ts.factory.createPropertySignature(\n    readonlyModifiers(ts, property.isReadonly),\n    toPropertyName(ts, property.name),\n    questionToken,\n    toTypeNode(ts, property.type),\n  );\n  return withComments(ts, signature, property.comments);\n}\n\nexport function toTypeElement(ts: TypeScriptModule, member: IrMember): ts.TypeElement {\n  if (member.kind === \"property\") {\n    return toPropertySignature(ts, member);\n  }\n  const parameter = ts.factory.createParameterDeclaration(\n    undefined,\n    undefined,\n    member.parameterName,\n    undefined,\n    toTypeNode(ts, member.parameterType),\n  );\n  const signature = ts.factory.createIndexSignature(\n    readonlyModifiers(ts, member.isReadonly),\n    [parameter],\n    toTypeNode(ts, member.type),\n  );\n  return withComments(ts, signature, member.comments);\n}\n"],"names":[],"mappings":"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"}

package/dist/adapters/type-ast-bridge/lazy-node.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+function lazyNode(create) {
+  let node;
+  const target = () => {
+    node ??= create();
+    return node;
+  };
+  return new Proxy({}, {
+    get: (_, key) => Reflect.get(target(), key),
+    set: (_, key, value) => Reflect.set(target(), key, value),
+    has: (_, key) => Reflect.has(target(), key),
+    ownKeys: () => Reflect.ownKeys(target()),
+    getOwnPropertyDescriptor: (_, key) => {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target(), key);
+      return descriptor === void 0 ? void 0 : { ...descriptor, configurable: true };
+    },
+    getPrototypeOf: () => Reflect.getPrototypeOf(target())
+  });
+}
+
+exports.lazyNode = lazyNode;
+//# sourceMappingURL=lazy-node.cjs.map

package/dist/adapters/type-ast-bridge/lazy-node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-node.cjs","sources":["../../../src/adapters/type-ast-bridge/lazy-node.ts"],"sourcesContent":["/**\n * A TypeScript node that is created on first use (for the deprecated `QUESTION_TOKEN` export):\n * the package must import without TypeScript installed (ADR-004, decision 4). Every property read,\n * write and check goes to the node, so the TypeScript factory and printer see a normal node.\n */\nexport function lazyNode<T extends object>(create: () => T): T {\n  let node: T | undefined;\n  const target = (): T => {\n    node ??= create();\n    return node;\n  };\n  return new Proxy({} as T, {\n    get: (_, key) => Reflect.get(target(), key),\n    set: (_, key, value) => Reflect.set(target(), key, value),\n    has: (_, key) => Reflect.has(target(), key),\n    ownKeys: () => Reflect.ownKeys(target()),\n    getOwnPropertyDescriptor: (_, key) => {\n      const descriptor = Reflect.getOwnPropertyDescriptor(target(), key);\n      // A proxy may report a property only as configurable when its own (empty) target lacks it.\n      return descriptor === undefined ? undefined : { ...descriptor, configurable: true };\n    },\n    getPrototypeOf: () => Reflect.getPrototypeOf(target()),\n  });\n}\n"],"names":[],"mappings":";;AAKO,SAAS,SAA2B,MAAA,EAAoB;AAC7D,EAAA,IAAI,IAAA;AACJ,EAAA,MAAM,SAAS,MAAS;AACtB,IAAA,IAAA,KAAS,MAAA,EAAO;AAChB,IAAA,OAAO,IAAA;AAAA,EACT,CAAA;AACA,EAAA,OAAO,IAAI,KAAA,CAAM,EAAC,EAAQ;AAAA,IACxB,GAAA,EAAK,CAAC,CAAA,EAAG,GAAA,KAAQ,QAAQ,GAAA,CAAI,MAAA,IAAU,GAAG,CAAA;AAAA,IAC1C,GAAA,EAAK,CAAC,CAAA,EAAG,GAAA,EAAK,KAAA,KAAU,QAAQ,GAAA,CAAI,MAAA,EAAO,EAAG,GAAA,EAAK,KAAK,CAAA;AAAA,IACxD,GAAA,EAAK,CAAC,CAAA,EAAG,GAAA,KAAQ,QAAQ,GAAA,CAAI,MAAA,IAAU,GAAG,CAAA;AAAA,IAC1C,OAAA,EAAS,MAAM,OAAA,CAAQ,OAAA,CAAQ,QAAQ,CAAA;AAAA,IACvC,wBAAA,EAA0B,CAAC,CAAA,EAAG,GAAA,KAAQ;AACpC,MAAA,MAAM,UAAA,GAAa,OAAA,CAAQ,wBAAA,CAAyB,MAAA,IAAU,GAAG,CAAA;AAEjE,MAAA,OAAO,eAAe,MAAA,GAAY,MAAA,GAAY,EAAE,GAAG,UAAA,EAAY,cAAc,IAAA,EAAK;AAAA,IACpF,CAAA;AAAA,IACA,cAAA,EAAgB,MAAM,OAAA,CAAQ,cAAA,CAAe,QAAQ;AAAA,GACtD,CAAA;AACH;;"}