@alloy-js/csharp 0.10.0 → 0.12.0

package/dist/test/enum.test.js

@@ -0,0 +1,179 @@
+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 enum with no members", () => {
+  const res = utils.toSourceText(_$createComponent(csharp.Enum, {
+    accessModifier: "public",
+    name: "TestEnum"
+  }));
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public enum TestEnum;
+    }
+  `);
+});
+it("declares enum with members", () => {
+  const res = utils.toSourceText(_$createComponent(csharp.Enum, {
+    accessModifier: "public",
+    name: "TestEnum",
+    get children() {
+      return [_$createComponent(csharp.EnumMember, {
+        name: "One"
+      }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
+        name: "Two"
+      })];
+    }
+  }));
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public enum TestEnum
+        {
+            One,
+            Two
+        }
+    }
+  `);
+});
+it("applies naming policy to enum and members", () => {
+  const res = utils.toSourceText(_$createComponent(csharp.Enum, {
+    accessModifier: "public",
+    name: "testEnum",
+    get children() {
+      return [_$createComponent(csharp.EnumMember, {
+        name: "one"
+      }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
+        name: "two"
+      })];
+    }
+  }));
+  expect(res).toBe(coretest.d`
+    namespace TestCode
+    {
+        public enum TestEnum
+        {
+            One,
+            Two
+        }
+    }
+  `);
+});
+it("can reference things by refkey", () => {
+  const enumRK = core.refkey();
+  const twoRK = core.refkey();
+  const res = core.render(_$createComponent(core.Output, {
+    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: enumRK,
+                get children() {
+                  return [_$createComponent(csharp.EnumMember, {
+                    name: "One"
+                  }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
+                    name: "Two",
+                    refkey: twoRK
+                  })];
+                }
+              }), _$createIntrinsic("hbr", {}), enumRK, ";", _$createIntrinsic("hbr", {}), twoRK, ";"];
+            }
+          });
+        }
+      });
+    }
+  }));
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public enum TestEnum
+        {
+            One,
+            Two
+        }
+        TestEnum;
+        TestEnum.Two;
+    }
+  `);
+});
+it("can reference things by refkey across files", () => {
+  const enumRK = core.refkey();
+  const barRK = core.refkey();
+  const res = core.render(_$createComponent(core.Output, {
+    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",
+                get children() {
+                  return [_$createComponent(csharp.EnumMember, {
+                    name: "One"
+                  }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
+                    name: "Two"
+                  })];
+                }
+              }), _$createIntrinsic("hbr", {}), enumRK, ";", _$createIntrinsic("hbr", {}), barRK, ";"];
+            }
+          }), _$createComponent(csharp.SourceFile, {
+            path: "Other.cs",
+            get children() {
+              return [_$createComponent(csharp.Enum, {
+                accessModifier: "public",
+                name: "OtherEnum",
+                refkey: enumRK,
+                get children() {
+                  return [_$createComponent(csharp.EnumMember, {
+                    name: "Foo"
+                  }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
+                    name: "Bar",
+                    refkey: barRK
+                  })];
+                }
+              }), _$createIntrinsic("hbr", {}), enumRK, ";", _$createIntrinsic("hbr", {}), barRK, ";"];
+            }
+          })];
+        }
+      });
+    }
+  }));
+  expect(res.contents[0].path).toBe("Test.cs");
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public enum TestEnum
+        {
+            One,
+            Two
+        }
+        OtherEnum;
+        OtherEnum.Bar;
+    }
+  `);
+  expect(res.contents[1].path).toBe("Other.cs");
+  expect(res.contents[1].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public enum OtherEnum
+        {
+            Foo,
+            Bar
+        }
+        OtherEnum;
+        OtherEnum.Bar;
+    }
+  `);
+});

package/dist/test/namespace.test.js

@@ -0,0 +1,82 @@
+import { createComponent as _$createComponent } 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";
+it("defines multiple namespaces and source files with unique content", () => {
+  const res = core.render(_$createComponent(core.Output, {
+    get children() {
+      return [_$createComponent(csharp.Namespace, {
+        name: "Namespace1",
+        get children() {
+          return [_$createComponent(csharp.SourceFile, {
+            path: "Model1.cs",
+            get children() {
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "Model1"
+              });
+            }
+          }), _$createComponent(csharp.SourceFile, {
+            path: "Model2.cs",
+            get children() {
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "Model2"
+              });
+            }
+          })];
+        }
+      }), _$createComponent(csharp.Namespace, {
+        name: "Namespace2",
+        get children() {
+          return [_$createComponent(csharp.SourceFile, {
+            path: "Model3.cs",
+            get children() {
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "Model3"
+              });
+            }
+          }), _$createComponent(csharp.SourceFile, {
+            path: "Model4.cs",
+            get children() {
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "Model4"
+              });
+            }
+          })];
+        }
+      })];
+    }
+  }));
+  expect(res.contents[0].path).equals("Model1.cs");
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace Namespace1
+    {
+        public class Model1;
+    }
+  `);
+  expect(res.contents[1].path).equals("Model2.cs");
+  expect(res.contents[1].contents).toBe(coretest.d`
+    namespace Namespace1
+    {
+        public class Model2;
+    }
+  `);
+  expect(res.contents[2].path).equals("Model3.cs");
+  expect(res.contents[2].contents).toBe(coretest.d`
+    namespace Namespace2
+    {
+        public class Model3;
+    }
+  `);
+  expect(res.contents[3].path).equals("Model4.cs");
+  expect(res.contents[3].contents).toBe(coretest.d`
+    namespace Namespace2
+    {
+        public class Model4;
+    }
+  `);
+});

