@alloy-js/csharp 0.18.0-dev.24 → 0.18.0-dev.4

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

@@ -1,165 +0,0 @@
-import { Children } from "@alloy-js/core/jsx-runtime";
-import { describe, expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { Attribute } from "../attributes/attributes.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; }
-    }
-  `);
-});
-
-it("specify attributes", () => {
-  expect(
-    <Wrapper>
-      <InterfaceProperty
-        name="Test"
-        type="int"
-        attributes={[<Attribute name="Test" />]}
-        get
-        set
-      />
-    </Wrapper>,
-  ).toRenderTo(`
-    public interface TestInterface
-    {
-      [Test]
-      int Test { get; set; }
-    }
-  `);
-});

package/src/components/interface/property.tsx

@@ -1,127 +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 { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
-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;
-
-  /**
-   * Define attributes to attach
-   * @example
-   * ```tsx
-   * <InterfaceProperty name="MyProp" attributes={[
-   *  <Attribute name="Test" />
-   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
-   * ]} />
-   * ```
-   * This will produce:
-   * ```csharp
-   * [Test]
-   * [Test2("arg1", "arg2")]
-   * int MyProp { get; set; }
-   * ```
-   */
-  attributes?: AttributesProp;
-}
-
-/**
- * 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} />
-        <AttributeList attributes={props.attributes} endline />
-        {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,209 +0,0 @@
-import { Children } from "@alloy-js/core/jsx-runtime";
-import { describe, expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { Attribute } from "../attributes/attributes.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";
-    }
-  `);
-});
-
-it("specify attributes", () => {
-  expect(
-    <Wrapper>
-      <Property
-        name="Test"
-        type="int"
-        attributes={[<Attribute name="Test" />]}
-        get
-        set
-      />
-    </Wrapper>,
-  ).toRenderTo(`
-    public class TestClass
-    {
-      [Test]
-      int Test { get; set; }
-    }
-  `);
-});