@alloy-js/csharp 0.18.0-dev.23 → 0.18.0-dev.3

package/dist/src/name-policy.js

@@ -11,11 +11,9 @@ export function createCSharpNamePolicy() {
       case "enum":
       case "enum-member":
       case "interface":
-      case "record":
       case "class-member-public":
       case "class-method":
       case "type-parameter":
-      case "class-property":
         return changecase.pascalCase(name);
       case "constant":
         return changecase.constantCase(name);

package/dist/test/class-method.test.js

@@ -1,11 +1,11 @@
-import { memo as _$memo, createComponent as _$createComponent, mergeProps as _$mergeProps } from "@alloy-js/core/jsx-runtime";
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
-import { ClassDeclaration, ClassMethod } from "../src/index.js";
+import { Class, ClassMethod } from "../src/index.js";
 import { TestNamespace } from "./utils.js";
 const Wrapper = props => _$createComponent(TestNamespace, {
   get children() {
-    return _$createComponent(ClassDeclaration, {
-      "public": true,
+    return _$createComponent(Class, {
+      accessModifier: "public",
       name: "TestClass",
       get children() {
         return props.children;
@@ -18,11 +18,10 @@ describe("modifiers", () => {
     it.each(["public", "private", "protected", "internal"])("%s", accessModifier => {
       expect(_$createComponent(Wrapper, {
         get children() {
-          return _$createComponent(ClassMethod, _$mergeProps({
-            [accessModifier]: true
-          }, {
+          return _$createComponent(ClassMethod, {
+            accessModifier: accessModifier,
             name: "MethodOne"
-          }));
+          });
         }
       })).toRenderTo(`
         public class TestClass
@@ -36,11 +35,10 @@ describe("modifiers", () => {
     it.each(["static", "virtual", "sealed"])("%s", methodModifier => {
       expect(_$createComponent(Wrapper, {
         get children() {
-          return _$createComponent(ClassMethod, _$mergeProps({
-            [methodModifier]: true
-          }, {
+          return _$createComponent(ClassMethod, {
+            methodModifier: methodModifier,
             name: "MethodOne"
-          }));
+          });
         }
       })).toRenderTo(`
         public class TestClass
@@ -53,7 +51,7 @@ describe("modifiers", () => {
       expect(_$createComponent(Wrapper, {
         get children() {
           return _$createComponent(ClassMethod, {
-            abstract: true,
+            methodModifier: "abstract",
             name: "MethodOne"
           });
         }
@@ -86,8 +84,8 @@ describe("modifiers", () => {
         return _$createComponent(ClassMethod, {
           async: true,
           returns: "Task",
-          "public": true,
-          abstract: true,
+          accessModifier: "public",
+          methodModifier: "abstract",
           name: "MethodOne"
         });
       }
@@ -124,7 +122,7 @@ it("defines params and return type", () => {
   const res = _$createComponent(Wrapper, {
     get children() {
       return _$createComponent(ClassMethod, {
-        "public": true,
+        accessModifier: "public",
         name: "MethodOne",
         parameters: params,
         returns: "string"
@@ -137,25 +135,4 @@ it("defines params and return type", () => {
       public string MethodOne(int intParam, string stringParam) {}
     }
   `);
-});
-it("specify doc comment", () => {
-  expect(_$createComponent(TestNamespace, {
-    get children() {
-      return _$createComponent(ClassDeclaration, {
-        name: "Test",
-        get children() {
-          return _$createComponent(ClassMethod, {
-            name: "Method",
-            doc: "This is a test"
-          });
-        }
-      });
-    }
-  })).toRenderTo(`
-    class Test
-    {
-      /// This is a test
-      void Method() {}
-    }
-  `);
 });

package/dist/test/class.test.d.ts

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

package/dist/test/class.test.d.ts.map

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

package/dist/test/class.test.js

@@ -0,0 +1,298 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import * as core from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import * as csharp from "../src/index.js";
+import * as utils from "./utils.js";
+it("declares class with no members", () => {
+  const res = utils.toSourceText(_$createComponent(csharp.Class, {
+    accessModifier: "public",
+    name: "TestClass"
+  }));
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass;
+    }
+  `);
+});
+it("declares class with some members", () => {
+  const res = utils.toSourceText(_$createComponent(csharp.Class, {
+    accessModifier: "public",
+    name: "TestClass",
+    get children() {
+      return _$createComponent(core.StatementList, {
+        get children() {
+          return [_$createComponent(csharp.ClassMember, {
+            accessModifier: "public",
+            name: "MemberOne",
+            type: "string"
+          }), _$createComponent(csharp.ClassMember, {
+            accessModifier: "private",
+            name: "MemberTwo",
+            type: "int"
+          })];
+        }
+      });
+    }
+  }));
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            public string MemberOne;
+            private int memberTwo;
+        }
+    }
+  `);
+});
+it("declares class with some methods", () => {
+  const res = utils.toSourceText(_$createComponent(csharp.Class, {
+    accessModifier: "public",
+    name: "TestClass",
+    get children() {
+      return _$createComponent(core.List, {
+        get children() {
+          return [_$createComponent(csharp.ClassMethod, {
+            accessModifier: "public",
+            name: "MethodOne"
+          }), _$createComponent(csharp.ClassMethod, {
+            accessModifier: "private",
+            methodModifier: "virtual",
+            name: "MethodTwo"
+          })];
+        }
+      });
+    }
+  }));
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            public void MethodOne() {}
+            private virtual void MethodTwo() {}
+        }
+    }
+  `);
+});
+it("uses refkeys for members, params, and return type", () => {
+  const inputTypeRefkey = core.refkey();
+  const testResultTypeRefkey = core.refkey();
+  const enumTypeRefkey = core.refkey();
+  const params = [{
+    name: "IntParam",
+    type: "int"
+  }, {
+    name: "BodyParam",
+    type: inputTypeRefkey
+  }];
+  const res = core.render(_$createComponent(core.Output, {
+    get namePolicy() {
+      return csharp.createCSharpNamePolicy();
+    },
+    get children() {
+      return _$createComponent(csharp.Namespace, {
+        name: "TestCode",
+        get children() {
+          return _$createComponent(csharp.SourceFile, {
+            path: "Test.cs",
+            get children() {
+              return [_$createComponent(csharp.Enum, {
+                accessModifier: "public",
+                name: "TestEnum",
+                refkey: enumTypeRefkey,
+                get children() {
+                  return _$createComponent(core.List, {
+                    comma: true,
+                    hardline: true,
+                    get children() {
+                      return [_$createComponent(csharp.EnumMember, {
+                        name: "One"
+                      }), _$createComponent(csharp.EnumMember, {
+                        name: "Two"
+                      })];
+                    }
+                  });
+                }
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "TestInput",
+                refkey: inputTypeRefkey
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "TestResult",
+                refkey: testResultTypeRefkey
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "TestClass",
+                get children() {
+                  return [_$createComponent(csharp.ClassMember, {
+                    accessModifier: "private",
+                    name: "MemberOne",
+                    type: enumTypeRefkey
+                  }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassMethod, {
+                    accessModifier: "public",
+                    name: "MethodOne",
+                    parameters: params,
+                    returns: testResultTypeRefkey,
+                    get children() {
+                      return ["return new ", testResultTypeRefkey, "();"];
+                    }
+                  })];
+                }
+              })];
+            }
+          });
+        }
+      });
+    }
+  }));
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public enum TestEnum
+        {
+            One,
+            Two
+        }
+        public class TestInput;
+        public class TestResult;
+        public class TestClass
+        {
+            private TestEnum memberOne;
+            public TestResult MethodOne(int intParam, TestInput bodyParam)
+            {
+                return new TestResult();
+            }
+        }
+    }
+  `);
+});
+it("declares class with generic parameters", () => {
+  const typeParameters = {
+    T: core.refkey(),
+    U: core.refkey()
+  };
+  const res = utils.toSourceText(_$createComponent(csharp.Class, {
+    accessModifier: "public",
+    name: "TestClass",
+    typeParameters: typeParameters,
+    get children() {
+      return [_$createComponent(csharp.ClassMember, {
+        accessModifier: "public",
+        name: "memberOne",
+        get type() {
+          return typeParameters.T;
+        }
+      }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassMember, {
+        accessModifier: "private",
+        name: "memberTwo",
+        get type() {
+          return typeParameters.U;
+        }
+      }), ";"];
+    }
+  }));
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass<T, U>
+        {
+            public T MemberOne;
+            private U memberTwo;
+        }
+    }
+  `);
+});
+it("declares class with invalid members", () => {
+  const decl = _$createComponent(csharp.Class, {
+    accessModifier: "public",
+    name: "TestClass",
+    get children() {
+      return [_$createComponent(csharp.EnumMember, {
+        name: "One"
+      }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
+        name: "Two"
+      })];
+    }
+  });
+  expect(() => utils.toSourceText(decl)).toThrow("can't define an enum member outside of an enum-decl scope");
+});
+it("declares class with constructor", () => {
+  const res = utils.toSourceText(_$createComponent(csharp.Class, {
+    accessModifier: "public",
+    name: "TestClass",
+    get children() {
+      return _$createComponent(csharp.ClassConstructor, {
+        accessModifier: "public"
+      });
+    }
+  }));
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            public TestClass() {}
+        }
+    }
+  `);
+});
+it("declares class with constructor params and assigns values to fields", () => {
+  const thisNameRefkey = core.refkey();
+  const thisSizeRefkey = core.refkey();
+  const paramNameRefkey = core.refkey();
+  const paramSizeRefkey = core.refkey();
+  const ctorParams = [{
+    name: "name",
+    type: "string",
+    refkey: paramNameRefkey
+  }, {
+    name: "size",
+    type: "int",
+    refkey: paramSizeRefkey
+  }];
+  const res = utils.toSourceText(_$createComponent(csharp.Class, {
+    accessModifier: "public",
+    name: "TestClass",
+    get children() {
+      return [_$createComponent(csharp.ClassMember, {
+        accessModifier: "private",
+        name: "name",
+        type: "string",
+        refkey: thisNameRefkey
+      }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassMember, {
+        accessModifier: "private",
+        name: "size",
+        type: "int",
+        refkey: thisSizeRefkey
+      }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassConstructor, {
+        accessModifier: "public",
+        parameters: ctorParams,
+        get children() {
+          return [thisNameRefkey, " = ", paramNameRefkey, ";", _$createIntrinsic("hbr", {}), thisSizeRefkey, " = ", paramSizeRefkey, ";"];
+        }
+      })];
+    }
+  }));
+
+  // TODO: assignments to members should have this. prefix
+  // e.g. this.name = name;
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass
+        {
+            private string name;
+            private int size;
+            public TestClass(string name, int size)
+            {
+                name = name;
+                size = size;
+            }
+        }
+    }
+  `);
+});

package/dist/test/enum.test.js

@@ -5,8 +5,8 @@ import { expect, it } from "vitest";
 import * as csharp from "../src/index.js";
 import * as utils from "./utils.js";
 it("declares enum with no members", () => {
-  const res = utils.toSourceText(_$createComponent(csharp.EnumDeclaration, {
-    "public": true,
+  const res = utils.toSourceText(_$createComponent(csharp.Enum, {
+    accessModifier: "public",
     name: "TestEnum"
   }));
   expect(res).toBe(coretest.d`
@@ -17,8 +17,8 @@ it("declares enum with no members", () => {
   `);
 });
 it("declares enum with members", () => {
-  const res = utils.toSourceText(_$createComponent(csharp.EnumDeclaration, {
-    "public": true,
+  const res = utils.toSourceText(_$createComponent(csharp.Enum, {
+    accessModifier: "public",
     name: "TestEnum",
     get children() {
       return [_$createComponent(csharp.EnumMember, {
@@ -40,8 +40,8 @@ it("declares enum with members", () => {
   `);
 });
 it("applies naming policy to enum and members", () => {
-  const res = utils.toSourceText(_$createComponent(csharp.EnumDeclaration, {
-    "public": true,
+  const res = utils.toSourceText(_$createComponent(csharp.Enum, {
+    accessModifier: "public",
     name: "testEnum",
     get children() {
       return [_$createComponent(csharp.EnumMember, {
@@ -73,8 +73,8 @@ it("can reference things by refkey", () => {
           return _$createComponent(csharp.SourceFile, {
             path: "Test.cs",
             get children() {
-              return [_$createComponent(csharp.EnumDeclaration, {
-                "public": true,
+              return [_$createComponent(csharp.Enum, {
+                accessModifier: "public",
                 name: "TestEnum",
                 refkey: enumRK,
                 get children() {
@@ -116,8 +116,8 @@ it("can reference things by refkey across files", () => {
           return [_$createComponent(csharp.SourceFile, {
             path: "Test.cs",
             get children() {
-              return [_$createComponent(csharp.EnumDeclaration, {
-                "public": true,
+              return [_$createComponent(csharp.Enum, {
+                accessModifier: "public",
                 name: "TestEnum",
                 get children() {
                   return [_$createComponent(csharp.EnumMember, {
@@ -131,8 +131,8 @@ it("can reference things by refkey across files", () => {
           }), _$createComponent(csharp.SourceFile, {
             path: "Other.cs",
             get children() {
-              return [_$createComponent(csharp.EnumDeclaration, {
-                "public": true,
+              return [_$createComponent(csharp.Enum, {
+                accessModifier: "public",
                 name: "OtherEnum",
                 refkey: enumRK,
                 get children() {

package/dist/test/namespace.test.js

@@ -12,16 +12,16 @@ it("defines multiple namespaces and source files with unique content", () => {
           return [_$createComponent(csharp.SourceFile, {
             path: "Model1.cs",
             get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "Model1"
               });
             }
           }), _$createComponent(csharp.SourceFile, {
             path: "Model2.cs",
             get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "Model2"
               });
             }
@@ -33,16 +33,16 @@ it("defines multiple namespaces and source files with unique content", () => {
           return [_$createComponent(csharp.SourceFile, {
             path: "Model3.cs",
             get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "Model3"
               });
             }
           }), _$createComponent(csharp.SourceFile, {
             path: "Model4.cs",
             get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "Model4"
               });
             }

package/dist/test/projectdirectory.test.d.ts

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

package/dist/test/projectdirectory.test.d.ts.map

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

package/dist/test/{project-directory.test.js → projectdirectory.test.js}

@@ -18,16 +18,16 @@ it("defines a project directory file with multiple source files", () => {
               return [_$createComponent(csharp.SourceFile, {
                 path: "Test1.cs",
                 get children() {
-                  return _$createComponent(csharp.ClassDeclaration, {
-                    "public": true,
+                  return _$createComponent(csharp.Class, {
+                    accessModifier: "public",
                     name: "TestClass1"
                   });
                 }
               }), _$createComponent(csharp.SourceFile, {
                 path: "Test2.cs",
                 get children() {
-                  return _$createComponent(csharp.ClassDeclaration, {
-                    "public": true,
+                  return _$createComponent(csharp.Class, {
+                    accessModifier: "public",
                     name: "TestClass2"
                   });
                 }
@@ -82,16 +82,16 @@ it("defines a project directory file with multiple source files and a custom TFM
               return [_$createComponent(csharp.SourceFile, {
                 path: "Test1.cs",
                 get children() {
-                  return _$createComponent(csharp.ClassDeclaration, {
-                    "public": true,
+                  return _$createComponent(csharp.Class, {
+                    accessModifier: "public",
                     name: "TestClass1"
                   });
                 }
               }), _$createComponent(csharp.SourceFile, {
                 path: "Test2.cs",
                 get children() {
-                  return _$createComponent(csharp.ClassDeclaration, {
-                    "public": true,
+                  return _$createComponent(csharp.Class, {
+                    accessModifier: "public",
                     name: "TestClass2"
                   });
                 }

package/dist/test/sourcefile.test.js

@@ -12,16 +12,16 @@ it("defines multiple source files with unique content", () => {
           return [_$createComponent(csharp.SourceFile, {
             path: "Test1.cs",
             get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "TestClass1"
               });
             }
           }), _$createComponent(csharp.SourceFile, {
             path: "Test2.cs",
             get children() {
-              return _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "TestClass2"
               });
             }

package/dist/test/using.test.js

@@ -63,16 +63,16 @@ it("adds using statement across namespaces", () => {
           return _$createComponent(csharp.SourceFile, {
             path: "Models.cs",
             get children() {
-              return [_$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              return [_$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "Input",
                 refkey: inputTypeRefkey
-              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "Output",
                 refkey: outputTypeRefkey
-              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumDeclaration, {
-                "public": true,
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.Enum, {
+                accessModifier: "public",
                 name: "TestEnum",
                 get children() {
                   return [_$createComponent(csharp.EnumMember, {
@@ -93,12 +93,12 @@ it("adds using statement across namespaces", () => {
             path: "Client.cs",
             using: ["System"],
             get children() {
-              return [_$createComponent(csharp.ClassDeclaration, {
-                "public": true,
+              return [_$createComponent(csharp.Class, {
+                accessModifier: "public",
                 name: "Client",
                 get children() {
                   return _$createComponent(csharp.ClassMethod, {
-                    "public": true,
+                    accessModifier: "public",
                     name: "MethodOne",
                     parameters: params,
                     returns: outputTypeRefkey