--ignore-not-supported, GenericRecords to object, resolve namespaces

Do not throw exception on non supported features.
GenericRecords transforms to object
Namespaces content are parsed

Author: Crusader4Christ

.gitignore

@@ -1,4 +1,5 @@
 dist/
+.idea
 
 # Logs
 logs
@@ -58,3 +59,4 @@ typings/
 
 # dotenv environment variables file
 .env
+

lib/index.ts

@@ -20,6 +20,7 @@ const ignoreNode = "";
 export interface ICompilerOptions {
   format?: "ts" | "js:esm" | "js:cjs"
   ignoreGenerics?: boolean;
+  ignoreNotSupported?: boolean;
   ignoreIndexSignature?: boolean;
   inlineImports?: boolean;
 }
@@ -37,7 +38,7 @@ export class Compiler {
     if (!topNode) {
       throw new Error(`Can't process ${filePath}: ${collectDiagnostics(program)}`);
     }
-    options = {format: defaultFormat, ignoreGenerics: false, ignoreIndexSignature: false, inlineImports: false, ...options}
+    options = {format: defaultFormat, ignoreGenerics: false, ignoreNotSupported: false, ignoreIndexSignature: false, inlineImports: false, ...options}
     return new Compiler(checker, options, topNode).compileNode(topNode);
   }
 
@@ -80,6 +81,12 @@ export class Compiler {
       case ts.SyntaxKind.ExportDeclaration:
       case ts.SyntaxKind.ImportDeclaration:
         return this._compileImportDeclaration(node as ts.ImportDeclaration);
+      case ts.SyntaxKind.ModuleDeclaration:
+        const body: ts.ModuleBody = node["body"];
+        if ("statements" in body) {
+          return body.statements.map(this.compileNode, this).filter(s => s).join("\n\n");
+        }
+        //return this._compileNamespaceDeclaration(node as ts.NamespaceDeclaration);
       case ts.SyntaxKind.SourceFile: return this._compileSourceFile(node as ts.SourceFile);
       case ts.SyntaxKind.AnyKeyword: return '"any"';
       case ts.SyntaxKind.NumberKeyword: return '"number"';
@@ -97,6 +104,12 @@ export class Compiler {
     }
     // Skip top-level statements that we haven't handled.
     if (ts.isSourceFile(node.parent!)) { return ""; }
+    
+    if (this.options.ignoreNotSupported) {
+      console.log(`Node ${ts.SyntaxKind[node.kind]} not supported by ts-interface-builder: ` +
+        node.getText());
+      return node.getText();
+    }
     throw new Error(`Node ${ts.SyntaxKind[node.kind]} not supported by ts-interface-builder: ` +
       node.getText());
   }
