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

package/src/components/property/property.tsx

@@ -1,172 +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 { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
-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;
-
-  /**
-   * Define attributes to attach
-   * @example
-   * ```tsx
-   * <Property 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# 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} />
-        <AttributeList attributes={props.attributes} endline />
-        {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>
-  );
-}

package/src/components/record/declaration.test.tsx

@@ -1,73 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { Property } from "../property/property.jsx";
-import { RecordDeclaration } from "./declaration.jsx";
-
-it("declares class with no members", () => {
-  expect(
-    <TestNamespace>
-      <RecordDeclaration name="TestRecord" />
-    </TestNamespace>,
-  ).toRenderTo(`
-      record TestRecord;
-  `);
-});
-
-describe("modifiers", () => {
-  it.each(["public", "private", "internal"])("%s", (mod) => {
-    expect(
-      <TestNamespace>
-        <RecordDeclaration {...{ [mod]: true }} name="TestRecord" />
-      </TestNamespace>,
-    ).toRenderTo(`
-        ${mod} record TestRecord;
-    `);
-  });
-
-  it.each(["partial"])("%s", (mod) => {
-    expect(
-      <TestNamespace>
-        <RecordDeclaration {...{ [mod]: true }} name="TestRecord" />
-      </TestNamespace>,
-    ).toRenderTo(`
-        ${mod} record TestRecord;
-    `);
-  });
-
-  it("combines modifiers", () => {
-    expect(
-      <TestNamespace>
-        <RecordDeclaration public partial name="TestRecord" />
-      </TestNamespace>,
-    ).toRenderTo(`
-        public partial record TestRecord;
-    `);
-  });
-});
-
-it("specify doc comment", () => {
-  expect(
-    <TestNamespace>
-      <RecordDeclaration name="TestRecord" doc="This is a test" />
-    </TestNamespace>,
-  ).toRenderTo(`
-    /// This is a test
-    record TestRecord;
-  `);
-});
-
-it("specify class property inside", () => {
-  expect(
-    <TestNamespace>
-      <RecordDeclaration name="TestRecord" doc="This is a test">
-        <Property name="Prop" get set type="string" />
-      </RecordDeclaration>
-    </TestNamespace>,
-  ).toRenderTo(`
-    /// This is a test
-    record TestRecord
-    {
-      string Prop { get; set; }
-    }
-  `);
-});

package/src/components/record/declaration.tsx

@@ -1,109 +0,0 @@
-import * as core 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 } from "../../symbols/scopes.js";
-import { DocWhen } from "../doc/comment.jsx";
-import { Name } from "../Name.jsx";
-
-export interface RecordModifiers {
-  readonly partial?: boolean;
-}
-
-const getRecordModifiers = makeModifiers<RecordModifiers>(["partial"]);
-
-/** Props to use the {@link RecordDeclaration} component */
-export interface RecordDeclarationProps
-  extends Omit<core.DeclarationProps, "nameKind">,
-    AccessModifiers,
-    RecordModifiers {
-  name: string;
-
-  /** Doc comment */
-  doc?: core.Children;
-  refkey?: core.Refkey;
-  typeParameters?: Record<string, core.Refkey>;
-}
-
-/**
- * CSharp record declaration.
- * @example
- * ```tsx
- * <RecordDeclaration public name="IMyRecord">
- *   <RecordMember public name="MyProperty" type="int" />
- *   <RecordMethod public name="MyMethod" returnType="void">
- *     <Parameter name="value" type="int" />
- *   </RecordMethod>
- * </RecordDeclaration>
- * ```
- * This will produce:
- * ```csharp
- * public record MyIface
- * {
- *   public int MyProperty { get; set; }
- *   public void MyMethod(int value);
- * }
- * ```
- */
-export function RecordDeclaration(props: RecordDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "record");
-
-  const thisRecordSymbol = new CSharpOutputSymbol(name, {
-    refkeys: props.refkey,
-  });
-
-  // this creates a new scope for the record definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisRecordScope = new CSharpMemberScope("record-decl", {
-    owner: thisRecordSymbol,
-  });
-
-  let typeParams: core.Children;
-  if (props.typeParameters) {
-    const typeParamNames = new Array<string>();
-    for (const entry of Object.entries(props.typeParameters)) {
-      typeParamNames.push(
-        useCSharpNamePolicy().getName(entry[0], "type-parameter"),
-      );
-      // create a symbol for each type param so its
-      // refkey resolves to the type param's name
-      new CSharpOutputSymbol(entry[0], {
-        scope: thisRecordScope,
-        refkeys: entry[1],
-      });
-    }
-    typeParams = (
-      <group>
-        {"<"}
-        <core.For each={typeParamNames} comma line>
-          {(name) => name}
-        </core.For>
-        {">"}
-      </group>
-    );
-  }
-
-  const modifiers = computeModifiersPrefix([
-    getAccessModifier(props),
-    getRecordModifiers(props),
-  ]);
-  return (
-    <core.Declaration symbol={thisRecordSymbol}>
-      <DocWhen doc={props.doc} />
-      {modifiers}record <Name />
-      {typeParams}
-      {props.children ?
-        <core.Block newline>
-          <core.Scope value={thisRecordScope}>{props.children}</core.Scope>
-        </core.Block>
-      : ";"}
-    </core.Declaration>
-  );
-}

