@alloy-js/csharp 0.18.0-dev.2 → 0.18.0-dev.20

package/dist/src/components/var/declaration.test.js

@@ -0,0 +1,73 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { List, refkey } from "@alloy-js/core";
+import { expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.js";
+import { SourceFile } from "../SourceFile.js";
+import { VarDeclaration } from "./declaration.js";
+it("declares var without type", () => {
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(VarDeclaration, {
+        name: "testVar",
+        children: "42"
+      });
+    }
+  })).toRenderTo(`
+      var testVar = 42;
+  `);
+});
+it("declares var with type", () => {
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(VarDeclaration, {
+        name: "testVar",
+        type: "int",
+        children: "42"
+      });
+    }
+  })).toRenderTo(`
+      int testVar = 42;
+  `);
+});
+it("name variables camel case", () => {
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(VarDeclaration, {
+        name: "test_var",
+        children: "42"
+      });
+    }
+  })).toRenderTo(`
+      var testVar = 42;
+  `);
+});
+it("links refkey", () => {
+  const key = refkey();
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "test.cs",
+        get children() {
+          return _$createComponent(List, {
+            get children() {
+              return [_$createComponent(VarDeclaration, {
+                name: "testVar",
+                refkey: key,
+                children: "42"
+              }), _$createComponent(VarDeclaration, {
+                name: "testVar2",
+                children: key
+              })];
+            }
+          });
+        }
+      });
+    }
+  })).toRenderTo(`
+      namespace TestCode
+      {
+        var testVar = 42;
+        var testVar2 = testVar;
+      }
+  `);
+});

package/dist/src/modifiers.d.ts

@@ -1,8 +1,14 @@
-export type AccessModifier = "public" | "protected" | "private" | "internal" | "protected-internal" | "private-protected" | "file";
-export declare function getAccessModifier(accessModifier?: AccessModifier): string;
-export type MethodModifier = "abstract" | "sealed" | "static" | "virtual";
-export declare function getMethodModifier(methodModifier?: MethodModifier): string;
+/** Access modifiers.  */
+export interface AccessModifiers {
+    readonly public?: boolean;
+    readonly protected?: boolean;
+    readonly private?: boolean;
+    readonly internal?: boolean;
+    readonly file?: boolean;
+}
+export declare const getAccessModifier: (data: AccessModifiers) => string;
 export declare function getAsyncModifier(async?: boolean): string;
 /** Resolve the modifier prefix */
 export declare function computeModifiersPrefix(modifiers: Array<string | undefined>): string;
+export declare function makeModifiers<T>(obj: Array<keyof T>): (data: T) => string;
 //# sourceMappingURL=modifiers.d.ts.map

package/dist/src/modifiers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"modifiers.d.ts","sourceRoot":"","sources":["../../src/modifiers.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,WAAW,GACX,SAAS,GACT,UAAU,GACV,oBAAoB,GACpB,mBAAmB,GACnB,MAAM,CAAC;AAgBX,wBAAgB,iBAAiB,CAAC,cAAc,CAAC,EAAE,cAAc,GAAG,MAAM,CAEzE;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAa1E,wBAAgB,iBAAiB,CAAC,cAAc,CAAC,EAAE,cAAc,GAAG,MAAM,CAEzE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAExD;AAED,kCAAkC;AAClC,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GACnC,MAAM,CAGR"}
+{"version":3,"file":"modifiers.d.ts","sourceRoot":"","sources":["../../src/modifiers.ts"],"names":[],"mappings":"AAGA,yBAAyB;AACzB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,eAAO,MAAM,iBAAiB,mCAM5B,CAAC;AAEH,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAExD;AAED,kCAAkC;AAClC,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GACnC,MAAM,CAGR;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,IAC1C,MAAM,CAAC,YAMhB"}

package/dist/src/modifiers.js

@@ -1,43 +1,20 @@
 // the possible C# access modifiers
 // https://learn.microsoft.com/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers
 
-// maps the above access modifier value to its C# syntax.
-// note that the C# keyword includes a trailing space
-const accessModifierLookup = {
-  public: "public ",
-  protected: "protected ",
-  private: "private ",
-  internal: "internal ",
-  "protected-internal": "protected internal ",
-  "private-protected": "private protected ",
-  file: "file "
-};
+/** Access modifiers.  */
 
-// returns the C# syntax for the specified access modifier.
-// if no access modifier is specified, the empty string is returned.
-export function getAccessModifier(accessModifier) {
-  return accessModifier ? accessModifierLookup[accessModifier] : "";
-}
-// maps the above method modifier value to its C# syntax.
-// note that the C# keyword includes a trailing space
-const methodModifierLookup = {
-  abstract: "abstract ",
-  sealed: "sealed ",
-  static: "static ",
-  virtual: "virtual "
-};
-
-// returns the C# syntax for the specified method modifier.
-// if no method modifier is specified, the empty string is returned.
-export function getMethodModifier(methodModifier) {
-  return methodModifier ? methodModifierLookup[methodModifier] : "";
-}
+export const getAccessModifier = makeModifiers(["public", "protected", "private", "internal", "file"]);
 export function getAsyncModifier(async) {
-  return async ? "async " : "";
+  return async ? "async" : "";
 }
 
 /** Resolve the modifier prefix */
 export function computeModifiersPrefix(modifiers) {
   const resolved = modifiers.filter(x => x);
-  return resolved.length > 0 ? resolved.join("") : "";
+  return resolved.length > 0 ? resolved.join(" ") + " " : "";
+}
+export function makeModifiers(obj) {
+  return data => {
+    return obj.map(key => data[key] ? key : undefined).filter(x => x).join(" ");
+  };
 }

