oazapfts/dist/context-9l26yjuA.cjs.map

OpenApi TypeScript client generator

{"version":3,"file":"context-9l26yjuA.cjs","names":[],"sources":["../src/helpers/getOnlyModeSuffix.ts","../src/helpers/toIdentifier.ts","../src/generate/tscodegen.ts","../src/generate/generateServers.ts","../src/context.ts"],"sourcesContent":["import { OnlyMode } from \"../context\";\n\nconst onlyModeSuffixes: Record<OnlyMode, string> = {\n  readOnly: \"Read\",\n  writeOnly: \"Write\",\n};\n\nexport function getOnlyModeSuffix(onlyMode?: OnlyMode) {\n  if (!onlyMode) return \"\";\n  return onlyModeSuffixes[onlyMode];\n}\n","import _ from \"lodash\";\nimport { OnlyMode } from \"../context\";\nimport { isValidIdentifier } from \"../generate/tscodegen\";\nimport { getOnlyModeSuffix } from \"./getOnlyModeSuffix\";\n\nexport function toIdentifier(s: string, upper = false, onlyMode?: OnlyMode) {\n  let cc = _.camelCase(s) + getOnlyModeSuffix(onlyMode);\n  if (upper) cc = _.upperFirst(cc);\n  if (isValidIdentifier(cc)) return cc;\n  return \"$\" + cc;\n}\n","import ts from \"typescript\";\nimport { toIdentifier } from \"../helpers/toIdentifier\";\n\nconst factory = ts.factory;\n\nexport const questionToken = factory.createToken(ts.SyntaxKind.QuestionToken);\n\nexport function createQuestionToken(token?: boolean | ts.QuestionToken) {\n  if (!token) return undefined;\n  if (token === true) return questionToken;\n  return token;\n}\n\nexport const keywordType = {\n  any: factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),\n  number: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n  integer: factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),\n  object: factory.createKeywordTypeNode(ts.SyntaxKind.ObjectKeyword),\n  string: factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),\n  boolean: factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword),\n  undefined: factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),\n  void: factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword),\n  never: factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword),\n  null: factory.createLiteralTypeNode(factory.createNull()),\n  unknown: factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),\n};\n\ntype KeywordTypeName = keyof typeof keywordType;\n\nexport function createKeywordType(type: KeywordTypeName) {\n  return keywordType[type];\n}\n\nexport const modifier = {\n  async: factory.createModifier(ts.SyntaxKind.AsyncKeyword),\n  export: factory.createModifier(ts.SyntaxKind.ExportKeyword),\n};\n\nexport function createLiteral(v: string | boolean | number) {\n  switch (typeof v) {\n    case \"string\":\n      return factory.createStringLiteral(v);\n    case \"boolean\":\n      return v ? factory.createTrue() : factory.createFalse();\n    case \"number\":\n      return String(v).charAt(0) === \"-\"\n        ? factory.createPrefixUnaryExpression(\n            ts.SyntaxKind.MinusToken,\n            factory.createNumericLiteral(String(-v)),\n          )\n        : factory.createNumericLiteral(String(v));\n  }\n}\n\nexport function createEnumTypeNode(values: Array<string | boolean | number>) {\n  const types = values.map((v) =>\n    v === null\n      ? keywordType.null\n      : factory.createLiteralTypeNode(createLiteral(v)),\n  );\n  return types.length > 1 ? factory.createUnionTypeNode(types) : types[0];\n}\n\nexport function createTypeAliasDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  type,\n}: {\n  modifiers?: Array<ts.Modifier>;\n  name: string | ts.Identifier;\n  typeParameters?: Array<ts.TypeParameterDeclaration>;\n  type: ts.TypeNode;\n}) {\n  return factory.createTypeAliasDeclaration(\n    modifiers,\n    name,\n    typeParameters,\n    type,\n  );\n}\n\nexport function createInterfaceAliasDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  type,\n  inheritedNodeNames,\n}: {\n  modifiers?: Array<ts.Modifier>;\n  name: string | ts.Identifier;\n  typeParameters?: Array<ts.TypeParameterDeclaration>;\n  type: ts.TypeNode;\n  inheritedNodeNames?: (string | ts.Identifier)[];\n}) {\n  const heritageClauses = inheritedNodeNames\n    ? [\n        factory.createHeritageClause(\n          ts.SyntaxKind.ExtendsKeyword,\n          inheritedNodeNames.map((name) => {\n            const extendedInterfaceName =\n              typeof name === \"string\" ? name : name.escapedText.toString();\n            return factory.createExpressionWithTypeArguments(\n              factory.createIdentifier(\n                toIdentifier(extendedInterfaceName, true),\n              ),\n              undefined,\n            );\n          }),\n        ),\n      ]\n    : [];\n  return factory.createInterfaceDeclaration(\n    modifiers,\n    name,\n    typeParameters,\n    heritageClauses,\n    (type as ts.TypeLiteralNode).members,\n  );\n}\n\nexport function toExpression(ex: ts.Expression | string) {\n  if (typeof ex === \"string\") return factory.createIdentifier(ex);\n  return ex;\n}\n\nexport function createCall(\n  expression: ts.Expression | string,\n  {\n    typeArgs,\n    args,\n  }: {\n    typeArgs?: Array<ts.TypeNode>;\n    args?: Array<ts.Expression>;\n  } = {},\n) {\n  return factory.createCallExpression(toExpression(expression), typeArgs, args);\n}\n\nexport function createMethodCall(\n  method: string,\n  opts: {\n    typeArgs?: Array<ts.TypeNode>;\n    args?: Array<ts.Expression>;\n  },\n) {\n  return createCall(\n    factory.createPropertyAccessExpression(factory.createThis(), method),\n    opts,\n  );\n}\n\nexport function createObjectLiteral(props: [string, string | ts.Expression][]) {\n  return factory.createObjectLiteralExpression(\n    props.map(([name, identifier]) =>\n      createPropertyAssignment(name, toExpression(identifier)),\n    ),\n    true,\n  );\n}\n\nexport function createPropertyAssignment(\n  name: string,\n  expression: ts.Expression,\n) {\n  if (ts.isIdentifier(expression)) {\n    if (expression.text === name) {\n      return factory.createShorthandPropertyAssignment(name);\n    }\n  }\n  return factory.createPropertyAssignment(propertyName(name), expression);\n}\n\nexport function block(...statements: ts.Statement[]) {\n  return factory.createBlock(statements, true);\n}\n\nexport function createArrowFunction(\n  parameters: ts.ParameterDeclaration[],\n  body: ts.ConciseBody,\n  {\n    modifiers,\n    typeParameters,\n    type,\n    equalsGreaterThanToken,\n  }: {\n    modifiers?: ts.Modifier[];\n    typeParameters?: ts.TypeParameterDeclaration[];\n    type?: ts.TypeNode;\n    equalsGreaterThanToken?: ts.EqualsGreaterThanToken;\n  } = {},\n) {\n  return factory.createArrowFunction(\n    modifiers,\n    typeParameters,\n    parameters,\n    type,\n    equalsGreaterThanToken,\n    body,\n  );\n}\n\nexport function createFunctionDeclaration(\n  name: string | ts.Identifier | undefined,\n  {\n    modifiers,\n    asteriskToken,\n    typeParameters,\n    type,\n  }: {\n    modifiers?: ts.Modifier[];\n    asteriskToken?: ts.AsteriskToken;\n    typeParameters?: ts.TypeParameterDeclaration[];\n    type?: ts.TypeNode;\n  },\n  parameters: ts.ParameterDeclaration[],\n  body?: ts.Block,\n): ts.FunctionDeclaration {\n  return factory.createFunctionDeclaration(\n    modifiers,\n    asteriskToken,\n    name,\n    typeParameters,\n    parameters,\n    type,\n    body,\n  );\n}\n\nexport function createClassDeclaration({\n  modifiers,\n  name,\n  typeParameters,\n  heritageClauses,\n  members,\n}: {\n  modifiers?: Array<ts.Modifier>;\n  name?: string | ts.Identifier;\n  typeParameters?: Array<ts.TypeParameterDeclaration>;\n  heritageClauses?: Array<ts.HeritageClause>;\n  members: Array<ts.ClassElement>;\n}) {\n  return factory.createClassDeclaration(\n    modifiers,\n    name,\n    typeParameters,\n    heritageClauses,\n    members,\n  );\n}\n\nexport function createConstructor({\n  modifiers,\n  parameters,\n  body,\n}: {\n  modifiers?: Array<ts.Modifier>;\n  parameters: Array<ts.ParameterDeclaration>;\n  body?: ts.Block;\n}) {\n  return factory.createConstructorDeclaration(modifiers, parameters, body);\n}\n\nexport function createMethod(\n  name:\n    | string\n    | ts.Identifier\n    | ts.StringLiteral\n    | ts.NumericLiteral\n    | ts.ComputedPropertyName,\n  {\n    modifiers,\n    asteriskToken,\n    questionToken,\n    typeParameters,\n    type,\n  }: {\n    modifiers?: ts.Modifier[];\n    asteriskToken?: ts.AsteriskToken;\n    questionToken?: ts.QuestionToken | boolean;\n    typeParameters?: ts.TypeParameterDeclaration[];\n    type?: ts.TypeNode;\n  } = {},\n  parameters: ts.ParameterDeclaration[] = [],\n  body?: ts.Block,\n): ts.MethodDeclaration {\n  return factory.createMethodDeclaration(\n    modifiers,\n    asteriskToken,\n    name,\n    createQuestionToken(questionToken),\n    typeParameters,\n    parameters,\n    type,\n    body,\n  );\n}\n\nexport function createParameter(\n  name: string | ts.BindingName,\n  {\n    modifiers,\n    dotDotDotToken,\n    questionToken,\n    type,\n    initializer,\n  }: {\n    modifiers?: Array<ts.Modifier>;\n    dotDotDotToken?: ts.DotDotDotToken;\n    questionToken?: ts.QuestionToken | boolean;\n    type?: ts.TypeNode;\n    initializer?: ts.Expression;\n  },\n): ts.ParameterDeclaration {\n  return factory.createParameterDeclaration(\n    modifiers,\n    dotDotDotToken,\n    name,\n    createQuestionToken(questionToken),\n    type,\n    initializer,\n  );\n}\n\nfunction propertyName(name: string | ts.PropertyName): ts.PropertyName {\n  if (typeof name === \"string\") {\n    return isValidIdentifier(name)\n      ? factory.createIdentifier(name)\n      : factory.createStringLiteral(name);\n  }\n  return name;\n}\n\nexport function createPropertySignature({\n  modifiers,\n  name,\n  questionToken,\n  type,\n}: {\n  modifiers?: Array<ts.Modifier>;\n  name: ts.PropertyName | string;\n  questionToken?: ts.QuestionToken | boolean;\n  type?: ts.TypeNode;\n}) {\n  return factory.createPropertySignature(\n    modifiers,\n    propertyName(name),\n    createQuestionToken(questionToken),\n    type,\n  );\n}\n\nexport function createIndexSignature(\n  type: ts.TypeNode,\n  {\n    modifiers,\n    indexName = \"key\",\n    indexType = keywordType.string,\n  }: {\n    indexName?: string;\n    indexType?: ts.TypeNode;\n    modifiers?: Array<ts.Modifier>;\n  } = {},\n) {\n  return factory.createIndexSignature(\n    modifiers,\n    [createParameter(indexName, { type: indexType })],\n    type,\n  );\n}\n\nexport function createObjectBinding(\n  elements: Array<{\n    name: string | ts.BindingName;\n    dotDotDotToken?: ts.DotDotDotToken;\n    propertyName?: string | ts.PropertyName;\n    initializer?: ts.Expression;\n  }>,\n) {\n  return factory.createObjectBindingPattern(\n    elements.map(({ dotDotDotToken, propertyName, name, initializer }) =>\n      factory.createBindingElement(\n        dotDotDotToken,\n        propertyName,\n        name,\n        initializer,\n      ),\n    ),\n  );\n}\n\nexport function createTemplateString(\n  head: string,\n  spans: Array<{ literal: string; expression: ts.Expression }>,\n) {\n  if (!spans.length) return factory.createStringLiteral(head);\n  return factory.createTemplateExpression(\n    factory.createTemplateHead(head),\n    spans.map(({ expression, literal }, i) =>\n      factory.createTemplateSpan(\n        expression,\n        i === spans.length - 1\n          ? factory.createTemplateTail(literal)\n          : factory.createTemplateMiddle(literal),\n      ),\n    ),\n  );\n}\n\nexport function findNode<T extends ts.Node>(\n  nodes: ts.NodeArray<ts.Node>,\n  kind: T extends { kind: infer K } ? K : never,\n  test?: (node: T) => boolean | undefined,\n): T {\n  const node = nodes.find(\n    (s) => s.kind === kind && (!test || test(s as T)),\n  ) as T;\n  if (!node) throw new Error(`Node not found: ${kind}`);\n  return node;\n}\n\nexport function getName(name: ts.Node) {\n  if (ts.isIdentifier(name)) {\n    return name.escapedText;\n  }\n  if (ts.isLiteralExpression(name)) {\n    return name.text;\n  }\n  return \"\";\n}\n\nexport function getFirstDeclarationName(n: ts.VariableStatement) {\n  const name = ts.getNameOfDeclaration(n.declarationList.declarations[0]);\n  return name ? getName(name) : \"\";\n}\n\nexport function findFirstVariableDeclaration(\n  nodes: ts.NodeArray<ts.Node>,\n  name: string,\n) {\n  const statement = findNode<ts.VariableStatement>(\n    nodes,\n    ts.SyntaxKind.VariableStatement,\n    (n) => getFirstDeclarationName(n) === name,\n  );\n  const [first] = statement.declarationList.declarations;\n  if (!first) throw new Error(`Missing ${name} declaration`);\n  return first;\n}\n\nexport function changePropertyValue(\n  o: ts.ObjectLiteralExpression,\n  property: string,\n  value: ts.Expression,\n) {\n  const p = o.properties.find(\n    (p) => ts.isPropertyAssignment(p) && getName(p.name) === property,\n  );\n  if (p && ts.isPropertyAssignment(p)) {\n    // p.initializer is readonly, this might break in a future TS version, but works fine for now.\n    Object.assign(p, { initializer: value });\n  } else {\n    throw new Error(`No such property: ${property}`);\n  }\n}\n\ntype Visitor = (\n  node: ts.Node,\n  context: ts.TransformationContext,\n) => void | ts.Node;\n\nfunction createTransformer(visitor: Visitor) {\n  return <T extends ts.Node>(context: ts.TransformationContext) =>\n    (rootNode: T) => {\n      function visit(node: ts.Node): ts.Node {\n        const result = visitor(node, context);\n\n        if (result) {\n          return result;\n        }\n\n        return ts.visitEachChild(node, visit, context);\n      }\n\n      return ts.visitNode(rootNode, visit);\n    };\n}\n\nexport function transform<T extends ts.Node>(\n  source: T,\n  ...visitors: Visitor[]\n) {\n  const result = ts.transform(source, visitors.map(createTransformer));\n\n  return result.transformed[0] as T;\n}\n\nexport function appendNodes<T extends ts.Node>(\n  array: ts.NodeArray<T>,\n  ...nodes: T[]\n) {\n  return factory.createNodeArray([...array, ...nodes]);\n}\n\nexport function addComment<T extends ts.Node>(node: T, comment?: string) {\n  if (!comment) return node;\n  return ts.addSyntheticLeadingComment(\n    node,\n    ts.SyntaxKind.MultiLineCommentTrivia,\n    `*\\n * ${comment.replace(/\\n/g, \"\\n * \")}\\n `,\n    true,\n  );\n}\n\nconst printer = ts.createPrinter({\n  newLine: ts.NewLineKind.LineFeed,\n});\n\nexport function printNode(node: ts.Node) {\n  const file = ts.createSourceFile(\n    \"someFileName.ts\",\n    \"\",\n    ts.ScriptTarget.Latest,\n    /*setParentNodes*/ false,\n    ts.ScriptKind.TS,\n  );\n  return printer.printNode(ts.EmitHint.Unspecified, node, file);\n}\n\nexport function printNodes(nodes: ts.Node[]) {\n  const file = ts.createSourceFile(\n    \"someFileName.ts\",\n    \"\",\n    ts.ScriptTarget.Latest,\n    /*setParentNodes*/ false,\n    ts.ScriptKind.TS,\n  );\n  return nodes\n    .map((node) => printer.printNode(ts.EmitHint.Unspecified, node, file))\n    .join(\"\\n\");\n}\n\nexport function printFile(sourceFile: ts.SourceFile) {\n  return printer.printFile(sourceFile);\n}\n\nexport function isValidIdentifier(str: string) {\n  if (!str.length || str.trim() !== str) return false;\n  const node = ts.parseIsolatedEntityName(str, ts.ScriptTarget.Latest);\n  return (\n    !!node &&\n    node.kind === ts.SyntaxKind.Identifier &&\n    ts.identifierToKeywordKind(node) === undefined\n  );\n}\n\nexport function updateVariableDeclaration(\n  node: ts.VariableDeclaration,\n  updates: Partial<ts.VariableDeclaration>,\n) {\n  return ts.factory.updateVariableDeclaration(\n    node,\n    updates.name || node.name,\n    updates.exclamationToken || node.exclamationToken,\n    updates.type || node.type,\n    updates.initializer || node.initializer,\n  );\n}\n\nexport function updateFunctionDeclaration(\n  node: ts.FunctionDeclaration,\n  updates: Partial<ts.FunctionDeclaration>,\n) {\n  return ts.factory.updateFunctionDeclaration(\n    node,\n    updates.modifiers || node.modifiers,\n    updates.asteriskToken || node.asteriskToken,\n    updates.name || node.name,\n    updates.typeParameters || node.typeParameters,\n    updates.parameters || node.parameters,\n    updates.type || node.type,\n    updates.body || node.body,\n  );\n}\n","import _ from \"lodash\";\nimport * as cg from \"./tscodegen\";\nimport ts from \"typescript\";\nimport { OpenAPIV3 } from \"openapi-types\";\nimport { ServerObject } from \"../helpers/openApi3-x\";\n\nconst factory = ts.factory;\n\nfunction createTemplate(url: string) {\n  const tokens = url.split(/{([\\s\\S]+?)}/g);\n  const chunks = _.chunk(tokens.slice(1), 2);\n  return cg.createTemplateString(\n    tokens[0],\n    chunks.map(([expression, literal]) => ({\n      expression: factory.createIdentifier(expression),\n      literal,\n    })),\n  );\n}\n\nfunction createServerFunction(\n  template: string,\n  vars: Record<string, OpenAPIV3.ServerVariableObject>,\n) {\n  const params = [\n    cg.createParameter(\n      cg.createObjectBinding(\n        Object.entries(vars || {}).map(([name, value]) => {\n          return {\n            name,\n            initializer: cg.createLiteral(value.default),\n          };\n        }),\n      ),\n      {\n        type: factory.createTypeLiteralNode(\n          Object.entries(vars || {}).map(([name, value]) => {\n            return cg.createPropertySignature({\n              name,\n              type: value.enum\n                ? cg.createEnumTypeNode(value.enum)\n                : factory.createUnionTypeNode([\n                    cg.keywordType.string,\n                    cg.keywordType.number,\n                    cg.keywordType.boolean,\n                  ]),\n            });\n          }),\n        ),\n      },\n    ),\n  ];\n\n  return cg.createArrowFunction(params, createTemplate(template));\n}\n\nfunction generateServerExpression(server: ServerObject) {\n  return server.variables\n    ? createServerFunction(server.url, server.variables)\n    : factory.createStringLiteral(server.url);\n}\n\nfunction defaultUrl(server?: ServerObject) {\n  if (!server) return \"/\";\n  const { url, variables } = server;\n  if (!variables) return url;\n  return url.replace(/\\{(.+?)\\}/g, (m, name) =>\n    variables[name] ? String(variables[name].default) : m,\n  );\n}\n\nexport function defaultBaseUrl(servers?: ServerObject[]) {\n  return defaultUrl(servers?.[0]);\n}\n\nfunction serverName(server: ServerObject, index: number) {\n  return server.description\n    ? _.camelCase(server.description.replace(/\\W+/, \" \"))\n    : `server${index + 1}`;\n}\n\nexport function generateServers(servers: ServerObject[]) {\n  return cg.createObjectLiteral(\n    servers.map((server, i) => [\n      serverName(server, i),\n      generateServerExpression(server),\n    ]),\n  );\n}\n\nexport function createServersStatement(servers: ServerObject[]) {\n  return ts.factory.createVariableStatement(\n    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],\n    ts.factory.createVariableDeclarationList(\n      [\n        ts.factory.createVariableDeclaration(\n          \"servers\",\n          undefined,\n          undefined,\n          generateServers(servers),\n        ),\n      ],\n      ts.NodeFlags.Const,\n    ),\n  );\n}\n","import ts, {\n  InterfaceDeclaration,\n  Statement,\n  TypeAliasDeclaration,\n  TypeReferenceNode,\n} from \"typescript\";\nimport type { OazapftsOptions } from \"./\";\nimport type {\n  Document,\n  SchemaObject,\n  ServerObject,\n} from \"./helpers/openApi3-x\";\nimport { defaultBaseUrl } from \"./generate/generateServers\";\nimport _ from \"lodash\";\nimport { CustomHeaders } from \"@oazapfts/runtime\";\n\n// ─── Data types for template parts ──────────────────────────────────────────\n\nexport type ImportSpecifier = {\n  name: string;\n  as?: string;\n};\nexport type DefaultImport = [string, { from: string }];\nexport type NamespaceImport = [{ namespace: string }, { from: string }];\nexport type ImportsWithoutDefault = [\n  (ImportSpecifier | string)[],\n  { from: string },\n];\nexport type ImportWithDefault = [\n  string,\n  (ImportSpecifier | string)[],\n  { from: string },\n];\n\nexport type Import =\n  | string\n  | ImportsWithoutDefault\n  | DefaultImport\n  | ImportWithDefault\n  | NamespaceImport;\n\nexport type OnlyMode = \"readOnly\" | \"writeOnly\";\nexport type OnlyModes = Record<OnlyMode, boolean>;\n\nexport type ReadonlyDeep<T> = {\n  readonly [P in keyof T]: ReadonlyDeep<T[P]>;\n};\n\nexport type Defaults = {\n  baseUrl?: string;\n  headers?: CustomHeaders;\n  FormData?: ts.ClassExpression | ts.Identifier;\n  fetch?: ts.FunctionExpression | ts.ArrowFunction | ts.Identifier;\n};\n\nexport type OazapftsContext = {\n  readonly opts: ReadonlyDeep<OazapftsOptions>;\n  readonly spec: Document;\n  readonly mode?: OnlyMode;\n\n  /** Banner comment at the top of the file (the text content, not including comment markers) */\n  banner: string;\n  /** Import declarations (AST nodes) */\n  imports: Import[];\n  /** Runtime defaults (baseUrl, etc.) - will be generated as `export const defaults = { ... }` */\n  defaults: Defaults;\n  /** Server definitions - will be generated as `export const servers = { ... }` */\n  servers: ServerObject[];\n  /** Initialization statements (e.g., `const oazapfts = Oazapfts.runtime(defaults)`) */\n  init: Statement[];\n\n  // see `preprocessComponents` for the definition of a discriminating schema\n  discriminatingSchemas: Set<SchemaObject>;\n\n  aliases: (TypeAliasDeclaration | InterfaceDeclaration)[];\n\n  enumAliases: Statement[];\n  enumRefs: Record<string, { values: string; type: TypeReferenceNode }>;\n\n  // Collect the types of all referenced schemas so we can export them later\n  // Referenced schemas can be pointing at the following versions:\n  // - \"base\": The regular type/interface e.g. ExampleSchema\n  // - \"readOnly\": The readOnly version e.g. ExampleSchemaRead\n  // - \"writeOnly\": The writeOnly version e.g. ExampleSchemaWrite\n  refs: Record<\n    string,\n    {\n      base: TypeReferenceNode;\n      readOnly?: TypeReferenceNode;\n      writeOnly?: TypeReferenceNode;\n    }\n  >;\n\n  // Maps a referenced schema to its readOnly/writeOnly status\n  // This field should be used exclusively within the `checkSchemaOnlyMode` method\n  refsOnlyMode: Map<string, OnlyModes>;\n\n  // Keep track of already used type aliases\n  typeAliases: Record<string, number>;\n  // Keep track of already used operation names for collision handling\n  operationNames: Map<string, number>;\n};\n\nexport function createContext(\n  inputSpec: Document,\n  opts: OazapftsContext[\"opts\"] = {},\n): OazapftsContext {\n  const spec = _.cloneDeep(inputSpec);\n\n  return {\n    opts,\n    spec,\n    mode: undefined,\n\n    // Template parts\n    banner: `DO NOT MODIFY - This file has been generated using oazapfts.\nSee https://www.npmjs.com/package/oazapfts`,\n    imports: [\n      [{ namespace: \"Oazapfts\" }, { from: \"@oazapfts/runtime\" }],\n      [{ namespace: \"QS\" }, { from: \"@oazapfts/runtime/query\" }],\n    ],\n    defaults: { baseUrl: defaultBaseUrl(spec.servers), headers: {} },\n    servers: spec.servers || [],\n    init: createInit(),\n\n    // Internal state\n    discriminatingSchemas: new Set(),\n    aliases: [],\n    enumAliases: [],\n    enumRefs: {},\n    refs: {},\n    refsOnlyMode: new Map(),\n    typeAliases: {},\n    operationNames: new Map(),\n  };\n}\n\nexport function withMode(\n  ctx: OazapftsContext,\n  mode?: OnlyMode,\n): OazapftsContext {\n  return { ...ctx, mode };\n}\n\n/** Creates: const oazapfts = Oazapfts.runtime(defaults); */\nfunction createInit(): Statement[] {\n  return [\n    ts.factory.createVariableStatement(\n      undefined,\n      ts.factory.createVariableDeclarationList(\n        [\n          ts.factory.createVariableDeclaration(\n            \"oazapfts\",\n            undefined,\n            undefined,\n            ts.factory.createCallExpression(\n              ts.factory.createPropertyAccessExpression(\n                ts.factory.createIdentifier(\"Oazapfts\"),\n                \"runtime\",\n              ),\n              undefined,\n              [ts.factory.createIdentifier(\"defaults\")],\n            ),\n          ),\n        ],\n        ts.NodeFlags.Const,\n      ),\n    ),\n  ];\n}\n"],"mappings":"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"}