@alloy-js/csharp 0.20.0-dev.3 → 0.20.0-dev.4

package/src/components/EnumDeclaration.tsx

@@ -1,98 +0,0 @@
-import * as core from "@alloy-js/core";
-import {
-  AccessModifiers,
-  computeModifiersPrefix,
-  getAccessModifier,
-} from "../modifiers.js";
-import { useCSharpNamePolicy } from "../name-policy.js";
-import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
-import {
-  CSharpMemberScope,
-  useCSharpMemberScope,
-  useCSharpScope,
-} from "../symbols/scopes.js";
-import { Name } from "./Name.jsx";
-
-// properties for creating an enum
-export interface EnumDeclarationProps extends AccessModifiers {
-  name: string;
-  refkey?: core.Refkey;
-  children?: core.Children;
-}
-
-/**
- * A C# enum declaration
- * @example
- * ```tsx
- * <EnumDeclaration public name="Color">
- *   <EnumMember name="Red" />
- *   <EnumMember name="Green" />
- *   <EnumMember name="Blue" />
- * </EnumDeclaration>
- * ```
- * This will produce:
- * ```csharp
- * public enum Color
- * {
- *   Red,
- *   Green,
- *   Blue
- * }
- * ```
- */
-export function EnumDeclaration(props: EnumDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "enum");
-  const scope = useCSharpScope();
-
-  const thisEnumSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? core.refkey(props.name),
-  });
-
-  // this creates a new scope for the enum definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisEnumScope = new CSharpMemberScope("enum-decl", {
-    parent: scope,
-    owner: thisEnumSymbol,
-  });
-
-  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
-
-  if (thisEnumScope.owner)
-    return (
-      <core.Declaration symbol={thisEnumSymbol}>
-        {modifiers}enum <Name />
-        {!props.children && ";"}
-        {props.children && (
-          <core.Scope value={thisEnumScope}>
-            <core.Block newline>{props.children}</core.Block>
-          </core.Scope>
-        )}
-      </core.Declaration>
-    );
-}
-
-// properties for creating a C# enum member
-export interface EnumMemberProps {
-  name: string;
-  refkey?: core.Refkey;
-}
-
-// a member within a C# enum
-export function EnumMember(props: EnumMemberProps) {
-  const scope = useCSharpMemberScope(["enum-decl"]);
-
-  const name = useCSharpNamePolicy().getName(props.name, "enum-member");
-  const thisEnumValueSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? core.refkey(props.name),
-  });
-
-  return (
-    <core.Declaration symbol={thisEnumValueSymbol}>
-      <Name />
-    </core.Declaration>
-  );
-}

package/src/components/Namespace.tsx

@@ -1,35 +0,0 @@
-import * as core from "@alloy-js/core";
-import { CSharpNamespaceScope } from "../symbols/scopes.js";
-
-// contains the info for the current namespace
-export interface NamespaceContext {
-  name: string;
-}
-
-const NamespaceContext = core.createContext<NamespaceContext>();
-
-// returns the current namespace
-export function useNamespace(): NamespaceContext | undefined {
-  return core.useContext(NamespaceContext) as NamespaceContext;
-}
-
-// properties for creating a C# namespace
-export interface NamespaceProps {
-  name: string;
-  children?: core.Children;
-}
-
-// a C# namespace. contains one or more source files
-export function Namespace(props: NamespaceProps) {
-  const scope = new CSharpNamespaceScope(props.name);
-
-  const namespaceCtx: NamespaceContext = {
-    name: props.name,
-  };
-
-  return (
-    <NamespaceContext.Provider value={namespaceCtx}>
-      <core.Scope value={scope}>{props.children}</core.Scope>
-    </NamespaceContext.Provider>
-  );
-}

package/src/symbols/csharp-output-symbol.ts

