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

package/src/components/using/using.test.tsx

@@ -0,0 +1,15 @@
+import { expect, it } from "vitest";
+import { Usings } from "./using.jsx";
+
+it("single using", () => {
+  expect(<Usings namespaces={["Foo"]} />).toRenderTo(`
+    using Foo;
+  `);
+});
+
+it("multiple using", () => {
+  expect(<Usings namespaces={["Foo", "Bar"]} />).toRenderTo(`
+    using Bar;
+    using Foo;
+  `);
+});

package/src/components/using/using.tsx

@@ -0,0 +1,52 @@
+import { computed, For } from "@alloy-js/core";
+import { NamespaceSymbol } from "../../symbols/namespace.js";
+
+export interface UsingsProps {
+  /**
+   * Namespace symbols or namespace names to use to generate using statements.
+   */
+  namespaces: (NamespaceSymbol | string)[];
+}
+
+/**
+ * Component rendering csharp using directive
+ * @example
+ *
+ * ```tsx
+ * <Usings namespaces={["System", "Models"]} />
+ * ```
+ *
+ * will render
+ *
+ * ```csharp
+ * using Models;
+ * using System;
+ * ```
+ */
+export function Usings(props: UsingsProps) {
+  const sortedNamespaces = computed(() => {
+    return props.namespaces
+      .map(getNamespaceName)
+      .sort((n1, n2) => n1.localeCompare(n2));
+  });
+
+  return (
+    <For each={sortedNamespaces}>
+      {(namespace) => <UsingNamespaceDirective namespace={namespace} />}
+    </For>
+  );
+}
+
+export interface UsingNamespaceDirective {
+  namespace: string;
+}
+
+export function UsingNamespaceDirective(props: UsingNamespaceDirective) {
+  return `using ${getNamespaceName(props.namespace)};`;
+}
+
+function getNamespaceName(namespace: string | NamespaceSymbol): string {
+  return typeof namespace === "string" ? namespace : (
+      namespace.getFullyQualifiedName({ omitGlobal: true })
+    );
+}

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

@@ -1,4 +1,4 @@
-import { List, refkey } from "@alloy-js/core";
+import { List, namekey, refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { VarDeclaration } from "./declaration.jsx";
@@ -51,3 +51,18 @@ it("links refkey", () => {
       var testVar2 = testVar;
   `);
 });
+
+it("links namekey", () => {
+  const key = namekey("test-var");
+  expect(
+    <TestNamespace>
+      <List>
+        <VarDeclaration name={key}>42</VarDeclaration>
+        <VarDeclaration name="testVar2">{key}</VarDeclaration>
+      </List>
+    </TestNamespace>,
+  ).toRenderTo(`
+      var testVar = 42;
+      var testVar2 = testVar;
+  `);
+});

package/src/components/var/declaration.tsx

@@ -3,6 +3,7 @@ import {
   Declaration,
   DeclarationProps,
   Name,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import { createVariableSymbol } from "../../symbols/factories.js";
@@ -11,7 +12,7 @@ import { createVariableSymbol } from "../../symbols/factories.js";
 export interface VarDeclarationProps
   extends Omit<DeclarationProps, "nameKind"> {
   /** Variable name */
-  name: string;
+  name: string | Namekey;
   /** Type of the variable declaration. If not specified, defaults to "var" */
   type?: Children;
   /** Variable refkey */

package/src/name-policy.ts

@@ -17,7 +17,8 @@ export type CSharpElements =
   | "class-method"
   | "class-property"
   | "parameter"
-  | "type-parameter";
+  | "type-parameter"
+  | "namespace";
 
 // creates the C# naming policy
 export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
@@ -33,6 +34,7 @@ export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
       case "class-method":
       case "type-parameter":
       case "class-property":
+      case "namespace":
         return changecase.pascalCase(name);
       case "constant":
         return changecase.constantCase(name);

package/src/symbols/factories.ts

@@ -118,13 +118,21 @@ export function createNamedTypeSymbol(
   );
 }
 
-export function createNamespaceSymbol(name: string) {
+export function createNamespaceSymbol(
+  name: string | Namekey,
+  options: CSharpSymbolOptions = {},
+) {
   const scope = useEnclosingNamespaceScope();
   const nsSymbol = scope?.ownerSymbol ?? getGlobalNamespace(useBinder());
-  if (nsSymbol.members.symbolNames.has(name)) {
-    return nsSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
+  const namePolicy =
+    options.namePolicy ?? useCSharpNamePolicy().for("namespace");
+  const expectedName = namePolicy(typeof name === "string" ? name : name.name);
+  if (nsSymbol.members.symbolNames.has(expectedName)) {
+    return nsSymbol.members.symbolNames.get(expectedName)! as NamespaceSymbol;
   }
-  return withCleanup(new NamespaceSymbol(name, nsSymbol));
+  return withCleanup(
+    new NamespaceSymbol(name, nsSymbol, withNamePolicy(options, "namespace")),
+  );
 }
 
 export interface CreateMethodSymbolOptions extends CSharpSymbolOptions {

package/src/symbols/namespace.ts

@@ -1,4 +1,4 @@
-import { OutputSymbolOptions } from "@alloy-js/core";
+import { Namekey, OutputSymbolOptions } from "@alloy-js/core";
 import { NamedTypeSymbol } from "./named-type.js";
 
 export interface NamespaceSymbolOptions extends OutputSymbolOptions {
@@ -11,7 +11,7 @@ export interface NamespaceSymbolOptions extends OutputSymbolOptions {
 export class NamespaceSymbol extends NamedTypeSymbol {
   public readonly symbolKind = "namespace";
   constructor(
-    name: string,
+    name: string | Namekey,
     parentNamespace?: NamespaceSymbol,
     options?: NamespaceSymbolOptions,
   ) {