@alloy-js/csharp 0.18.0-dev.19 → 0.18.0-dev.2

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,19 +0,0 @@
-import { expect, it } from "vitest";
-import { TestNamespace } from "../../../test/utils.jsx";
-import { TypeParameters } from "./type-parameters.jsx";
-
-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,72 +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);
-
-    // const typeParameters = normalizeAndDeclareParameters(props.parameters);
-
-    // onCleanup(() => {
-    //   for (const param of typeParameters) {
-    //     param.symbol.delete();
-    //   }
-    // });
-
-    return (
-      <>
-        {"<"}
-        <group>
-          <Indent softline>
-            <For each={typeParameters} comma line>
-              {(param) => <TypeParameter {...param} />}
-            </For>
-            <ifBreak>,</ifBreak>
-          </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;
-      }
-  `);
-});

package/src/components/var/declaration.tsx

@@ -1,47 +0,0 @@
-import { Children, DeclarationProps, Name, Refkey } from "@alloy-js/core";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { Declaration } from "../Declaration.jsx";
-
-/** Props for {@link VarDeclaration} component */
-export interface VarDeclarationProps
-  extends Omit<DeclarationProps, "nameKind"> {
-  /** Variable name */
-  name: string;
-  /** Type of the variable declaration. If not specified, defaults to "var" */
-  type?: Children;
-  /** Variable refkey */
-  refkey?: Refkey;
-  /** Variable value */
-  children?: Children;
-}
-
-/**
- * Render a variable declaration
- *
- * @example with var
- * ```tsx
- * <VarDeclaration name="myVar">42</VarDeclaration>
- * ```
- * This will render:
- * ```csharp
- * var myVar = 42;
- * ```
- *
- * @example with type
- * ```tsx
- * <VarDeclaration name="myVar" type="int">42</VarDeclaration>
- * ```
- * This will render:
- * ```csharp
- * int myVar = 42;
- * ```
- */
-export function VarDeclaration(props: VarDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "variable");
-
-  return (
-    <Declaration name={name} refkey={props.refkey}>
-      {props.type ?? "var"} <Name /> = {props.children};
-    </Declaration>
-  );
-}