@alloy-js/csharp 0.20.0-dev.0 → 0.20.0-dev.10

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

@@ -1,484 +0,0 @@
-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 { Field } from "../src/components/field/field.js";
-import { Constructor } from "../src/components/stc/index.js";
-import * as csharp from "../src/index.js";
-import { ClassDeclaration, Property, SourceFile } from "../src/index.js";
-import * as utils from "./utils.js";
-import { findFile } 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(List, {
-        get children() {
-          return [_$createComponent(Field, {
-            "public": true,
-            name: "MemberOne",
-            type: "string"
-          }), _$createComponent(Field, {
-            "public": true,
-            name: "MemberTwo",
-            type: "int"
-          })];
-        }
-      });
-    }
-  }));
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public class TestClass
-        {
-            public string MemberOne;
-            public 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.Method, {
-            "public": true,
-            name: "MethodOne"
-          }), _$createComponent(csharp.Method, {
-            "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(Field, {
-                    "private": true,
-                    name: "MemberOne",
-                    type: enumTypeRefkey
-                  }), _$createIntrinsic("hbr", {}), _$createComponent(csharp.Method, {
-                    "public": true,
-                    name: "MethodOne",
-                    parameters: params,
-                    returns: testResultTypeRefkey,
-                    get children() {
-                      return ["return new ", testResultTypeRefkey, "();"];
-                    }
-                  })];
-                }
-              })];
-            }
-          });
-        }
-      });
-    }
-  }));
-  expect(findFile(res, "Test.cs").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(Constructor, {
-        "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(Field, {
-        "private": true,
-        name: "name",
-        type: "string",
-        refkey: thisNameRefkey
-      }), _$createIntrinsic("hbr", {}), _$createComponent(Field, {
-        "private": true,
-        name: "size",
-        type: "int",
-        refkey: thisSizeRefkey
-      }), _$createIntrinsic("hbr", {}), _$createComponent(Constructor, {
-        "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(Field, {
-            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/enum.test.d.ts

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

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

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

package/dist/test/enum.test.js

@@ -1,178 +0,0 @@
-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";
-import { findFile } from "./utils.js";
-it("declares enum with no members", () => {
-  const res = utils.toSourceText(_$createComponent(csharp.EnumDeclaration, {
-    "public": true,
-    name: "TestEnum"
-  }));
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum;
-    }
-  `);
-});
-it("declares enum with members", () => {
-  const res = utils.toSourceText(_$createComponent(csharp.EnumDeclaration, {
-    "public": true,
-    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.EnumDeclaration, {
-    "public": true,
-    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.EnumDeclaration, {
-                "public": true,
-                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(findFile(res, "Test.cs").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.EnumDeclaration, {
-                "public": true,
-                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.EnumDeclaration, {
-                "public": true,
-                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(findFile(res, "Test.cs").contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-        OtherEnum;
-        OtherEnum.Bar;
-    }
-  `);
-  expect(findFile(res, "Other.cs").contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum OtherEnum
-        {
-            Foo,
-            Bar
-        }
-        OtherEnum;
-        OtherEnum.Bar;
-    }
-  `);
-});

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

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