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

package/bin/run

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const converter = require("../dist/index.mjs")
+const input = process.argv[2]
+const output = process.argv[3]
+const primitives = process.argv[4].split(',')
+console.log(primitives)
+console.log(typeof primitives)
+converter.converter(input, output, primitives)

package/dist/cjs/index.cjs

@@ -32,11 +32,13 @@ var src_exports = {};
 __export(src_exports, {
   ConversionError: () => ConversionError,
   TSWriter: () => TSWriter,
-  TsConverter: () => TsConverter
+  TsConverter: () => TsConverter,
+  converter: () => converter,
+  writeManifest: () => writeManifest
 });
 module.exports = __toCommonJS(src_exports);
 
-// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts-to-xlr.ts
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/ts-to-xlr.ts
 var import_typescript = __toESM(require("typescript"));
 var import_xlr_utils = require("@xlr-lib/xlr-utils");
 
@@ -51,10 +53,16 @@ var ConversionError = class _ConversionError extends Error {
   }
 };
 
-// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts-to-xlr.ts
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/ts-to-xlr.ts
 function isMappedTypeNode(x) {
   return ["Pick", "Omit", "Required", "Partial", "Exclude"].includes(x);
 }
+function getPropertyNameText(name) {
+  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return name.getText();
+}
 var AnyTypeNode = {
   type: "any"
 };
@@ -364,6 +372,15 @@ var TsConverter = class {
           or: [...elements.elementTypes.map((element) => element.type)]
         };
       }
