@alloy-js/csharp 0.18.0-dev.9 → 0.19.0-dev.0

package/dist/test/{class.test.js → class-declaration.test.js}

@@ -1,9 +1,11 @@
 import { createComponent as _$createComponent, mergeProps as _$mergeProps, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
 import * as core from "@alloy-js/core";
+import { List, refkey } from "@alloy-js/core";
 import * as coretest from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
+import { Attribute } from "../src/components/attributes/attributes.js";
 import * as csharp from "../src/index.js";
-import { ClassDeclaration } from "../src/index.js";
+import { ClassDeclaration, ClassMember, Property, SourceFile } from "../src/index.js";
 import * as utils from "./utils.js";
 it("declares class with no members", () => {
   expect(_$createComponent(utils.TestNamespace, {
@@ -58,6 +60,45 @@ describe("modifiers", () => {
     `);
   });
 });
+describe("base", () => {
+  it("define base class", () => {
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(csharp.ClassDeclaration, {
+          name: "TestClass",
+          baseType: "Foo"
+        });
+      }
+    })).toRenderTo(`
+        class TestClass : Foo;
+    `);
+  });
+  it("define multiple interface types", () => {
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(csharp.ClassDeclaration, {
+          name: "TestClass",
+          interfaceTypes: ["Foo", "Bar"]
+        });
+      }
+    })).toRenderTo(`
+        class TestClass : Foo, Bar;
+    `);
+  });
+  it("define base class and multiple interface types", () => {
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(csharp.ClassDeclaration, {
+          name: "TestClass",
+          baseType: "BaseClass",
+          interfaceTypes: ["Foo", "Bar"]
+        });
+      }
+    })).toRenderTo(`
+        class TestClass : BaseClass, Foo, Bar;
+    `);
+  });
+});
 it("declares class with some members", () => {
   const res = utils.toSourceText(_$createComponent(csharp.ClassDeclaration, {
     "public": true,
@@ -212,41 +253,86 @@ it("uses refkeys for members, params, and return type", () => {
     }
   `);
 });
-it("declares class with generic parameters", () => {
-  const typeParameters = {
-    T: core.refkey(),
-    U: core.refkey()
-  };
-  const res = utils.toSourceText(_$createComponent(csharp.ClassDeclaration, {
-    "public": true,
-    name: "TestClass",
-    typeParameters: typeParameters,
-    get children() {
-      return [_$createComponent(csharp.ClassMember, {
-        "public": true,
-        name: "memberOne",
-        get type() {
-          return typeParameters.T;
-        }
-      }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassMember, {
-        "private": true,
-        name: "memberTwo",
-        get type() {
-          return typeParameters.U;
-        }
-      }), ";"];
-    }
-  }));
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
+describe("with type parameters", () => {
+  it("reference parameters", () => {
+    const typeParameters = [{
+      name: "T",
+      refkey: refkey()
+    }, {
+      name: "U",
+      refkey: refkey()
+    }];
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(SourceFile, {
+          path: "Test.cs",
+          get children() {
+            return _$createComponent(ClassDeclaration, {
+              "public": true,
+              name: "TestClass",
+              typeParameters: typeParameters,
+              get children() {
+                return _$createComponent(List, {
+                  get children() {
+                    return [_$createComponent(Property, {
+                      name: "PropA",
+                      get type() {
+                        return typeParameters[0].refkey;
+                      },
+                      get: true,
+                      set: true
+                    }), _$createComponent(Property, {
+                      name: "PropB",
+                      get type() {
+                        return typeParameters[1].refkey;
+                      },
+                      get: true,
+                      set: true
+                    })];
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    })).toRenderTo(`
+      namespace TestCode
+      {
         public class TestClass<T, U>
         {
-            public T MemberOne;
-            private U memberTwo;
+          T PropA { get; set; }
+          U PropB { get; set; }
         }
-    }
-  `);
+      }
+    `);
+  });
+  it("defines with constraints", () => {
+    const typeParameters = [{
+      name: "T",
+      constraints: "IFoo"
+    }, {
+      name: "U",
+      constraints: "IBar"
+    }];
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(ClassDeclaration, {
+          "public": true,
+          name: "TestClass",
+          typeParameters: typeParameters,
+          children: "// Body"
+        });
+      }
+    })).toRenderTo(`
+      public class TestClass<T, U>
+        where T : IFoo
+        where U : IBar
+      {
+        // Body
+      }
+    `);
+  });
 });
 it("declares class with invalid members", () => {
   const decl = _$createComponent(csharp.ClassDeclaration, {
@@ -350,4 +436,46 @@ it("specify doc comment", () => {
     /// This is a test
     class Test;
   `);
+});
+it("supports class member doc comments", () => {
+  expect(_$createComponent(utils.TestNamespace, {
+    get children() {
+      return _$createComponent(ClassDeclaration, {
+        name: "Test",
+        doc: "This is a test",
+        get children() {
+          return _$createComponent(ClassMember, {
+            name: "Member",
+            "public": true,
+            type: "int",
+            doc: "This is a member"
+          });
+        }
+      });
+    }
+  })).toRenderTo(`
+    /// This is a test
+    class Test
+    {
+      /// This is a member
+      public int Member
+    }
+  `);
+});
+it("specify attributes", () => {
+  expect(_$createComponent(utils.TestNamespace, {
+    get children() {
+      return _$createComponent(ClassDeclaration, {
+        name: "Test",
+        get attributes() {
+          return [_$createComponent(Attribute, {
+            name: "Test"
+          })];
+        }
+      });
+    }
+  })).toRenderTo(`
+    [Test]
+    class Test;
+  `);
 });

package/dist/test/project-directory.test.d.ts

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

package/dist/test/project-directory.test.d.ts.map

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