@alloy-js/csharp 0.23.0 → 0.24.0-dev.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/csharp",
-  "version": "0.23.0",
+  "version": "0.24.0-dev.1",
   "description": "Alloy components for CSharp language.",
   "repository": {
     "type": "git",
@@ -43,23 +43,23 @@
   "author": "jhendrix@microsoft.com",
   "license": "MIT",
   "dependencies": {
+    "@alloy-js/core": "~0.23.1 || >= 0.24.0-dev.7",
+    "@alloy-js/msbuild": "~0.23.0 || >= 0.24.0-dev.0",
     "change-case": "^5.4.4",
     "marked": "^16.1.1",
-    "pathe": "^2.0.3",
-    "@alloy-js/core": "~0.23.0",
-    "@alloy-js/msbuild": "~0.23.0"
+    "pathe": "^2.0.3"
   },
   "devDependencies": {
+    "@alloy-js/cli": "~0.23.0 || >= 0.24.0-dev.1",
+    "@alloy-js/rollup-plugin": "~0.1.1 || >= 0.1.2-dev.2",
+    "@alloy-js/typescript": "~0.23.0 || >= 0.24.0-dev.1",
     "@microsoft/api-extractor": "~7.52.8",
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/js-yaml": "^4.0.9",
     "concurrently": "^9.2.0",
     "js-yaml": "^4.1.0",
     "typescript": "^5.8.3",
-    "vitest": "3.2.4",
-    "@alloy-js/rollup-plugin": "~0.1.1",
-    "@alloy-js/cli": "~0.23.0",
-    "@alloy-js/typescript": "~0.23.0"
+    "vitest": "3.2.4"
   },
   "type": "module",
   "scripts": {

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

@@ -1,7 +1,7 @@
 import { ClassDeclaration } from "#components/class/declaration.jsx";
 import { Method } from "#components/method/method.jsx";
 import { TestNamespace } from "#test/utils.jsx";
-import { List, namekey, printTree, renderTree } from "@alloy-js/core";
+import { List, namekey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { CSharpSymbol } from "../../symbols/csharp.js";
 import { AccessExpression } from "./access-expression.jsx";
@@ -49,15 +49,18 @@ it("makes an id part from a symbol", () => {
 
 it("makes an id part from a symbol reactively", () => {
   const symbol = new CSharpSymbol("Symbol", undefined);
-  const tree = renderTree(
+  const template = (
     <AccessExpression>
       <AccessExpression.Part id="Foo" />
       <AccessExpression.Part symbol={symbol} />
-    </AccessExpression>,
+    </AccessExpression>
   );
-  expect(printTree(tree)).toEqual("Foo.Symbol");
+
+  expect(template).toRenderTo("Foo.Symbol");
+
+  const tree = template;
   symbol.name = "Bar";
-  expect(printTree(tree)).toEqual("Foo.Bar");
+  expect(tree).toRenderTo("Foo.Bar");
 });
 
 it("makes an id part from refkey, where the first part is a full reference, and subsequent parts are just the id", () => {

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

@@ -2,30 +2,23 @@ import { Constructor } from "#components/constructor/constructor.jsx";
 import { EnumDeclaration } from "#components/enum/declaration.jsx";
 import { EnumMember } from "#components/enum/member.jsx";
 import {
-  Children,
   code,
   createNamePolicy,
   List,
   NamePolicyContext,
-  Output,
   refkey,
+  render,
 } from "@alloy-js/core";
 import * as coretest from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
-import { TestNamespace, toSourceText } from "../../../test/utils.jsx";
-import { createCSharpNamePolicy } from "../../name-policy.js";
+import { TestNamespace } from "../../../test/utils.jsx";
 import { Attribute } from "../attributes/attributes.jsx";
 import { Field } from "../field/field.jsx";
 import { Method } from "../method/method.jsx";
 import { Property } from "../property/property.jsx";
-import { SourceFile } from "../source-file/source-file.jsx";
 import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { ClassDeclaration } from "./declaration.jsx";
 
-function Wrapper({ children }: { children: Children }) {
-  return <TestNamespace>{children}</TestNamespace>;
-}
-
 it("declares class with no members", () => {
   expect(
     <TestNamespace>
@@ -181,37 +174,35 @@ it("uses refkeys for members, params, and return type", () => {
   ];
 
   expect(
-    <Output namePolicy={createCSharpNamePolicy()}>
-      <SourceFile path="Test.cs">
-        <EnumDeclaration public name="TestEnum" refkey={enumTypeRefkey}>
-          <List comma hardline>
-            <EnumMember name="One" />
-            <EnumMember name="Two" />
-          </List>
-        </EnumDeclaration>
-        <hbr />
-        <ClassDeclaration public name="TestInput" refkey={inputTypeRefkey} />
+    <TestNamespace>
+      <EnumDeclaration public name="TestEnum" refkey={enumTypeRefkey}>
+        <List comma hardline>
+          <EnumMember name="One" />
+          <EnumMember name="Two" />
+        </List>
+      </EnumDeclaration>
+      <hbr />
+      <ClassDeclaration public name="TestInput" refkey={inputTypeRefkey} />
+      <hbr />
+      <ClassDeclaration
+        public
+        name="TestResult"
+        refkey={testResultTypeRefkey}
+      />
+      <hbr />
+      <ClassDeclaration public name="TestClass">
+        <Field private name="MemberOne" type={enumTypeRefkey} />
         <hbr />
-        <ClassDeclaration
+        <Method
           public
-          name="TestResult"
-          refkey={testResultTypeRefkey}
-        />
-        <hbr />
-        <ClassDeclaration public name="TestClass">
-          <Field private name="MemberOne" type={enumTypeRefkey} />
-          <hbr />
-          <Method
-            public
-            name="MethodOne"
-            parameters={params}
-            returns={testResultTypeRefkey}
-          >
-            return new {testResultTypeRefkey}();
-          </Method>
-        </ClassDeclaration>
-      </SourceFile>
-    </Output>,
+          name="MethodOne"
+          parameters={params}
+          returns={testResultTypeRefkey}
+        >
+          return new {testResultTypeRefkey}();
+        </Method>
+      </ClassDeclaration>
+    </TestNamespace>,
   ).toRenderTo(`
     public enum TestEnum
     {
@@ -307,7 +298,7 @@ it("declares class with invalid members", () => {
     </ClassDeclaration>
   );
 
-  expect(() => toSourceText(decl)).toThrow(
+  expect(() => render(<TestNamespace>{decl}</TestNamespace>)).toThrow(
     "EnumMember must be used within an EnumDeclaration.",
   );
 });
@@ -398,7 +389,7 @@ describe("constructor", () => {
     ];
 
     expect(
-      <Wrapper>
+      <TestNamespace>
         <ClassDeclaration
           public
           name="TestClass"
@@ -411,7 +402,7 @@ describe("constructor", () => {
             initializer={code`$"{${paramNameRefkey}} {${paramSizeRefkey}}"`}
           />
         </ClassDeclaration>
-      </Wrapper>,
+      </TestNamespace>,
     ).toRenderTo(`
       public class TestClass(string name, int size)
       {
@@ -424,7 +415,7 @@ describe("constructor", () => {
     const ctorParams = [{ name: "name", type: "string" }];
 
     expect(
-      <Wrapper>
+      <TestNamespace>
         <NamePolicyContext.Provider value={createNamePolicy((x) => x)}>
           <ClassDeclaration
             public
@@ -434,7 +425,7 @@ describe("constructor", () => {
             <Field name="name" type="string" />
           </ClassDeclaration>
         </NamePolicyContext.Provider>
-      </Wrapper>,
+      </TestNamespace>,
     ).toRenderTo(`
       public class TestClass(string name)
       {

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

@@ -1,31 +1,28 @@
-import { TestNamespace, toSourceText } from "#test/utils.jsx";
+import { TestNamespace } from "#test/utils.jsx";
 import { namekey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import { EnumDeclaration } from "./declaration.jsx";
 import { EnumMember } from "./member.jsx";
 
 it("declares enum with no members", () => {
-  const res = toSourceText(<EnumDeclaration public name="TestEnum" />);
-
-  expect(res).toBe(d`
-    namespace TestCode;
-
+  expect(
+    <TestNamespace>
+      <EnumDeclaration public name="TestEnum" />
+    </TestNamespace>,
+  ).toRenderTo(`
     public enum TestEnum;
   `);
 });
 
 it("applies naming policy to enum and members", () => {
-  const res = toSourceText(
-    <EnumDeclaration public name="testEnum">
-      <EnumMember name="one" />,<hbr />
-      <EnumMember name="two" />
-    </EnumDeclaration>,
-  );
-
-  expect(res).toBe(d`
-    namespace TestCode;
-
+  expect(
+    <TestNamespace>
+      <EnumDeclaration public name="testEnum">
+        <EnumMember name="one" />,<hbr />
+        <EnumMember name="two" />
+      </EnumDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
     public enum TestEnum
     {
         One,
@@ -47,16 +44,14 @@ it("takes a namekey", () => {
 });
 
 it("renders doc comment", () => {
-  const res = toSourceText(
-    <EnumDeclaration public name="TestEnum" doc="This is a test enum">
-      <EnumMember name="One" />,<hbr />
-      <EnumMember name="Two" />
-    </EnumDeclaration>,
-  );
-
-  expect(res).toBe(d`
-    namespace TestCode;
-
+  expect(
+    <TestNamespace>
+      <EnumDeclaration public name="TestEnum" doc="This is a test enum">
+        <EnumMember name="One" />,<hbr />
+        <EnumMember name="Two" />
+      </EnumDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
     /// This is a test enum
     public enum TestEnum
     {

package/src/components/enum/member.test.tsx

@@ -1,21 +1,18 @@
-import { TestNamespace, toSourceText } from "#test/utils.jsx";
+import { TestNamespace } from "#test/utils.jsx";
 import { namekey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import { EnumDeclaration } from "./declaration.jsx";
 import { EnumMember } from "./member.jsx";
 
 it("declares enum with members", () => {
-  const res = toSourceText(
-    <EnumDeclaration public name="TestEnum">
-      <EnumMember name="One" />,<hbr />
-      <EnumMember name="Two" />
-    </EnumDeclaration>,
-  );
-
-  expect(res).toBe(d`
-    namespace TestCode;
-
+  expect(
+    <TestNamespace>
+      <EnumDeclaration public name="TestEnum">
+        <EnumMember name="One" />,<hbr />
+        <EnumMember name="Two" />
+      </EnumDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
     public enum TestEnum
     {
         One,
@@ -45,16 +42,14 @@ it("takes a namekey", () => {
 });
 
 it("renders doc comment", () => {
-  const res = toSourceText(
-    <EnumDeclaration public name="TestEnum">
-      <EnumMember name="One" doc="First value" />,<hbr />
-      <EnumMember name="Two" doc="Second value" />
-    </EnumDeclaration>,
-  );
-
-  expect(res).toBe(d`
-    namespace TestCode;
-
+  expect(
+    <TestNamespace>
+      <EnumDeclaration public name="TestEnum">
+        <EnumMember name="One" doc="First value" />,<hbr />
+        <EnumMember name="Two" doc="Second value" />
+      </EnumDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
     public enum TestEnum
     {
         /// First value

package/test/utils.tsx

@@ -1,6 +1,4 @@
 import * as core from "@alloy-js/core";
-import * as coretest from "@alloy-js/core/testing";
-import { expect } from "vitest";
 import * as csharp from "../src/index.js";
 
 export interface TestNamespaceProps extends csharp.CSharpFormatOptions {
@@ -15,66 +13,3 @@ export function TestNamespace(props: TestNamespaceProps): core.Children {
     </core.Output>
   );
 }
-export function toSourceText(c: core.Children): string {
-  const res = core.render(
-    <core.Output namePolicy={csharp.createCSharpNamePolicy()}>
-      <csharp.Namespace name="TestCode">
-        <csharp.SourceFile path="Test.cs">{c}</csharp.SourceFile>
-      </csharp.Namespace>
-    </core.Output>,
-    { insertFinalNewLine: false },
-  );
-
-  const file = findFile(res, "Test.cs");
-  return file.contents;
-}
-
-export function testRender(c: core.Children): core.OutputDirectory {
-  return core.render(
-    <core.Output>
-      <csharp.Namespace name="TestCode">{c}</csharp.Namespace>
-    </core.Output>,
-  );
-}
-
-export function findFile(
-  res: core.OutputDirectory,
-  path: string,
-): core.ContentOutputFile {
-  const result = findFileWorker(res, path);
-
-  if (!result) {
-    throw new Error("Expected to find file " + path);
-  }
-  return result as core.ContentOutputFile;
-
-  function findFileWorker(
-    res: core.OutputDirectory,
-    path: string,
-  ): core.OutputFile | null {
-    for (const item of res.contents) {
-      if (item.kind === "file") {
-        if (item.path.includes(path)) {
-          return item;
-        }
-        continue;
-      } else {
-        const found = findFileWorker(item, path);
-        if (found) {
-          return found;
-        }
-      }
-    }
-    return null;
-  }
-}
-
-export function assertFileContents(
-  res: core.OutputDirectory,
-  expectedFiles: Record<string, string>,
-): void {
-  for (const [path, contents] of Object.entries(expectedFiles)) {
-    const file = findFile(res, path);
-    expect(file.contents).toBe(coretest.dedent(contents));
-  }
-}