package/dist/test/projectdirectory.test.js

@@ -0,0 +1,132 @@
+import { createComponent as _$createComponent } 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";
+it("defines a project directory file with multiple source files", () => {
+  const res = core.render(_$createComponent(core.Output, {
+    get children() {
+      return _$createComponent(csharp.ProjectDirectory, {
+        name: "TestProject",
+        path: "~/projects",
+        version: "0.1.0",
+        description: "a test project",
+        get children() {
+          return _$createComponent(csharp.Namespace, {
+            name: "TestCode",
+            get children() {
+              return [_$createComponent(csharp.SourceFile, {
+                path: "Test1.cs",
+                get children() {
+                  return _$createComponent(csharp.Class, {
+                    accessModifier: "public",
+                    name: "TestClass1"
+                  });
+                }
+              }), _$createComponent(csharp.SourceFile, {
+                path: "Test2.cs",
+                get children() {
+                  return _$createComponent(csharp.Class, {
+                    accessModifier: "public",
+                    name: "TestClass2"
+                  });
+                }
+              })];
+            }
+          });
+        }
+      });
+    }
+  }));
+  const projDir = res.contents[0];
+  expect(projDir.path).equals("~/projects/TestProject");
+  expect(projDir.contents[0].path).equals("~/projects/TestProject/TestProject.csproj");
+  expect(projDir.contents[0].contents).toBe(coretest.d`
+    <Project Sdk="Microsoft.NET.Sdk">
+      <PropertyGroup>
+        <Version>0.1.0</Version>
+        <Description>a test project</Description>
+        <TargetFramework>net8.0</TargetFramework>
+      </PropertyGroup>
+    </Project>
+  `);
+  const srcDir = projDir.contents[1];
+  expect(srcDir.contents[0].path).equals("~/projects/TestProject/src/Test1.cs");
+  expect(srcDir.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass1;
+    }
+  `);
+  expect(srcDir.contents[1].path).equals("~/projects/TestProject/src/Test2.cs");
+  expect(srcDir.contents[1].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass2;
+    }
+  `);
+});
+it("defines a project directory file with multiple source files and a custom TFM", () => {
+  const res = core.render(_$createComponent(core.Output, {
+    get children() {
+      return _$createComponent(csharp.ProjectDirectory, {
+        name: "TestProject",
+        path: "~/projects",
+        version: "0.1.0",
+        description: "a test project",
+        targetFrameworkMoniker: "netstandard2.1",
+        get children() {
+          return _$createComponent(csharp.Namespace, {
+            name: "TestCode",
+            get children() {
+              return [_$createComponent(csharp.SourceFile, {
+                path: "Test1.cs",
+                get children() {
+                  return _$createComponent(csharp.Class, {
+                    accessModifier: "public",
+                    name: "TestClass1"
+                  });
+                }
+              }), _$createComponent(csharp.SourceFile, {
+                path: "Test2.cs",
+                get children() {
+                  return _$createComponent(csharp.Class, {
+                    accessModifier: "public",
+                    name: "TestClass2"
+                  });
+                }
+              })];
+            }
+          });
+        }
+      });
+    }
+  }));
+  const projDir = res.contents[0];
+  expect(projDir.path).equals("~/projects/TestProject");
+  expect(projDir.contents[0].path).equals("~/projects/TestProject/TestProject.csproj");
+  expect(projDir.contents[0].contents).toBe(coretest.d`
+    <Project Sdk="Microsoft.NET.Sdk">
+      <PropertyGroup>
+        <Version>0.1.0</Version>
+        <Description>a test project</Description>
+        <TargetFramework>netstandard2.1</TargetFramework>
+      </PropertyGroup>
+    </Project>
+  `);
+  const srcDir = projDir.contents[1];
+  expect(srcDir.contents[0].path).equals("~/projects/TestProject/src/Test1.cs");
+  expect(srcDir.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass1;
+    }
+  `);
+  expect(srcDir.contents[1].path).equals("~/projects/TestProject/src/Test2.cs");
+  expect(srcDir.contents[1].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass2;
+    }
+  `);
+});

