@alloy-js/csharp 0.21.0-dev.2 → 0.21.0-dev.21

package/src/builtins/index.ts

@@ -0,0 +1,2 @@
+export { default as Microsoft } from "./Microsoft/index.js";
+export { default as System } from "./System/index.js";

package/src/components/access-expression/access-expression.tsx

@@ -5,7 +5,7 @@ import {
   computed,
   For,
   isComponentCreator,
-  Refkey,
+  Refkeyable,
   Show,
   takeSymbols,
 } from "@alloy-js/core";
@@ -92,7 +92,7 @@ export interface AccessExpressionPartProps {
    * A refkey for the symbol whose name becomes this part's identifier. When a refkey is provided for the first
    * part, it will be fully resolved. Otherwise, just the symbol's name is used.
    */
-  refkey?: Refkey;
+  refkey?: Refkeyable;
 
   /**
    * The symbol whose name becomes this part's identifier.
@@ -122,6 +122,12 @@ export interface AccessExpressionPartProps {
    * you provide a symbol or refkey and the symbol's nullable flag is set.
    */
   nullable?: boolean;
+
+  /**
+   * Wether this part is an attribute reference (used in an attribute context).
+   * In that case the "Attribute" suffix is trimmed from the name if present.
+   */
+  attribute?: boolean;
 }
 
 AccessExpression.Part = function (props: AccessExpressionPartProps) {

package/src/components/access-expression/part-descriptors.ts

@@ -128,9 +128,12 @@ function createPartDescriptorFromProps(
       } else if (first && partProps.refkey) {
         return partProps.refkey;
       } else if (partProps.id !== undefined) {
-        return partProps.id;
+        return normalizeIfAttribute(partProps.id, partProps.attribute);
       } else if (symbolSource.value) {
-        return escapeId(symbolSource.value.name);
+        return normalizeIfAttribute(
+          escapeId(symbolSource.value.name),
+          partProps.attribute,
+        );
       } else {
         return "<unresolved symbol>";
       }
@@ -173,3 +176,24 @@ function createPartDescriptorFromProps(
 function escapeId(id: string) {
   return id.replace(/"/g, '\\"');
 }
+
+function normalizeIfAttribute(id: string, isAttribute?: boolean) {
+  if (isAttribute) {
+    return normalizeAttributeName(id);
+  }
+  return id;
+}
+
+/**
+ * Normalize attribute name by removing the "Attribute" suffix if present.
+ * @example
+ * ```ts
+ * normalizeAttributeName("TestAttribute") // returns "Test"
+ * ```
+ */
+export function normalizeAttributeName(name: string) {
+  if (name !== undefined && name.endsWith("Attribute")) {
+    return name.substring(0, name.length - "Attribute".length);
+  }
+  return name;
+}

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

@@ -1,12 +1,53 @@
-import { expect, it } from "vitest";
+import { ClassDeclaration } from "#components/class/declaration.jsx";
+import { createLibrary } from "#createLibrary";
+import { TestNamespace } from "#test/utils.jsx";
+import { List, namekey } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
 import { Attribute, AttributeList } from "./attributes.jsx";
-
 it("define attribute", () => {
   expect(<Attribute name="Test" />).toRenderTo(`
       [Test]
   `);
 });
 
+describe("Attribute suffix trimming", () => {
+  it("define attribute whose name ending with 'Attribute'", () => {
+    expect(<Attribute name="TestAttribute" />).toRenderTo(`
+      [Test]
+    `);
+  });
+
+  it("when using namekey", () => {
+    const key = namekey("TestAttribute");
+    expect(
+      <TestNamespace>
+        <List>
+          <Attribute name={key} />
+          <ClassDeclaration name={key} />
+        </List>
+      </TestNamespace>,
+    ).toRenderTo(`
+      [Test]
+      class TestAttribute;
+    `);
+  });
+
+  it("when referenced from library", () => {
+    const TestLib = createLibrary("TestLib", {
+      TestAttribute: { kind: "method", methodKind: "ordinary" },
+    });
+    expect(
+      <TestNamespace>
+        <Attribute name={TestLib.TestAttribute} />
+      </TestNamespace>,
+    ).toRenderTo(`
+      using TestLib;
+      
+      [Test]
+    `);
+  });
+});
+
 it("define attribute with single arg", () => {
   expect(<Attribute name="Test" args={[`"abc"`]} />).toRenderTo(`
       [Test("abc")]

package/src/components/attributes/attributes.tsx

@@ -1,15 +1,13 @@
+import { normalizeAttributeName } from "#components/access-expression/part-descriptors.js";
 import {
   Children,
   findKeyedChildren,
   For,
   Indent,
+  Refkeyable,
   taggedComponent,
 } from "@alloy-js/core";
-
-export interface AttributeItem {
-  name: string;
-  args?: string[];
-}
+import { ReferenceContext } from "../../contexts/reference-context.js";
 
 export type AttributesProp = Array<string | AttributeProps | Children>;
 
@@ -54,7 +52,7 @@ function renderAttribute(attr: string | AttributeProps | Children): Children {
 
 export interface AttributeProps {
   /** Attribute name */
-  name: Children;
+  name: string | Refkeyable;
 
   /** Argument */
   args?: Children[];
@@ -81,7 +79,8 @@ export const Attribute = taggedComponent(
   (props: AttributeProps) => {
     return (
       <group>
-        [{props.name}
+        [
+        <AttributeName name={props.name} />
         {props.args && props.args.length > 0 && (
           <>
             (
@@ -98,3 +97,11 @@ export const Attribute = taggedComponent(
     );
   },
 );
+
+function AttributeName(props: Pick<AttributeProps, "name">) {
+  return typeof props.name === "string" ?
+      normalizeAttributeName(props.name)
+    : <ReferenceContext.Provider value={"attribute"}>
+        {props.name}
+      </ReferenceContext.Provider>;
+}

package/src/components/csproj-file/csproj-file.test.tsx

@@ -0,0 +1,19 @@
+import { expect, it } from "vitest";
+import { CsprojFile } from "./csproj-file.jsx";
+
+it("create empty .csproj file", () => {
+  expect(<CsprojFile path={"foo.csproj"}>{"<!-- content -->"}</CsprojFile>)
+    .toRenderTo(`
+    <Project Sdk="Microsoft.NET.Sdk"><!-- content --></Project>
+  `);
+});
+
+it("set different sdk", () => {
+  expect(
+    <CsprojFile path={"foo.csproj"} sdk="Microsoft.NET.Sdk.Web">
+      {"<!-- content -->"}
+    </CsprojFile>,
+  ).toRenderTo(`
+    <Project Sdk="Microsoft.NET.Sdk.Web"><!-- content --></Project>
+  `);
+});

package/src/components/csproj-file/csproj-file.tsx

@@ -0,0 +1,32 @@
+import { Children, SourceFile } from "@alloy-js/core";
+import { Project } from "@alloy-js/msbuild/components";
+
+export type CSharpProjectSdk =
+  | "Microsoft.NET.Sdk"
+  | "Microsoft.NET.Sdk.Web"
+  | "Microsoft.NET.Sdk.Worker"
+  | "Microsoft.NET.Sdk.Razor"
+  | "Microsoft.NET.Sdk.BlazorWebAssembly"
+  | "Aspire.AppHost.Sdk"
+  | "MSTest.Sdk";
+
+export interface CsprojProps {
+  path: `${string}.csproj`;
+  /**
+   * Project SDK https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview
+   * @default "Microsoft.NET.Sdk"
+   */
+  sdk?: CSharpProjectSdk;
+
+  /** Content inside <project> */
+  children?: Children;
+}
+
+/** Create a .csproj file */
+export function CsprojFile(props: CsprojProps) {
+  return (
+    <SourceFile path={props.path} filetype="xml" tabWidth={4}>
+      <Project Sdk={props.sdk ?? "Microsoft.NET.Sdk"}>{props.children}</Project>
+    </SourceFile>
+  );
+}

package/src/components/enum/declaration.ref.test.tsx

@@ -1,4 +1,4 @@
-import { Namespace } from "#components/namespace.jsx";
+import { Namespace } from "#components/namespace/namespace.jsx";
 import { SourceFile } from "#components/source-file/source-file.jsx";
 import { Output, refkey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";

package/src/components/if/if-statement.test.tsx

@@ -0,0 +1,26 @@
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { ElseClause, ElseIfClause, IfStatement } from "./if-statement.jsx";
+
+it("works with blocks", () => {
+  expect(
+    <>
+      <IfStatement condition="x === 1">// do thing</IfStatement>
+      <ElseIfClause condition="x === 2">// do another thing</ElseIfClause>
+      <ElseClause>// do default thing</ElseClause>
+    </>,
+  ).toRenderTo(d`
+    if (x === 1)
+    {
+      // do thing
+    }
+    else if (x === 2)
+    {
+      // do another thing
+    }
+    else
+    {
+      // do default thing
+    }
+  `);
+});

package/src/components/if/if-statement.tsx

@@ -0,0 +1,50 @@
+import { Block, type Children } from "@alloy-js/core";
+
+export interface IfStatementProps {
+  condition: Children;
+  children: Children;
+}
+
+/**
+ * An if statement.
+ */
+export function IfStatement(props: IfStatementProps) {
+  return (
+    <>
+      if ({props.condition}) <Block newline>{props.children}</Block>
+    </>
+  );
+}
+
+export interface ElseIfClauseProps {
+  condition: Children;
+  children: Children;
+}
+
+/**
+ * An else clause with an if statement.
+ */
+export function ElseIfClause(props: ElseIfClauseProps) {
+  return (
+    <>
+      <hardline />
+      else if ({props.condition}) <Block newline>{props.children}</Block>
+    </>
+  );
+}
+
+export interface ElseClauseProps {
+  children: Children;
+}
+
+/**
+ * The else clause of an if statement.
+ */
+export function ElseClause(props: ElseClauseProps) {
+  return (
+    <>
+      <hardline />
+      else <Block newline>{props.children}</Block>
+    </>
+  );
+}

package/src/components/index.ts

@@ -1,12 +1,15 @@
+export * from "./access-expression/access-expression.jsx";
 export * from "./attributes/attributes.jsx";
 export * from "./class/declaration.jsx";
 export * from "./constructor/constructor.jsx";
+export * from "./csproj-file/csproj-file.jsx";
 export * from "./Declaration.js";
 export * from "./doc/comment.jsx";
 export * from "./doc/from-markdown.jsx";
 export * from "./enum/declaration.jsx";
 export * from "./enum/member.jsx";
 export * from "./field/field.jsx";
+export * from "./if/if-statement.jsx";
 export * from "./interface/declaration.js";
 export * from "./interface/method.js";
 export * from "./interface/property.js";
@@ -15,9 +18,8 @@ export * from "./lexical-scope.jsx";
 export * from "./method-scope.jsx";
 export * from "./method/method.jsx";
 export * from "./Name.js";
-export * from "./namespace.js";
+export { Namespace, type NamespaceProps } from "./namespace/namespace.jsx";
 export * from "./parameters/parameters.jsx";
-export * from "./ProjectDirectory.js";
 export * from "./property/property.jsx";
 export * from "./record/declaration.js";
 export * from "./Reference.js";

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

@@ -158,3 +158,52 @@ it("use expression body form", () => {
     }
   `);
 });
+
+describe("format", () => {
+  it("split expression after => if too long", () => {
+    expect(
+      <TestNamespace printWidth={60}>
+        <ClassDeclaration name="Test">
+          <Method public override name="ThisIsAVeryLongMethodName" expression>
+            this.WithAVeryLongPropertyName.AndAnEvenLongerMemberName
+          </Method>
+        </ClassDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      class Test
+      {
+          public override void ThisIsAVeryLongMethodName() =>
+              this.WithAVeryLongPropertyName.AndAnEvenLongerMemberName;
+      }
+  `);
+  });
+
+  it("split parameters first if too long", () => {
+    expect(
+      <TestNamespace printWidth={60}>
+        <ClassDeclaration name="Test">
+          <Method
+            public
+            override
+            name="ThisIsAVeryLongMethodName"
+            expression
+            parameters={[
+              { name: "firstParameter", type: "int" },
+              { name: "secondParameter", type: "string" },
+            ]}
+          >
+            this.Short
+          </Method>
+        </ClassDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      class Test
+      {
+          public override void ThisIsAVeryLongMethodName(
+              int firstParameter,
+              string secondParameter
+          ) => this.Short;
+      }
+  `);
+  });
+});

package/src/components/method/method.tsx

@@ -154,9 +154,12 @@ export function Method(props: MethodProps) {
 
 const ExpressionBody = (props: { children?: Children }) => {
   return (
-    <>
-      {" => "}
-      {props.children};
-    </>
+    <group>
+      {" =>"}
+      <indent>
+        <line />
+        {props.children};
+      </indent>
+    </group>
   );
 };

package/src/components/namespace/namespace-name.tsx

@@ -0,0 +1,31 @@
+import { useNamespaceContext } from "../../contexts/namespace.js";
+import { NamespaceSymbol } from "../../symbols/namespace.js";
+
+/** @internal */
+export interface NamespaceNameProps {
+  symbol: NamespaceSymbol;
+
+  /** If it should print relative to the parent context */
+  relative?: boolean;
+}
+
+/** @internal */
+export function NamespaceName(props: NamespaceNameProps) {
+  const names = [props.symbol.name];
+  const parent = props.relative ? useNamespaceContext()?.symbol : undefined;
+
+  let current = props.symbol.ownerSymbol;
+  while (current) {
+    if (
+      current === parent ||
+      !(current instanceof NamespaceSymbol) ||
+      current.isGlobal
+    ) {
+      break;
+    }
+    names.unshift(current.name);
+    current = current.ownerSymbol;
+  }
+
+  return names.join(".");
+}

package/src/components/namespace/namespace.test.tsx

@@ -0,0 +1,145 @@
+import { TestNamespace } from "#test/utils.jsx";
+import { Output } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { ClassDeclaration } from "../class/declaration.jsx";
+import { SourceFile } from "../source-file/source-file.jsx";
+import { Namespace } from "./namespace.jsx";
+
+it("defines multiple namespaces and source files with unique content", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Namespace1">
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+        <SourceFile path="Model2.cs">
+          <ClassDeclaration public name="Model2" />
+        </SourceFile>
+      </Namespace>
+      <Namespace name="Namespace2">
+        <SourceFile path="Model3.cs">
+          <ClassDeclaration public name="Model3" />
+        </SourceFile>
+        <SourceFile path="Model4.cs">
+          <ClassDeclaration public name="Model4" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "Model1.cs": d`
+      namespace Namespace1;
+
+      public class Model1;
+    `,
+    "Model2.cs": d`
+      namespace Namespace1;
+
+      public class Model2;
+    `,
+    "Model3.cs": d`
+      namespace Namespace2;
+      
+      public class Model3;
+    `,
+    "Model4.cs": d`
+      namespace Namespace2;
+      
+      public class Model4;
+    `,
+  });
+});
+
+it("nest namespaces", () => {
+  const tree = (
+    <Output>
+      <Namespace name={["Namespace1"]}>
+        <Namespace name={["Namespace2"]}>
+          <SourceFile path="Model1.cs">
+            <ClassDeclaration public name="Model1" />
+          </SourceFile>
+        </Namespace>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Namespace1.Namespace2;
+
+    public class Model1;
+  `);
+});
+
+it("define nested namespace directly with array", () => {
+  const tree = (
+    <Output>
+      <Namespace name={["Namespace1", "Namespace2"]}>
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Namespace1.Namespace2;
+
+    public class Model1;
+  `);
+});
+
+it("define nested namespace directly as dotted notation", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Namespace1.Namespace2">
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "Model1.cs": d`
+      namespace Namespace1.Namespace2;
+
+      public class Model1;
+    `,
+  });
+});
+
+it("uses a name policy", () => {
+  expect(
+    <TestNamespace>
+      <Namespace name="my-namespace" />
+    </TestNamespace>,
+  ).toRenderTo(`
+    namespace MyNamespace {
+
+    }
+  `);
+});
+
+it("define nested namespace in sourcefile", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Base">
+        <SourceFile path="Model1.cs">
+          <Namespace name="Namespace1.Namespace2">
+            <ClassDeclaration public name="Model1" />
+          </Namespace>
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Base {
+        namespace Namespace1.Namespace2 {
+            public class Model1;
+        }
+    }
+  `);
+});

package/src/components/{namespace.tsx → namespace/namespace.tsx}

@@ -1,12 +1,13 @@
 import { Block, Namekey, Refkey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
-import { NamespaceContext } from "../contexts/namespace.js";
-import { useSourceFileScope } from "../scopes/source-file.js";
-import { createNamespaceSymbol } from "../symbols/factories.js";
-import { NamespaceScope } from "./namespace-scopes.jsx";
+import { NamespaceContext } from "../../contexts/namespace.js";
+import { useSourceFileScope } from "../../scopes/source-file.js";
+import { createNamespaceSymbol } from "../../symbols/factories.js";
+import { NamespaceScope } from "../namespace-scopes.jsx";
+import { NamespaceName } from "./namespace-name.jsx";
 
 export interface NamespaceProps {
-  name: string | Namekey;
+  name: string | Namekey | (string | Namekey)[];
   refkey?: Refkey | Refkey[];
   children?: Children;
 }
@@ -27,7 +28,7 @@ export function Namespace(props: NamespaceProps) {
     sfScope.hasBlockNamespace = true;
     return (
       <>
-        namespace {namespaceSymbol.name}{" "}
+        namespace <NamespaceName symbol={namespaceSymbol} relative />{" "}
         <Block>
           <NamespaceContext.Provider value={{ symbol: namespaceSymbol }}>
             <NamespaceScope symbol={namespaceSymbol}>
@@ -39,10 +40,3 @@ export function Namespace(props: NamespaceProps) {
     );
   }
 }
-
-/*
-  const scope = createCSharpNamespaceScope(namespaceSymbol);
-
-  return <Scope value={scope}>{props.children}</Scope>;
-}
-  */

package/src/components/namespace.ref.test.tsx

@@ -1,7 +1,7 @@
 import { List, memberRefkey, namekey, Output, refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { ClassDeclaration } from "./class/declaration.jsx";
-import { Namespace } from "./namespace.jsx";
+import { Namespace } from "./namespace/namespace.jsx";
 import { SourceFile } from "./source-file/source-file.jsx";
 
 it("references types in the same namespace", () => {