Improvements: module export, support for negative enum values, better support for generic inheritance

Author: engthiago

src/typesharp-ts/dist/main.js

@@ -9,5 +9,5 @@ await esbuild.build({
     platform: 'node',
     format: 'esm',
     entryPoints: [ './src/main.ts' ],
-    outdir: './dist'
+    outfile: './dist/main.mjs'
 });

src/typesharp-ts/dist/main.mjs

@@ -2,7 +2,7 @@
   "name": "@onboxdesign/onbox-typesharp",
   "version": "0.0.4",
   "description": "Commandline app to convert CSharp data models into Typescript",
-  "main": "./dist/main.js",
+  "main": "./dist/main.mjs",
   "types": "./dist/main.d.ts",
   "type": "module",
   "scripts": {

src/typesharp-ts/esbuild.mjs

@@ -1,4 +1,4 @@
-import test from "node:test";
+import { test } from "vitest";
 import { strict as assert } from "node:assert";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -72,6 +72,27 @@ namespace Demo {
   assert.match(person, /score: 1\.2 \| 2\.2;/);
 });
 
+test("supports signed enum values", () => {
+  const generated = new Map(generate([
+    parseSourceFile(
+      "status.cs",
+      `
+public enum Status {
+  Invalid = -1,
+  None = 0,
+  Valid = +1,
+  Next
+}`,
+    ),
+  ]).map((file) => [file.name, file.text]));
+
+  const status = generated.get("Status.ts")!;
+  assert.match(status, /Invalid = -1,/);
+  assert.match(status, /None = 0,/);
+  assert.match(status, /Valid = 1,/);
+  assert.match(status, /Next = 2,/);
+});
+
 test("supports configured Record dictionaries, readonly properties, quotes, and semicolons", () => {
   const generated = new Map(generate([
     parseSourceFile(
@@ -116,10 +137,52 @@ public class Person {
   assert.match(person, /name: string;/);
 });
 
+test("supports interfaces and multiple implemented generic interfaces", () => {
+  const generated = new Map(generate([
+    parseSourceFile(
+      "engineering.cs",
+      `
+using System.Collections.Generic;
+
+namespace Shedmate.Designer.Models.Engineering.FEM
+{
+    public class EngineeringResult : IOptionalError<List<string>>, IOptionalWarning<List<string>>
+    {
+        public bool Done { get; set; }
+        public bool Success { get; set ; }
+        public List<string> Error { get; set; }
+        public List<string> Warning { get; set; }
+        public string Critical { get; set; }
+    }
+
+    public interface IOptionalError<T>
+    {
+        public bool Success { get; set; }
+        public T Error { get; set;}
+    }
+
+    public interface IOptionalWarning<T>
+    {
+        public bool Success { get; set; }
+        public T Warning { get; set;}
+    }
+}`,
+    ),
+  ]).map((file) => [file.name, file.text]));
+
+  assert.match(
+    generated.get("EngineeringResult.ts")!,
+    /export interface EngineeringResult extends IOptionalError<string\[\]>, IOptionalWarning<string\[\]> \{/,
+  );
+  assert.match(generated.get("IOptionalError.ts")!, /export interface IOptionalError<T> \{/);
+  assert.match(generated.get("IOptionalError.ts")!, /error: T;/);
+  assert.match(generated.get("IOptionalWarning.ts")!, /warning: T;/);
+});
+
 test("generates sample outputs for current golden DTOs", async () => {
   const temp = await mkdtemp(join(tmpdir(), "typesharp-"));
   try {
-    const root = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+    const root = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
     await convert({
       source: join(root, "samples/SampleModels"),
       fileFilter: "*.cs",

src/typesharp-ts/package.json

@@ -37,6 +37,7 @@ export interface ClassNode {
   namespaceName?: string;
   typeParameters: string[];
   baseType?: TypeReferenceNode;
+  baseTypes?: TypeReferenceNode[];
   properties: PropertyNode[];
   attributes: AttributeNode[];
   leadingComments: CommentTrivia[];

src/typesharp-ts/spec/node_test.ts

@@ -78,7 +78,10 @@ function generateClass(node: ClassNode, typeMap: TypeMap, options: Required<Gene
   }
   lines.push("");
   const typeParams = node.typeParameters.length > 0 ? `<${node.typeParameters.join(", ")}>` : "";
-  const base = node.baseType ? ` extends ${toTypeScriptType(node.baseType, node, typeMap, options)}` : "";
+  const baseTypes = node.baseTypes ?? (node.baseType ? [node.baseType] : []);
+  const base = baseTypes.length > 0
+    ? ` extends ${baseTypes.map((type) => toTypeScriptType(type, node, typeMap, options)).join(", ")}`
+    : "";
   const readonlyClass = options.readonlyProperties || hasAttribute(node.attributes, "Readonly") ||
     hasAttribute(node.attributes, "ReadOnly") || hasAttribute(node.attributes, "ReadonlyProperties");
   lines.push(`export interface ${node.name}${typeParams}${base} {`);
@@ -115,7 +118,7 @@ function collectImports(node: ClassNode, typeMap: TypeMap): string[] {
     }
     for (const arg of type.args) visit(arg);
   };
-  if (node.baseType) visit(node.baseType);
+  for (const baseType of node.baseTypes ?? (node.baseType ? [node.baseType] : [])) visit(baseType);
   for (const prop of node.properties) visit(prop.type);
   return [...imports];
 }

src/typesharp-ts/src/ast.ts

@@ -65,7 +65,7 @@ class Parser {
 
       if (
         attributes.length > 0 || this.isText("public") || this.isText("partial") || this.isText("class") ||
-        this.isText("enum")
+        this.isText("interface") || this.isText("enum")
       ) {
         declarations.push(...this.parseDeclaration(undefined, attributes));
         continue;
@@ -83,7 +83,11 @@ class Parser {
     this.matchText("partial");
 
     if (this.matchText("class")) {
-      return [this.parseClass(namespaceName, attributes, leadingComments)];
+      return [this.parseClass(namespaceName, attributes, leadingComments, "class")];
+    }
+
+    if (this.matchText("interface")) {
+      return [this.parseClass(namespaceName, attributes, leadingComments, "interface")];
     }
 
     if (this.matchText("enum")) {
@@ -99,11 +103,11 @@ class Parser {
     namespaceName: string | undefined,
     attributes: AttributeNode[],
     leadingComments: CommentTrivia[],
+    declarationKind: "class" | "interface",
   ): ClassNode {
-    const name = this.expectIdentifier("Expected class name").text;
+    const name = this.expectIdentifier(`Expected ${declarationKind} name`).text;
     const typeParameters = this.parseTypeParameters();
-    let baseType: TypeReferenceNode | undefined;
-    if (this.matchText(":")) baseType = this.parseTypeReference();
+    const baseTypes = this.parseBaseTypes();
     this.expectText("{");
     const properties: PropertyNode[] = [];
 
@@ -115,7 +119,7 @@ class Parser {
         continue;
       }
 
-      if (this.isText("class") || this.isText("enum")) {
+      if (this.isText("class") || this.isText("interface") || this.isText("enum")) {
         this.skipUnsupportedMember("Nested type declarations are not supported");
         continue;
       }
@@ -150,14 +154,22 @@ class Parser {
       name,
       namespaceName,
       typeParameters,
-      baseType,
+      baseType: baseTypes[0],
+      baseTypes,
       properties,
       attributes,
       leadingComments,
       trailingComments: this.previous().trailingComments,
     };
   }
 
+  private parseBaseTypes(): TypeReferenceNode[] {
+    const baseTypes: TypeReferenceNode[] = [];
+    if (!this.matchText(":")) return baseTypes;
+    do baseTypes.push(this.parseTypeReference()); while (this.matchText(","));
+    return baseTypes;
+  }
+
   private parseEnum(
     namespaceName: string | undefined,
     attributes: AttributeNode[],
@@ -172,8 +184,7 @@ class Parser {
       const token = this.expectIdentifier("Expected enum member name");
       let value: number | undefined;
       if (this.matchText("=")) {
-        const valueToken = this.expect("number", "Expected enum member numeric value");
-        value = Number(valueToken.text);
+        value = this.parseEnumNumericValue();
         nextImplicitValue = value + 1;
       } else {
         value = nextImplicitValue++;
@@ -198,6 +209,12 @@ class Parser {
     };
   }
 
+  private parseEnumNumericValue(): number {
+    const sign = this.matchText("-") ? -1 : this.matchText("+") ? 1 : 1;
+    const valueToken = this.expect("number", "Expected enum member numeric value");
+    return sign * Number(valueToken.text);
+  }
+
   private parseAttributes(): AttributeNode[] {
     const attributes: AttributeNode[] = [];
     while (this.matchText("[")) {