@typespec/emitter-framework 0.9.0-dev.0 → 0.9.0-dev.10

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

@@ -0,0 +1,5 @@
+export * from "./class/declaration.js";
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC"}

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

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

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

@@ -0,0 +1,15 @@
+import { type Children } from "@alloy-js/core";
+import { type ModelProperty } from "@typespec/compiler";
+export interface PropertyProps {
+    type: ModelProperty;
+    /** If set the property will add the json serialization attributes(using System.Text.Json). */
+    jsonAttributes?: boolean;
+}
+/**
+ * Create a C# property declaration from a TypeSpec property type.
+ */
+export declare function Property(props: PropertyProps): Children;
+export interface JsonNameAttributeProps {
+    type: ModelProperty;
+}
+//# sourceMappingURL=property.d.ts.map

package/dist/src/csharp/components/property/property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.d.ts","sourceRoot":"","sources":["../../../../../src/csharp/components/property/property.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C,OAAO,EAAE,KAAK,aAAa,EAAiC,MAAM,oBAAoB,CAAC;AAKvF,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,aAAa,CAAC;IACpB,8FAA8F;IAC9F,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,QAAQ,CAiBvD;AAED,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,aAAa,CAAC;CACrB"}

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

@@ -0,0 +1,85 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import * as cs from "@alloy-js/csharp";
+import { Attribute } from "@alloy-js/csharp";
+import { resolveEncodedName } from "@typespec/compiler";
+import { useTsp } from "../../../core/index.js";
+import { TypeExpression } from "../type-expression.js";
+import { getDocComments } from "../utils/doc-comments.js";
+/**
+ * Create a C# property declaration from a TypeSpec property type.
+ */
+export function Property(props) {
+  const result = preprocessPropertyType(props.type.type);
+  const {
+    $
+  } = useTsp();
+  return _$createComponent(cs.Property, {
+    get name() {
+      return props.type.name;
+    },
+    get type() {
+      return _$createComponent(TypeExpression, {
+        get type() {
+          return result.type;
+        }
+      });
+    },
+    "public": true,
+    get required() {
+      return !props.type.optional;
+    },
+    get nullable() {
+      return result.nullable;
+    },
+    get doc() {
+      return getDocComments($, props.type);
+    },
+    get attributes() {
+      return _$memo(() => !!props.jsonAttributes)() ? [_$createComponent(JsonNameAttribute, {
+        get type() {
+          return props.type;
+        }
+      })] : undefined;
+    },
+    get: true,
+    set: true
+  });
+}
+function JsonNameAttribute(props) {
+  const {
+    program
+  } = useTsp();
+  const jsonName = resolveEncodedName(program, props.type, "application/json");
+  return _$createComponent(Attribute, {
+    name: "System.Text.Json.JsonPropertyName",
+    get args() {
+      return [JSON.stringify(jsonName)];
+    }
+  });
+}
+function preprocessPropertyType(type) {
+  const {
+    $
+  } = useTsp();
+  if (type.kind === "Union") {
+    const variants = type.variants;
+    const nonNullVariant = [...variants.values()].find(v => v.type !== $.intrinsic.null);
+    const nullVariant = [...variants.values()].find(v => v.type !== $.intrinsic.null);
+    if (nonNullVariant && nullVariant && variants.size === 2) {
+      return {
+        type: nonNullVariant.type,
+        nullable: true
+      };
+    } else {
+      return {
+        type,
+        nullable: false
+      };
+    }
+  } else {
+    return {
+      type,
+      nullable: false
+    };
+  }
+}

package/dist/src/csharp/components/property/property.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=property.test.d.ts.map

package/dist/src/csharp/components/property/property.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.test.d.ts","sourceRoot":"","sources":["../../../../../src/csharp/components/property/property.test.tsx"],"names":[],"mappings":""}

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

@@ -0,0 +1,117 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Tester } from "#test/test-host.js";
+import { ClassDeclaration, createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { t } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
+import { Output } from "../../../core/components/output.js";
+import { Property } from "./property.js";
+let tester;
+beforeEach(async () => {
+  tester = await Tester.createInstance();
+});
+function Wrapper(props) {
+  const policy = createCSharpNamePolicy();
+  return _$createComponent(Output, {
+    get program() {
+      return tester.program;
+    },
+    namePolicy: policy,
+    get children() {
+      return _$createComponent(Namespace, {
+        name: "TestNamespace",
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.cs",
+            get children() {
+              return _$createComponent(ClassDeclaration, {
+                name: "Test",
+                get children() {
+                  return props.children;
+                }
+              });
+            }
+          });
+        }
+      });
+    }
+  });
+}
+it("maps prop: string | null to nullable property", async () => {
+  const {
+    prop1
+  } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}: string | null;
+    }
+  `);
+  expect(_$createComponent(Wrapper, {
+    get children() {
+      return _$createComponent(Property, {
+        type: prop1
+      });
+    }
+  })).toRenderTo(`
+      namespace TestNamespace
+      {
+          class Test
+          {
+              public required string? Prop1 { get; set; }
+          }
+      }
+  `);
+});
+describe("jsonAttributes", () => {
+  it("adds [JsonNameAttribute]", async () => {
+    const {
+      prop1
+    } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+    expect(_$createComponent(Wrapper, {
+      get children() {
+        return _$createComponent(Property, {
+          type: prop1,
+          jsonAttributes: true
+        });
+      }
+    })).toRenderTo(`
+      namespace TestNamespace
+      {
+          class Test
+          {
+              [System.Text.Json.JsonPropertyName("prop1")]
+              public required string Prop1 { get; set; }
+          }
+      }
+  `);
+  });
+  it("adds [JsonNameAttribute] respecting encodedName", async () => {
+    const {
+      prop1
+    } = await tester.compile(t.code`
+    model TestModel {
+      @encodedName("application/json", "prop_1")
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+    expect(_$createComponent(Wrapper, {
+      get children() {
+        return _$createComponent(Property, {
+          type: prop1,
+          jsonAttributes: true
+        });
+      }
+    })).toRenderTo(`
+      namespace TestNamespace
+      {
+          class Test
+          {
+              [System.Text.Json.JsonPropertyName("prop_1")]
+              public required string Prop1 { get; set; }
+          }
+      }
+  `);
+  });
+});

package/dist/src/csharp/components/type-expression.d.ts

@@ -0,0 +1,11 @@
+import { type Children } from "@alloy-js/core";
+import { type IntrinsicType, type Scalar, type Type } from "@typespec/compiler";
+import type { Typekit } from "@typespec/compiler/typekit";
+export interface TypeExpressionProps {
+    type: Type;
+}
+export declare function TypeExpression(props: TypeExpressionProps): Children;
+declare const intrinsicNameToCSharpType: Map<string, string | null>;
+export declare function getScalarIntrinsicExpression($: Typekit, type: Scalar | IntrinsicType): string | null;
+export { intrinsicNameToCSharpType };
+//# sourceMappingURL=type-expression.d.ts.map

package/dist/src/csharp/components/type-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-expression.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/type-expression.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAQ,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAe,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAK1D,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,GAAG,QAAQ,CAgBnE;AAED,QAAA,MAAM,yBAAyB,4BAqC7B,CAAC;AAEH,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,OAAO,EACV,IAAI,EAAE,MAAM,GAAG,aAAa,GAC3B,MAAM,GAAG,IAAI,CAoBf;AA0BD,OAAO,EAAE,yBAAyB,EAAE,CAAC"}