@@ -1,22 +0,0 @@
-import * as core from "@alloy-js/core";
-import { useNamespace } from "../components/Namespace.jsx";
-import { CSharpOutputScope } from "./scopes.js";
-
-// represents a symbol from a .cs file. Class, enum, interface etc.
-
-export class CSharpOutputSymbol extends core.OutputSymbol {
-  get scope() {
-    return super.scope as CSharpOutputScope;
-  }
-  set scope(value: CSharpOutputScope) {
-    super.scope = value;
-  }
-
-  constructor(name: string, options?: core.OutputSymbolOptions) {
-    const namespaceCtx = useNamespace();
-    if (!namespaceCtx) {
-      throw new Error("symbol must be declared inside a namespace");
-    }
-    super(name, options);
-  }
-}

package/src/symbols/scopes.ts

@@ -1,61 +0,0 @@
-import * as core from "@alloy-js/core";
-import { CSharpOutputSymbol } from "./csharp-output-symbol.js";
-
-// indicates that the scope for a symbols is at the namespace level
-export class CSharpNamespaceScope extends core.OutputScope {
-  get kind() {
-    return "namespace";
-  }
-}
-
-// the kind of member scope. i.e. are we in an enum, class, etc
-export type CSharpMemberScopeName =
-  | "class-decl"
-  | "constructor-decl"
-  | "enum-decl"
-  | "method-decl";
-
-// indicates that the scope for a symbol resides within a type
-// e.g. for an enum value, class field etc, these would have
-// member scope where the owner is the containing type.
-export class CSharpMemberScope extends core.OutputScope {
-  get kind() {
-    return "member";
-  }
-
-  get name() {
-    return super.name as CSharpMemberScopeName;
-  }
-
-  get owner() {
-    return super.owner as CSharpOutputSymbol;
-  }
-}
-
-// contains the possible scopes where a declaration can reside
-export type CSharpOutputScope = CSharpMemberScope | CSharpNamespaceScope;
-
-// returns the current C# scope
-export function useCSharpScope(): CSharpOutputScope {
-  return core.useScope() as CSharpOutputScope;
-}
-
-export function useCSharpMemberScope<T extends unknown[]>(
-  names: T,
-): CSharpMemberScope & { name: T[number] } {
-  const scope = useCSharpScope();
-  assertMemberOfScope(scope, names);
-  return scope;
-}
-
-export function assertMemberOfScope<T extends unknown[]>(
-  scope: CSharpOutputScope,
-  names: T,
-): asserts scope is CSharpMemberScope & { name: T[number] } {
-  if (scope.kind !== "member" || !names.includes(scope.name as T[number])) {
-    const context = core.getContext();
-    throw new Error(
-      `Can't define a ${context?.componentOwner?.component.name} outside of a ${names.join(" or ")} scope`,
-    );
-  }
-}

package/test/enum.test.tsx

