@player-tools/xlr-converters 0.0.2-next.0

package/dist/index.cjs.js

@@ -0,0 +1,756 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ts = require('typescript');
+var xlrUtils = require('@player-tools/xlr-utils');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+
+class ConversionError extends Error {
+  constructor(msg) {
+    super(msg);
+    Object.setPrototypeOf(this, ConversionError.prototype);
+  }
+  toString() {
+    return `Conversion Error: ${this.message}`;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const AnyTypeNode = {
+  type: "any"
+};
+class TsConverter {
+  constructor(typeChecker, customPrimitives) {
+    this.context = {
+      customPrimitives: customPrimitives != null ? customPrimitives : [],
+      typeChecker,
+      throwError: (message) => {
+        throw new ConversionError(message);
+      },
+      cache: {
+        convertedNodes: new Map(),
+        convertedTemplates: new Map()
+      }
+    };
+  }
+  convertSourceFile(sourceFile) {
+    const declarations = sourceFile.statements.filter((statement) => ts__default["default"].isTypeAliasDeclaration(statement) || ts__default["default"].isInterfaceDeclaration(statement));
+    const types = declarations.filter((declaration) => xlrUtils.isExportedDeclaration(declaration)).map((statement) => this.convertDeclaration(statement)).filter((v) => !!v);
+    return {
+      data: { version: 1, types },
+      convertedTypes: types.map(({ name }) => name)
+    };
+  }
+  convertDeclaration(node) {
+    var _a;
+    const sourceFile = node.parent;
+    const { fileName } = sourceFile;
+    if (ts__default["default"].isTypeAliasDeclaration(node)) {
+      let genericTokens;
+      if (xlrUtils.isGenericTypeDeclaration(node)) {
+        genericTokens = this.generateGenerics(node.typeParameters);
+      }
+      return __spreadProps(__spreadValues$1(__spreadValues$1({
+        name: node.name.getText(),
+        source: fileName
+      }, (_a = this.convertTsTypeNode(node.type)) != null ? _a : AnyTypeNode), xlrUtils.decorateNode(node)), {
+        genericTokens
+      });
+    }
+    if (ts__default["default"].isInterfaceDeclaration(node)) {
+      let genericTokens;
+      if (xlrUtils.isGenericInterfaceDeclaration(node)) {
+        genericTokens = this.generateGenerics(node.typeParameters);
+      }
+      const baseObject = __spreadProps(__spreadValues$1(__spreadValues$1({
+        name: node.name.getText(),
+        type: "object",
+        source: fileName
+      }, this.fromTsObjectMembers(node)), xlrUtils.decorateNode(node)), {
+        genericTokens
+      });
+      if (node.heritageClauses) {
+        return this.handleHeritageClauses(node.heritageClauses, baseObject, this.context.typeChecker);
+      }
+      return baseObject;
+    }
+    this.context.throwError(`Error: type node is not an Interface or a Type, can't convert as Declaration`);
+  }
+  convertTsTypeNode(node) {
+    if (this.context.cache.convertedNodes.has(node)) {
+      return this.context.cache.convertedNodes.get(node);
+    }
+    const convertedNode = this.tsNodeToType(node);
+    this.context.cache.convertedNodes.set(node, convertedNode);
+    return convertedNode;
+  }
+  tsNodeToType(node) {
+    var _a, _b, _c, _d;
+    if (ts__default["default"].isUnionTypeNode(node)) {
+      return __spreadValues$1({
+        type: "or",
+        or: node.types.map((child) => this.convertTsTypeNode(child)).filter(xlrUtils.isNonNullable)
+      }, xlrUtils.decorateNode(node));
+    }
+    if (ts__default["default"].isIntersectionTypeNode(node)) {
+      return __spreadValues$1({
+        type: "and",
+        and: node.types.map((child) => this.convertTsTypeNode(child)).filter(xlrUtils.isNonNullable)
+      }, xlrUtils.decorateNode(node));
+    }
+    if (ts__default["default"].isParenthesizedTypeNode(node)) {
+      const children = [...node.getChildren()];
+      if (((_a = children[0]) == null ? void 0 : _a.kind) === ts__default["default"].SyntaxKind.OpenParenToken) {
+        children.shift();
+      }
+      if (((_b = children[children.length - 1]) == null ? void 0 : _b.kind) === ts__default["default"].SyntaxKind.CloseParenToken) {
+        children.pop();
+      }
+      const element = children[0];
+      if (children.length !== 1 || !ts__default["default"].isTypeNode(element)) {
+        this.context.throwError(`Parenthesis type not understood. Length ${children.length}, Is Type Node: ${ts__default["default"].SyntaxKind[element.kind]}`);
+      }
+      return this.convertTsTypeNode(element);
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.AnyKeyword) {
+      return __spreadValues$1({ type: "any" }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.UnknownKeyword) {
+      return __spreadValues$1({ type: "unknown" }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.StringKeyword) {
+      return __spreadValues$1({ type: "string" }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.NumberKeyword) {
+      return __spreadValues$1({ type: "number" }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.BooleanKeyword) {
+      return __spreadValues$1({ type: "boolean" }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.UndefinedKeyword) {
+      return __spreadValues$1({ type: "undefined" }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.NeverKeyword) {
+      return __spreadValues$1({ type: "never" }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.ObjectKeyword) {
+      return __spreadValues$1({
+        type: "object",
+        properties: {},
+        additionalProperties: AnyTypeNode
+      }, xlrUtils.decorateNode(node));
+    }
+    if (ts__default["default"].isTemplateLiteralTypeNode(node)) {
+      let format;
+      if (this.context.cache.convertedTemplates.has(node)) {
+        format = this.context.cache.convertedTemplates.get(node);
+      } else {
+        format = xlrUtils.buildTemplateRegex(node, this.context.typeChecker);
+        this.context.cache.convertedTemplates.set(node, format);
+      }
+      return {
+        type: "template",
+        format
+      };
+    }
+    if (ts__default["default"].isArrayTypeNode(node)) {
+      return __spreadValues$1({
+        type: "array",
+        elementType: (_c = this.convertTsTypeNode(node.elementType)) != null ? _c : AnyTypeNode
+      }, xlrUtils.decorateNode(node));
+    }
+    if (ts__default["default"].isConditionalTypeNode(node)) {
+      const xlrNode = {
+        type: "conditional",
+        check: {
+          left: this.convertTsTypeNode(node.checkType),
+          right: this.convertTsTypeNode(node.extendsType)
+        },
+        value: {
+          true: this.convertTsTypeNode(node.trueType),
+          false: this.convertTsTypeNode(node.falseType)
+        }
+      };
+      return xlrUtils.resolveConditional(xlrNode);
+    }
+    if (ts__default["default"].isTypeReferenceNode(node)) {
+      return this.resolveRefNode(node);
+    }
+    if (ts__default["default"].isTupleTypeNode(node)) {
+      return __spreadValues$1(__spreadValues$1({
+        type: "tuple"
+      }, this.fromTsTuple(node)), xlrUtils.decorateNode(node));
+    }
+    if (ts__default["default"].isLiteralTypeNode(node)) {
+      if (ts__default["default"].isNumericLiteral(node.literal)) {
+        return __spreadValues$1({
+          type: "number",
+          const: Number(node.literal.text)
+        }, xlrUtils.decorateNode(node));
+      }
+      if (ts__default["default"].isStringLiteral(node.literal)) {
+        return __spreadValues$1({
+          type: "string",
+          const: node.literal.text
+        }, xlrUtils.decorateNode(node));
+      }
+      if (node.literal.kind === ts__default["default"].SyntaxKind.TrueKeyword) {
+        return __spreadValues$1({
+          type: "boolean",
+          const: true
+        }, xlrUtils.decorateNode(node));
+      }
+      if (node.literal.kind === ts__default["default"].SyntaxKind.FalseKeyword) {
+        return __spreadValues$1({
+          type: "boolean",
+          const: false
+        }, xlrUtils.decorateNode(node));
+      }
+      if (node.literal.kind === ts__default["default"].SyntaxKind.NullKeyword) {
+        return __spreadValues$1({ type: "null" }, xlrUtils.decorateNode(node));
+      }
+      if (node.literal.kind === ts__default["default"].SyntaxKind.PrefixUnaryExpression) {
+        this.context.throwError("Prefix unary expressions not supported");
+      }
+      this.context.throwError("Literal type not understood");
+    } else if (ts__default["default"].isTypeLiteralNode(node)) {
+      return __spreadValues$1(__spreadValues$1({
+        type: "object"
+      }, this.fromTsObjectMembers(node)), xlrUtils.decorateNode(node));
+    } else if (ts__default["default"].isFunctionTypeNode(node)) {
+      const parameters = node.parameters.map((param) => {
+        let typeNode;
+        if (param.type) {
+          typeNode = this.convertTsTypeNode(param.type);
+        }
+        return {
+          name: param.name.getText(),
+          type: typeNode != null ? typeNode : AnyTypeNode,
+          optional: param.questionToken ? true : void 0,
+          default: param.initializer ? this.convertTsTypeNode(param.initializer) : void 0
+        };
+      });
+      const returnType = node.type.kind === ts__default["default"].SyntaxKind.VoidKeyword ? void 0 : this.convertTsTypeNode(node.type);
+      return __spreadValues$1({
+        type: "function",
+        parameters,
+        returnType
+      }, xlrUtils.decorateNode(node));
+    } else if (ts__default["default"].isIndexedAccessTypeNode(node)) {
+      if (ts__default["default"].isTypeReferenceNode(node.objectType) && ts__default["default"].isLiteralTypeNode(node.indexType)) {
+        const baseObject = this.convertTsTypeNode(node.objectType);
+        const accessor = node.indexType.literal.getText().replace(/["']/g, "");
+        if (Object.keys((_d = baseObject.properties) != null ? _d : {}).includes(accessor)) {
+          return baseObject.properties[accessor].node;
+        }
+        if (baseObject.additionalProperties) {
+          return baseObject.additionalProperties;
+        }
+      }
+      return { type: "null" };
+    } else {
+      this.context.throwError(`Unimplemented type ${ts__default["default"].SyntaxKind[node.kind]}`);
+    }
+  }
+  fromTsObjectMembers(node) {
+    const ret = {
+      properties: {},
+      additionalProperties: false
+    };
+    node.members.forEach((member) => {
+      var _a, _b, _c;
+      if (ts__default["default"].isPropertySignature(member) && member.type) {
+        const name = member.name.getText();
+        ret.properties[name] = {
+          required: !xlrUtils.isOptionalProperty(member),
+          node: __spreadValues$1(__spreadValues$1({}, (_a = this.convertTsTypeNode(member.type)) != null ? _a : AnyTypeNode), xlrUtils.decorateNode(member))
+        };
+      } else if (ts__default["default"].isIndexSignatureDeclaration(member)) {
+        const param = member.parameters[0];
+        if (((_b = param.type) == null ? void 0 : _b.kind) !== ts__default["default"].SyntaxKind.StringKeyword) {
+          this.context.throwError("Will not convert non-string index signature");
+        }
+        ret.additionalProperties = (_c = this.convertTsTypeNode(member.type)) != null ? _c : AnyTypeNode;
+      }
+    });
+    return ret;
+  }
+  fromTsTuple(node) {
+    var _a;
+    if (node.elements.length === 0) {
+      return { elementTypes: [], additionalItems: false, minItems: 0 };
+    }
+    const hasRest = ts__default["default"].isRestTypeNode(node.elements[node.elements.length - 1]);
+    const [elements, rest] = hasRest ? [
+      node.elements.slice(0, node.elements.length - 1),
+      node.elements[node.elements.length - 1]
+    ] : [[...node.elements], void 0];
+    const elementTypes = elements.map((element) => {
+      var _a2;
+      return (_a2 = this.convertTsTypeNode(xlrUtils.tsStripOptionalType(element))) != null ? _a2 : AnyTypeNode;
+    });
+    const additionalItems = rest ? (_a = this.convertTsTypeNode(rest.type.elementType)) != null ? _a : AnyTypeNode : false;
+    const firstOptional = elements.findIndex((element) => ts__default["default"].isOptionalTypeNode(element));
+    const minItems = firstOptional === -1 ? elements.length : firstOptional;
+    return __spreadProps(__spreadValues$1({
+      elementTypes
+    }, additionalItems && additionalItems.type === "any" ? { additionalItems: AnyTypeNode } : { additionalItems }), {
+      minItems
+    });
+  }
+  handleHeritageClauses(clauses, baseObject, typeChecker) {
+    let newProperties = {};
+    let newAdditionalProperties = false;
+    clauses.forEach((heritageClause) => {
+      var _a;
+      const parent = heritageClause.types[0];
+      const parentType = typeChecker.getTypeAtLocation(parent);
+      const parentSymbol = parentType.symbol;
+      const parentDeclarations = parentSymbol == null ? void 0 : parentSymbol.declarations;
+      let parentInterface = parentDeclarations == null ? void 0 : parentDeclarations[0];
+      if (parentInterface && ts__default["default"].isTypeLiteralNode(parentInterface) && ts__default["default"].isTypeAliasDeclaration(parentInterface.parent)) {
+        parentInterface = parentInterface.parent;
+      }
+      if (parentInterface && xlrUtils.isTopLevelNode(parentInterface)) {
+        const parentInterfaceType = this.convertDeclaration(parentInterface);
+        if (parentInterface.typeParameters && parent.typeArguments) {
+          const filledInInterface = this.solveGenerics(parentInterfaceType, parentInterface.typeParameters, parent.typeArguments);
+          newProperties = filledInInterface.properties;
+          newAdditionalProperties = filledInInterface.additionalProperties;
+        } else {
+          if (xlrUtils.isGenericNodeType(baseObject)) {
+            baseObject.genericTokens.push(...(_a = parentInterfaceType.genericTokens) != null ? _a : []);
+          }
+          newProperties = parentInterfaceType.properties;
+          newAdditionalProperties = parentInterfaceType.additionalProperties;
+        }
+      }
+    });
+    newAdditionalProperties = baseObject.additionalProperties === false ? newAdditionalProperties : false;
+    return __spreadProps(__spreadValues$1({}, baseObject), {
+      properties: __spreadValues$1(__spreadValues$1({}, newProperties), baseObject.properties),
+      additionalProperties: newAdditionalProperties
+    });
+  }
+  solveGenerics(baseInterface, typeParameters, typeArguments) {
+    if (typeArguments && typeArguments.length === 0)
+      return baseInterface;
+    const genericMap = new Map();
+    typeParameters.forEach((tp, i) => {
+      let typeToProcess;
+      if (typeArguments && i < typeArguments.length) {
+        typeToProcess = typeArguments[i];
+      } else if (tp.default) {
+        typeToProcess = tp.default;
+      } else {
+        typeToProcess = ts__default["default"].factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.AnyKeyword);
+      }
+      const processedNodeType = this.convertTsTypeNode(typeToProcess);
+      if (processedNodeType) {
+        genericMap.set(tp.name.getText(), processedNodeType);
+      }
+    });
+    return xlrUtils.fillInGenerics(baseInterface, genericMap);
+  }
+  generateGenerics(params) {
+    const genericArray = [];
+    params == null ? void 0 : params.forEach((param) => {
+      const serializedObject = {
+        symbol: param.name.text
+      };
+      if (param.constraint) {
+        serializedObject.constraints = this.convertTsTypeNode(param.constraint);
+      } else {
+        serializedObject.constraints = AnyTypeNode;
+      }
+      if (param.default) {
+        serializedObject.default = this.convertTsTypeNode(param.default);
+      } else {
+        serializedObject.default = AnyTypeNode;
+      }
+      genericArray.push(serializedObject);
+    });
+    return genericArray;
+  }
+  resolveRefNode(node) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    let refName;
+    if (node.typeName.kind === ts__default["default"].SyntaxKind.QualifiedName) {
+      refName = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;
+    } else {
+      refName = node.typeName.text;
+    }
+    if (xlrUtils.isTypeReferenceGeneric(node, this.context.typeChecker)) {
+      if (ts__default["default"].isIndexedAccessTypeNode(node.parent)) {
+        const genericSymbol = this.context.typeChecker.getSymbolAtLocation(node.typeName);
+        const typeParameters = this.generateGenerics(genericSymbol == null ? void 0 : genericSymbol.declarations);
+        const typeParameter = typeParameters[0];
+        if (typeParameter) {
+          if (typeParameter.constraints) {
+            return typeParameter.constraints;
+          }
+          if (typeParameter.default) {
+            return typeParameter.default;
+          }
+        }
+        return AnyTypeNode;
+      }
+      return __spreadValues$1({ type: "ref", ref: node.getText() }, xlrUtils.decorateNode(node));
+    }
+    if (refName === "Array") {
+      const typeArgs = node.typeArguments;
+      return __spreadValues$1({
+        type: "array",
+        elementType: typeArgs ? (_a = this.convertTsTypeNode(typeArgs[0])) != null ? _a : AnyTypeNode : AnyTypeNode
+      }, xlrUtils.decorateNode(node));
+    }
+    if (refName === "Record") {
+      const indexType = (_b = node.typeArguments) == null ? void 0 : _b[0];
+      const valueType = (_c = node.typeArguments) == null ? void 0 : _c[1];
+      return __spreadValues$1({
+        type: "record",
+        keyType: (_d = this.convertTsTypeNode(indexType)) != null ? _d : AnyTypeNode,
+        valueType: (_e = this.convertTsTypeNode(valueType)) != null ? _e : AnyTypeNode
+      }, xlrUtils.decorateNode(node));
+    }
+    if (refName === "Pick" || refName === "Omit") {
+      const baseType = (_f = node.typeArguments) == null ? void 0 : _f[0];
+      const modifiers = (_g = node.typeArguments) == null ? void 0 : _g[1];
+      const baseObj = this.convertTsTypeNode(baseType);
+      const modifierNames = xlrUtils.getStringLiteralsFromUnion(modifiers);
+      return (_h = xlrUtils.applyPickOrOmitToNodeType(baseObj, refName, modifierNames)) != null ? _h : {
+        type: "never"
+      };
+    }
+    if (refName === "Partial" || refName === "Required") {
+      const baseType = (_i = node.typeArguments) == null ? void 0 : _i[0];
+      const baseObj = this.convertTsTypeNode(baseType);
+      const modifier = refName !== "Partial";
+      return xlrUtils.applyPartialOrRequiredToNodeType(baseObj, modifier);
+    }
+    if (!this.context.customPrimitives.includes(refName)) {
+      const typeInfo = xlrUtils.getReferencedType(node, this.context.typeChecker);
+      if (typeInfo) {
+        const genericType = this.convertDeclaration(typeInfo.declaration);
+        const genericParams = typeInfo.declaration.typeParameters;
+        const genericArgs2 = node.typeArguments;
+        if (genericType && genericParams && genericArgs2) {
+          return this.solveGenerics(genericType, genericParams, genericArgs2);
+        }
+        if (genericType) {
+          return genericType;
+        }
+      }
+      this.context.throwError(`Can't find referenced type ${refName}, is it available in the current package or node_modules?`);
+    }
+    const genericArgs = [];
+    if (node.typeArguments) {
+      node.typeArguments.forEach((typeArg) => {
+        let convertedNode;
+        if (xlrUtils.isTopLevelNode(typeArg)) {
+          convertedNode = this.convertDeclaration(typeArg);
+        } else {
+          convertedNode = this.convertTsTypeNode(typeArg);
+        }
+        if (convertedNode) {
+          genericArgs.push(convertedNode);
+        } else {
+          this.context.throwError(`Conversion Error: Couldn't convert type argument in type ${refName}`);
+        }
+      });
+    }
+    return __spreadProps(__spreadValues$1({
+      type: "ref",
+      ref: node.getText()
+    }, xlrUtils.decorateNode(node)), {
+      genericArguments: genericArgs.length > 0 ? genericArgs : void 0
+    });
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const templateSplit = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+class TSWriter {
+  constructor(factory) {
+    this.context = {
+      factory: factory != null ? factory : ts__default["default"].factory,
+      throwError: (message) => {
+        throw new ConversionError(message);
+      }
+    };
+    this.importSet = new Set();
+    this.additionalTypes = new Map();
+  }
+  convertNamedType(type) {
+    this.importSet.clear();
+    this.additionalTypes.clear();
+    const finalNode = this.convertNamedTypeNode(type);
+    const referencedTypes = this.importSet.size > 0 ? this.importSet : void 0;
+    const additionalTypes = this.additionalTypes.size > 0 ? this.additionalTypes : void 0;
+    return {
+      type: this.makeAnnotations(finalNode, type),
+      referencedTypes,
+      additionalTypes
+    };
+  }
+  convertNamedTypeNode(type) {
+    const typeName = type.name;
+    const tsNode = this.convertTypeNode(type);
+    let generics;
+    if (xlrUtils.isGenericNamedType(type)) {
+      generics = this.createTypeParameters(type);
+    }
+    let finalNode;
+    if (ts__default["default"].isTypeLiteralNode(tsNode)) {
+      finalNode = this.makeInterfaceDeclaration(typeName, tsNode.members, generics);
+    } else {
+      finalNode = this.makeTypeDeclaration(typeName, tsNode, generics);
+    }
+    return finalNode;
+  }
+  convertTypeNode(type) {
+    if (type.type === "object") {
+      return this.createObjectNode(type);
+    }
+    if (type.type === "and") {
+      return this.context.factory.createIntersectionTypeNode(type.and.map((element) => {
+        return this.convertTypeNode(element);
+      }));
+    }
+    if (type.type === "or") {
+      return this.context.factory.createUnionTypeNode(type.or.map((element) => {
+        return this.convertTypeNode(element);
+      }));
+    }
+    if (type.type === "array") {
+      return this.context.factory.createTypeReferenceNode(this.context.factory.createIdentifier("Array"), [this.convertTypeNode(type.elementType)]);
+    }
+    if (xlrUtils.isPrimitiveTypeNode(type)) {
+      return this.createPrimitiveNode(type);
+    }
+    if (type.type === "conditional") {
+      return this.createConditionalTypeNode(type);
+    }
+    if (type.type === "function") {
+      return this.createFunctionDeclarationNode(type);
+    }
+    if (type.type === "record") {
+      return this.createRecordNode(type);
+    }
+    if (type.type === "ref") {
+      return this.createRefNode(type);
+    }
+    if (type.type === "template") {
+      return this.createTemplateLiteral(type);
+    }
+    if (type.type === "tuple") {
+      return this.createTupleNode(type);
+    }
+    this.context.throwError(`Unable to convert node type: ${type.type}`);
+  }
+  createRefNode(xlrNode) {
+    if (xlrNode.genericArguments) {
+      xlrNode.genericArguments.forEach((genericArg) => {
+        if (genericArg.name) {
+          const additionalType = this.convertNamedTypeNode(genericArg);
+          this.additionalTypes.set(genericArg.name, additionalType);
+        } else if (genericArg.type === "and") {
+          genericArg.and.forEach((type) => {
+            if (type.name) {
+              const additionalType = this.convertNamedTypeNode(type);
+              this.additionalTypes.set(type.name, additionalType);
+            }
+          });
+        } else if (genericArg.type === "or") {
+          genericArg.or.forEach((type) => {
+            if (type.name) {
+              const additionalType = this.convertNamedTypeNode(type);
+              this.additionalTypes.set(type.name, additionalType);
+            }
+          });
+        }
+      });
+    }
+    const importName = xlrNode.ref.split("<")[0];
+    this.importSet.add(importName);
+    return this.context.factory.createTypeReferenceNode(xlrNode.ref);
+  }
+  createPrimitiveNode(xlrNode) {
+    if ((xlrNode.type === "string" || xlrNode.type === "boolean" || xlrNode.type === "number") && xlrNode.const || xlrNode.type === "null") {
+      return this.context.factory.createLiteralTypeNode(this.createLiteralTypeNode(xlrNode));
+    }
+    switch (xlrNode.type) {
+      case "string":
+        return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.StringKeyword);
+      case "number":
+        return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.NumberKeyword);
+      case "boolean":
+        return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.BooleanKeyword);
+      case "any":
+        return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.AnyKeyword);
+      case "unknown":
+        return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.UnknownKeyword);
+      case "never":
+        return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.NeverKeyword);
+      case "undefined":
+        return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.UndefinedKeyword);
+      default:
+        this.context.throwError(`Unknown primitive type ${xlrNode.type}`);
+    }
+  }
+  createLiteralTypeNode(xlrNode) {
+    if (xlrNode.type === "boolean") {
+      return xlrNode.const ? this.context.factory.createTrue() : this.context.factory.createFalse();
+    }
+    if (xlrNode.type === "number") {
+      return xlrNode.const ? this.context.factory.createNumericLiteral(xlrNode.const) : this.context.throwError("Can't make literal type out of non constant number");
+    }
+    if (xlrNode.type === "string") {
+      return xlrNode.const ? this.context.factory.createStringLiteral(xlrNode.const) : this.context.throwError("Can't make literal type out of non constant string");
+    }
+    if (xlrNode.type === "null") {
+      return this.context.factory.createNull();
+    }
+    this.context.throwError(`Can't make literal out of type ${xlrNode.type}`);
+  }
+  createTupleNode(xlrNode) {
+    return this.context.factory.createTupleTypeNode(xlrNode.elementTypes.map((e) => this.convertTypeNode(e)));
+  }
+  createFunctionDeclarationNode(xlrNode) {
+    return this.context.factory.createFunctionTypeNode(void 0, xlrNode.parameters.map((e) => {
+      return this.context.factory.createParameterDeclaration(void 0, void 0, void 0, e.name, e.optional ? this.context.factory.createToken(ts__default["default"].SyntaxKind.QuestionToken) : void 0, this.convertTypeNode(e.type), e.default ? this.createLiteralTypeNode(e.default) : void 0);
+    }), xlrNode.returnType ? this.convertTypeNode(xlrNode.returnType) : this.context.factory.createToken(ts__default["default"].SyntaxKind.VoidKeyword));
+  }
+  createRecordNode(xlrNode) {
+    const keyType = this.convertTypeNode(xlrNode.keyType);
+    const valueType = this.convertTypeNode(xlrNode.valueType);
+    return this.context.factory.createTypeReferenceNode(this.context.factory.createIdentifier("Record"), [keyType, valueType]);
+  }
+  createConditionalTypeNode(xlrNode) {
+    const leftCheck = this.convertTypeNode(xlrNode.check.left);
+    const rightCheck = this.convertTypeNode(xlrNode.check.right);
+    const trueValue = this.convertTypeNode(xlrNode.value.true);
+    const falseValue = this.convertTypeNode(xlrNode.value.false);
+    return this.context.factory.createConditionalTypeNode(leftCheck, rightCheck, trueValue, falseValue);
+  }
+  createObjectNode(xlrNode) {
+    const { properties, additionalProperties = false } = xlrNode;
+    const propertyNodes = [
+      ...Object.keys(properties).map((name) => __spreadValues({ name }, properties[name])).map(({ name, node, required }) => this.makeAnnotations(this.context.factory.createPropertySignature(void 0, name, required ? void 0 : this.context.factory.createToken(ts__default["default"].SyntaxKind.QuestionToken), this.convertTypeNode(node)), node))
+    ];
+    if (additionalProperties) {
+      propertyNodes.push(this.context.factory.createIndexSignature(void 0, void 0, [
+        this.context.factory.createParameterDeclaration(void 0, void 0, void 0, "key", void 0, this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.StringKeyword))
+      ], this.convertTypeNode(additionalProperties)));
+    }
+    return this.context.factory.createTypeLiteralNode(propertyNodes);
+  }
+  createTemplateLiteral(xlrNode) {
+    const templateSegments = xlrNode.format.split(templateSplit);
+    let templateHead;
+    if (templateSegments.length % 2) {
+      templateHead = this.context.factory.createTemplateHead(templateSegments[0]);
+      templateSegments.splice(0, 1);
+    } else {
+      templateHead = this.context.factory.createTemplateHead("");
+    }
+    return this.context.factory.createTemplateLiteralType(templateHead, templateSegments.map((segments, i) => {
+      const [regexSegment, stringSegment] = segments.split(" ", 1);
+      let regexTemplateType;
+      if (regexSegment === ".*") {
+        regexTemplateType = ts__default["default"].SyntaxKind.StringKeyword;
+      } else if (regexSegment === "[0-9]*") {
+        regexTemplateType = ts__default["default"].SyntaxKind.NumberKeyword;
+      } else if (regexSegment === "true|false") {
+        regexTemplateType = ts__default["default"].SyntaxKind.BooleanKeyword;
+      } else {
+        this.context.throwError(`Can't make template literal type from regex ${regexSegment}`);
+      }
+      let stringTemplateType;
+      if (i === templateSegments.length - 1) {
+        stringTemplateType = this.context.factory.createTemplateTail(stringSegment);
+      } else {
+        stringTemplateType = this.context.factory.createTemplateMiddle(stringSegment);
+      }
+      return this.context.factory.createTemplateLiteralTypeSpan(this.context.factory.createKeywordTypeNode(regexTemplateType), stringTemplateType);
+    }));
+  }
+  createGenericArgumentNode(node) {
+    if (node) {
+      if (node.type === "object" && node.name) {
+        const additionalType = this.convertNamedTypeNode(node);
+        this.additionalTypes.set(node.name, additionalType);
+        return this.context.factory.createTypeReferenceNode(node.name);
+      }
+      return this.convertTypeNode(node);
+    }
+    return void 0;
+  }
+  makeAnnotations(tsNode, xlrAnnotations) {
+    let comment = xlrAnnotations.description;
+    if (!comment) {
+      return tsNode;
+    }
+    if (comment.includes("\n")) {
+      comment = `*
+${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
+`;
+    } else {
+      comment = `* ${comment} `;
+    }
+    return ts__default["default"].addSyntheticLeadingComment(tsNode, ts__default["default"].SyntaxKind.MultiLineCommentTrivia, comment, true);
+  }
+  createTypeParameters(genericxlrNode) {
+    return genericxlrNode.genericTokens.map((generic) => {
+      return this.context.factory.createTypeParameterDeclaration(generic.symbol, this.createGenericArgumentNode(generic.constraints), this.createGenericArgumentNode(generic.default));
+    });
+  }
+  makeInterfaceDeclaration(name, node, generics) {
+    return this.context.factory.createInterfaceDeclaration(void 0, this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, void 0, node);
+  }
+  makeTypeDeclaration(name, node, generics) {
+    return this.context.factory.createTypeAliasDeclaration(void 0, this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, node);
+  }
+}
+
+exports.ConversionError = ConversionError;
+exports.TSWriter = TSWriter;
+exports.TsConverter = TsConverter;
+//# sourceMappingURL=index.cjs.js.map