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

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

@@ -1,463 +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 * 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
-    }
-  `);
-});

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

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

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

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

package/dist/test/vitest.setup.d.ts

@@ -1,2 +0,0 @@
-import "@alloy-js/core/testing";
-//# sourceMappingURL=vitest.setup.d.ts.map

package/dist/test/vitest.setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vitest.setup.d.ts","sourceRoot":"","sources":["../../test/vitest.setup.ts"],"names":[],"mappings":"AAAA,OAAO,wBAAwB,CAAC"}

package/dist/test/vitest.setup.js

@@ -1 +0,0 @@
-import "@alloy-js/core/testing";

package/src/components/ClassDeclaration.tsx

@@ -1,213 +0,0 @@
-import * as core from "@alloy-js/core";
-import { join } from "@alloy-js/core";
-import {
-  AccessModifiers,
-  computeModifiersPrefix,
-  getAccessModifier,
-  makeModifiers,
-} from "../modifiers.js";
-import { CSharpElements, useCSharpNamePolicy } from "../name-policy.js";
-import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
-import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
-import { DocWhen } from "./doc/comment.jsx";
-import { Name } from "./Name.jsx";
-import { ParameterProps, Parameters } from "./parameters/parameters.jsx";
-import { TypeParameterConstraints } from "./type-parameters/type-parameter-constraints.jsx";
-import { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
-import { TypeParameters } from "./type-parameters/type-parameters.jsx";
-
-export interface ClassModifiers {
-  readonly abstract?: boolean;
-  readonly partial?: boolean;
-  readonly sealed?: boolean;
-  readonly static?: boolean;
-}
-
-const getClassModifiers = makeModifiers<ClassModifiers>([
-  "abstract",
-  "partial",
-  "sealed",
-  "static",
-]);
-
-// properties for creating a class
-export interface ClassDeclarationProps
-  extends Omit<core.DeclarationProps, "nameKind">,
-    AccessModifiers,
-    ClassModifiers {
-  name: string;
-  /** Doc comment */
-  doc?: core.Children;
-  refkey?: core.Refkey;
-
-  /**
-   * Type parameters for the class
-   *
-   * @example
-   * ```tsx
-   * <ClassDeclaration name="MyClass" typeParameters={["T"]} />
-   * ```
-   * This will produce:
-   * ```csharp
-   * public class MyClass<T>
-   * ```
-   */
-  typeParameters?: (string | TypeParameterProps)[];
-
-  /** Base class that this class extends */
-  baseType?: core.Children;
-
-  /** Interfaces this class implements */
-  interfaceTypes?: core.Children[];
-}
-
-/**
- * CSharp class declaration.
- * @example
- * ```tsx
- * <ClassDeclaration public name="MyClass">
- *   <ClassMember public name="MyField" type="int" />
- *   <ClassConstructor>
- *     <Parameter name="value" type="int" />
- *     this.MyField = value;
- *   </ClassConstructor>
- * </ClassDeclaration>
- * ```
- * This will produce:
- * ```csharp
- * public class MyClass
- * {
- *   public int MyField;
- *   public MyClass(int value)
- *   {
- *     this.MyField = value;
- *   }
- * }
- * ```
- */
-export function ClassDeclaration(props: ClassDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "class");
-
-  const thisClassSymbol = new CSharpOutputSymbol(name, {
-    refkeys: props.refkey,
-  });
-
-  // this creates a new scope for the class definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisClassScope = new CSharpMemberScope("class-decl", {
-    owner: thisClassSymbol,
-  });
-
-  const bases = [
-    ...(props.baseType ? [props.baseType] : []),
-    ...(props.interfaceTypes || []),
-  ];
-  const base =
-    bases.length > 0 ? <> : {join(bases, { joiner: ", " })}</> : null;
-  const modifiers = computeModifiersPrefix([
-    getAccessModifier(props),
-    getClassModifiers(props),
-  ]);
-  return (
-    <core.Declaration symbol={thisClassSymbol}>
-      <DocWhen doc={props.doc} />
-      {modifiers}class <Name />
-      {props.typeParameters && (
-        <TypeParameters parameters={props.typeParameters} />
-      )}
-      {base}
-      {props.typeParameters && (
-        <TypeParameterConstraints parameters={props.typeParameters} />
-      )}
-      {!props.children && ";"}
-      {props.children && (
-        <core.Block newline>
-          <core.Scope value={thisClassScope}>{props.children}</core.Scope>
-        </core.Block>
-      )}
-    </core.Declaration>
-  );
-}
-
-export interface ClassConstructorProps extends AccessModifiers {
-  parameters?: Array<ParameterProps>;
-  refkey?: core.Refkey;
-  symbol?: core.OutputSymbol;
-  children?: core.Children;
-}
-
-// a C# class constructor
-export function ClassConstructor(props: ClassConstructorProps) {
-  const scope = useCSharpScope();
-  if (scope.kind !== "member" || scope.name !== "class-decl") {
-    throw new Error(
-      "can't define a class constructor outside of a class-decl scope",
-    );
-  }
-
-  // fetch the class name from the scope
-  const name = useCSharpNamePolicy().getName(scope.owner!.name, "class-method");
-  const ctorSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? core.refkey(name),
-  });
-
-  // scope for ctor declaration
-  const ctorDeclScope = new CSharpMemberScope("constructor-decl", {
-    owner: ctorSymbol,
-  });
-
-  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
-
-  // note that scope wraps the ctor decl so that the params get the correct scope
-  return (
-    <core.Declaration symbol={ctorSymbol}>
-      <core.Scope value={ctorDeclScope}>
-        {modifiers}
-        <Name />
-        <Parameters parameters={props.parameters} />
-        <core.Block newline>{props.children}</core.Block>
-      </core.Scope>
-    </core.Declaration>
-  );
-}
-
-// properties for creating a class member
-export interface ClassMemberProps extends AccessModifiers {
-  name: string;
-  type: core.Children;
-  refkey?: core.Refkey;
-  /** Doc comment */
-  doc?: core.Children;
-}
-
-// a C# class member (i.e. a field within a class like "private int count")
-export function ClassMember(props: ClassMemberProps) {
-  let nameElement: CSharpElements = "class-member-private";
-  if (props.public) {
-    nameElement = "class-member-public";
-  }
-  const name = useCSharpNamePolicy().getName(props.name, nameElement);
-  const scope = useCSharpScope();
-  if (scope.kind !== "member" || scope.name !== "class-decl") {
-    throw new Error(
-      "can't define a class member outside of a class-decl scope",
-    );
-  }
-
-  const memberSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? core.refkey(props.name),
-  });
-
-  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
-  return (
-    <core.Declaration symbol={memberSymbol}>
-      <DocWhen doc={props.doc} />
-      {modifiers}
-      {props.type} <Name />
-    </core.Declaration>
-  );
-}