package/src/components/type-parameters/type-parameter-constraints.test.tsx

@@ -1,93 +0,0 @@
-import { expect, it } from "vitest";
-import { TypeParameterConstraints } from "./type-parameter-constraints.jsx";
-
-it("renders nothing if there is no constraints", () => {
-  expect(<TypeParameterConstraints parameters={["A", "B"]} />).toRenderTo(``);
-});
-
-it("renders inline if there is only one", () => {
-  expect(
-    <>
-      {"code()"}
-      <TypeParameterConstraints
-        parameters={[{ name: "A", constraints: "string" }]}
-      />
-    </>,
-  ).toRenderTo(`
-    code() where A : string
-  `);
-});
-
-it("renders multiple constraints", () => {
-  expect(
-    <>
-      {"code()"}
-      <TypeParameterConstraints
-        parameters={[{ name: "A", constraints: ["string", "int"] }]}
-      />
-    </>,
-  ).toRenderTo(`
-    code() where A : string, int
-  `);
-});
-
-it("renders newline if constraint is very long", () => {
-  expect(
-    <>
-      {"code()"}
-      <TypeParameterConstraints
-        parameters={[
-          {
-            name: "ThisIsQuiteALongName",
-            constraints: "VeryLongBuilderFactorySingletonThatShouldBeSplit",
-          },
-        ]}
-      />
-    </>,
-  ).toRenderTo(`
-    code()
-      where ThisIsQuiteALongName : VeryLongBuilderFactorySingletonThatShouldBeSplit
-  `);
-});
-
-it("renders multiple constraints on new lines if they are very long", () => {
-  expect(
-    <>
-      {"code()"}
-      <TypeParameterConstraints
-        parameters={[
-          {
-            name: "A",
-            constraints: [
-              "IVeryLongBuilderFactorySingletonThatShouldBeSplitA",
-              "IVeryLongBuilderFactorySingletonThatShouldBeSplitB",
-            ],
-          },
-        ]}
-      />
-    </>,
-  ).toRenderTo(`
-    code()
-      where A :
-        IVeryLongBuilderFactorySingletonThatShouldBeSplitA,
-        IVeryLongBuilderFactorySingletonThatShouldBeSplitB
-  `);
-});
-
-it("declare type parameters using parameters", () => {
-  expect(
-    <>
-      {"code()"}
-      <TypeParameterConstraints
-        parameters={[
-          { name: "A", constraints: "string" },
-          { name: "B", constraints: "string" },
-        ]}
-      />
-    </>,
-  ).toRenderTo(`
-    code()
-      where A : string
-      where B : string
-  `);
-});

package/src/components/type-parameters/type-parameter-constraints.tsx

@@ -1,46 +0,0 @@
-import { Children, code, For, Indent } from "@alloy-js/core";
-import { TypeParameterProps } from "./type-parameter.jsx";
-import { normalizeParameters } from "./type-parameters.jsx";
-
-export interface TypeParameterConstraintsProps {
-  /** Parameters */
-  parameters: (TypeParameterProps | string)[];
-}
-
-export function TypeParameterConstraints(
-  props: TypeParameterConstraintsProps,
-): Children {
-  const parameters = normalizeParameters(props.parameters);
-  if (!parameters.some((x) => x.constraints)) {
-    return null;
-  }
-  return (
-    <group>
-      <Indent line>
-        <For each={parameters} hardline>
-          {(param) => <TypeParameterConstraint {...param} />}
-        </For>
-      </Indent>
-    </group>
-  );
-}
-
-function TypeParameterConstraint(props: TypeParameterProps): Children {
-  const constraints = arrayify(props.constraints);
-  return (
-    <>
-      where {code`${props.name} : `}
-      <group>
-        <Indent softline>
-          <For each={constraints} comma line>
-            {(constraint) => code`${constraint}`}
-          </For>
-        </Indent>
-      </group>
-    </>
-  );
-}
-
-function arrayify<T>(value: T | T[]): T[] {
-  return Array.isArray(value) ? value : [value];
-}

package/src/components/type-parameters/type-parameter.tsx

@@ -1,35 +0,0 @@
-import { Children, MemberDeclaration, 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";
-
-/**
- * Information for a TypeScript generic type parameter.
- */
-export interface TypeParameterProps {
-  /**
-   * The name of the type parameter.
-   */
-  readonly name: string;
-
-  /**
-   * The parameter constraint
-   */
-  readonly constraints?: Children | Children[];
-
-  /**
-   * A refkey or array of refkeys for this type parameter.
-   */
-  readonly refkey?: Refkey | Refkey[];
-}
-
-export function TypeParameter(props: TypeParameterProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "type-parameter");
-  const scope = useCSharpScope();
-  const symbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
-  });
-
-  return <MemberDeclaration symbol={symbol}>{name}</MemberDeclaration>;
-}