@@ -139,6 +152,8 @@ export class Compiler {
       return this.compileNode(node.typeArguments[0]);
     } else if (node.typeName.getText() === "Array") {
       return `t.array(${this.compileNode(node.typeArguments[0])})`;
+    } else if (node.typeName.getText() === "Record") {
+      return '"object"';
     } else if (this.options.ignoreGenerics) {
       return '"any"';
     } else {
@@ -180,8 +195,15 @@ export class Compiler {
   }
   private _compileEnumDeclaration(node: ts.EnumDeclaration): string {
     const name = this.getName(node.name);
-    const members: string[] = node.members.map(m =>
-      `  "${this.getName(m.name)}": ${getTextOfConstantValue(this.checker.getConstantValue(m))},\n`);
+    let counter = 0;
+    const members: string[] = node.members.map(m => {
+      let value = getTextOfConstantValue(this.checker.getConstantValue(m));
+      if (value === "undefined") {
+        value = counter.toString(10);
+        ++counter;
+      }
+      return `  "${this.getName(m.name)}": ${value},\n`
+    });
     this.exportedNames.push(name);
     return this._formatExport(name, `t.enumtype({\n${members.join("")}})`);
   }
@@ -214,6 +236,13 @@ export class Compiler {
   private _compileParenthesizedTypeNode(node: ts.ParenthesizedTypeNode): string {
     return this.compileNode(node.type);
   }
+  // private _compileNamespaceDeclaration(node: ts.NamespaceDeclaration): string {
+  //   if ("statements" in node.body) {
+  //     const name = this.getName(node.name);
+  //     const prefix = node.modifiers.map(n => n.getText()).filter(s => s).join(" ");
+  //     return `${prefix} ${name} {\n${this._compileSourceFileStatements(node.body.statements)}\n}\n`;
+  //   }
+  // }
   private _compileImportDeclaration(node: ts.ImportDeclaration): string {
     if (this.options.inlineImports) {
       const importedSym = this.checker.getSymbolAtLocation(node.moduleSpecifier);
@@ -226,26 +255,27 @@ export class Compiler {
     }
     return '';
   }
-  private _compileSourceFileStatements(node: ts.SourceFile): string {
-    return node.statements.map(this.compileNode, this).filter((s) => s).join("\n\n");
+  private _compileSourceFileStatements(statements: ts.NodeArray<ts.Statement>): string {
+    
+    return statements.map(this.compileNode, this).filter((s) => s).join("\n\n");
   }
   private _compileSourceFile(node: ts.SourceFile): string {
     // for imported source files, skip the wrapper
     if (node !== this.topNode) {
-      return this._compileSourceFileStatements(node);
+      return this._compileSourceFileStatements(node.statements);
     }
     // wrap the top node with a default export
     if (this.options.format === "js:cjs") {
       return `const t = require("ts-interface-checker");\n\n` +
         "module.exports = {\n" +
-        this._compileSourceFileStatements(node) + "\n" +
+        this._compileSourceFileStatements(node.statements) + "\n" +
         "};\n"
     }
     const prefix = `import * as t from "ts-interface-checker";\n` +
                    (this.options.format === "ts" ? "// tslint:disable:object-literal-key-quotes\n" : "") +
                    "\n";
     return prefix +
-      this._compileSourceFileStatements(node) + "\n\n" +
+      this._compileSourceFileStatements(node.statements) + "\n\n" +
       "const exportedTypeSuite" + (this.options.format === "ts" ? ": t.ITypeSuite" : "") + " = {\n" +
       this.exportedNames.map((n) => `  ${n},\n`).join("") +
       "};\n" +
@@ -302,6 +332,7 @@ export function main() {
   .option("--format <format>", `Format to use for output; options are 'ts' (default), 'js:esm', 'js:cjs'`)
   .option("-g, --ignore-generics", `Ignores generics`)
   .option("-i, --ignore-index-signature", `Ignores index signature`)
+  .option("--ignore-not-supported", `Skip all not supported code`)
   .option("--inline-imports", `Traverses the full import tree and inlines all types into output`)
   .option("-s, --suffix <suffix>", `Suffix to append to generated files (default ${defaultSuffix})`, defaultSuffix)
   .option("-o, --outDir <path>", `Directory for output files; same as source file if omitted`)
@@ -317,6 +348,7 @@ export function main() {
   const options: ICompilerOptions = {
     format: commander.format || defaultFormat,
     ignoreGenerics: commander.ignoreGenerics,
+    ignoreNotSupported: commander.ignoreNotSupported,
     ignoreIndexSignature: commander.ignoreIndexSignature,
     inlineImports: commander.inlineImports,
   };

lib/macro.ts

@@ -48,8 +48,8 @@ const macroHandler: MacroHandler = (params) => {
 
   // Begin mutations
 
-  programPath.scope.rename(tsInterfaceCheckerIdentifier);
-  programPath.scope.rename(onceIdentifier);
+  programPath?.scope.rename(tsInterfaceCheckerIdentifier);
+  programPath?.scope.rename(onceIdentifier);
   toReplace.forEach(({ callPath, id }) => {
     scopeRenameRecursive(callPath.scope, id);
   });
@@ -127,7 +127,7 @@ const macroHandler: MacroHandler = (params) => {
   }
 
   function prependProgramStatement(statement: types.Statement) {
-    (programPath.get("body.0") as NodePath).insertBefore(statement);
+    (programPath?.get("body.0") as NodePath).insertBefore(statement);
   }
 };
 

test/fixtures/namespaces-ti.ts

@@ -0,0 +1,20 @@
+import * as t from "ts-interface-checker";
+// tslint:disable:object-literal-key-quotes
+
+export const SomeInterface = t.iface([], {
+  "foo": "number",
+});
+
+export const SomeEnum = t.enumtype({
+  "Foo": 0,
+  "Boo": 1,
+});
+
+export const SomeAlias = t.name("number");
+
+const exportedTypeSuite: t.ITypeSuite = {
+  SomeInterface,
+  SomeEnum,
+  SomeAlias,
+};
+export default exportedTypeSuite;

test/fixtures/namespaces.ts

@@ -0,0 +1,8 @@
+export declare namespace TestNameSpace {
+  export interface SomeInterface {
+    foo: number
+  }
+  export enum SomeEnum { Foo, Boo }
+  
+  export type SomeAlias = number;
+}

test/test_index.ts

@@ -11,7 +11,13 @@ describe("ts-interface-builder", () => {
     const expected = await readFile(join(fixtures, "sample-ti.ts"), {encoding: "utf8"});
     assert.deepEqual(output, expected);
   });
-
+  
+  it("should compile namespace to runtime code", async () => {
+    const output = await Compiler.compile(join(fixtures, "namespaces.ts"), {ignoreNotSupported: true});
+    const expected = await readFile(join(fixtures, "namespaces-ti.ts"), {encoding: "utf8"});
+    assert.deepEqual(output, expected);
+  });
+  
   it("should strip out promises", async () => {
     const output = await Compiler.compile(join(fixtures, "promises.ts"));
     const expected = await readFile(join(fixtures, "promises-ti.ts"), {encoding: "utf8"});

tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
-    "target": "es6",
-    "strict": true,
+    "target": "es2018",
+    "strict": false,
     "noUnusedLocals": true,
     "module": "commonjs",
     "baseUrl": ".",