package/dist/test/sourcefile.test.js

@@ -0,0 +1,57 @@
+import { createComponent as _$createComponent } 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";
+it("defines multiple source files with unique content", () => {
+  const res = core.render(_$createComponent(core.Output, {
+    get children() {
+      return _$createComponent(csharp.Namespace, {
+        name: "TestCode",
+        get children() {
+          return [_$createComponent(csharp.SourceFile, {
+            path: "Test1.cs",
+            get children() {
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "TestClass1"
+              });
+            }
+          }), _$createComponent(csharp.SourceFile, {
+            path: "Test2.cs",
+            get children() {
+              return _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "TestClass2"
+              });
+            }
+          })];
+        }
+      });
+    }
+  }));
+  expect(res.contents[0].path).equals("Test1.cs");
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass1;
+    }
+  `);
+  expect(res.contents[1].path).equals("Test2.cs");
+  expect(res.contents[1].contents).toBe(coretest.d`
+    namespace TestCode
+    {
+        public class TestClass2;
+    }
+  `);
+});
+it("throws when declaring a source file outside a namespace", () => {
+  const decl = _$createComponent(core.Output, {
+    get children() {
+      return _$createComponent(csharp.SourceFile, {
+        path: "Test.cs"
+      });
+    }
+  });
+  expect(() => core.render(decl)).toThrow("SourceFile must be declared inside a namespace");
+});

package/dist/test/using.test.js

@@ -0,0 +1,139 @@
+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";
+it("uses a single namespace", () => {
+  const res = core.render(_$createComponent(core.Output, {
+    get children() {
+      return _$createComponent(csharp.Namespace, {
+        name: "TestCode",
+        get children() {
+          return _$createComponent(csharp.SourceFile, {
+            path: "Test1.cs",
+            using: ["Foo"]
+          });
+        }
+      });
+    }
+  }));
+  expect(res.contents[0].contents).toBe(coretest.d`
+    using Foo;
+
+    namespace TestCode {}
+  `);
+});
+it("uses multiple namespaces", () => {
+  const res = core.render(_$createComponent(core.Output, {
+    get children() {
+      return _$createComponent(csharp.Namespace, {
+        name: "TestCode",
+        get children() {
+          return _$createComponent(csharp.SourceFile, {
+            path: "Test1.cs",
+            using: ["Foo", "Bar.Baz"]
+          });
+        }
+      });
+    }
+  }));
+  expect(res.contents[0].contents).toBe(coretest.d`
+    using Bar.Baz;
+    using Foo;
+
+    namespace TestCode {}
+  `);
+});
+it("adds using statement across namespaces", () => {
+  const inputTypeRefkey = core.refkey();
+  const outputTypeRefkey = core.refkey();
+  const twoValRefkey = core.refkey();
+  const params = [{
+    name: "BodyParam",
+    type: inputTypeRefkey
+  }];
+  const res = core.render(_$createComponent(core.Output, {
+    get namePolicy() {
+      return csharp.createCSharpNamePolicy();
+    },
+    get children() {
+      return [_$createComponent(csharp.Namespace, {
+        name: "Models",
+        get children() {
+          return _$createComponent(csharp.SourceFile, {
+            path: "Models.cs",
+            get children() {
+              return [_$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "Input",
+                refkey: inputTypeRefkey
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "Output",
+                refkey: outputTypeRefkey
+              }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.Enum, {
+                accessModifier: "public",
+                name: "TestEnum",
+                get children() {
+                  return [_$createComponent(csharp.EnumMember, {
+                    name: "One"
+                  }), ",", _$createIntrinsic("hbr", {}), _$createComponent(csharp.EnumMember, {
+                    name: "Two",
+                    refkey: twoValRefkey
+                  })];
+                }
+              })];
+            }
+          });
+        }
+      }), _$createComponent(csharp.Namespace, {
+        name: "Client",
+        get children() {
+          return _$createComponent(csharp.SourceFile, {
+            path: "Client.cs",
+            using: ["System"],
+            get children() {
+              return [_$createComponent(csharp.Class, {
+                accessModifier: "public",
+                name: "Client",
+                get children() {
+                  return _$createComponent(csharp.ClassMethod, {
+                    accessModifier: "public",
+                    name: "MethodOne",
+                    parameters: params,
+                    returns: outputTypeRefkey
+                  });
+                }
+              }), _$createIntrinsic("hbr", {}), twoValRefkey, ";"];
+            }
+          });
+        }
+      })];
+    }
+  }));
+  expect(res.contents[0].contents).toBe(coretest.d`
+    namespace Models
+    {
+        public class Input;
+        public class Output;
+        public enum TestEnum
+        {
+            One,
+            Two
+        }
+    }
+  `);
+  expect(res.contents[1].contents).toBe(coretest.d`
+    using Models;
+    using System;
+
+    namespace Client
+    {
+        public class Client
+        {
+            public Output MethodOne(Input bodyParam) {}
+        }
+        TestEnum.Two;
+    }
+  `);
+});

package/dist/test/utils.js

@@ -0,0 +1,64 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import * as core from "@alloy-js/core";
+import * as coretest from "@alloy-js/core/testing";
+import { expect } from "vitest";
+import * as csharp from "../src/index.js";
+export function toSourceText(c) {
+  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",
+            children: c
+          });
+        }
+      });
+    }
+  }));
+  const file = findFile(res, "Test.cs");
+  return file.contents;
+}
+export function testRender(c) {
+  return core.render(_$createComponent(core.Output, {
+    get children() {
+      return _$createComponent(csharp.Namespace, {
+        name: "TestCode",
+        children: c
+      });
+    }
+  }));
+}
+export function findFile(res, path) {
+  const result = findFileWorker(res, path);
+  if (!result) {
+    throw new Error("Expected to find file " + path);
+  }
+  return result;
+  function findFileWorker(res, path) {
+    for (const item of res.contents) {
+      if (item.kind === "file") {
+        if (item.path.includes(path)) {
+          return item;
+        }
+        continue;
+      } else {
+        const found = findFileWorker(item, path);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    return null;
+  }
+}
+export function assertFileContents(res, expectedFiles) {
+  for (const [path, contents] of Object.entries(expectedFiles)) {
+    const file = findFile(res, path);
+    expect(file.contents).toBe(coretest.dedent(contents));
+  }
+}