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

package/src/components/interface/property.test.tsx

@@ -1,144 +0,0 @@
-import { Children } from "@alloy-js/core/jsx-runtime";
-import { describe, expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { InterfaceDeclaration } from "./declaration.jsx";
-import { InterfaceProperty } from "./property.jsx";
-
-const Wrapper = (props: { children: Children }) => (
-  <TestNamespace>
-    <InterfaceDeclaration public name="TestInterface">
-      {props.children}
-    </InterfaceDeclaration>
-  </TestNamespace>
-);
-
-describe("modifiers", () => {
-  describe("access modifiers", () => {
-    it.each(["public", "private", "protected", "internal"] as const)(
-      "%s",
-      (accessModifier) => {
-        expect(
-          <Wrapper>
-            <InterfaceProperty
-              {...{ [accessModifier]: true }}
-              name="TestProp"
-              type="string"
-              get
-            />
-          </Wrapper>,
-        ).toRenderTo(`
-        public interface TestInterface
-        {
-          ${accessModifier} string TestProp { get; }
-        }
-      `);
-      },
-    );
-  });
-
-  describe("method modifiers", () => {
-    it.each(["new"] as const)("%s", (methodModifier) => {
-      expect(
-        <Wrapper>
-          <InterfaceProperty
-            {...{ [methodModifier]: true }}
-            name="TestProp"
-            type="string"
-            get
-          />
-        </Wrapper>,
-      ).toRenderTo(`
-        public interface TestInterface
-        {
-          ${methodModifier} string TestProp { get; }
-        }
-      `);
-    });
-  });
-
-  it("combine modifiers", () => {
-    expect(
-      <Wrapper>
-        <InterfaceProperty public new name="TestProp" type="string" get />
-      </Wrapper>,
-    ).toRenderTo(`
-        public interface TestInterface
-        {
-          public new string TestProp { get; }
-        }
-      `);
-  });
-});
-
-it("applies PascalCase naming policy", () => {
-  expect(
-    <Wrapper>
-      <InterfaceProperty name="test_prop" type="string" get />
-    </Wrapper>,
-  ).toRenderTo(`
-    public interface TestInterface
-    {
-      string TestProp { get; }
-    }
-`);
-});
-
-it("has getter only", () => {
-  expect(
-    <Wrapper>
-      <InterfaceProperty name="TestProp" type="string" get />
-    </Wrapper>,
-  ).toRenderTo(`
-    public interface TestInterface
-    {
-      string TestProp { get; }
-    }
-  `);
-});
-
-it("has setter only", () => {
-  expect(
-    <Wrapper>
-      <InterfaceProperty name="TestProp" type="string" set />
-    </Wrapper>,
-  ).toRenderTo(`
-    public interface TestInterface
-    {
-      string TestProp { set; }
-    }
-  `);
-});
-it("has getter and setter", () => {
-  expect(
-    <Wrapper>
-      <InterfaceProperty name="TestProp" type="string" get set />
-    </Wrapper>,
-  ).toRenderTo(`
-    public interface TestInterface
-    {
-      string TestProp { get; set; }
-    }
-  `);
-});
-
-it("specify doc comment", () => {
-  expect(
-    <TestNamespace>
-      <InterfaceDeclaration name="Test">
-        <InterfaceProperty
-          name="Method"
-          type="string"
-          get
-          set
-          doc="This is a test"
-        />
-      </InterfaceDeclaration>
-    </TestNamespace>,
-  ).toRenderTo(`
-    interface Test
-    {
-      /// This is a test
-      string Method { get; set; }
-    }
-  `);
-});

package/src/components/interface/property.tsx

@@ -1,107 +0,0 @@
-import {
-  Block,
-  Children,
-  List,
-  MemberDeclaration,
-  refkey,
-  Refkey,
-  Scope,
-} from "@alloy-js/core";
-import {
-  AccessModifiers,
-  computeModifiersPrefix,
-  getAccessModifier,
-  makeModifiers,
-} from "../../modifiers.js";
-import { 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";
-
-/** Method modifiers. Can only be one. */
-export interface InterfacePropertyModifiers {
-  readonly new?: boolean;
-}
-
-const getModifiers = makeModifiers<InterfacePropertyModifiers>(["new"]);
-
-// properties for creating a method
-export interface InterfacePropertyProps
-  extends AccessModifiers,
-    InterfacePropertyModifiers {
-  name: string;
-  refkey?: Refkey;
-
-  /** Property type */
-  type: Children;
-
-  /** If property should have a getter */
-  get?: boolean;
-
-  /** If property should have a setter */
-  set?: boolean;
-
-  /** Doc comment */
-  doc?: Children;
-
-  /**
-   * Property initializer
-   * @example `<ClassProperty name="My" get set nullable />`
-   *
-   * ```cs
-   * int? My { get; set; };
-   * ```
-   */
-  nullable?: boolean;
-}
-
-/**
- * Render a C# interface property.
- *
- * @example `<InterfaceProperty public name="My" get set  />`
- *
- * ```cs
- * public int My { get; set; };
- * ```
- */
-export function InterfaceProperty(props: InterfacePropertyProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "class-property");
-  const scope = useCSharpScope();
-  if (scope.kind !== "member" || scope.name !== "interface-decl") {
-    throw new Error(
-      "can't define an interface method outside of an interface scope",
-    );
-  }
-
-  const propertySymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
-  });
-
-  // scope for property declaration
-  const propertyScope = new CSharpMemberScope("property-decl", {
-    owner: propertySymbol,
-  });
-
-  const modifiers = computeModifiersPrefix([
-    getAccessModifier(props),
-    getModifiers(props),
-  ]);
-  // note that scope wraps the method decl so that the params get the correct scope
-  return (
-    <MemberDeclaration symbol={propertySymbol}>
-      <Scope value={propertyScope}>
-        <DocWhen doc={props.doc} />
-        {modifiers}
-        {props.type}
-        {props.nullable && "?"} {name}{" "}
-        <Block newline inline>
-          <List joiner=" ">
-            {props.get && "get;"}
-            {props.set && "set;"}
-          </List>
-        </Block>
-      </Scope>
-    </MemberDeclaration>
-  );
-}

