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

package/dist/cjs/index.cjs

@@ -0,0 +1,1289 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ConversionError: () => ConversionError,
+  TSWriter: () => TSWriter,
+  TsConverter: () => TsConverter
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts-to-xlr.ts
+var import_typescript = __toESM(require("typescript"));
+var import_xlr_utils = require("@xlr-lib/xlr-utils");
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/types.ts
+var ConversionError = class _ConversionError extends Error {
+  constructor(msg) {
+    super(msg);
+    Object.setPrototypeOf(this, _ConversionError.prototype);
+  }
+  toString() {
+    return `Conversion Error: ${this.message}`;
+  }
+};
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts-to-xlr.ts
+function isMappedTypeNode(x) {
+  return ["Pick", "Omit", "Required", "Partial", "Exclude"].includes(x);
+}
+var AnyTypeNode = {
+  type: "any"
+};
+var TsConverter = class {
+  context;
+  constructor(typeChecker, customPrimitives) {
+    this.context = {
+      customPrimitives: customPrimitives ?? [],
+      typeChecker,
+      throwError: (message) => {
+        throw new ConversionError(message);
+      },
+      cache: {
+        convertedNodes: /* @__PURE__ */ new Map(),
+        convertedTemplates: /* @__PURE__ */ new Map()
+      }
+    };
+  }
+  /** Converts all exported objects to a XLR representation */
+  convertSourceFile(sourceFile) {
+    const declarations = sourceFile.statements.filter(import_xlr_utils.isTopLevelNode);
+    const types = declarations.filter((declaration) => (0, import_xlr_utils.isExportedDeclaration)(declaration)).map((statement) => this.convertTopLevelNode(statement)).filter((v) => !!v);
+    return {
+      data: { version: 1, types },
+      convertedTypes: types.map(({ name }) => name)
+    };
+  }
+  convertTopLevelNode(node) {
+    const sourceFile = node.parent;
+    const { fileName } = sourceFile;
+    if (import_typescript.default.isVariableStatement(node)) {
+      return {
+        source: fileName,
+        ...this.convertVariable(node)
+      };
+    }
+    return {
+      source: fileName,
+      ...this.convertDeclaration(node)
+    };
+  }
+  /** Converts a single type/interface declaration to XLRs */
+  convertDeclaration(node) {
+    if (import_typescript.default.isTypeAliasDeclaration(node)) {
+      let genericTokens;
+      if ((0, import_xlr_utils.isGenericTypeDeclaration)(node)) {
+        genericTokens = this.generateGenerics(node.typeParameters);
+      }
+      return {
+        name: node.name.getText(),
+        ...this.convertTsTypeNode(node.type) ?? AnyTypeNode,
+        ...(0, import_xlr_utils.decorateNode)(node),
+        genericTokens
+      };
+    }
+    if (import_typescript.default.isInterfaceDeclaration(node)) {
+      let genericTokens;
+      if ((0, import_xlr_utils.isGenericInterfaceDeclaration)(node)) {
+        genericTokens = this.generateGenerics(node.typeParameters);
+      }
+      const baseObject = {
+        name: node.name.getText(),
+        type: "object",
+        ...this.tsObjectMembersToProperties(node),
+        ...(0, import_xlr_utils.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`
+    );
+  }
+  convertVariable(node) {
+    const variableDeclarations = node.declarationList.declarations;
+    if (variableDeclarations.length === 1) {
+      const variable = variableDeclarations[0];
+      if (variable.initializer) {
+        let resultingNode;
+        if (import_typescript.default.isCallExpression(variable.initializer) || import_typescript.default.isArrowFunction(variable.initializer)) {
+          resultingNode = this.resolveFunctionCall(
+            variable.initializer,
+            node.parent
+          );
+        } else {
+          resultingNode = this.tsLiteralToType(variable.initializer);
+        }
+        if (resultingNode.type === "function" || resultingNode.type === "ref") {
+          resultingNode = { ...resultingNode, name: variable.name.getText() };
+        }
+        return {
+          name: variable.name.getText(),
+          ...resultingNode
+        };
+      }
+    }
+    this.context.throwError(
+      `Error: Multi-variable declaration on line ${node.pos} is not supported for conversion`
+    );
+  }
+  /** Converts an arbitrary ts.TypeNode to XLRs */
+  convertTsTypeNode(node) {
+    if (this.context.cache.convertedNodes.has(node)) {
+      const cachedType = this.context.cache.convertedNodes.get(
+        node
+      );
+      return JSON.parse(JSON.stringify(cachedType));
+    }
+    const convertedNode = this.tsNodeToType(node);
+    this.context.cache.convertedNodes.set(node, convertedNode);
+    return convertedNode;
+  }
+  /** Should not be called directly unless you want to bypass the cache, use `convertTsTypeNode` */
+  tsNodeToType(node) {
+    if (import_typescript.default.isUnionTypeNode(node)) {
+      return {
+        type: "or",
+        or: node.types.map((child) => this.convertTsTypeNode(child)).filter(import_xlr_utils.isNonNullable),
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (import_typescript.default.isIntersectionTypeNode(node)) {
+      return {
+        type: "and",
+        and: node.types.map((child) => this.convertTsTypeNode(child)).filter(import_xlr_utils.isNonNullable),
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (import_typescript.default.isParenthesizedTypeNode(node)) {
+      const children = [];
+      node.forEachChild((child) => {
+        children.push(child);
+      });
+      if (children[0]?.kind === import_typescript.default.SyntaxKind.OpenParenToken) {
+        children.shift();
+      }
+      if (children[children.length - 1]?.kind === import_typescript.default.SyntaxKind.CloseParenToken) {
+        children.pop();
+      }
+      const element = children[0];
+      if (children.length !== 1 || !import_typescript.default.isTypeNode(element)) {
+        this.context.throwError(
+          `Parenthesis type not understood. Length ${children.length}, Is Type Node: ${import_typescript.default.SyntaxKind[element.kind]}`
+        );
+      }
+      return this.convertTsTypeNode(element);
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.AnyKeyword) {
+      return { type: "any", ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.UnknownKeyword) {
+      return { type: "unknown", ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.StringKeyword) {
+      return { type: "string", ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.NumberKeyword) {
+      return { type: "number", ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.BooleanKeyword) {
+      return { type: "boolean", ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.UndefinedKeyword) {
+      return { type: "undefined", ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.NeverKeyword) {
+      return { type: "never", ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.ObjectKeyword) {
+      return {
+        type: "object",
+        properties: {},
+        additionalProperties: AnyTypeNode,
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.VoidKeyword) {
+      return {
+        type: "void",
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (import_typescript.default.isTemplateLiteralTypeNode(node)) {
+      let format;
+      if (this.context.cache.convertedTemplates.has(node)) {
+        format = this.context.cache.convertedTemplates.get(node);
+      } else {
+        format = (0, import_xlr_utils.buildTemplateRegex)(node, this.context.typeChecker);
+        this.context.cache.convertedTemplates.set(node, format);
+      }
+      return {
+        type: "template",
+        format
+      };
+    }
+    if (import_typescript.default.isArrayTypeNode(node)) {
+      return {
+        type: "array",
+        elementType: this.convertTsTypeNode(node.elementType) ?? AnyTypeNode,
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (import_typescript.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)
+        }
+      };
+      if ((0, import_xlr_utils.isPrimitiveTypeNode)(xlrNode.check.left) && (0, import_xlr_utils.isPrimitiveTypeNode)(xlrNode.check.right)) {
+        return (0, import_xlr_utils.resolveConditional)(xlrNode);
+      } else {
+        return xlrNode;
+      }
+    }
+    if (import_typescript.default.isTypeReferenceNode(node)) {
+      return this.resolveRefNode(node);
+    }
+    if (import_typescript.default.isTupleTypeNode(node)) {
+      return {
+        type: "tuple",
+        ...this.tsTupleToType(node),
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (import_typescript.default.isLiteralTypeNode(node)) {
+      return this.tsLiteralToType(node.literal);
+    }
+    if (import_typescript.default.isTypeLiteralNode(node)) {
+      return {
+        type: "object",
+        ...this.tsObjectMembersToProperties(node),
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (import_typescript.default.isFunctionTypeNode(node) || import_typescript.default.isFunctionDeclaration(node) || import_typescript.default.isArrowFunction(node)) {
+      const parameters = node.parameters.map(
+        (param) => {
+          let typeNode;
+          if (param.type) {
+            typeNode = this.convertTsTypeNode(param.type);
+          }
+          return {
+            name: param.name.getText(),
+            type: typeNode ?? AnyTypeNode,
+            optional: param.questionToken ? true : void 0,
+            default: param.initializer ? this.convertTsTypeNode(
+              param.initializer
+            ) : void 0
+          };
+        }
+      );
+      let returnType;
+      if (node.type !== void 0) {
+        returnType = this.convertTsTypeNode(node.type);
+      }
+      return {
+        type: "function",
+        parameters,
+        returnType,
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (import_typescript.default.isIndexedAccessTypeNode(node)) {
+      if (import_typescript.default.isTypeReferenceNode(node.objectType) && import_typescript.default.isLiteralTypeNode(node.indexType)) {
+        const baseObject = this.convertTsTypeNode(node.objectType);
+        const accessor = node.indexType.literal.getText().replace(/["']/g, "");
+        if (!baseObject) {
+          this.context.throwError(
+            `Error: Couldn't resolve index access on property ${accessor} on type ${node.objectType.typeName.getText()}`
+          );
+        } else if (baseObject.type === "object") {
+          if (Object.keys(baseObject.properties ?? {}).includes(accessor)) {
+            return baseObject.properties[accessor].node;
+          }
+          if (baseObject.additionalProperties) {
+            return baseObject.additionalProperties;
+          }
+        } else if (baseObject.type === "ref") {
+          return { ...baseObject, property: accessor };
+        } else {
+          this.context.throwError(
+            `Error: Index access on non object/ref type ${baseObject.type}`
+          );
+        }
+      }
+      let queryNode = node.objectType;
+      if (import_typescript.default.isParenthesizedTypeNode(node.objectType)) {
+        queryNode = node.objectType.type;
+      }
+      if (import_typescript.default.isTypeQueryNode(queryNode)) {
+        const elements = this.tsNodeToType(node.objectType);
+        return {
+          type: "or",
+          or: [...elements.elementTypes.map((element) => element.type)]
+        };
+      }
+      this.context.throwError(
+        `Error: could not solve IndexedAccessType: ${node.getFullText()}`
+      );
+    }
+    if (import_typescript.default.isTypeQueryNode(node)) {
+      const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
+      const syntheticType = this.context.typeChecker.typeToTypeNode(
+        effectiveType,
+        node,
+        import_typescript.default.NodeBuilderFlags.NoTruncation
+      );
+      if (syntheticType) {
+        return this.tsNodeToType(syntheticType);
+      }
+      this.context.throwError(
+        `Error: could not synthesize type for ${node.getText()}`
+      );
+    }
+    if (import_typescript.default.isTypeOperatorNode(node)) {
+      return this.tsNodeToType(node.type);
+    }
+    this.context.throwError(
+      `Unimplemented type ${import_typescript.default.SyntaxKind[node.kind]} at ${node.getText()}`
+    );
+  }
+  tsLiteralToType(node) {
+    if (import_typescript.default.isNumericLiteral(node)) {
+      return {
+        type: "number",
+        const: Number(node.text),
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (import_typescript.default.isStringLiteral(node)) {
+      return {
+        type: "string",
+        const: node.text,
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.TrueKeyword) {
+      return {
+        type: "boolean",
+        const: true,
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.FalseKeyword) {
+      return {
+        type: "boolean",
+        const: false,
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (node.kind === import_typescript.default.SyntaxKind.NullKeyword) {
+      return { type: "null", ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (import_typescript.default.isPrefixUnaryExpression(node)) {
+      this.context.throwError("Prefix unary expressions not supported");
+    }
+    if (import_typescript.default.isArrayLiteralExpression(node)) {
+      const arrayElements = [];
+      node.elements.forEach((element) => {
+        if (import_typescript.default.isSpreadElement(element)) {
+          const arrayReference = this.resolveLiteralReference(
+            element.expression
+          );
+          arrayElements.push(...arrayReference.const ?? []);
+        } else {
+          arrayElements.push(this.tsLiteralToType(element));
+        }
+      });
+      return {
+        type: "array",
+        elementType: { type: "any" },
+        const: arrayElements
+      };
+    }
+    if (import_typescript.default.isObjectLiteralExpression(node)) {
+      const ret = {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      };
+      node.properties.forEach((property) => {
+        if (import_typescript.default.isPropertyAssignment(property)) {
+          const propertyName = property.name?.getText();
+          ret.properties[propertyName] = {
+            required: true,
+            node: this.tsLiteralToType(property.initializer)
+          };
+        } else if (import_typescript.default.isSpreadAssignment(property)) {
+          const spreadValue = this.resolveLiteralReference(
+            property.expression
+          );
+          ret.properties = {
+            ...ret.properties,
+            ...spreadValue.properties
+          };
+        }
+      });
+      return ret;
+    }
+    if (import_typescript.default.isIdentifier(node)) {
+      return this.resolveLiteralReference(node);
+    }
+    this.context.throwError(
+      `Literal type not understood ${import_typescript.default.SyntaxKind[node.kind]} at ${node.getText()}`
+    );
+  }
+  resolveLiteralReference(expression) {
+    if (import_typescript.default.isIdentifier(expression)) {
+      const symbol = this.context.typeChecker.getSymbolAtLocation(expression);
+      let expressionReference = symbol?.declarations?.[0];
+      if (symbol && expressionReference && import_typescript.default.isImportSpecifier(expressionReference)) {
+        const referencedDeclaration = this.context.typeChecker.getAliasedSymbol(symbol);
+        expressionReference = referencedDeclaration.declarations?.[0];
+      }
+      if (expressionReference && import_typescript.default.isVariableDeclaration(expressionReference) && expressionReference.initializer) {
+        return this.convertVariable(
+          expressionReference.parent.parent
+        );
+      }
+      this.context.throwError(
+        `Error: Can't resolve non-variable declaration ${expressionReference?.getText()}`
+      );
+    }
+    this.context.throwError(
+      `Error: Can't resolve non-identifier reference in literal ${expression.getText()}`
+    );
+  }
+  resolveFunctionCall(functionCall, document) {
+    if (import_typescript.default.isArrowFunction(functionCall)) {
+      const declaredReturnType = functionCall.parent.type;
+      if (declaredReturnType) {
+        return this.tsNodeToType(declaredReturnType);
+      }
+    }
+    const functionReturnType = this.context.typeChecker.getTypeAtLocation(functionCall);
+    let syntheticNode = this.context.typeChecker.typeToTypeNode(
+      functionReturnType,
+      document,
+      void 0
+    );
+    if (import_typescript.default.isArrowFunction(functionCall)) {
+      const syntheticWithParameters = {
+        ...syntheticNode,
+        parameters: functionCall.parameters
+      };
+      syntheticNode = syntheticWithParameters;
+    }
+    if (syntheticNode) {
+      if (import_typescript.default.isTypeReferenceNode(syntheticNode) && import_typescript.default.isIdentifier(syntheticNode.typeName)) {
+        const { typeName } = syntheticNode;
+        if (this.context.customPrimitives.includes(typeName.text)) {
+          return this.makeBasicRefNode(syntheticNode);
+        }
+        const declarationSymbol = typeName.symbol;
+        if (declarationSymbol && declarationSymbol.declarations?.[0]) {
+          const declaration = declarationSymbol.declarations[0];
+          if (import_typescript.default.isTypeAliasDeclaration(declaration) || import_typescript.default.isInterfaceDeclaration(declaration)) {
+            return this.convertDeclaration(declaration);
+          }
+        }
+        this.context.throwError(
+          `Error: could not get referenced type ${syntheticNode.getText()}`
+        );
+      }
+      return this.tsNodeToType(syntheticNode);
+    }
+    this.context.throwError(
+      `Error: could not determine effective return type of ${functionCall.getText()}`
+    );
+  }
+  tsObjectMembersToProperties(node) {
+    const ret = {
+      properties: {},
+      additionalProperties: false
+    };
+    node.members.forEach((member) => {
+      if (import_typescript.default.isPropertySignature(member) && member.type) {
+        const name = member.name.getText();
+        ret.properties[name] = {
+          required: !(0, import_xlr_utils.isOptionalProperty)(member),
+          node: {
+            ...this.convertTsTypeNode(member.type) ?? AnyTypeNode,
+            ...(0, import_xlr_utils.decorateNode)(member)
+          }
+        };
+      } else if (import_typescript.default.isIndexSignatureDeclaration(member)) {
+        const param = member.parameters[0];
+        if (param.type?.kind !== import_typescript.default.SyntaxKind.StringKeyword) {
+          this.context.throwError(
+            "Will not convert non-string index signature"
+          );
+        }
+        ret.additionalProperties = this.convertTsTypeNode(member.type) ?? AnyTypeNode;
+      }
+    });
+    return ret;
+  }
+  tsTupleToType(node) {
+    if (node.elements.length === 0) {
+      return { elementTypes: [], additionalItems: false, minItems: 0 };
+    }
+    const hasRest = import_typescript.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) => {
+      if (import_typescript.default.isNamedTupleMember(element)) {
+        let typeNode;
+        if (element.type) {
+          typeNode = this.convertTsTypeNode(element.type);
+        }
+        return {
+          name: element.name.text,
+          type: typeNode ?? AnyTypeNode,
+          optional: element.questionToken ? true : void 0
+        };
+      }
+      return {
+        type: this.convertTsTypeNode((0, import_xlr_utils.tsStripOptionalType)(element)),
+        optional: import_typescript.default.isOptionalTypeNode(element)
+      };
+    });
+    const additionalItems = rest ? this.convertTsTypeNode(rest.type.elementType) ?? AnyTypeNode : false;
+    const firstOptional = elementTypes.findIndex(
+      (element) => element.optional === true
+    );
+    const minItems = firstOptional === -1 ? elements.length : firstOptional;
+    return {
+      elementTypes,
+      ...additionalItems && additionalItems.type === "any" ? { additionalItems: AnyTypeNode } : { additionalItems },
+      minItems
+    };
+  }
+  handleHeritageClauses(clauses, baseObject, typeChecker) {
+    let newProperties = {};
+    const additionalPropertiesCollector = [];
+    let extendsType;
+    clauses.forEach((heritageClause) => {
+      heritageClause.types.forEach((parent) => {
+        let typeToApply;
+        const typeName = parent.expression.getText();
+        if (isMappedTypeNode(typeName)) {
+          typeToApply = this.makeMappedType(typeName, parent);
+        } else {
+          const parentType = typeChecker.getTypeAtLocation(parent);
+          const parentSymbol = parentType.symbol;
+          const parentDeclarations = parentSymbol?.declarations;
+          if (!parentDeclarations?.[0]) {
+            this.context.throwError(
+              `Error: Unable to get underlying interface for extending class ${parent.getFullText()}`
+            );
+          }
+          let parentInterface;
+          if (import_typescript.default.isTypeLiteralNode(parentDeclarations?.[0]) && import_typescript.default.isTypeAliasDeclaration(parentDeclarations?.[0].parent)) {
+            parentInterface = parentDeclarations?.[0].parent;
+          } else {
+            parentInterface = parentDeclarations?.[0];
+          }
+          if (this.context.customPrimitives.includes(parentInterface.name.text)) {
+            extendsType = this.makeBasicRefNode(parent);
+            return;
+          }
+          typeToApply = this.convertDeclaration(parentInterface);
+          if (typeToApply.extends) {
+            extendsType = typeToApply.extends;
+          }
+          if (parentInterface.typeParameters && parent.typeArguments) {
+            typeToApply = this.resolveGenerics(
+              typeToApply,
+              parentInterface.typeParameters,
+              parent.typeArguments
+            );
+          } else if ((0, import_xlr_utils.isGenericNodeType)(baseObject)) {
+            baseObject.genericTokens.push(
+              ...typeToApply.genericTokens ?? []
+            );
+          }
+        }
+        newProperties = {
+          ...newProperties,
+          ...typeToApply.properties
+        };
+        if (typeToApply.additionalProperties) {
+          additionalPropertiesCollector.push(typeToApply.additionalProperties);
+        }
+      });
+    });
+    let additionalProperties = false;
+    if (baseObject.additionalProperties === false) {
+      if (additionalPropertiesCollector.length === 1) {
+        additionalProperties = additionalPropertiesCollector[0];
+      } else if (additionalPropertiesCollector.length >= 1) {
+        additionalProperties = {
+          type: "or",
+          or: additionalPropertiesCollector
+        };
+      }
+    }
+    return {
+      ...baseObject,
+      ...extendsType ? { extends: extendsType } : {},
+      properties: { ...newProperties, ...baseObject.properties },
+      additionalProperties
+    };
+  }
+  resolveGenerics(baseInterface, typeParameters, typeArguments) {
+    if (typeArguments && typeArguments.length === 0) return baseInterface;
+    const genericMap = /* @__PURE__ */ 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 = import_typescript.default.factory.createKeywordTypeNode(
+          import_typescript.default.SyntaxKind.AnyKeyword
+        );
+      }
+      const processedNodeType = this.convertTsTypeNode(typeToProcess);
+      if (processedNodeType) {
+        genericMap.set(tp.name.getText(), processedNodeType);
+      }
+    });
+    return (0, import_xlr_utils.fillInGenerics)(baseInterface, genericMap);
+  }
+  generateGenerics(params) {
+    const genericArray = [];
+    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) {
+    let refName;
+    if (node.typeName.kind === import_typescript.default.SyntaxKind.QualifiedName) {
+      refName = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;
+    } else {
+      refName = node.typeName.text;
+    }
+    if ((0, import_xlr_utils.isTypeReferenceGeneric)(node, this.context.typeChecker)) {
+      if (import_typescript.default.isIndexedAccessTypeNode(node.parent)) {
+        const genericSymbol = this.context.typeChecker.getSymbolAtLocation(
+          node.typeName
+        );
+        const typeParameters = this.generateGenerics(
+          genericSymbol?.declarations
+        );
+        const typeParameter = typeParameters[0];
+        if (typeParameter) {
+          if (typeParameter.constraints) {
+            return typeParameter.constraints;
+          }
+          if (typeParameter.default) {
+            return typeParameter.default;
+          }
+        }
+        return AnyTypeNode;
+      }
+      return { type: "ref", ref: node.getText(), ...(0, import_xlr_utils.decorateNode)(node) };
+    }
+    if (refName === "Array") {
+      const typeArgs = node.typeArguments;
+      return {
+        type: "array",
+        elementType: typeArgs ? this.convertTsTypeNode(typeArgs[0]) ?? AnyTypeNode : AnyTypeNode,
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (refName === "Record") {
+      const indexType = node.typeArguments?.[0];
+      const valueType = node.typeArguments?.[1];
+      return {
+        type: "record",
+        keyType: this.convertTsTypeNode(indexType) ?? AnyTypeNode,
+        valueType: this.convertTsTypeNode(valueType) ?? AnyTypeNode,
+        ...(0, import_xlr_utils.decorateNode)(node)
+      };
+    }
+    if (isMappedTypeNode(refName)) {
+      return this.makeMappedType(refName, node);
+    }
+    if (!this.context.customPrimitives.includes(refName)) {
+      const typeInfo = (0, import_xlr_utils.getReferencedType)(node, this.context.typeChecker);
+      if (typeInfo) {
+        const genericType = this.convertTopLevelNode(typeInfo.declaration);
+        const genericParams = typeInfo.declaration.typeParameters;
+        const genericArgs = node.typeArguments;
+        if (genericType && genericParams && genericArgs) {
+          return this.resolveGenerics(
+            genericType,
+            genericParams,
+            genericArgs
+          );
+        }
+        if (genericType) {
+          return genericType;
+        }
+      }
+      this.context.throwError(
+        `Can't find referenced type ${refName}, is it available in the current package or node_modules?`
+      );
+    }
+    return this.makeBasicRefNode(node);
+  }
+  makeMappedType(refName, node) {
+    if (refName === "Pick" || refName === "Omit" || refName === "Exclude") {
+      const baseType = node.typeArguments?.[0];
+      const modifiers = node.typeArguments?.[1];
+      const baseObj = this.convertTsTypeNode(baseType);
+      if (refName === "Exclude") {
+        if (baseObj.type === "or") {
+          return (0, import_xlr_utils.applyExcludeToNodeType)(
+            baseObj,
+            this.convertTsTypeNode(modifiers)
+          );
+        }
+        throw new ConversionError(
+          "Error: Can't solve Exclude type on non-union node"
+        );
+      } else {
+        return (0, import_xlr_utils.applyPickOrOmitToNodeType)(
+          baseObj,
+          refName,
+          (0, import_xlr_utils.getStringLiteralsFromUnion)(modifiers)
+        );
+      }
+    }
+    if (refName === "Partial" || refName === "Required") {
+      const baseType = node.typeArguments?.[0];
+      const baseObj = this.convertTsTypeNode(baseType);
+      const modifier = refName !== "Partial";
+      return (0, import_xlr_utils.applyPartialOrRequiredToNodeType)(baseObj, modifier);
+    }
+    this.context.throwError(`Can't convert non-MappedType ${refName}`);
+  }
+  makeBasicRefNode(node) {
+    const genericArgs = [];
+    if (node.typeArguments) {
+      node.typeArguments.forEach((typeArg) => {
+        let convertedNode;
+        if ((0, import_xlr_utils.isTopLevelDeclaration)(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 ${node.getText()}`
+          );
+        }
+      });
+    }
+    let ref;
+    if (node.pos === -1 && import_typescript.default.isTypeReferenceNode(node) && import_typescript.default.isIdentifier(node.typeName)) {
+      ref = node.typeName.text;
+    } else {
+      ref = node.getText();
+    }
+    return {
+      type: "ref",
+      ref,
+      ...(0, import_xlr_utils.decorateNode)(node),
+      genericArguments: genericArgs.length > 0 ? genericArgs : void 0
+    };
+  }
+};
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/xlr-to-ts.ts
+var import_xlr_utils2 = require("@xlr-lib/xlr-utils");
+var import_typescript2 = __toESM(require("typescript"));
+var templateTokenize = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+var tokenSplit = /(?<=true\|false|\.\*|\[0-9]\*)/gm;
+var TSWriter = class {
+  context;
+  importSet;
+  additionalTypes;
+  constructor(factory) {
+    this.context = {
+      factory: factory ?? import_typescript2.default.factory,
+      throwError: (message) => {
+        throw new ConversionError(message);
+      }
+    };
+    this.importSet = /* @__PURE__ */ new Set();
+    this.additionalTypes = /* @__PURE__ */ 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 customPrimitiveHeritageClass;
+    if (type.type === "object" && type.extends) {
+      const refName = type.extends.ref.split("<")[0];
+      customPrimitiveHeritageClass = [
+        this.context.factory.createHeritageClause(
+          import_typescript2.default.SyntaxKind.ExtendsKeyword,
+          [
+            this.context.factory.createExpressionWithTypeArguments(
+              this.context.factory.createIdentifier(refName),
+              type.extends.genericArguments ? type.extends.genericArguments.map(
+                (node) => this.convertTypeNode(node)
+              ) : void 0
+            )
+          ]
+        )
+      ];
+    }
+    let generics;
+    if ((0, import_xlr_utils2.isGenericNamedType)(type)) {
+      generics = this.createTypeParameters(type);
+      type.genericTokens.forEach((token) => {
+        if (this.importSet.has(token.symbol)) {
+          this.importSet.delete(token.symbol);
+        }
+      });
+    }
+    let finalNode;
+    if (import_typescript2.default.isTypeLiteralNode(tsNode)) {
+      finalNode = this.makeInterfaceDeclaration(
+        typeName,
+        tsNode.members,
+        generics,
+        customPrimitiveHeritageClass
+      );
+    } 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") {
+      if (type.const) {
+        return this.context.factory.createTupleTypeNode(
+          type.const.map(
+            (element) => this.convertTypeNode(element)
+          )
+        );
+      }
+      return this.context.factory.createTypeReferenceNode(
+        this.context.factory.createIdentifier("Array"),
+        [this.convertTypeNode(type.elementType)]
+      );
+    }
+    if ((0, import_xlr_utils2.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) {
+    const typeArgs = [];
+    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);
+            }
+          });
+        } else {
+          typeArgs.push(this.convertTypeNode(genericArg));
+        }
+      });
+    }
+    const importName = xlrNode.ref.split("<")[0];
+    this.importSet.add(importName);
+    return this.context.factory.createTypeReferenceNode(importName, typeArgs);
+  }
+  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(
+          import_typescript2.default.SyntaxKind.StringKeyword
+        );
+      case "number":
+        return this.context.factory.createKeywordTypeNode(
+          import_typescript2.default.SyntaxKind.NumberKeyword
+        );
+      case "boolean":
+        return this.context.factory.createKeywordTypeNode(
+          import_typescript2.default.SyntaxKind.BooleanKeyword
+        );
+      case "any":
+        return this.context.factory.createKeywordTypeNode(
+          import_typescript2.default.SyntaxKind.AnyKeyword
+        );
+      case "unknown":
+        return this.context.factory.createKeywordTypeNode(
+          import_typescript2.default.SyntaxKind.UnknownKeyword
+        );
+      case "never":
+        return this.context.factory.createKeywordTypeNode(
+          import_typescript2.default.SyntaxKind.NeverKeyword
+        );
+      case "undefined":
+        return this.context.factory.createKeywordTypeNode(
+          import_typescript2.default.SyntaxKind.UndefinedKeyword
+        );
+      case "void":
+        return this.context.factory.createKeywordTypeNode(
+          import_typescript2.default.SyntaxKind.VoidKeyword
+        );
+      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, true) : 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) => {
+        if (e.name) {
+          return this.context.factory.createNamedTupleMember(
+            void 0,
+            this.context.factory.createIdentifier(e.name),
+            e.optional ? this.context.factory.createToken(import_typescript2.default.SyntaxKind.QuestionToken) : void 0,
+            this.convertTypeNode(e.type)
+          );
+        }
+        return this.convertTypeNode(e.type);
+      })
+    );
+  }
+  createFunctionDeclarationNode(xlrNode) {
+    return this.context.factory.createFunctionTypeNode(
+      void 0,
+      xlrNode.parameters.map((e) => {
+        return this.context.factory.createParameterDeclaration(
+          void 0,
+          void 0,
+          e.name,
+          e.optional ? this.context.factory.createToken(import_typescript2.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(import_typescript2.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) => ({ name, ...properties[name] })).map(
+        ({ name, node, required }) => this.makeAnnotations(
+          this.context.factory.createPropertySignature(
+            void 0,
+            // modifiers
+            name,
+            required ? void 0 : this.context.factory.createToken(import_typescript2.default.SyntaxKind.QuestionToken),
+            this.convertTypeNode(node)
+          ),
+          node
+        )
+      )
+    ];
+    if (additionalProperties) {
+      propertyNodes.push(
+        this.context.factory.createIndexSignature(
+          void 0,
+          // modifiers
+          [
+            this.context.factory.createParameterDeclaration(
+              void 0,
+              // modifiers
+              void 0,
+              // dotdotdot token
+              "key",
+              void 0,
+              // question token
+              this.context.factory.createKeywordTypeNode(
+                import_typescript2.default.SyntaxKind.StringKeyword
+              )
+            )
+          ],
+          this.convertTypeNode(additionalProperties)
+        )
+      );
+    }
+    return this.context.factory.createTypeLiteralNode(propertyNodes);
+  }
+  createTemplateLiteral(xlrNode) {
+    const templateSegments = xlrNode.format.split(templateTokenize);
+    let templateHead;
+    if (templateSegments.length % 2 === 0) {
+      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(tokenSplit);
+        let regexTemplateType;
+        if (regexSegment === ".*") {
+          regexTemplateType = import_typescript2.default.SyntaxKind.StringKeyword;
+        } else if (regexSegment === "[0-9]*") {
+          regexTemplateType = import_typescript2.default.SyntaxKind.NumberKeyword;
+        } else if (regexSegment === "true|false") {
+          regexTemplateType = import_typescript2.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 import_typescript2.default.addSyntheticLeadingComment(
+      tsNode,
+      import_typescript2.default.SyntaxKind.MultiLineCommentTrivia,
+      comment,
+      true
+    );
+  }
+  createTypeParameters(genericXLRNode) {
+    return genericXLRNode.genericTokens.map((generic) => {
+      return this.context.factory.createTypeParameterDeclaration(
+        void 0,
+        generic.symbol,
+        this.createGenericArgumentNode(generic.constraints),
+        this.createGenericArgumentNode(generic.default)
+      );
+    });
+  }
+  makeInterfaceDeclaration(name, node, generics, heritageClass) {
+    return this.context.factory.createInterfaceDeclaration(
+      this.context.factory.createModifiersFromModifierFlags(
+        import_typescript2.default.ModifierFlags.Export
+      ),
+      this.context.factory.createIdentifier(name),
+      generics,
+      // type parameters
+      heritageClass,
+      // heritage
+      node
+    );
+  }
+  makeTypeDeclaration(name, node, generics) {
+    return this.context.factory.createTypeAliasDeclaration(
+      this.context.factory.createModifiersFromModifierFlags(
+        import_typescript2.default.ModifierFlags.Export
+      ),
+      this.context.factory.createIdentifier(name),
+      generics,
+      // type parameters
+      node
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConversionError,
+  TSWriter,
+  TsConverter
+});
+//# sourceMappingURL=index.cjs.map