openapi-typesafe 0.0.0 → 1.0.0-rc.0

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,145 @@
+'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);
+  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  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,139 @@
+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);
+  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  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;;"}

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

@@ -0,0 +1,21 @@
+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())
+  });
+}
+
+export { lazyNode };
+//# sourceMappingURL=lazy-node.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-node.mjs","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;;"}

package/dist/adapters/type-ast-bridge/load-typescript.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+const node_module = require('node:module');
+const path = require('node:path');
+const errors = require('../../domain/errors.cjs');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const TYPESCRIPT_PACKAGES = ["typescript", "@typescript/typescript6"];
+const UNAVAILABLE_CODES = /* @__PURE__ */ new Set([
+  "MODULE_NOT_FOUND",
+  "ERR_REQUIRE_ESM",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED"
+]);
+class TypeScriptNotFoundError extends errors.OpenAPITypesafeError {
+  constructor() {
+    super({
+      code: errors.ERROR_CODES.TYPESCRIPT_NOT_FOUND,
+      message: 'A callback or helper uses TypeScript compiler nodes, which needs the TypeScript JavaScript API. Install "typescript" version 6 or earlier, or "@typescript/typescript6" on TypeScript 7, or use IR callbacks (irCallbacks: true).',
+      details: { packages: [...TYPESCRIPT_PACKAGES] }
+    });
+    this.name = "TypeScriptNotFoundError";
+  }
+}
+function defaultModuleRequires() {
+  return [node_module.createRequire(path.join(process.cwd(), "package.json")), node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('adapters/type-ast-bridge/load-typescript.cjs', document.baseURI).href)))];
+}
+function hasCompilerApi(value) {
+  const module = value;
+  return typeof module?.factory?.createTypeReferenceNode === "function" && typeof module.createPrinter === "function";
+}
+function tryRequire(load, id) {
+  try {
+    return load(id);
+  } catch (error) {
+    if (UNAVAILABLE_CODES.has(error.code ?? "")) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+function loadTypeScript(requires = defaultModuleRequires()) {
+  for (const id of TYPESCRIPT_PACKAGES) {
+    for (const load of requires) {
+      const module = tryRequire(load, id);
+      if (hasCompilerApi(module)) {
+        return module;
+      }
+    }
+  }
+  throw new TypeScriptNotFoundError();
+}
+
+exports.TYPESCRIPT_PACKAGES = TYPESCRIPT_PACKAGES;
+exports.TypeScriptNotFoundError = TypeScriptNotFoundError;
+exports.defaultModuleRequires = defaultModuleRequires;
+exports.loadTypeScript = loadTypeScript;
+//# sourceMappingURL=load-typescript.cjs.map