+      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 solve IndexedAccessType: ${node.getFullText()}`
       );
@@ -390,6 +407,9 @@ var TsConverter = class {
     );
   }
   tsLiteralToType(node) {
+    if (import_typescript.default.isAsExpression(node)) {
+      return this.tsLiteralToType(node.expression);
+    }
     if (import_typescript.default.isNumericLiteral(node)) {
       return {
         type: "number",
@@ -449,8 +469,8 @@ var TsConverter = class {
         additionalProperties: false
       };
       node.properties.forEach((property) => {
-        if (import_typescript.default.isPropertyAssignment(property)) {
-          const propertyName = property.name?.getText();
+        if (import_typescript.default.isPropertyAssignment(property) && property.name) {
+          const propertyName = getPropertyNameText(property.name);
           ret.properties[propertyName] = {
             required: true,
             node: this.tsLiteralToType(property.initializer)
@@ -545,7 +565,7 @@ var TsConverter = class {
     };
     node.members.forEach((member) => {
       if (import_typescript.default.isPropertySignature(member) && member.type) {
-        const name = member.name.getText();
+        const name = getPropertyNameText(member.name);
         ret.properties[name] = {
           required: !(0, import_xlr_utils.isOptionalProperty)(member),
           node: {
@@ -717,8 +737,10 @@ var TsConverter = class {
   }
   resolveRefNode(node) {
     let refName;
+    let namespace;
     if (node.typeName.kind === import_typescript.default.SyntaxKind.QualifiedName) {
-      refName = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;
+      namespace = node.typeName.left.getText();
+      refName = node.typeName.right.getText();
     } else {
       refName = node.typeName.text;
     }
@@ -764,21 +786,36 @@ var TsConverter = class {
     if (isMappedTypeNode(refName)) {
       return this.makeMappedType(refName, node);
     }
+    if ((0, import_xlr_utils.isTypeScriptLibType)(node, this.context.typeChecker)) {
+      return this.makeBasicRefNode(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 convertedType = this.convertTopLevelNode(typeInfo.declaration);
         const genericParams = typeInfo.declaration.typeParameters;
         const genericArgs = node.typeArguments;
-        if (genericType && genericParams && genericArgs) {
-          return this.resolveGenerics(
-            genericType,
+        if (convertedType && genericParams && genericArgs) {
+          const resolvedType = this.resolveGenerics(
+            convertedType,
             genericParams,
             genericArgs
           );
+          if ("name" in resolvedType && genericArgs.length > 0) {
+            const argsText = Array.from(genericArgs).map((arg) => arg.getText()).join(", ");
+            const baseName = namespace ? `${namespace}.${refName}` : refName;
+            return { ...resolvedType, name: `${baseName}<${argsText}>` };
+          }
+          if (namespace && "name" in resolvedType) {
+            return { ...resolvedType, name: `${namespace}.${refName}` };
+          }
+          return resolvedType;
         }
-        if (genericType) {
-          return genericType;
+        if (convertedType) {
+          if (namespace && "name" in convertedType) {
+            return { ...convertedType, name: `${namespace}.${refName}` };
+          }
+          return convertedType;
         }
       }
       this.context.throwError(
@@ -838,8 +875,14 @@ var TsConverter = class {
       });
     }
     let ref;
-    if (node.pos === -1 && import_typescript.default.isTypeReferenceNode(node) && import_typescript.default.isIdentifier(node.typeName)) {
-      ref = node.typeName.text;
+    if (import_typescript.default.isTypeReferenceNode(node)) {
+      if (node.typeName.kind === import_typescript.default.SyntaxKind.QualifiedName) {
+        ref = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;
+      } else if (node.pos === -1 && import_typescript.default.isIdentifier(node.typeName)) {
+        ref = node.typeName.text;
+      } else {
+        ref = node.getText();
+      }
     } else {
       ref = node.getText();
     }
@@ -852,7 +895,7 @@ var TsConverter = class {
   }
 };
 
-// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/xlr-to-ts.ts
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/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;
@@ -1280,10 +1323,74 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
     );
   }
 };
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/helpers/converter.ts
+var import_typescript3 = __toESM(require("typescript"));
+var import_path2 = __toESM(require("path"));
+var import_fs2 = __toESM(require("fs"));
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/helpers/writeManifest.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+function replacer(key, value) {
+  if (value instanceof Map) {
+    return Object.fromEntries(value.entries());
+  }
+  return value;
+}
+function writeManifest(capabilities, outputDirectory) {
+  const jsonManifest = JSON.stringify(capabilities, replacer, 4);
+  import_fs.default.writeFileSync(import_path.default.join(outputDirectory, "manifest.json"), jsonManifest);
+  const tsManifestFile = `${[...capabilities.capabilities?.values() ?? []].flat(2).map((capability) => {
+    return `const ${capability} = require("./${capability}.json")`;
+  }).join("\n")}
+
+    module.exports = {
+      "pluginName": "${capabilities.pluginName}",
+      "capabilities": {
+        ${[...capabilities.capabilities?.entries() ?? []].map(([capabilityName, provides]) => {
+    return `"${capabilityName}":[${provides.join(",")}],`;
+  }).join("\n		")}
+      },
+      "customPrimitives": [
+        ${[capabilities.customPrimitives?.map((i) => `"${i}"`).join(",") ?? ""]}
+      ]
+    }
+`;
+  import_fs.default.writeFileSync(import_path.default.join(outputDirectory, "manifest.js"), tsManifestFile);
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/helpers/converter.ts
+function converter(sourceFile, outputDirectory, customPrimitives, tsOptions = {}) {
+  const program = import_typescript3.default.createProgram([sourceFile], tsOptions);
+  import_fs2.default.mkdirSync(outputDirectory, { recursive: true });
+  const checker = program.getTypeChecker();
+  const converter2 = new TsConverter(checker, customPrimitives);
+  const convertedTypes = converter2.convertSourceFile(
+    program.getSourceFiles()[0]
+  );
+  if (convertedTypes.data.types.length === 0) {
+    return void 0;
+  }
+  convertedTypes.data.types.forEach((type) => {
+    import_fs2.default.writeFileSync(
+      import_path2.default.join(outputDirectory, `${type.name}.json`),
+      JSON.stringify(type, void 0, 4)
+    );
+  });
+  const manifest = {
+    pluginName: "Types",
+    capabilities: /* @__PURE__ */ new Map([["Types", convertedTypes.convertedTypes]]),
+    customPrimitives
+  };
+  writeManifest(manifest, outputDirectory);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConversionError,
   TSWriter,
-  TsConverter
+  TsConverter,
+  converter,
+  writeManifest
 });
 //# sourceMappingURL=index.cjs.map