package/src/components/parameters/parameters.tsx

@@ -1,74 +0,0 @@
-import {
-  Children,
-  code,
-  Declaration,
-  For,
-  Indent,
-  OutputSymbol,
-  refkey,
-  Refkey,
-} from "@alloy-js/core";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { useCSharpScope } from "../../symbols/scopes.js";
-import { Name } from "../Name.jsx";
-
-export interface ParameterProps {
-  name: string;
-  type: Children;
-  /** If the parmaeter is optional(without default value) */
-  optional?: boolean;
-  /** Default value for the parameter */
-  default?: Children;
-  refkey?: Refkey;
-  symbol?: OutputSymbol;
-}
-
-/** Define a parameter to be used in class or interface method. */
-export function Parameter(props: ParameterProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "parameter");
-  const scope = useCSharpScope();
-  if (
-    scope.kind !== "member" ||
-    (scope.name !== "constructor-decl" && scope.name !== "method-decl")
-  ) {
-    throw new Error(
-      "can't define a parameter outside of a constructor-decl or method-decl scope",
-    );
-  }
-
-  const memberSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
-  });
-
-  return (
-    <Declaration symbol={memberSymbol}>
-      {props.type}
-      {props.optional ? "?" : ""} <Name />
-      {props.default ? code` = ${props.default}` : ""}
-    </Declaration>
-  );
-}
-
-export interface ParametersProps {
-  parameters: ParameterProps[] | undefined;
-}
-
-/** Render a collection of parameters */
-export function Parameters(props: ParametersProps) {
-  return (
-    <group>
-      {"("}
-      {props.parameters && (
-        <Indent softline>
-          <For each={props.parameters} joiner={", "}>
-            {(param) => <Parameter {...param} />}
-          </For>
-        </Indent>
-      )}
-      <softline />
-      {")"}
-    </group>
-  );
-}