@@ -1,149 +0,0 @@
-import * as core from "@alloy-js/core";
-import * as coretest from "@alloy-js/core/testing";
-import { expect, it } from "vitest";
-import * as csharp from "../src/index.js";
-import * as utils from "./utils.js";
-import { findFile } from "./utils.js";
-
-it("declares enum with no members", () => {
-  const res = utils.toSourceText(
-    <csharp.EnumDeclaration public name="TestEnum" />,
-  );
-
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum;
-    }
-  `);
-});
-
-it("declares enum with members", () => {
-  const res = utils.toSourceText(
-    <csharp.EnumDeclaration public name="TestEnum">
-      <csharp.EnumMember name="One" />,<hbr />
-      <csharp.EnumMember name="Two" />
-    </csharp.EnumDeclaration>,
-  );
-
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-    }
-  `);
-});
-
-it("applies naming policy to enum and members", () => {
-  const res = utils.toSourceText(
-    <csharp.EnumDeclaration public name="testEnum">
-      <csharp.EnumMember name="one" />,<hbr />
-      <csharp.EnumMember name="two" />
-    </csharp.EnumDeclaration>,
-  );
-
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-    }
-  `);
-});
-
-it("can reference things by refkey", () => {
-  const enumRK = core.refkey();
-  const twoRK = core.refkey();
-
-  const res = core.render(
-    <core.Output>
-      <csharp.Namespace name="TestCode">
-        <csharp.SourceFile path="Test.cs">
-          <csharp.EnumDeclaration public name="TestEnum" refkey={enumRK}>
-            <csharp.EnumMember name="One" />,<hbr />
-            <csharp.EnumMember name="Two" refkey={twoRK} />
-          </csharp.EnumDeclaration>
-          <hbr />
-          {enumRK};<hbr />
-          {twoRK};
-        </csharp.SourceFile>
-      </csharp.Namespace>
-    </core.Output>,
-  );
-
-  expect(findFile(res, "Test.cs").contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-        TestEnum;
-        TestEnum.Two;
-    }
-  `);
-});
-
-it("can reference things by refkey across files", () => {
-  const enumRK = core.refkey();
-  const barRK = core.refkey();
-
-  const res = core.render(
-    <core.Output>
-      <csharp.Namespace name="TestCode">
-        <csharp.SourceFile path="Test.cs">
-          <csharp.EnumDeclaration public name="TestEnum">
-            <csharp.EnumMember name="One" />,<hbr />
-            <csharp.EnumMember name="Two" />
-          </csharp.EnumDeclaration>
-          <hbr />
-          {enumRK};<hbr />
-          {barRK};
-        </csharp.SourceFile>
-        <csharp.SourceFile path="Other.cs">
-          <csharp.EnumDeclaration public name="OtherEnum" refkey={enumRK}>
-            <csharp.EnumMember name="Foo" />,<hbr />
-            <csharp.EnumMember name="Bar" refkey={barRK} />
-          </csharp.EnumDeclaration>
-          <hbr />
-          {enumRK};<hbr />
-          {barRK};
-        </csharp.SourceFile>
-      </csharp.Namespace>
-    </core.Output>,
-  );
-
-  expect(findFile(res, "Test.cs").contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-        OtherEnum;
-        OtherEnum.Bar;
-    }
-  `);
-
-  expect(findFile(res, "Other.cs").contents).toBe(coretest.d`
-    namespace TestCode
-    {
-        public enum OtherEnum
-        {
-            Foo,
-            Bar
-        }
-        OtherEnum;
-        OtherEnum.Bar;
-    }
-  `);
-});

package/test/namespace.test.tsx

@@ -1,55 +0,0 @@
-import * as core from "@alloy-js/core";
-import * as coretest from "@alloy-js/core/testing";
-import { it } from "vitest";
-import * as csharp from "../src/index.js";
-import { assertFileContents } from "./utils.jsx";
-
-it("defines multiple namespaces and source files with unique content", () => {
-  const res = core.render(
-    <core.Output>
-      <csharp.Namespace name="Namespace1">
-        <csharp.SourceFile path="Model1.cs">
-          <csharp.ClassDeclaration public name="Model1" />
-        </csharp.SourceFile>
-        <csharp.SourceFile path="Model2.cs">
-          <csharp.ClassDeclaration public name="Model2" />
-        </csharp.SourceFile>
-      </csharp.Namespace>
-      <csharp.Namespace name="Namespace2">
-        <csharp.SourceFile path="Model3.cs">
-          <csharp.ClassDeclaration public name="Model3" />
-        </csharp.SourceFile>
-        <csharp.SourceFile path="Model4.cs">
-          <csharp.ClassDeclaration public name="Model4" />
-        </csharp.SourceFile>
-      </csharp.Namespace>
-    </core.Output>,
-  );
-
-  assertFileContents(res, {
-    "Model1.cs": coretest.d`
-      namespace Namespace1
-      {
-          public class Model1;
-      }
-    `,
-    "Model2.cs": coretest.d`
-      namespace Namespace1
-      {
-          public class Model2;
-      }
-    `,
-    "Model3.cs": coretest.d`
-      namespace Namespace2
-      {
-          public class Model3;
-      }
-    `,
-    "Model4.cs": coretest.d`
-      namespace Namespace2
-      {
-          public class Model4;
-      }
-    `,
-  });
-});