@alloy-js/csharp 0.18.0-dev.8 → 0.18.0

package/src/components/doc/comment.tsx

@@ -1,4 +1,4 @@
-import { Children, code, List, Prose, Show } from "@alloy-js/core";
+import { Children, code, For, Indent, List, Prose, Show } from "@alloy-js/core";
 
 export interface DocCommentProps {
   children: Children;
@@ -53,7 +53,7 @@ export function makeInlineDocCommentTag(name: string) {
 
 export const DocSummary = makeDocCommentTag("summary");
 export const DocCode = makeDocCommentTag("code");
-export const DocC = makeDocCommentTag("c");
+export const DocC = makeInlineDocCommentTag("c");
 export const DocExample = makeDocCommentTag("example");
 export const DocException = makeDocCommentTag("exception");
 
@@ -85,29 +85,40 @@ export const DocReturns = makeDocCommentTag("returns");
 export const DocRemarks = makeDocCommentTag("remarks");
 export const DocValue = makeDocCommentTag("value");
 export const DocPermission = makeDocCommentTag("permission");
-export const DocResponse = makeDocCommentTag("response");
-export const DocCompletionList = makeDocCommentTag("completionlist");
-export const DocList = makeDocCommentTag("list");
-export const DocItem = makeDocCommentTag("item");
-export const DocTerm = makeDocCommentTag("term");
 export const DocDescription = makeDocCommentTag("description");
 export const DocPara = makeDocCommentTag("para");
 
 export interface DocSeeProps {
-  cref: string;
+  cref?: string;
+  href?: string;
   langword?: string;
   children?: Children;
 }
-export const DocSee = (props: DocSeeProps) =>
-  `<see cref="${props.cref}"${props.langword ? ` langword="${props.langword}"` : ""}${props.children ? `>${props.children}</see>` : " />"}`;
+export const DocSee = (props: DocSeeProps) => {
+  const attributes = [
+    props.cref ? `cref="${props.cref}"` : undefined,
+    props.href ? `href="${props.href}"` : undefined,
+    props.langword ? `langword="${props.langword}"` : undefined,
+  ]
+    .filter(Boolean)
+    .join(" ");
+  return code`<see ${attributes}${props.children ? code`>${props.children}</see>` : " />"}`;
+};
 
 export interface DocSeeAlsoProps {
-  cref: string;
-  langword?: string;
+  cref?: string;
+  href?: string;
   children?: Children;
 }
-export const DocSeeAlso = (props: DocSeeAlsoProps) =>
-  `<seealso cref="${props.cref}"${props.langword ? ` langword="${props.langword}"` : ""}${props.children ? `>${props.children}</seealso>` : " />"}`;
+export const DocSeeAlso = (props: DocSeeAlsoProps) => {
+  const attributes = [
+    props.cref ? `cref="${props.cref}"` : undefined,
+    props.href ? `href="${props.href}"` : undefined,
+  ]
+    .filter(Boolean)
+    .join(" ");
+  return code`<seealso ${attributes}${props.children ? code`>${props.children}</seealso>` : " />"}`;
+};
 
 export interface DocParamRefProps {
   name: string;
@@ -120,3 +131,22 @@ export interface DocTypeParamRefProps {
 }
 export const DocTypeParamRef = (props: DocTypeParamRefProps) =>
   `<typeparamref name="${props.name}" />`;
+
+export interface DocListProps {
+  type?: "bullet" | "number";
+  items: Children[];
+}
+export function DocList(props: DocListProps) {
+  return (
+    <Prose>
+      {`<list type="${props.type ?? "bullet"}">`}
+      <Indent>
+        <For each={props.items}>
+          {(item) => code`<item><description>${item}</description></item>`}
+        </For>
+      </Indent>
+      <hbr />
+      {`</list>`}
+    </Prose>
+  );
+}

package/src/components/doc/from-markdown.test.tsx

@@ -0,0 +1,103 @@
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import { DocFromMarkdown } from "./from-markdown.jsx";
+
+it("convert code block to <code>", () => {
+  expect(
+    <DocFromMarkdown
+      markdown={d`
+        Some markdown with code
+        \`\`\`csharp
+        var foo = "bar";
+        \`\`\`
+    `}
+    />,
+  ).toRenderTo(`
+    Some markdown with code
+    <code>
+    var foo = "bar";
+    </code>
+  `);
+});
+
+it("convert inline code block to <c>", () => {
+  expect(
+    <DocFromMarkdown
+      markdown={d`
+        Some markdown with \`inline\` code
+    `}
+    />,
+  ).toRenderTo(`
+    Some markdown with <c>inline</c> code
+  `);
+});
+
+it("convert link to <see>", () => {
+  expect(
+    <DocFromMarkdown
+      markdown={d`
+        Some markdown with [link](https://example.com)
+    `}
+    />,
+  ).toRenderTo(`
+    Some markdown with <see href="https://example.com">link</see>
+  `);
+});
+
+it("convert bullet list to <list>", () => {
+  expect(
+    <DocFromMarkdown
+      markdown={d`
+        - Item 1
+        - Item 2
+        - Item 3
+    `}
+    />,
+  ).toRenderTo(`
+    <list type="bullet">
+      <item><description>Item 1</description></item>
+      <item><description>Item 2</description></item>
+      <item><description>Item 3</description></item>
+    </list>
+  `);
+});
+
+it("convert numbered list to <list>", () => {
+  expect(
+    <DocFromMarkdown
+      markdown={d`
+        1. Item 1
+        2. Item 2
+        3. Item 3
+    `}
+    />,
+  ).toRenderTo(`
+    <list type="number">
+      <item><description>Item 1</description></item>
+      <item><description>Item 2</description></item>
+      <item><description>Item 3</description></item>
+    </list>
+  `);
+});
+
+describe("strip unsupported elements", () => {
+  it("bold", () => {
+    expect(
+      <DocFromMarkdown
+        markdown={d`
+        Some markdown with **bold** text
+    `}
+      />,
+    ).toRenderTo(`Some markdown with bold text`);
+  });
+
+  it("italic", () => {
+    expect(
+      <DocFromMarkdown
+        markdown={d`
+        Some markdown with *italic* text
+    `}
+      />,
+    ).toRenderTo(`Some markdown with italic text`);
+  });
+});

package/src/components/doc/from-markdown.tsx

@@ -0,0 +1,58 @@
+import { marked, Tokens, type Token } from "marked";
+import { DocC, DocCode, DocList, DocSee } from "./comment.jsx";
+
+export interface DocFromMarkdownProps {
+  markdown: string;
+}
+
+/** Convert markdown to a Csharp doc comment */
+export function DocFromMarkdown(props: DocFromMarkdownProps) {
+  const tokens = marked.lexer(props.markdown);
+  return renderTokens(tokens);
+}
+
+function renderTokens(tokens: Token[]) {
+  return (
+    <>
+      {tokens.map((token, index) => (
+        <>
+          <DocFromMarkedToken token={token} />
+          {token.type === "paragraph" && index !== tokens.length - 1 && <br />}
+        </>
+      ))}
+    </>
+  );
+}
+
+function DocFromMarkedToken(props: { token: Token }) {
+  const { token } = props;
+  switch (token.type) {
+    case "paragraph":
+      return token.tokens ? renderTokens(token.tokens) : null;
+    case "code":
+      return <DocCode>{token.text}</DocCode>;
+    case "codespan":
+      return <DocC>{token.text}</DocC>;
+    case "list":
+      return (
+        <DocList
+          type={token.ordered ? "number" : "bullet"}
+          items={token.items.map((x: Tokens.ListItem) => (
+            <>{renderTokens(x.tokens)}</>
+          ))}
+        />
+      );
+    case "link":
+      return (
+        <DocSee href={token.href}>
+          {token.tokens && renderTokens(token.tokens)}
+        </DocSee>
+      );
+    case "strong":
+    case "em":
+      return token.text;
+    case "text":
+    default:
+      return token.raw;
+  }
+}

package/src/components/index.ts

@@ -1,13 +1,21 @@
+export * from "./attributes/attributes.jsx";
 export * from "./ClassDeclaration.jsx";
 export * from "./ClassMethod.jsx";
 export * from "./Declaration.js";
+export * from "./doc/comment.jsx";
+export * from "./doc/from-markdown.jsx";
 export * from "./EnumDeclaration.jsx";
 export * from "./interface/declaration.js";
 export * from "./interface/method.js";
+export * from "./interface/property.js";
 export * from "./Name.js";
 export * from "./Namespace.js";
-export * from "./Parameters.js";
+export * from "./parameters/parameters.jsx";
 export * from "./ProjectDirectory.js";
+export * from "./property/property.jsx";
+export * from "./record/declaration.js";
 export * from "./Reference.js";
 export * from "./SourceFile.js";
+export type { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
 export * from "./UsingDirective.js";
+export * from "./var/declaration.jsx";

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

@@ -1,6 +1,11 @@
+import { List, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
+import { Attribute } from "../attributes/attributes.jsx";
+import { SourceFile } from "../SourceFile.jsx";
+import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
+import { InterfaceProperty } from "./property.jsx";
 
 it("declares class with no members", () => {
   expect(
@@ -54,3 +59,100 @@ it("specify doc comment", () => {
     interface TestInterface;
   `);
 });
+
+describe("with type parameters", () => {
+  it("reference parameters", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        refkey: refkey(),
+      },
+      {
+        name: "U",
+        refkey: refkey(),
+      },
+    ];
+
+    expect(
+      <TestNamespace>
+        <SourceFile path="Test.cs">
+          <InterfaceDeclaration
+            public
+            name="Test"
+            typeParameters={typeParameters}
+          >
+            <List>
+              <InterfaceProperty
+                name="PropA"
+                type={typeParameters[0].refkey}
+                get
+                set
+              />
+              <InterfaceProperty
+                name="PropB"
+                type={typeParameters[1].refkey}
+                get
+                set
+              />
+            </List>
+          </InterfaceDeclaration>
+        </SourceFile>
+      </TestNamespace>,
+    ).toRenderTo(`
+      namespace TestCode
+      {
+        public interface Test<T, U>
+        {
+          T PropA { get; set; }
+          U PropB { get; set; }
+        }
+      }
+    `);
+  });
+
+  it("defines with constraints", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        constraints: "IFoo",
+      },
+      {
+        name: "U",
+        constraints: "IBar",
+      },
+    ];
+
+    expect(
+      <TestNamespace>
+        <InterfaceDeclaration
+          public
+          name="Test"
+          typeParameters={typeParameters}
+        >
+          // Body
+        </InterfaceDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      public interface Test<T, U>
+        where T : IFoo
+        where U : IBar
+      {
+        // Body
+      }
+    `);
+  });
+});
+
+it("specify attributes", () => {
+  expect(
+    <TestNamespace>
+      <InterfaceDeclaration
+        name="Test"
+        attributes={[<Attribute name="Test" />]}
+      />
+    </TestNamespace>,
+  ).toRenderTo(`
+    [Test]
+    interface Test;
+  `);
+});

package/src/components/interface/declaration.tsx

@@ -8,8 +8,12 @@ import {
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope } from "../../symbols/scopes.js";
+import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 import { Name } from "../Name.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 InterfaceModifiers {
   readonly partial?: boolean;
@@ -27,7 +31,38 @@ export interface InterfaceDeclarationProps
   /** Doc comment */
   doc?: core.Children;
   refkey?: core.Refkey;
-  typeParameters?: Record<string, core.Refkey>;
+
+  /**
+   * Type parameters for the interface
+   *
+   * @example
+   * ```tsx
+   * <InterfaceDeclaration name="IList" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public interface IList<T>
+   * ```
+   */
+  typeParameters?: (TypeParameterProps | string)[];
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <InterfaceDeclaration name="MyInterface" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * public interface MyInterface
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 /**
@@ -65,31 +100,6 @@ export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
     owner: thisInterfaceSymbol,
   });
 
-  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: thisInterfaceScope,
-        refkeys: entry[1],
-      });
-    }
-    typeParams = (
-      <group>
-        {"<"}
-        <core.For each={typeParamNames} comma line>
-          {(name) => name}
-        </core.For>
-        {">"}
-      </group>
-    );
-  }
-
   const modifiers = computeModifiersPrefix([
     getAccessModifier(props),
     getInterfaceModifiers(props),
@@ -97,8 +107,14 @@ export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
   return (
     <core.Declaration symbol={thisInterfaceSymbol}>
       <DocWhen doc={props.doc} />
+      <AttributeList attributes={props.attributes} endline />
       {modifiers}interface <Name />
-      {typeParams}
+      {props.typeParameters && (
+        <TypeParameters parameters={props.typeParameters} />
+      )}
+      {props.typeParameters && (
+        <TypeParameterConstraints parameters={props.typeParameters} />
+      )}
       {props.children ?
         <core.Block newline>
           <core.Scope value={thisInterfaceScope}>{props.children}</core.Scope>

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

@@ -1,6 +1,10 @@
+import { refkey } from "@alloy-js/core";
 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 { SourceFile } from "../SourceFile.jsx";
+import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
 import { InterfaceMethod } from "./method.jsx";
 
@@ -103,6 +107,58 @@ it("defines params and return type", () => {
   `);
 });
 
+it("defines optional param", () => {
+  const res = (
+    <Wrapper>
+      <InterfaceMethod
+        public
+        name="MethodOne"
+        parameters={[
+          {
+            name: "intParam",
+            type: "int",
+            optional: true,
+          },
+        ]}
+        returns="string"
+      />
+    </Wrapper>
+  );
+
+  expect(res).toRenderTo(`
+    public interface TestInterface
+    {
+      public string MethodOne(int? intParam);
+    }
+  `);
+});
+
+it("defines optional param with default", () => {
+  const res = (
+    <Wrapper>
+      <InterfaceMethod
+        public
+        name="MethodOne"
+        parameters={[
+          {
+            name: "intParam",
+            type: "int",
+            default: 12,
+          },
+        ]}
+        returns="string"
+      />
+    </Wrapper>
+  );
+
+  expect(res).toRenderTo(`
+    public interface TestInterface
+    {
+      public string MethodOne(int intParam = 12);
+    }
+  `);
+});
+
 it("specify doc comment", () => {
   expect(
     <TestNamespace>
@@ -118,3 +174,120 @@ it("specify doc comment", () => {
     }
   `);
 });
+
+it("specify attributes", () => {
+  expect(
+    <Wrapper>
+      <InterfaceMethod name="Test" attributes={[<Attribute name="Test" />]} />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      [Test]
+      void Test();
+    }
+  `);
+});
+
+describe("with type parameters", () => {
+  it("reference parameters", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        refkey: refkey(),
+      },
+      {
+        name: "U",
+        refkey: refkey(),
+      },
+    ];
+
+    expect(
+      <TestNamespace>
+        <SourceFile path="TestFile.cs">
+          <InterfaceDeclaration public name="TestInterface">
+            <InterfaceMethod
+              name="Test"
+              public
+              typeParameters={typeParameters}
+              parameters={[
+                {
+                  name: "paramA",
+                  type: typeParameters[0].refkey,
+                },
+              ]}
+              returns={typeParameters[0].refkey}
+            />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </TestNamespace>,
+    ).toRenderTo(`
+      namespace TestCode
+      {
+        public interface TestInterface
+        {
+          public T Test<T, U>(T paramA);
+        }
+      }
+    `);
+  });
+
+  it("defines with constraints", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        constraints: "IFoo",
+      },
+      {
+        name: "U",
+        constraints: "IBar",
+      },
+    ];
+
+    expect(
+      <Wrapper>
+        <InterfaceMethod public name="Test" typeParameters={typeParameters}>
+          // Body
+        </InterfaceMethod>
+      </Wrapper>,
+    ).toRenderTo(`
+      public interface TestInterface
+      {
+        public void Test<T, U>()
+          where T : IFoo
+          where U : IBar
+        {
+          // Body
+        }
+      }
+    `);
+  });
+});
+
+describe("formatting", () => {
+  it("Split parameters before type parameters", () => {
+    expect(
+      <Wrapper>
+        <InterfaceMethod
+          public
+          name="Handle"
+          parameters={[
+            {
+              name: "message",
+              type: "Some.Quite.Long.Type.That.Will.Split",
+            },
+          ]}
+          typeParameters={["T"]}
+          returns="Some.Quite.Long.Type.That.Will.Split"
+        />
+      </Wrapper>,
+    ).toRenderTo(`
+      public interface TestInterface
+      {
+        public Some.Quite.Long.Type.That.Will.Split Handle<T>(
+          Some.Quite.Long.Type.That.Will.Split message
+        );
+      }
+    `);
+  });
+});