package/src/components/property/property.test.tsx

@@ -1,188 +0,0 @@
-import { Children } from "@alloy-js/core/jsx-runtime";
-import { describe, expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { ClassDeclaration } from "../ClassDeclaration.jsx";
-import { Property } from "./property.jsx";
-
-const Wrapper = (props: { children: Children }) => (
-  <TestNamespace>
-    <ClassDeclaration public name="TestClass">
-      {props.children}
-    </ClassDeclaration>
-  </TestNamespace>
-);
-
-describe("modifiers", () => {
-  describe("access modifiers", () => {
-    it.each(["public", "private", "protected", "internal"] as const)(
-      "%s",
-      (accessModifier) => {
-        expect(
-          <Wrapper>
-            <Property
-              {...{ [accessModifier]: true }}
-              name="TestProp"
-              type="string"
-              get
-            />
-          </Wrapper>,
-        ).toRenderTo(`
-        public class TestClass
-        {
-          ${accessModifier} string TestProp { get; }
-        }
-      `);
-      },
-    );
-  });
-
-  describe("property modifiers", () => {
-    it.each([
-      "new",
-      "static",
-      "virtual",
-      "sealed",
-      "override",
-      "abstract",
-      "extern",
-      "readonly",
-      "required",
-    ] as const)("%s", (methodModifier) => {
-      expect(
-        <Wrapper>
-          <Property
-            {...{ [methodModifier]: true }}
-            name="TestProp"
-            type="string"
-            get
-          />
-        </Wrapper>,
-      ).toRenderTo(`
-        public class TestClass
-        {
-          ${methodModifier} string TestProp { get; }
-        }
-      `);
-    });
-  });
-
-  it("combine modifiers", () => {
-    expect(
-      <Wrapper>
-        <Property public new name="TestProp" type="string" get />
-      </Wrapper>,
-    ).toRenderTo(`
-        public class TestClass
-        {
-          public new string TestProp { get; }
-        }
-      `);
-  });
-});
-
-it("applies PascalCase naming policy", () => {
-  expect(
-    <Wrapper>
-      <Property name="test_prop" type="string" get />
-    </Wrapper>,
-  ).toRenderTo(`
-    public class TestClass
-    {
-      string TestProp { get; }
-    }
-`);
-});
-
-it("has getter only", () => {
-  expect(
-    <Wrapper>
-      <Property name="TestProp" type="string" get />
-    </Wrapper>,
-  ).toRenderTo(`
-    public class TestClass
-    {
-      string TestProp { get; }
-    }
-  `);
-});
-
-it("has setter only", () => {
-  expect(
-    <Wrapper>
-      <Property name="TestProp" type="string" set />
-    </Wrapper>,
-  ).toRenderTo(`
-    public class TestClass
-    {
-      string TestProp { set; }
-    }
-  `);
-});
-
-it("has getter and setter", () => {
-  expect(
-    <Wrapper>
-      <Property name="TestProp" type="string" get set />
-    </Wrapper>,
-  ).toRenderTo(`
-    public class TestClass
-    {
-      string TestProp { get; set; }
-    }
-  `);
-});
-
-it("has getter and init", () => {
-  expect(
-    <Wrapper>
-      <Property name="TestProp" type="string" get init />
-    </Wrapper>,
-  ).toRenderTo(`
-    public class TestClass
-    {
-      string TestProp { get; init; }
-    }
-  `);
-});
-
-it("specify doc comment", () => {
-  expect(
-    <TestNamespace>
-      <ClassDeclaration name="Test">
-        <Property name="Method" type="string" get set doc="This is a test" />
-      </ClassDeclaration>
-    </TestNamespace>,
-  ).toRenderTo(`
-    class Test
-    {
-      /// This is a test
-      string Method { get; set; }
-    }
-  `);
-});
-
-it("specify nullable property", () => {
-  expect(
-    <Wrapper>
-      <Property name="TestProp" type="string" nullable get set />
-    </Wrapper>,
-  ).toRenderTo(`
-    public class TestClass
-    {
-      string? TestProp { get; set; }
-    }
-  `);
-});
-
-it("specify initializer", () => {
-  expect(
-    <Wrapper>
-      <Property name="TestProp" type="string" get set initializer={`"abc"`} />
-    </Wrapper>,
-  ).toRenderTo(`
-    public class TestClass
-    {
-      string TestProp { get; set; } = "abc";
-    }
-  `);
-});

package/src/components/property/property.tsx

@@ -1,152 +0,0 @@
-import {
-  Block,
-  Children,
-  code,
-  List,
-  MemberDeclaration,
-  refkey,
-  Refkey,
-  Scope,
-} from "@alloy-js/core";
-import {
-  AccessModifiers,
-  computeModifiersPrefix,
-  getAccessModifier,
-  makeModifiers,
-} from "../../modifiers.js";
-import { 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";
-
-/** Property modifiers. */
-export interface PropertyModifiers {
-  readonly new?: boolean;
-  readonly static?: boolean;
-  readonly virtual?: boolean;
-  readonly sealed?: boolean;
-  readonly override?: boolean;
-  readonly abstract?: boolean;
-  readonly extern?: boolean;
-  readonly readonly?: boolean;
-  /**
-   * Set required modifier on property
-   * https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required
-   */
-  readonly required?: boolean;
-}
-
-const getModifiers = makeModifiers<PropertyModifiers>([
-  "new",
-  "static",
-  "virtual",
-  "sealed",
-  "override",
-  "abstract",
-  "extern",
-  "readonly",
-  "required",
-]);
-
-/** Properties for {@link Property} component */
-export interface PropertyProps extends AccessModifiers, PropertyModifiers {
-  name: string;
-  refkey?: Refkey;
-
-  /** Property type */
-  type: Children;
-
-  /** If property should have a getter */
-  get?: boolean;
-
-  /** If property should have a setter */
-  set?: boolean;
-
-  /** If property should only be set on the type creation */
-  init?: boolean;
-
-  /** Doc comment */
-  doc?: Children;
-
-  /**
-   * Property initializer
-   * @example `<ClassProperty name="My" get set nullable />`
-   *
-   * ```cs
-   * int? My { get; set; };
-   * ```
-   */
-  nullable?: boolean;
-
-  /**
-   * Property initializer
-   * @example `<ClassProperty name="My" get set init={42} />`
-   *
-   * ```cs
-   * int My { get; set; } = 42;
-   * ```
-   */
-  initializer?: Children;
-}
-
-/**
- * Render a C# class property.
- *
- * @example `<ClassProperty public name="My" get set  />`
- *
- * ```cs
- * public int My { get; set; };
- * ```
- */
-export function Property(props: PropertyProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "class-property");
-  const scope = useCSharpScope();
-  if (
-    scope.kind !== "member" ||
-    (scope.name !== "class-decl" && scope.name !== "record-decl")
-  ) {
-    throw new Error(
-      "can't define an interface method outside of an interface scope",
-    );
-  }
-
-  const propertySymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
-  });
-
-  // scope for property declaration
-  const propertyScope = new CSharpMemberScope("property-decl", {
-    owner: propertySymbol,
-  });
-
-  const modifiers = computeModifiersPrefix([
-    getAccessModifier(props),
-    getModifiers(props),
-  ]);
-
-  if (props.init && props.set) {
-    throw new Error(
-      `Cannot use 'init' and 'set' together on property '${name}'`,
-    );
-  }
-  // note that scope wraps the method decl so that the params get the correct scope
-  return (
-    <MemberDeclaration symbol={propertySymbol}>
-      <Scope value={propertyScope}>
-        <DocWhen doc={props.doc} />
-        {modifiers}
-        {props.type}
-        {props.nullable && "?"} {name}{" "}
-        <Block newline inline>
-          <List joiner=" ">
-            {props.get && "get;"}
-            {props.set && "set;"}
-            {props.init && "init;"}
-          </List>
-        </Block>
-        {props.initializer && code` = ${props.initializer};`}
-      </Scope>
-    </MemberDeclaration>
-  );
-}