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

package/src/components/ClassDeclaration.tsx

@@ -1,233 +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 { AttributeList, AttributesProp } from "./attributes/attributes.jsx";
-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[];
-
-  /**
-   * Define attributes to attach
-   * @example
-   * ```tsx
-   * <ClassDeclaration name="MyClass" attributes={[
-   *  <Attribute name="Test" />
-   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
-   * ]}>
-   * ```
-   * This will produce:
-   * ```csharp
-   * [Test]
-   * [Test2("arg1", "arg2")]
-   * public class MyClass
-   * ```
-   */
-  attributes?: AttributesProp;
-}
-
-/**
- * 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} />
-      <AttributeList attributes={props.attributes} endline />
-      {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>
-  );
-}

package/src/components/attributes/attributes.test.tsx

@@ -1,61 +0,0 @@
-import { expect, it } from "vitest";
-import { Attribute, AttributeList } from "./attributes.jsx";
-
-it("define attribute", () => {
-  expect(<Attribute name="Test" />).toRenderTo(`
-      [Test]
-  `);
-});
-
-it("define attribute with single arg", () => {
-  expect(<Attribute name="Test" args={[`"abc"`]} />).toRenderTo(`
-      [Test("abc")]
-  `);
-});
-
-it("define attribute with multiple arg", () => {
-  expect(<Attribute name="Test" args={[`"abc"`, `"def"`]} />).toRenderTo(`
-      [Test("abc", "def")]
-  `);
-});
-
-it("define attribute list with Attribute components", () => {
-  expect(
-    <AttributeList
-      attributes={[<Attribute name="TestA" />, <Attribute name="TestB" />]}
-    />,
-  ).toRenderTo(`
-      [TestA]
-      [TestB]
-  `);
-});
-
-it("define attribute list with attribute names", () => {
-  expect(<AttributeList attributes={["TestA", "TestB"]} />).toRenderTo(`
-      [TestA]
-      [TestB]
-  `);
-});
-
-it("define attribute list with attribute props", () => {
-  expect(
-    <AttributeList
-      attributes={[{ name: "TestA" }, { name: "TestB", args: [`"test"`] }]}
-    />,
-  ).toRenderTo(`
-      [TestA]
-      [TestB("test")]
-  `);
-});
-
-it("define attribute list with children", () => {
-  expect(
-    <AttributeList>
-      <Attribute name="TestA" />
-      <Attribute name="TestB" />
-    </AttributeList>,
-  ).toRenderTo(`
-      [TestA]
-      [TestB]
-  `);
-});

package/src/components/attributes/attributes.tsx

@@ -1,100 +0,0 @@
-import {
-  Children,
-  findKeyedChildren,
-  For,
-  Indent,
-  taggedComponent,
-} from "@alloy-js/core";
-
-export interface AttributeItem {
-  name: string;
-  args?: string[];
-}
-
-export type AttributesProp = Array<string | AttributeProps | Children>;
-
-export interface AttributeListProps {
-  /** If the attribute list should finish with a hard line if there is any attribute */
-  endline?: boolean;
-  attributes?: AttributesProp;
-  children?: Children[];
-}
-
-/**
- * Render each attributes in a new line.
- */
-export function AttributeList(props: AttributeListProps) {
-  const attributes =
-    props.attributes ??
-    (props.children && findKeyedChildren(props.children, Attribute.tag));
-
-  if (!attributes) {
-    return null;
-  }
-
-  return (
-    <>
-      <For each={attributes} line>
-        {(arg) => renderAttribute(arg)}
-      </For>
-      {props.endline && attributes.length > 0 && <hbr />}
-    </>
-  );
-}
-
-function renderAttribute(attr: string | AttributeProps | Children): Children {
-  if (typeof attr === "string") {
-    return <Attribute name={attr} />;
-  } else if (typeof attr === "object" && attr && "name" in attr) {
-    return <Attribute {...attr} />;
-  } else {
-    return attr;
-  }
-}
-
-export interface AttributeProps {
-  /** Attribute name */
-  name: Children;
-
-  /** Argument */
-  args?: Children[];
-}
-
-const AttributeTag = Symbol("AttributeTag");
-/**
- * Render a csharp attribute.
- *
- * @example
- * ```tsx
- * <Attribute name="Test" /><hbr/>
- * <Attribute name="Test" args={["arg1", "arg2"]} />
- * ```
- *
- * will render:
- * ```csharp
- * [Test]
- * [Test("arg1", "arg2")]
- * ```
- */
-export const Attribute = taggedComponent(
-  AttributeTag,
-  (props: AttributeProps) => {
-    return (
-      <group>
-        [{props.name}
-        {props.args && props.args.length > 0 && (
-          <>
-            (
-            <Indent softline>
-              <For each={props.args ?? []} comma line>
-                {(arg) => arg}
-              </For>
-            </Indent>
-            )
-          </>
-        )}
-        ]
-      </group>
-    );
-  },
-);