package/src/components/type-parameters/type-parameters.test.tsx

@@ -1,46 +0,0 @@
-import { expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { TypeParameters } from "./type-parameters.jsx";
-
-it("render one", () => {
-  expect(
-    <TestNamespace>
-      <TypeParameters parameters={["A"]} />
-    </TestNamespace>,
-  ).toRenderTo(`<A>`);
-});
-
-it("render very long", () => {
-  expect(
-    <TestNamespace>
-      <TypeParameters
-        parameters={[
-          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesA",
-          "SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesB",
-        ]}
-      />
-    </TestNamespace>,
-  ).toRenderTo(
-    `
-    <
-      SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesA,
-      SomeVeryVeryLongParamThatMightGetSplitOverMultipleLinesB>
-    `,
-  );
-});
-
-it("declare type parameters using parameters names", () => {
-  expect(
-    <TestNamespace>
-      <TypeParameters parameters={["A", "B"]} />
-    </TestNamespace>,
-  ).toRenderTo(`<A, B>`);
-});
-
-it("declare type parameters using parameters", () => {
-  expect(
-    <TestNamespace>
-      <TypeParameters parameters={[{ name: "A" }, { name: "B" }]} />
-    </TestNamespace>,
-  ).toRenderTo(`<A, B>`);
-});

package/src/components/type-parameters/type-parameters.tsx

@@ -1,63 +0,0 @@
-import { For, Indent, taggedComponent } from "@alloy-js/core";
-import { TypeParameter, TypeParameterProps } from "./type-parameter.jsx";
-
-export const typeParametersTag = Symbol.for("csharp.type-parameters");
-
-export interface TypeParametersProps {
-  /** Parameters */
-  parameters: (TypeParameterProps | string)[];
-}
-
-/**
- * Represent type parameters
- *
- * @example
- * ```ts
- * <A, B extends string>
- * ```
- */
-export const TypeParameters = taggedComponent(
-  typeParametersTag,
-  function TypeParameters(props: TypeParametersProps) {
-    const typeParameters = normalizeParameters(props.parameters);
-
-    return (
-      <>
-        {"<"}
-        <group>
-          <Indent softline>
-            <For each={typeParameters} comma line>
-              {(param) => <TypeParameter {...param} />}
-            </For>
-          </Indent>
-        </group>
-        {">"}
-      </>
-    );
-  },
-);
-
-export function normalizeParameters(
-  parameters: (TypeParameterProps | string)[],
-): TypeParameterProps[] {
-  return parameters.map((param) => {
-    if (typeof param === "string") {
-      return { name: param };
-    }
-    return param;
-  });
-}
-
-// export function declareParameter(
-//   parameters: TypeParameterProps[],
-// ): TypeParameterProps[] {
-//   return parameters.map((param) => {
-//     return {
-//       ...param,
-//       symbol: new CSharpOutputSymbol(entry[0], {
-//         scope: thisClassScope,
-//         refkeys: entry[1],
-//       }),
-//     };
-//   });
-// }

package/src/components/var/declaration.test.tsx

@@ -1,59 +0,0 @@
-import { List, refkey } from "@alloy-js/core";
-import { expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { SourceFile } from "../SourceFile.jsx";
-import { VarDeclaration } from "./declaration.jsx";
-
-it("declares var without type", () => {
-  expect(
-    <TestNamespace>
-      <VarDeclaration name="testVar">42</VarDeclaration>
-    </TestNamespace>,
-  ).toRenderTo(`
-      var testVar = 42;
-  `);
-});
-
-it("declares var with type", () => {
-  expect(
-    <TestNamespace>
-      <VarDeclaration name="testVar" type="int">
-        42
-      </VarDeclaration>
-    </TestNamespace>,
-  ).toRenderTo(`
-      int testVar = 42;
-  `);
-});
-
-it("name variables camel case", () => {
-  expect(
-    <TestNamespace>
-      <VarDeclaration name="test_var">42</VarDeclaration>
-    </TestNamespace>,
-  ).toRenderTo(`
-      var testVar = 42;
-  `);
-});
-
-it("links refkey", () => {
-  const key = refkey();
-  expect(
-    <TestNamespace>
-      <SourceFile path="test.cs">
-        <List>
-          <VarDeclaration name="testVar" refkey={key}>
-            42
-          </VarDeclaration>
-          <VarDeclaration name="testVar2">{key}</VarDeclaration>
-        </List>
-      </SourceFile>
-    </TestNamespace>,
-  ).toRenderTo(`
-      namespace TestCode
-      {
-        var testVar = 42;
-        var testVar2 = testVar;
-      }
-  `);
-});