@typespec/emitter-framework 0.9.0-dev.7 → 0.9.0-dev.8

package/dist/src/csharp/components/enum/declaration.test.js

@@ -0,0 +1,309 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { Tester } from "#test/test-host.js";
+import { createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { t } from "@typespec/compiler/testing";
+import { beforeEach, expect, it } from "vitest";
+import { Output } from "../../../core/index.js";
+import { EnumDeclaration } from "../../index.js";
+let runner;
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+function Wrapper(props) {
+  const policy = createCSharpNamePolicy();
+  return _$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    namePolicy: policy,
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return props.children;
+            }
+          });
+        }
+      });
+    }
+  });
+}
+it("renders a basic enum declaration", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+      Value3;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            Value1,
+            Value2,
+            Value3
+        }
+    }
+  `);
+});
+it("renders an empty enum declaration", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {}
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+
+        }
+    }
+  `);
+});
+it("can override enum name", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum,
+        name: "CustomEnumName"
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum CustomEnumName
+        {
+            Value1,
+            Value2
+        }
+    }
+  `);
+});
+it("renders an enum with access modifiers", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum,
+        internal: true
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        internal enum TestEnum
+        {
+            Value1,
+            Value2
+        }
+    }
+  `);
+});
+it("renders enum with C# naming conventions", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      value_one;
+      value_two;
+      value_three;
+    }
+  `);
+  expect(_$createComponent(Output, {
+    get program() {
+      return runner.program;
+    },
+    get namePolicy() {
+      return createCSharpNamePolicy();
+    },
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(EnumDeclaration, {
+                type: TestEnum
+              });
+            }
+          });
+        }
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            ValueOne,
+            ValueTwo,
+            ValueThree
+        }
+    }
+  `);
+});
+it("renders enum with single value", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      OnlyValue;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            OnlyValue
+        }
+    }
+  `);
+});
+it("renders enum with numeric-like member names", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value0;
+      Value1;
+      Value10;
+      Value100;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            Value0,
+            Value1,
+            Value10,
+            Value100
+        }
+    }
+  `);
+});
+it("renders multiple enums in the same namespace", async () => {
+  const {
+    TestEnum1,
+    TestEnum2
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum1")} {
+      Value1;
+      Value2;
+    }
+    @test enum ${t.enum("TestEnum2")} {
+      OptionA;
+      OptionB;
+      OptionC;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return [_$createComponent(EnumDeclaration, {
+        type: TestEnum1
+      }), _$createIntrinsic("hbr", {}), _$createComponent(EnumDeclaration, {
+        type: TestEnum2
+      })];
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum1
+        {
+            Value1,
+            Value2
+        }
+        enum TestEnum2
+        {
+            OptionA,
+            OptionB,
+            OptionC
+        }
+    }
+  `);
+});
+it("renders an enum with doc comments", async () => {
+  const {
+    TestEnum
+  } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      @doc("This is value one")
+      Value1;
+      /** This is value two */
+      Value2;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(EnumDeclaration, {
+        type: TestEnum
+      });
+    }
+  })).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            /// <summary>
+            /// This is value one
+            /// </summary>
+            Value1,
+            /// <summary>
+            /// This is value two
+            /// </summary>
+            Value2
+        }
+    }
+  `);
+});

package/dist/src/csharp/components/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./class/declaration.js";
-export * from "./enum-declaration.jsx";
+export * from "./enum/declaration.jsx";
 export * from "./property/property.jsx";
 export * from "./type-expression.jsx";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/csharp/components/index.js

@@ -1,4 +1,4 @@
 export * from "./class/declaration.js";
-export * from "./enum-declaration.js";
+export * from "./enum/declaration.js";
 export * from "./property/property.js";
 export * from "./type-expression.js";

package/dist/src/csharp/components/property/property.test.js

@@ -53,10 +53,10 @@ it("maps prop: string | null to nullable property", async () => {
   })).toRenderTo(`
       namespace TestNamespace
       {
-        class Test
-        {
-          public required string? Prop1 { get; set; }
-        }
+          class Test
+          {
+              public required string? Prop1 { get; set; }
+          }
       }
   `);
 });
@@ -79,11 +79,11 @@ describe("jsonAttributes", () => {
     })).toRenderTo(`
       namespace TestNamespace
       {
-        class Test
-        {
-          [System.Text.Json.JsonPropertyName("prop1")]
-          public required string Prop1 { get; set; }
-        }
+          class Test
+          {
+              [System.Text.Json.JsonPropertyName("prop1")]
+              public required string Prop1 { get; set; }
+          }
       }
   `);
   });
@@ -106,11 +106,11 @@ describe("jsonAttributes", () => {
     })).toRenderTo(`
       namespace TestNamespace
       {
-        class Test
-        {
-          [System.Text.Json.JsonPropertyName("prop_1")]
-          public required string Prop1 { get; set; }
-        }
+          class Test
+          {
+              [System.Text.Json.JsonPropertyName("prop_1")]
+              public required string Prop1 { get; set; }
+          }
       }
   `);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.9.0-dev.7",
+  "version": "0.9.0-dev.8",
   "type": "module",
   "main": "dist/index.js",
   "repository": {
@@ -22,14 +22,17 @@
     }
   },
   "imports": {
-    "#test/*": "./test/*"
+    "#test/*": "./test/*",
+    "#core/*": "./src/core/*",
+    "#csharp/*": "./src/csharp/*",
+    "#typescript/*": "./src/typescript/*"
   },
   "keywords": [],
   "author": "",
   "license": "MIT",
   "description": "",
   "peerDependencies": {
-    "@alloy-js/core": "^0.18.0",
+    "@alloy-js/core": "^0.18.2",
     "@alloy-js/typescript": "^0.18.0",
     "@alloy-js/csharp": "^0.18.0",
     "@typespec/compiler": "^1.1.0",
@@ -39,7 +42,7 @@
   "devDependencies": {
     "@alloy-js/cli": "^0.18.0",
     "@alloy-js/rollup-plugin": "^0.1.0",
-    "@alloy-js/core": "^0.18.0",
+    "@alloy-js/core": "^0.18.2",
     "@alloy-js/typescript": "^0.18.0",
     "@types/minimist": "^1.2.5",
     "@typespec/compiler": "^1.1.0",