package/dist/src/name-policy.d.ts

@@ -1,5 +1,5 @@
 import * as core from "@alloy-js/core";
-export type CSharpElements = "class" | "constant" | "enum" | "enum-member" | "function" | "interface" | "class-member-private" | "class-member-public" | "class-method" | "parameter" | "type-parameter";
+export type CSharpElements = "class" | "constant" | "variable" | "enum" | "enum-member" | "function" | "interface" | "record" | "class-member-private" | "class-member-public" | "class-method" | "class-property" | "parameter" | "type-parameter";
 export declare function createCSharpNamePolicy(): core.NamePolicy<CSharpElements>;
 export declare function useCSharpNamePolicy(): core.NamePolicy<CSharpElements>;
 //# sourceMappingURL=name-policy.d.ts.map

package/dist/src/name-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"name-policy.d.ts","sourceRoot":"","sources":["../../src/name-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AAIvC,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,UAAU,GACV,MAAM,GACN,aAAa,GACb,UAAU,GACV,WAAW,GACX,sBAAsB,GACtB,qBAAqB,GACrB,cAAc,GACd,WAAW,GACX,gBAAgB,CAAC;AAGrB,wBAAgB,sBAAsB,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAiBxE;AAGD,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAErE"}
+{"version":3,"file":"name-policy.d.ts","sourceRoot":"","sources":["../../src/name-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AAIvC,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,UAAU,GACV,UAAU,GACV,MAAM,GACN,aAAa,GACb,UAAU,GACV,WAAW,GACX,QAAQ,GACR,sBAAsB,GACtB,qBAAqB,GACrB,cAAc,GACd,gBAAgB,GAChB,WAAW,GACX,gBAAgB,CAAC;AAGrB,wBAAgB,sBAAsB,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAmBxE;AAGD,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAErE"}

package/dist/src/name-policy.js

@@ -11,9 +11,11 @@ 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-declaration.test.d.ts

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

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

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

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

@@ -0,0 +1,463 @@
+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 * as csharp 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, {
+    get children() {
+      return _$createComponent(ClassDeclaration, {
+        name: "TestClass"
+      });
+    }
+  })).toRenderTo(`
+      class TestClass;
+  `);
+});
+describe("modifiers", () => {
+  it.each(["public", "private"])("%s", mod => {
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(ClassDeclaration, _$mergeProps({
+          [mod]: true
+        }, {
+          name: "TestClass"
+        }));
+      }
+    })).toRenderTo(`
+        ${mod} class TestClass;
+    `);
+  });
+  it.each(["partial", "abstract", "static", "sealed"])("%s", mod => {
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(ClassDeclaration, _$mergeProps({
+          [mod]: true
+        }, {
+          name: "TestClass"
+        }));
+      }
+    })).toRenderTo(`
+        ${mod} class TestClass;
+    `);
+  });
+  it("combines modifiers", () => {
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(ClassDeclaration, {
+          "public": true,
+          abstract: true,
+          partial: true,
+          name: "TestClass"
+        });
+      }
+    })).toRenderTo(`
+        public abstract partial class TestClass;
+    `);
+  });
+});
+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,
+    name: "TestClass",
+    get children() {
+      return _$createComponent(core.StatementList, {
+        get children() {
+          return [_$createComponent(csharp.ClassMember, {
+            "public": true,
+            name: "MemberOne",
+            type: "string"
+          }), _$createComponent(csharp.ClassMember, {
+            "private": true,
+            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.ClassDeclaration, {
+    "public": true,
+    name: "TestClass",
+    get children() {
+      return _$createComponent(core.List, {
+        get children() {
+          return [_$createComponent(csharp.ClassMethod, {
+            "public": true,
+            name: "MethodOne"
+          }), _$createComponent(csharp.ClassMethod, {
+            "private": true,
+            virtual: true,
+            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.EnumDeclaration, {
+                "public": true,
+                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.ClassDeclaration, {
+                "public": true,
+                name: "TestInput",
+                refkey: inputTypeRefkey
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassDeclaration, {
+                "public": true,
+                name: "TestResult",
+                refkey: testResultTypeRefkey
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassDeclaration, {
+                "public": true,
+                name: "TestClass",
+                get children() {
+                  return [_$createComponent(csharp.ClassMember, {
+                    "private": true,
+                    name: "MemberOne",
+                    type: enumTypeRefkey
+                  }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassMethod, {
+                    "public": true,
+                    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();
+            }
+        }
+    }
+  `);
+});
+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>
+        {
+          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, {
+    "public": true,
+    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.ClassDeclaration, {
+    "public": true,
+    name: "TestClass",
+    get children() {
+      return _$createComponent(csharp.ClassConstructor, {
+        "public": true
+      });
+    }
+  }));
+  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.ClassDeclaration, {
+    "public": true,
+    name: "TestClass",
+    get children() {
+      return [_$createComponent(csharp.ClassMember, {
+        "private": true,
+        name: "name",
+        type: "string",
+        refkey: thisNameRefkey
+      }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassMember, {
+        "private": true,
+        name: "size",
+        type: "int",
+        refkey: thisSizeRefkey
+      }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassConstructor, {
+        "public": true,
+        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;
+            }
+        }
+    }
+  `);
+});
+it("specify doc comment", () => {
+  expect(_$createComponent(utils.TestNamespace, {
+    get children() {
+      return _$createComponent(ClassDeclaration, {
+        name: "Test",
+        doc: "This is a test"
+      });
+    }
+  })).toRenderTo(`
+    /// 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
+    }
+  `);
+});