@xlr-lib/xlr-converters 0.1.1-next.0

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/index.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts-to-xlr.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/types.ts","../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/xlr-to-ts.ts"],"sourcesContent":["export { TsConverter } from \"./ts-to-xlr\";\nexport type { TSConverterContext } from \"./ts-to-xlr\";\nexport { TSWriter } from \"./xlr-to-ts\";\nexport type { ConvertedType } from \"./xlr-to-ts\";\nexport * from \"./types\";\n","import ts from \"typescript\";\nimport type {\n  NodeType,\n  FunctionTypeParameters,\n  TupleType,\n  NamedType,\n  ObjectType,\n  NamedTypeWithGenerics,\n  NodeTypeWithGenerics,\n  ObjectProperty,\n  AnyType,\n  ParamTypeNode,\n  ConditionalType,\n  RefType,\n  ArrayType,\n  OrType,\n} from \"@xlr-lib/xlr\";\nimport type { TopLevelDeclaration, TopLevelNode } from \"@xlr-lib/xlr-utils\";\nimport {\n  buildTemplateRegex,\n  decorateNode,\n  fillInGenerics,\n  getReferencedType,\n  getStringLiteralsFromUnion,\n  isExportedDeclaration,\n  isGenericInterfaceDeclaration,\n  isGenericNodeType,\n  isGenericTypeDeclaration,\n  isOptionalProperty,\n  isTypeReferenceGeneric,\n  tsStripOptionalType,\n  isNonNullable,\n  applyPartialOrRequiredToNodeType,\n  applyPickOrOmitToNodeType,\n  isTopLevelNode,\n  isTopLevelDeclaration,\n  resolveConditional,\n  applyExcludeToNodeType,\n  isPrimitiveTypeNode,\n} from \"@xlr-lib/xlr-utils\";\nimport { ConversionError } from \"./types\";\n\nexport type MappedType = \"Pick\" | \"Omit\" | \"Required\" | \"Partial\" | \"Exclude\";\n\n/**\n * Returns if the string is one of TypeScript\"s MappedTypes\n */\nexport function isMappedTypeNode(x: string): x is MappedType {\n  return [\"Pick\", \"Omit\", \"Required\", \"Partial\", \"Exclude\"].includes(x);\n}\n\nexport interface TSConverterContext {\n  /** */\n  customPrimitives: Array<string>;\n\n  /** */\n  typeChecker: ts.TypeChecker;\n\n  /** */\n  throwError: (message: string) => never;\n\n  /** Cached conversion operations */\n  cache: {\n    /** Converted TS Nodes */\n    convertedNodes: Map<ts.TypeNode, NodeType | undefined>;\n\n    /** Processed Template Strings */\n    convertedTemplates: Map<ts.TemplateLiteralTypeNode, string>;\n  };\n}\n\nconst AnyTypeNode: AnyType = {\n  type: \"any\",\n};\n\n/** Converts TS Nodes/Files to XLRs */\nexport class TsConverter {\n  private context: TSConverterContext;\n\n  constructor(typeChecker: ts.TypeChecker, customPrimitives?: Array<string>) {\n    this.context = {\n      customPrimitives: customPrimitives ?? [],\n      typeChecker,\n      throwError: (message: string) => {\n        throw new ConversionError(message);\n      },\n      cache: {\n        convertedNodes: new Map(),\n        convertedTemplates: new Map(),\n      },\n    };\n  }\n\n  /** Converts all exported objects to a XLR representation */\n  public convertSourceFile(sourceFile: ts.SourceFile) {\n    const declarations = sourceFile.statements.filter(isTopLevelNode);\n\n    const types = declarations\n      .filter((declaration) => isExportedDeclaration(declaration))\n      .map((statement) => this.convertTopLevelNode(statement) as NamedType)\n      .filter(<T>(v: T): v is NonNullable<T> => !!v);\n\n    return {\n      data: { version: 1, types },\n      convertedTypes: types.map(({ name }) => name),\n    };\n  }\n\n  public convertTopLevelNode(\n    node: TopLevelNode,\n  ): NamedType | NamedTypeWithGenerics {\n    const sourceFile = node.parent as ts.SourceFile;\n    const { fileName } = sourceFile;\n\n    if (ts.isVariableStatement(node)) {\n      return {\n        source: fileName,\n        ...this.convertVariable(node),\n      } as NamedType;\n    }\n\n    return {\n      source: fileName,\n      ...this.convertDeclaration(node),\n    } as NamedType;\n  }\n\n  /** Converts a single type/interface declaration to XLRs */\n  public convertDeclaration(\n    node: TopLevelDeclaration,\n  ): ObjectType | NodeTypeWithGenerics<ObjectType> {\n    if (ts.isTypeAliasDeclaration(node)) {\n      let genericTokens;\n      if (isGenericTypeDeclaration(node)) {\n        genericTokens = this.generateGenerics(node.typeParameters);\n      }\n\n      return {\n        name: node.name.getText(),\n        ...(this.convertTsTypeNode(node.type) ?? AnyTypeNode),\n        ...decorateNode(node),\n        genericTokens,\n      } as NamedTypeWithGenerics<ObjectType>;\n    }\n\n    if (ts.isInterfaceDeclaration(node)) {\n      let genericTokens;\n      if (isGenericInterfaceDeclaration(node)) {\n        genericTokens = this.generateGenerics(node.typeParameters);\n      }\n\n      const baseObject = {\n        name: node.name.getText(),\n        type: \"object\",\n        ...this.tsObjectMembersToProperties(node),\n        ...decorateNode(node),\n        genericTokens,\n      };\n      // See if there are interfaces being implemented/extended\n      if (node.heritageClauses) {\n        return this.handleHeritageClauses(\n          node.heritageClauses,\n          baseObject as ObjectType,\n          this.context.typeChecker,\n        ) as NamedType<ObjectType>;\n      }\n\n      return baseObject as ObjectType;\n    }\n\n    this.context.throwError(\n      `Error: type node is not an Interface or a Type, can't convert as Declaration`,\n    );\n  }\n\n  public convertVariable(node: ts.VariableStatement): NodeType {\n    const variableDeclarations = node.declarationList.declarations;\n    if (variableDeclarations.length === 1) {\n      const variable = variableDeclarations[0];\n\n      if (variable.initializer) {\n        let resultingNode;\n        if (\n          ts.isCallExpression(variable.initializer) ||\n          ts.isArrowFunction(variable.initializer)\n        ) {\n          resultingNode = this.resolveFunctionCall(\n            variable.initializer,\n            node.parent,\n          );\n        } else {\n          resultingNode = this.tsLiteralToType(variable.initializer);\n        }\n\n        // If resultingNode is a reference to a function or custom primitive and not a concrete value\n        // we need to update the name to be the name of the exporting variable\n        // not the name of the identifier its aliasing\n        if (resultingNode.type === \"function\" || resultingNode.type === \"ref\") {\n          resultingNode = { ...resultingNode, name: variable.name.getText() };\n        }\n\n        return {\n          name: variable.name.getText(),\n          ...resultingNode,\n        } as NamedType;\n      }\n    }\n\n    this.context.throwError(\n      `Error: Multi-variable declaration on line ${node.pos} is not supported for conversion`,\n    );\n  }\n\n  /** Converts an arbitrary ts.TypeNode to XLRs */\n  public convertTsTypeNode(node: ts.TypeNode): NodeType {\n    if (this.context.cache.convertedNodes.has(node)) {\n      const cachedType = this.context.cache.convertedNodes.get(\n        node,\n      ) as NodeType;\n      // return deep copy of node so modifications don't effect referenced to the original\n      return JSON.parse(JSON.stringify(cachedType));\n    }\n\n    const convertedNode = this.tsNodeToType(node);\n    this.context.cache.convertedNodes.set(node, convertedNode);\n    return convertedNode;\n  }\n\n  /** Should not be called directly unless you want to bypass the cache, use `convertTsTypeNode` */\n  private tsNodeToType(node: ts.TypeNode): NodeType {\n    if (ts.isUnionTypeNode(node)) {\n      return {\n        type: \"or\",\n        or: node.types\n          .map((child) => this.convertTsTypeNode(child))\n          .filter(isNonNullable),\n        ...decorateNode(node),\n      };\n    }\n\n    if (ts.isIntersectionTypeNode(node)) {\n      return {\n        type: \"and\",\n        and: node.types\n          .map((child) => this.convertTsTypeNode(child))\n          .filter(isNonNullable),\n        ...decorateNode(node),\n      };\n    }\n\n    if (ts.isParenthesizedTypeNode(node)) {\n      const children: ts.Node[] = [];\n      node.forEachChild((child) => {\n        children.push(child);\n      });\n\n      if (children[0]?.kind === ts.SyntaxKind.OpenParenToken) {\n        children.shift();\n      }\n\n      if (\n        children[children.length - 1]?.kind === ts.SyntaxKind.CloseParenToken\n      ) {\n        children.pop();\n      }\n\n      const element = children[0];\n\n      if (children.length !== 1 || !ts.isTypeNode(element)) {\n        this.context.throwError(\n          `Parenthesis type not understood. Length ${\n            children.length\n          }, Is Type Node: ${ts.SyntaxKind[element.kind]}`,\n        );\n      }\n\n      return this.convertTsTypeNode(element);\n    }\n\n    if (node.kind === ts.SyntaxKind.AnyKeyword) {\n      return { type: \"any\", ...decorateNode(node) };\n    }\n\n    if (node.kind === ts.SyntaxKind.UnknownKeyword) {\n      return { type: \"unknown\", ...decorateNode(node) };\n    }\n\n    if (node.kind === ts.SyntaxKind.StringKeyword) {\n      return { type: \"string\", ...decorateNode(node) };\n    }\n\n    if (node.kind === ts.SyntaxKind.NumberKeyword) {\n      return { type: \"number\", ...decorateNode(node) };\n    }\n\n    if (node.kind === ts.SyntaxKind.BooleanKeyword) {\n      return { type: \"boolean\", ...decorateNode(node) };\n    }\n\n    if (node.kind === ts.SyntaxKind.UndefinedKeyword) {\n      return { type: \"undefined\", ...decorateNode(node) };\n    }\n\n    if (node.kind === ts.SyntaxKind.NeverKeyword) {\n      return { type: \"never\", ...decorateNode(node) };\n    }\n\n    if (node.kind === ts.SyntaxKind.ObjectKeyword) {\n      return {\n        type: \"object\",\n        properties: {},\n        additionalProperties: AnyTypeNode,\n        ...decorateNode(node),\n      };\n    }\n\n    if (node.kind === ts.SyntaxKind.VoidKeyword) {\n      return {\n        type: \"void\",\n        ...decorateNode(node),\n      };\n    }\n\n    if (ts.isTemplateLiteralTypeNode(node)) {\n      let format;\n\n      if (this.context.cache.convertedTemplates.has(node)) {\n        format = this.context.cache.convertedTemplates.get(node) as string;\n      } else {\n        format = buildTemplateRegex(node, this.context.typeChecker);\n        this.context.cache.convertedTemplates.set(node, format);\n      }\n\n      return {\n        type: \"template\",\n        format,\n      };\n    }\n\n    if (ts.isArrayTypeNode(node)) {\n      return {\n        type: \"array\",\n        elementType: this.convertTsTypeNode(node.elementType) ?? AnyTypeNode,\n        ...decorateNode(node),\n      };\n    }\n\n    if (ts.isConditionalTypeNode(node)) {\n      const xlrNode = {\n        type: \"conditional\",\n        check: {\n          left: this.convertTsTypeNode(node.checkType) as NodeType,\n          right: this.convertTsTypeNode(node.extendsType) as NodeType,\n        },\n        value: {\n          true: this.convertTsTypeNode(node.trueType) as NodeType,\n          false: this.convertTsTypeNode(node.falseType) as NodeType,\n        },\n      } as ConditionalType;\n      // Resolve simple conditionals now, defer complex ones to runtime\n      if (\n        isPrimitiveTypeNode(xlrNode.check.left) &&\n        isPrimitiveTypeNode(xlrNode.check.right)\n      ) {\n        return resolveConditional(xlrNode);\n      } else {\n        return xlrNode;\n      }\n    }\n\n    if (ts.isTypeReferenceNode(node)) {\n      return this.resolveRefNode(node);\n    }\n\n    if (ts.isTupleTypeNode(node)) {\n      return {\n        type: \"tuple\",\n        ...this.tsTupleToType(node),\n        ...decorateNode(node),\n      };\n    }\n\n    if (ts.isLiteralTypeNode(node)) {\n      return this.tsLiteralToType(node.literal);\n    }\n\n    if (ts.isTypeLiteralNode(node)) {\n      return {\n        type: \"object\",\n        ...this.tsObjectMembersToProperties(node),\n        ...decorateNode(node),\n      };\n    }\n\n    if (\n      ts.isFunctionTypeNode(node) ||\n      ts.isFunctionDeclaration(node) ||\n      ts.isArrowFunction(node)\n    ) {\n      const parameters: Array<FunctionTypeParameters> = node.parameters.map(\n        (param) => {\n          let typeNode;\n          if (param.type) {\n            typeNode = this.convertTsTypeNode(param.type);\n          }\n\n          return {\n            name: param.name.getText(),\n            type: typeNode ?? AnyTypeNode,\n            optional: param.questionToken ? true : undefined,\n            default: param.initializer\n              ? this.convertTsTypeNode(\n                  param.initializer as unknown as ts.TypeNode,\n                )\n              : undefined,\n          };\n        },\n      );\n\n      let returnType;\n      if (node.type !== undefined) {\n        returnType = this.convertTsTypeNode(node.type);\n      }\n\n      return {\n        type: \"function\",\n        parameters,\n        returnType,\n        ...decorateNode(node),\n      };\n    }\n\n    // Handle generics\n    if (ts.isIndexedAccessTypeNode(node)) {\n      if (\n        ts.isTypeReferenceNode(node.objectType) &&\n        ts.isLiteralTypeNode(node.indexType)\n      ) {\n        const baseObject = this.convertTsTypeNode(node.objectType);\n        const accessor = node.indexType.literal.getText().replace(/[\"']/g, \"\");\n        if (!baseObject) {\n          this.context.throwError(\n            `Error: Couldn't resolve index access on property ${accessor} on type ${node.objectType.typeName.getText()}`,\n          );\n        } else if (baseObject.type === \"object\") {\n          if (Object.keys(baseObject.properties ?? {}).includes(accessor)) {\n            return baseObject.properties[accessor].node;\n          }\n\n          if (baseObject.additionalProperties) {\n            return baseObject.additionalProperties;\n          }\n        } else if (baseObject.type === \"ref\") {\n          return { ...baseObject, property: accessor };\n        } else {\n          this.context.throwError(\n            `Error: Index access on non object/ref type ${baseObject.type}`,\n          );\n        }\n      }\n\n      let queryNode = node.objectType;\n      // handle cases where the object being accessed is wrapped in () because of linting\n      if (ts.isParenthesizedTypeNode(node.objectType)) {\n        queryNode = node.objectType.type;\n      }\n\n      if (ts.isTypeQueryNode(queryNode)) {\n        const elements = this.tsNodeToType(node.objectType) as TupleType;\n        return {\n          type: \"or\",\n          or: [...elements.elementTypes.map((element) => element.type)],\n        };\n      }\n\n      this.context.throwError(\n        `Error: could not solve IndexedAccessType: ${node.getFullText()}`,\n      );\n    }\n\n    if (ts.isTypeQueryNode(node)) {\n      const effectiveType = this.context.typeChecker.getTypeAtLocation(node);\n      const syntheticType = this.context.typeChecker.typeToTypeNode(\n        effectiveType,\n        node,\n        ts.NodeBuilderFlags.NoTruncation,\n      );\n      if (syntheticType) {\n        return this.tsNodeToType(syntheticType);\n      }\n\n      this.context.throwError(\n        `Error: could not synthesize type for ${node.getText()}`,\n      );\n    }\n\n    if (ts.isTypeOperatorNode(node)) {\n      return this.tsNodeToType(node.type);\n    }\n\n    this.context.throwError(\n      `Unimplemented type ${ts.SyntaxKind[node.kind]} at ${node.getText()}`,\n    );\n  }\n\n  private tsLiteralToType(node: ts.Expression): NodeType {\n    if (ts.isNumericLiteral(node)) {\n      return {\n        type: \"number\",\n        const: Number(node.text),\n        ...decorateNode(node),\n      };\n    }\n\n    if (ts.isStringLiteral(node)) {\n      return {\n        type: \"string\",\n        const: node.text,\n        ...decorateNode(node),\n      };\n    }\n\n    if (node.kind === ts.SyntaxKind.TrueKeyword) {\n      return {\n        type: \"boolean\",\n        const: true,\n        ...decorateNode(node),\n      };\n    }\n\n    if (node.kind === ts.SyntaxKind.FalseKeyword) {\n      return {\n        type: \"boolean\",\n        const: false,\n        ...decorateNode(node),\n      };\n    }\n\n    if (node.kind === ts.SyntaxKind.NullKeyword) {\n      return { type: \"null\", ...decorateNode(node) };\n    }\n\n    if (ts.isPrefixUnaryExpression(node)) {\n      this.context.throwError(\"Prefix unary expressions not supported\");\n    }\n\n    if (ts.isArrayLiteralExpression(node)) {\n      const arrayElements: unknown[] = [];\n      node.elements.forEach((element) => {\n        if (ts.isSpreadElement(element)) {\n          const arrayReference = this.resolveLiteralReference(\n            element.expression,\n          ) as ArrayType;\n          arrayElements.push(...(arrayReference.const ?? []));\n        } else {\n          arrayElements.push(this.tsLiteralToType(element));\n        }\n      });\n      return {\n        type: \"array\",\n        elementType: { type: \"any\" },\n        const: arrayElements,\n      };\n    }\n\n    if (ts.isObjectLiteralExpression(node)) {\n      const ret = {\n        type: \"object\",\n        properties: {},\n        additionalProperties: false,\n      } as ObjectType;\n\n      node.properties.forEach((property) => {\n        if (ts.isPropertyAssignment(property)) {\n          const propertyName = property.name?.getText() as string;\n          ret.properties[propertyName] = {\n            required: true,\n            node: this.tsLiteralToType(property.initializer),\n          };\n        } else if (ts.isSpreadAssignment(property)) {\n          const spreadValue = this.resolveLiteralReference(\n            property.expression,\n          ) as ObjectType;\n          ret.properties = {\n            ...ret.properties,\n            ...spreadValue.properties,\n          };\n        }\n      });\n\n      return ret;\n    }\n\n    if (ts.isIdentifier(node)) {\n      return this.resolveLiteralReference(node);\n    }\n\n    this.context.throwError(\n      `Literal type not understood ${\n        ts.SyntaxKind[node.kind]\n      } at ${node.getText()}`,\n    );\n  }\n\n  private resolveLiteralReference(expression: ts.Expression): NodeType {\n    if (ts.isIdentifier(expression)) {\n      const symbol = this.context.typeChecker.getSymbolAtLocation(expression);\n      let expressionReference = symbol?.declarations?.[0];\n      if (\n        symbol &&\n        expressionReference &&\n        ts.isImportSpecifier(expressionReference)\n      ) {\n        const referencedDeclaration =\n          this.context.typeChecker.getAliasedSymbol(symbol);\n        expressionReference = referencedDeclaration.declarations?.[0];\n      }\n\n      if (\n        expressionReference &&\n        ts.isVariableDeclaration(expressionReference) &&\n        expressionReference.initializer\n      ) {\n        return this.convertVariable(\n          expressionReference.parent.parent as ts.VariableStatement,\n        );\n      }\n\n      this.context.throwError(\n        `Error: Can't resolve non-variable declaration ${expressionReference?.getText()}`,\n      );\n    }\n\n    this.context.throwError(\n      `Error: Can't resolve non-identifier reference in literal ${expression.getText()}`,\n    );\n  }\n\n  private resolveFunctionCall(\n    functionCall: ts.CallExpression | ts.ArrowFunction,\n    document: ts.Node,\n  ): NodeType {\n    if (ts.isArrowFunction(functionCall)) {\n      const declaredReturnType = (functionCall.parent as ts.VariableDeclaration)\n        .type;\n      if (declaredReturnType) {\n        return this.tsNodeToType(declaredReturnType);\n      }\n    }\n\n    const functionReturnType =\n      this.context.typeChecker.getTypeAtLocation(functionCall);\n\n    let syntheticNode = this.context.typeChecker.typeToTypeNode(\n      functionReturnType,\n      document,\n      undefined,\n    );\n\n    // Synthetic node loses parameter location information, and text making it unable\n    // to get the parameter name in tsNodeToType\n    if (ts.isArrowFunction(functionCall)) {\n      const syntheticWithParameters = {\n        ...syntheticNode,\n        parameters: functionCall.parameters,\n      };\n      syntheticNode = syntheticWithParameters as unknown as ts.TypeNode;\n    }\n\n    if (syntheticNode) {\n      if (\n        ts.isTypeReferenceNode(syntheticNode) &&\n        ts.isIdentifier(syntheticNode.typeName)\n      ) {\n        const { typeName } = syntheticNode;\n\n        if (this.context.customPrimitives.includes(typeName.text)) {\n          return this.makeBasicRefNode(syntheticNode);\n        }\n\n        // Can't use typechecker on synthetic nodes\n        const declarationSymbol = (typeName as any).symbol as ts.Symbol;\n\n        if (declarationSymbol && declarationSymbol.declarations?.[0]) {\n          const declaration = declarationSymbol.declarations[0];\n          if (\n            ts.isTypeAliasDeclaration(declaration) ||\n            ts.isInterfaceDeclaration(declaration)\n          ) {\n            return this.convertDeclaration(declaration);\n          }\n        }\n\n        this.context.throwError(\n          `Error: could not get referenced type ${syntheticNode.getText()}`,\n        );\n      }\n\n      return this.tsNodeToType(syntheticNode) as NodeType;\n    }\n\n    this.context.throwError(\n      `Error: could not determine effective return type of ${functionCall.getText()}`,\n    );\n  }\n\n  private tsObjectMembersToProperties(\n    node: ts.InterfaceDeclaration | ts.TypeLiteralNode,\n  ): Pick<ObjectType, \"properties\" | \"additionalProperties\"> {\n    const ret: Pick<ObjectType, \"properties\" | \"additionalProperties\"> = {\n      properties: {},\n      additionalProperties: false,\n    };\n\n    node.members.forEach((member) => {\n      if (ts.isPropertySignature(member) && member.type) {\n        const name = member.name.getText();\n        ret.properties[name] = {\n          required: !isOptionalProperty(member),\n          node: {\n            ...(this.convertTsTypeNode(member.type) ?? AnyTypeNode),\n            ...decorateNode(member),\n          },\n        };\n      } else if (ts.isIndexSignatureDeclaration(member)) {\n        const param = member.parameters[0];\n        if (param.type?.kind !== ts.SyntaxKind.StringKeyword) {\n          this.context.throwError(\n            \"Will not convert non-string index signature\",\n          );\n        }\n\n        ret.additionalProperties =\n          this.convertTsTypeNode(member.type) ?? AnyTypeNode;\n      }\n    });\n\n    return ret;\n  }\n\n  private tsTupleToType(\n    node: ts.TupleTypeNode,\n  ): Pick<TupleType, \"elementTypes\" | \"additionalItems\" | \"minItems\"> {\n    if (node.elements.length === 0) {\n      return { elementTypes: [], additionalItems: false, minItems: 0 };\n    }\n\n    const hasRest = ts.isRestTypeNode(node.elements[node.elements.length - 1]);\n\n    const [elements, rest] = hasRest\n      ? [\n          node.elements.slice(0, node.elements.length - 1),\n          node.elements[node.elements.length - 1] as ts.RestTypeNode,\n        ]\n      : [[...node.elements], undefined];\n\n    const elementTypes = elements.map((element) => {\n      if (ts.isNamedTupleMember(element)) {\n        let typeNode;\n        if (element.type) {\n          typeNode = this.convertTsTypeNode(element.type);\n        }\n\n        return {\n          name: element.name.text,\n          type: typeNode ?? AnyTypeNode,\n          optional: element.questionToken ? true : undefined,\n        };\n      }\n\n      return {\n        type: this.convertTsTypeNode(tsStripOptionalType(element)),\n        optional: ts.isOptionalTypeNode(element),\n      };\n    });\n\n    const additionalItems = rest\n      ? (this.convertTsTypeNode((rest.type as ts.ArrayTypeNode).elementType) ??\n        AnyTypeNode)\n      : false;\n\n    const firstOptional = elementTypes.findIndex(\n      (element) => element.optional === true,\n    );\n    const minItems = firstOptional === -1 ? elements.length : firstOptional;\n\n    return {\n      elementTypes,\n      ...(additionalItems && additionalItems.type === \"any\"\n        ? { additionalItems: AnyTypeNode }\n        : { additionalItems }),\n      minItems,\n    };\n  }\n\n  private handleHeritageClauses(\n    clauses: ts.NodeArray<ts.HeritageClause>,\n    baseObject: ObjectType,\n    typeChecker: ts.TypeChecker,\n  ): ObjectType {\n    let newProperties: { [x: string]: ObjectProperty } = {};\n    const additionalPropertiesCollector: Array<NodeType> = [];\n    let extendsType: RefType | undefined;\n\n    clauses.forEach((heritageClause) => {\n      heritageClause.types.forEach((parent) => {\n        let typeToApply: ObjectType;\n\n        // Check if its a Mapped Type\n        const typeName = parent.expression.getText();\n        if (isMappedTypeNode(typeName)) {\n          typeToApply = this.makeMappedType(typeName, parent) as ObjectType;\n        } else {\n          const parentType = typeChecker.getTypeAtLocation(parent);\n          const parentSymbol = parentType.symbol;\n          const parentDeclarations = parentSymbol?.declarations;\n\n          if (!parentDeclarations?.[0]) {\n            this.context.throwError(\n              `Error: Unable to get underlying interface for extending class ${parent.getFullText()}`,\n            );\n          }\n\n          let parentInterface: TopLevelDeclaration;\n\n          if (\n            ts.isTypeLiteralNode(parentDeclarations?.[0]) &&\n            ts.isTypeAliasDeclaration(parentDeclarations?.[0].parent)\n          ) {\n            // check for if the node is a type to get the actual type declaration\n            parentInterface = parentDeclarations?.[0].parent;\n          } else {\n            parentInterface = parentDeclarations?.[0] as TopLevelDeclaration;\n          }\n\n          if (\n            this.context.customPrimitives.includes(parentInterface.name.text)\n          ) {\n            extendsType = this.makeBasicRefNode(parent);\n            return;\n          }\n\n          typeToApply = this.convertDeclaration(parentInterface);\n\n          if (typeToApply.extends) {\n            extendsType = typeToApply.extends;\n          }\n\n          if (parentInterface.typeParameters && parent.typeArguments) {\n            typeToApply = this.resolveGenerics(\n              typeToApply as NodeTypeWithGenerics,\n              parentInterface.typeParameters,\n              parent.typeArguments,\n            ) as NamedType<ObjectType>;\n          } else if (isGenericNodeType(baseObject)) {\n            baseObject.genericTokens.push(\n              ...((typeToApply as NodeTypeWithGenerics).genericTokens ?? []),\n            );\n          }\n        }\n\n        newProperties = {\n          ...newProperties,\n          ...typeToApply.properties,\n        };\n        if (typeToApply.additionalProperties) {\n          additionalPropertiesCollector.push(typeToApply.additionalProperties);\n        }\n      });\n    });\n    // Resolve Additional Properties\n    let additionalProperties: NodeType | false = false;\n    if (baseObject.additionalProperties === false) {\n      if (additionalPropertiesCollector.length === 1) {\n        additionalProperties = additionalPropertiesCollector[0];\n      } else if (additionalPropertiesCollector.length >= 1) {\n        additionalProperties = {\n          type: \"or\",\n          or: additionalPropertiesCollector,\n        };\n      }\n    }\n\n    return {\n      ...baseObject,\n      ...(extendsType ? { extends: extendsType } : {}),\n      properties: { ...newProperties, ...baseObject.properties },\n      additionalProperties,\n    };\n  }\n\n  private resolveGenerics(\n    baseInterface: NodeTypeWithGenerics,\n    typeParameters: ts.NodeArray<ts.TypeParameterDeclaration>,\n    typeArguments?: ts.NodeArray<ts.TypeNode>,\n  ): NodeTypeWithGenerics | NodeType {\n    // map type args to generics\n    if (typeArguments && typeArguments.length === 0) return baseInterface;\n    const genericMap: Map<string, NodeType> = new Map();\n    typeParameters.forEach((tp, i) => {\n      let typeToProcess: ts.TypeNode;\n      if (typeArguments && i < typeArguments.length) {\n        typeToProcess = typeArguments[i];\n      } else if (tp.default) {\n        typeToProcess = tp.default;\n      } else {\n        // might need to do some error checking here if there is no type to fill in\n        typeToProcess = ts.factory.createKeywordTypeNode(\n          ts.SyntaxKind.AnyKeyword,\n        );\n      }\n\n      const processedNodeType = this.convertTsTypeNode(typeToProcess);\n      if (processedNodeType) {\n        genericMap.set(tp.name.getText(), processedNodeType);\n      }\n    });\n\n    return fillInGenerics(baseInterface, genericMap);\n  }\n\n  private generateGenerics(\n    params: ts.NodeArray<ts.TypeParameterDeclaration> | undefined,\n  ): Array<ParamTypeNode> {\n    const genericArray: Array<ParamTypeNode> = [];\n\n    params?.forEach((param) => {\n      const serializedObject: ParamTypeNode = {\n        symbol: param.name.text,\n      };\n      if (param.constraint) {\n        // any case is unsafe but it can be either a Type or TypeNode and both are parsed fine\n        serializedObject.constraints = this.convertTsTypeNode(param.constraint);\n      } else {\n        serializedObject.constraints = AnyTypeNode;\n      }\n\n      if (param.default) {\n        // any case is unsafe but it can be either a Type or TypeNode and both are parsed fine\n        serializedObject.default = this.convertTsTypeNode(param.default);\n      } else {\n        serializedObject.default = AnyTypeNode;\n      }\n\n      genericArray.push(serializedObject);\n    });\n\n    return genericArray;\n  }\n\n  private resolveRefNode(node: ts.TypeReferenceNode): NodeType {\n    let refName: string;\n\n    if (node.typeName.kind === ts.SyntaxKind.QualifiedName) {\n      refName = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;\n    } else {\n      refName = node.typeName.text;\n    }\n\n    // the use of a generic in an interface/type\n    if (isTypeReferenceGeneric(node, this.context.typeChecker)) {\n      if (ts.isIndexedAccessTypeNode(node.parent)) {\n        const genericSymbol = this.context.typeChecker.getSymbolAtLocation(\n          node.typeName,\n        );\n        const typeParameters = this.generateGenerics(\n          genericSymbol?.declarations as unknown as ts.NodeArray<ts.TypeParameterDeclaration>,\n        );\n        const typeParameter = typeParameters[0];\n        if (typeParameter) {\n          if (typeParameter.constraints) {\n            return typeParameter.constraints;\n          }\n\n          if (typeParameter.default) {\n            return typeParameter.default;\n          }\n        }\n\n        return AnyTypeNode;\n      }\n\n      return { type: \"ref\", ref: node.getText(), ...decorateNode(node) };\n    }\n\n    if (refName === \"Array\") {\n      const typeArgs = node.typeArguments as ts.NodeArray<ts.TypeNode>;\n      return {\n        type: \"array\",\n        elementType: typeArgs\n          ? (this.convertTsTypeNode(typeArgs[0]) ?? AnyTypeNode)\n          : AnyTypeNode,\n        ...decorateNode(node),\n      };\n    }\n\n    if (refName === \"Record\") {\n      const indexType = node.typeArguments?.[0] as ts.TypeNode;\n      const valueType = node.typeArguments?.[1] as ts.TypeNode;\n      return {\n        type: \"record\",\n        keyType: this.convertTsTypeNode(indexType) ?? AnyTypeNode,\n        valueType: this.convertTsTypeNode(valueType) ?? AnyTypeNode,\n        ...decorateNode(node),\n      };\n    }\n\n    if (isMappedTypeNode(refName)) {\n      return this.makeMappedType(refName, node);\n    }\n\n    // catch all for all other type references\n    if (!this.context.customPrimitives.includes(refName)) {\n      const typeInfo = getReferencedType(node, this.context.typeChecker);\n      if (typeInfo) {\n        const genericType = this.convertTopLevelNode(typeInfo.declaration);\n        const genericParams = typeInfo.declaration.typeParameters;\n        const genericArgs = node.typeArguments;\n        if (genericType && genericParams && genericArgs) {\n          return this.resolveGenerics(\n            genericType as NamedTypeWithGenerics,\n            genericParams,\n            genericArgs,\n          );\n        }\n\n        if (genericType) {\n          return genericType;\n        }\n      }\n\n      this.context.throwError(\n        `Can't find referenced type ${refName}, is it available in the current package or node_modules?`,\n      );\n    }\n\n    return this.makeBasicRefNode(node);\n  }\n\n  private makeMappedType(\n    refName: MappedType,\n    node: ts.NodeWithTypeArguments,\n  ): ObjectType {\n    if (refName === \"Pick\" || refName === \"Omit\" || refName === \"Exclude\") {\n      const baseType = node.typeArguments?.[0] as ts.TypeNode;\n      const modifiers = node.typeArguments?.[1] as ts.TypeNode;\n\n      const baseObj = this.convertTsTypeNode(baseType);\n\n      if (refName === \"Exclude\") {\n        if (baseObj.type === \"or\") {\n          return applyExcludeToNodeType(\n            baseObj as OrType,\n            this.convertTsTypeNode(modifiers),\n          ) as ObjectType;\n        }\n\n        throw new ConversionError(\n          \"Error: Can't solve Exclude type on non-union node\",\n        );\n      } else {\n        return applyPickOrOmitToNodeType(\n          baseObj,\n          refName,\n          getStringLiteralsFromUnion(modifiers),\n        ) as ObjectType;\n      }\n    }\n\n    if (refName === \"Partial\" || refName === \"Required\") {\n      const baseType = node.typeArguments?.[0] as ts.TypeNode;\n      const baseObj = this.convertTsTypeNode(baseType) as NodeType;\n      const modifier = refName !== \"Partial\";\n\n      return applyPartialOrRequiredToNodeType(baseObj, modifier) as ObjectType;\n    }\n\n    this.context.throwError(`Can't convert non-MappedType ${refName}`);\n  }\n\n  private makeBasicRefNode(node: ts.NodeWithTypeArguments): RefType {\n    const genericArgs: Array<NodeType | NamedType<ObjectType>> = [];\n    if (node.typeArguments) {\n      node.typeArguments.forEach((typeArg) => {\n        let convertedNode;\n        if (isTopLevelDeclaration(typeArg)) {\n          convertedNode = this.convertDeclaration(typeArg);\n        } else {\n          convertedNode = this.convertTsTypeNode(typeArg);\n        }\n\n        if (convertedNode) {\n          genericArgs.push(convertedNode);\n        } else {\n          this.context.throwError(\n            `Conversion Error: Couldn't convert type argument in type ${node.getText()}`,\n          );\n        }\n      });\n    }\n\n    let ref;\n    if (\n      node.pos === -1 &&\n      ts.isTypeReferenceNode(node) &&\n      ts.isIdentifier(node.typeName)\n    ) {\n      ref = node.typeName.text;\n    } else {\n      ref = node.getText();\n    }\n\n    return {\n      type: \"ref\",\n      ref,\n      ...decorateNode(node),\n      genericArguments: genericArgs.length > 0 ? genericArgs : undefined,\n    };\n  }\n}\n","/**\n * Specific error that can be caught to indicate an error in conversion\n */\nexport class ConversionError extends Error {\n  constructor(msg: string) {\n    super(msg);\n\n    // Set the prototype explicitly.\n    Object.setPrototypeOf(this, ConversionError.prototype);\n  }\n\n  toString() {\n    return `Conversion Error: ${this.message}`;\n  }\n}\n","import type {\n  ConditionalType,\n  Annotations,\n  FunctionType,\n  NamedType,\n  NodeType,\n  NodeTypeWithGenerics,\n  ObjectType,\n  PrimitiveTypes,\n  RecordType,\n  RefType,\n  TemplateLiteralType,\n  TupleType,\n} from \"@xlr-lib/xlr\";\nimport type { TopLevelDeclaration } from \"@xlr-lib/xlr-utils\";\nimport { isGenericNamedType, isPrimitiveTypeNode } from \"@xlr-lib/xlr-utils\";\nimport ts from \"typescript\";\nimport { ConversionError } from \"./types\";\n\nconst templateTokenize = /(?=true\\|false|\\.\\*|\\[0-9]\\*)/gm;\nconst tokenSplit = /(?<=true\\|false|\\.\\*|\\[0-9]\\*)/gm;\n\nexport interface ConvertedType {\n  /** Converted input type represented as in TS Nodes */\n  type: TopLevelDeclaration;\n\n  /** Types that may require import statements to be added */\n  referencedTypes?: Set<string>;\n\n  /** Any additionally referenced types that were deserialized that should be separate declarations */\n  additionalTypes?: Map<string, TopLevelDeclaration>;\n}\n\ninterface TSWriterContext {\n  /** */\n  factory: ts.NodeFactory;\n\n  /** */\n  throwError: (message: string) => never;\n}\n\n/** */\nexport class TSWriter {\n  private context: TSWriterContext;\n  private importSet: Set<string>;\n  private additionalTypes: Map<string, TopLevelDeclaration>;\n\n  constructor(factory?: ts.NodeFactory) {\n    this.context = {\n      factory: factory ?? ts.factory,\n      throwError: (message: string) => {\n        throw new ConversionError(message);\n      },\n    };\n    this.importSet = new Set();\n    this.additionalTypes = new Map();\n  }\n\n  public convertNamedType(type: NamedType): ConvertedType {\n    this.importSet.clear();\n    this.additionalTypes.clear();\n\n    const finalNode = this.convertNamedTypeNode(type);\n\n    const referencedTypes =\n      this.importSet.size > 0 ? this.importSet : undefined;\n    const additionalTypes =\n      this.additionalTypes.size > 0 ? this.additionalTypes : undefined;\n\n    return {\n      type: this.makeAnnotations(finalNode, type),\n      referencedTypes,\n      additionalTypes,\n    };\n  }\n\n  private convertNamedTypeNode(type: NamedType): TopLevelDeclaration {\n    const typeName = type.name;\n    const tsNode = this.convertTypeNode(type);\n\n    let customPrimitiveHeritageClass;\n    if (type.type === \"object\" && type.extends) {\n      const refName = type.extends.ref.split(\"<\")[0];\n      customPrimitiveHeritageClass = [\n        this.context.factory.createHeritageClause(\n          ts.SyntaxKind.ExtendsKeyword,\n          [\n            this.context.factory.createExpressionWithTypeArguments(\n              this.context.factory.createIdentifier(refName),\n              type.extends.genericArguments\n                ? (type.extends.genericArguments.map((node) =>\n                    this.convertTypeNode(node),\n                  ) as any)\n                : undefined,\n            ),\n          ],\n        ),\n      ];\n    }\n\n    let generics;\n    if (isGenericNamedType(type)) {\n      generics = this.createTypeParameters(type);\n      type.genericTokens.forEach((token) => {\n        // clean up any references that are actually generic tokens\n        if (this.importSet.has(token.symbol)) {\n          this.importSet.delete(token.symbol);\n        }\n      });\n    }\n\n    let finalNode;\n    if (ts.isTypeLiteralNode(tsNode)) {\n      finalNode = this.makeInterfaceDeclaration(\n        typeName,\n        tsNode.members,\n        generics,\n        customPrimitiveHeritageClass,\n      );\n    } else {\n      finalNode = this.makeTypeDeclaration(typeName, tsNode, generics);\n    }\n\n    return finalNode;\n  }\n\n  private convertTypeNode(type: NodeType): ts.TypeNode {\n    if (type.type === \"object\") {\n      return this.createObjectNode(type);\n    }\n\n    if (type.type === \"and\") {\n      return this.context.factory.createIntersectionTypeNode(\n        type.and.map((element) => {\n          return this.convertTypeNode(element);\n        }),\n      );\n    }\n\n    if (type.type === \"or\") {\n      return this.context.factory.createUnionTypeNode(\n        type.or.map((element) => {\n          return this.convertTypeNode(element);\n        }),\n      );\n    }\n\n    if (type.type === \"array\") {\n      if (type.const) {\n        return this.context.factory.createTupleTypeNode(\n          type.const.map((element) =>\n            this.convertTypeNode(element as NodeType),\n          ),\n        );\n      }\n\n      return this.context.factory.createTypeReferenceNode(\n        this.context.factory.createIdentifier(\"Array\"),\n        [this.convertTypeNode(type.elementType)],\n      );\n    }\n\n    if (isPrimitiveTypeNode(type)) {\n      return this.createPrimitiveNode(type);\n    }\n\n    if (type.type === \"conditional\") {\n      return this.createConditionalTypeNode(type);\n    }\n\n    if (type.type === \"function\") {\n      return this.createFunctionDeclarationNode(type);\n    }\n\n    if (type.type === \"record\") {\n      return this.createRecordNode(type);\n    }\n\n    if (type.type === \"ref\") {\n      return this.createRefNode(type);\n    }\n\n    if (type.type === \"template\") {\n      return this.createTemplateLiteral(type);\n    }\n\n    if (type.type === \"tuple\") {\n      return this.createTupleNode(type);\n    }\n\n    this.context.throwError(\n      `Unable to convert node type: ${(type as any).type}`,\n    );\n  }\n\n  private createRefNode(xlrNode: RefType): ts.TypeReferenceNode {\n    const typeArgs: ts.TypeNode[] = [];\n    if (xlrNode.genericArguments) {\n      xlrNode.genericArguments.forEach((genericArg) => {\n        if (genericArg.name) {\n          const additionalType = this.convertNamedTypeNode(\n            genericArg as NamedType,\n          );\n          this.additionalTypes.set(genericArg.name, additionalType);\n        } else if (genericArg.type === \"and\") {\n          genericArg.and.forEach((type) => {\n            if (type.name) {\n              const additionalType = this.convertNamedTypeNode(\n                type as NamedType,\n              );\n              this.additionalTypes.set(type.name, additionalType);\n            }\n          });\n        } else if (genericArg.type === \"or\") {\n          genericArg.or.forEach((type) => {\n            if (type.name) {\n              const additionalType = this.convertNamedTypeNode(\n                type as NamedType,\n              );\n              this.additionalTypes.set(type.name, additionalType);\n            }\n          });\n        } else {\n          typeArgs.push(this.convertTypeNode(genericArg));\n        }\n      });\n    }\n\n    const importName = xlrNode.ref.split(\"<\")[0];\n    this.importSet.add(importName);\n    return this.context.factory.createTypeReferenceNode(importName, typeArgs);\n  }\n\n  private createPrimitiveNode(xlrNode: PrimitiveTypes): ts.TypeNode {\n    if (\n      ((xlrNode.type === \"string\" ||\n        xlrNode.type === \"boolean\" ||\n        xlrNode.type === \"number\") &&\n        xlrNode.const) ||\n      xlrNode.type === \"null\"\n    ) {\n      return this.context.factory.createLiteralTypeNode(\n        this.createLiteralTypeNode(xlrNode),\n      );\n    }\n\n    switch (xlrNode.type) {\n      case \"string\":\n        return this.context.factory.createKeywordTypeNode(\n          ts.SyntaxKind.StringKeyword,\n        );\n      case \"number\":\n        return this.context.factory.createKeywordTypeNode(\n          ts.SyntaxKind.NumberKeyword,\n        );\n      case \"boolean\":\n        return this.context.factory.createKeywordTypeNode(\n          ts.SyntaxKind.BooleanKeyword,\n        );\n      case \"any\":\n        return this.context.factory.createKeywordTypeNode(\n          ts.SyntaxKind.AnyKeyword,\n        );\n      case \"unknown\":\n        return this.context.factory.createKeywordTypeNode(\n          ts.SyntaxKind.UnknownKeyword,\n        );\n      case \"never\":\n        return this.context.factory.createKeywordTypeNode(\n          ts.SyntaxKind.NeverKeyword,\n        );\n      case \"undefined\":\n        return this.context.factory.createKeywordTypeNode(\n          ts.SyntaxKind.UndefinedKeyword,\n        );\n      case \"void\":\n        return this.context.factory.createKeywordTypeNode(\n          ts.SyntaxKind.VoidKeyword,\n        );\n      default:\n        this.context.throwError(\n          `Unknown primitive type ${(xlrNode as any).type}`,\n        );\n    }\n  }\n\n  private createLiteralTypeNode(\n    xlrNode: NodeType,\n  ): ts.NullLiteral | ts.BooleanLiteral | ts.LiteralExpression {\n    if (xlrNode.type === \"boolean\") {\n      return xlrNode.const\n        ? this.context.factory.createTrue()\n        : this.context.factory.createFalse();\n    }\n\n    if (xlrNode.type === \"number\") {\n      return xlrNode.const\n        ? this.context.factory.createNumericLiteral(xlrNode.const)\n        : this.context.throwError(\n            \"Can't make literal type out of non constant number\",\n          );\n    }\n\n    if (xlrNode.type === \"string\") {\n      return xlrNode.const\n        ? this.context.factory.createStringLiteral(xlrNode.const, true)\n        : this.context.throwError(\n            \"Can't make literal type out of non constant string\",\n          );\n    }\n\n    if (xlrNode.type === \"null\") {\n      return this.context.factory.createNull();\n    }\n\n    this.context.throwError(`Can't make literal out of type ${xlrNode.type}`);\n  }\n\n  private createTupleNode(xlrNode: TupleType): ts.TypeNode {\n    return this.context.factory.createTupleTypeNode(\n      xlrNode.elementTypes.map((e) => {\n        if (e.name) {\n          return this.context.factory.createNamedTupleMember(\n            undefined,\n            this.context.factory.createIdentifier(e.name),\n            e.optional\n              ? this.context.factory.createToken(ts.SyntaxKind.QuestionToken)\n              : undefined,\n            this.convertTypeNode(e.type),\n          );\n        }\n\n        return this.convertTypeNode(e.type);\n      }),\n    );\n  }\n\n  private createFunctionDeclarationNode(xlrNode: FunctionType): ts.TypeNode {\n    return this.context.factory.createFunctionTypeNode(\n      undefined,\n      xlrNode.parameters.map((e) => {\n        return this.context.factory.createParameterDeclaration(\n          undefined,\n          undefined,\n          e.name,\n          e.optional\n            ? this.context.factory.createToken(ts.SyntaxKind.QuestionToken)\n            : undefined,\n          this.convertTypeNode(e.type),\n          e.default ? this.createLiteralTypeNode(e.default) : undefined,\n        );\n      }),\n      xlrNode.returnType\n        ? this.convertTypeNode(xlrNode.returnType)\n        : this.context.factory.createToken(ts.SyntaxKind.VoidKeyword),\n    );\n  }\n\n  private createRecordNode(xlrNode: RecordType): ts.TypeNode {\n    const keyType = this.convertTypeNode(xlrNode.keyType);\n    const valueType = this.convertTypeNode(xlrNode.valueType);\n    return this.context.factory.createTypeReferenceNode(\n      this.context.factory.createIdentifier(\"Record\"),\n      [keyType, valueType],\n    );\n  }\n\n  private createConditionalTypeNode(xlrNode: ConditionalType): ts.TypeNode {\n    const leftCheck = this.convertTypeNode(xlrNode.check.left);\n    const rightCheck = this.convertTypeNode(xlrNode.check.right);\n    const trueValue = this.convertTypeNode(xlrNode.value.true);\n    const falseValue = this.convertTypeNode(xlrNode.value.false);\n\n    return this.context.factory.createConditionalTypeNode(\n      leftCheck,\n      rightCheck,\n      trueValue,\n      falseValue,\n    );\n  }\n\n  private createObjectNode(xlrNode: ObjectType): ts.TypeLiteralNode {\n    const { properties, additionalProperties = false } = xlrNode;\n\n    const propertyNodes: Array<ts.TypeElement> = [\n      ...Object.keys(properties)\n        .map((name) => ({ name, ...properties[name] }))\n        .map(({ name, node, required }) =>\n          this.makeAnnotations(\n            this.context.factory.createPropertySignature(\n              undefined, // modifiers\n              name,\n              required\n                ? undefined\n                : this.context.factory.createToken(ts.SyntaxKind.QuestionToken),\n              this.convertTypeNode(node),\n            ),\n            node,\n          ),\n        ),\n    ];\n\n    if (additionalProperties) {\n      propertyNodes.push(\n        this.context.factory.createIndexSignature(\n          undefined, // modifiers\n          [\n            this.context.factory.createParameterDeclaration(\n              undefined, // modifiers\n              undefined, // dotdotdot token\n              \"key\",\n              undefined, // question token\n              this.context.factory.createKeywordTypeNode(\n                ts.SyntaxKind.StringKeyword,\n              ),\n            ),\n          ],\n          this.convertTypeNode(additionalProperties),\n        ),\n      );\n    }\n\n    return this.context.factory.createTypeLiteralNode(propertyNodes);\n  }\n\n  private createTemplateLiteral(xlrNode: TemplateLiteralType) {\n    const templateSegments = xlrNode.format.split(templateTokenize);\n    let templateHead;\n\n    if (templateSegments.length % 2 === 0) {\n      templateHead = this.context.factory.createTemplateHead(\n        templateSegments[0],\n      );\n      templateSegments.splice(0, 1);\n    } else {\n      templateHead = this.context.factory.createTemplateHead(\"\");\n    }\n\n    return this.context.factory.createTemplateLiteralType(\n      templateHead,\n      templateSegments.map((segments, i) => {\n        const [regexSegment, stringSegment = \"\"] = segments.split(tokenSplit);\n\n        let regexTemplateType: ts.KeywordSyntaxKind;\n        if (regexSegment === \".*\") {\n          regexTemplateType = ts.SyntaxKind.StringKeyword;\n        } else if (regexSegment === \"[0-9]*\") {\n          regexTemplateType = ts.SyntaxKind.NumberKeyword;\n        } else if (regexSegment === \"true|false\") {\n          regexTemplateType = ts.SyntaxKind.BooleanKeyword;\n        } else {\n          this.context.throwError(\n            `Can't make template literal type from regex ${regexSegment}`,\n          );\n        }\n\n        let stringTemplateType;\n\n        if (i === templateSegments.length - 1) {\n          stringTemplateType =\n            this.context.factory.createTemplateTail(stringSegment);\n        } else {\n          stringTemplateType =\n            this.context.factory.createTemplateMiddle(stringSegment);\n        }\n\n        return this.context.factory.createTemplateLiteralTypeSpan(\n          this.context.factory.createKeywordTypeNode(regexTemplateType),\n          stringTemplateType,\n        );\n      }),\n    );\n  }\n\n  private createGenericArgumentNode(node?: NodeType): ts.TypeNode | undefined {\n    if (node) {\n      if (node.type === \"object\" && node.name) {\n        const additionalType = this.convertNamedTypeNode(\n          node as NamedType<ObjectType>,\n        );\n        this.additionalTypes.set(node.name, additionalType);\n        return this.context.factory.createTypeReferenceNode(node.name);\n      }\n\n      return this.convertTypeNode(node);\n    }\n\n    return undefined;\n  }\n\n  private makeAnnotations<T extends ts.Node>(\n    tsNode: T,\n    xlrAnnotations: Annotations,\n  ) {\n    let comment = xlrAnnotations.description;\n    if (!comment) {\n      return tsNode;\n    }\n\n    if (comment.includes(\"\\n\")) {\n      comment = `*\\n${comment\n        .split(\"\\n\")\n        .map((s) => ` * ${s}`)\n        .join(\"\\n\")}\\n`;\n    } else {\n      comment = `* ${comment} `;\n    }\n\n    return ts.addSyntheticLeadingComment(\n      tsNode,\n      ts.SyntaxKind.MultiLineCommentTrivia,\n      comment,\n      true,\n    );\n  }\n\n  private createTypeParameters(\n    genericXLRNode: NodeTypeWithGenerics,\n  ): Array<ts.TypeParameterDeclaration> {\n    return genericXLRNode.genericTokens.map((generic) => {\n      return this.context.factory.createTypeParameterDeclaration(\n        undefined,\n        generic.symbol,\n        this.createGenericArgumentNode(generic.constraints),\n        this.createGenericArgumentNode(generic.default),\n      );\n    });\n  }\n\n  private makeInterfaceDeclaration(\n    name: string,\n    node: ts.NodeArray<ts.TypeElement>,\n    generics: Array<ts.TypeParameterDeclaration> | undefined,\n    heritageClass: ts.HeritageClause[] | undefined,\n  ) {\n    return this.context.factory.createInterfaceDeclaration(\n      this.context.factory.createModifiersFromModifierFlags(\n        ts.ModifierFlags.Export,\n      ),\n      this.context.factory.createIdentifier(name),\n      generics, // type parameters\n      heritageClass, // heritage\n      node,\n    );\n  }\n\n  private makeTypeDeclaration(\n    name: string,\n    node: ts.TypeNode,\n    generics: Array<ts.TypeParameterDeclaration> | undefined,\n  ) {\n    return this.context.factory.createTypeAliasDeclaration(\n      this.context.factory.createModifiersFromModifierFlags(\n        ts.ModifierFlags.Export,\n      ),\n      this.context.factory.createIdentifier(name),\n      generics, // type parameters\n      node,\n    );\n  }\n}\n"],"mappings":"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","names":["ts","import_xlr_utils","import_typescript","ts"]}