@alloy-js/csharp 0.18.0-dev.3 → 0.18.0-dev.5

package/src/components/ClassMethod.tsx

@@ -7,12 +7,12 @@ import {
   Scope,
 } from "@alloy-js/core";
 import {
-  AccessModifier,
+  AccessModifiers,
   computeModifiersPrefix,
   getAccessModifier,
   getAsyncModifier,
   getMethodModifier,
-  MethodModifier,
+  MethodModifiers,
 } from "../modifiers.js";
 import { useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
@@ -20,12 +20,10 @@ import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
 import { ParameterProps, Parameters } from "./Parameters.jsx";
 
 // properties for creating a method
-export interface ClassMethodProps {
+export interface ClassMethodProps extends AccessModifiers, MethodModifiers {
   name: string;
   refkey?: Refkey;
   children?: Children;
-  accessModifier?: AccessModifier;
-  methodModifier?: MethodModifier;
   parameters?: Array<ParameterProps>;
   returns?: Children;
 
@@ -58,8 +56,8 @@ export function ClassMethod(props: ClassMethodProps) {
   const returns = props.returns ?? (props.async ? "Task" : "void");
 
   const modifiers = computeModifiersPrefix([
-    getAccessModifier(props.accessModifier),
-    getMethodModifier(props.methodModifier),
+    getAccessModifier(props),
+    getMethodModifier(props),
     getAsyncModifier(props.async),
   ]);
   // note that scope wraps the method decl so that the params get the correct scope
@@ -68,9 +66,7 @@ export function ClassMethod(props: ClassMethodProps) {
       <Scope value={methodScope}>
         {modifiers}
         {returns} {name}({params})
-        {props.methodModifier === "abstract" ?
-          ";"
-        : <Block newline>{props.children}</Block>}
+        {props.abstract ? ";" : <Block newline>{props.children}</Block>}
       </Scope>
     </MemberDeclaration>
   );

package/src/components/{Enum.tsx → EnumDeclaration.tsx}

@@ -1,20 +1,42 @@
 import * as core from "@alloy-js/core";
-import { AccessModifier, getAccessModifier } from "../modifiers.js";
+import {
+  AccessModifiers,
+  computeModifiersPrefix,
+  getAccessModifier,
+} from "../modifiers.js";
 import { useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
 import { Name } from "./Name.jsx";
 
 // properties for creating an enum
-export interface EnumProps {
+export interface EnumProps extends AccessModifiers {
   name: string;
   refkey?: core.Refkey;
   children?: core.Children;
-  accessModifier?: AccessModifier;
 }
 
-// a C# enum declaration
-export function Enum(props: EnumProps) {
+/**
+ * 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: EnumProps) {
   const name = useCSharpNamePolicy().getName(props.name!, "enum");
   const scope = useCSharpScope();
 
@@ -32,10 +54,12 @@ export function Enum(props: EnumProps) {
     owner: thisEnumSymbol,
   });
 
+  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
+
   if (thisEnumScope.owner)
     return (
       <core.Declaration symbol={thisEnumSymbol}>
-        {getAccessModifier(props.accessModifier)}enum <Name />
+        {modifiers}enum <Name />
         {!props.children && ";"}
         {props.children && (
           <core.Scope value={thisEnumScope}>

package/src/components/index.ts

@@ -1,7 +1,7 @@
-export * from "./Class.js";
+export * from "./ClassDeclaration.jsx";
 export { ClassMethod, type ClassMethodProps } from "./ClassMethod.jsx";
 export * from "./Declaration.js";
-export * from "./Enum.js";
+export * from "./EnumDeclaration.jsx";
 export * from "./Name.js";
 export * from "./Namespace.js";
 export * from "./Parameters.js";

package/src/components/stc/index.ts

@@ -1,11 +1,11 @@
 import * as core from "@alloy-js/core";
 import * as base from "../index.js";
 
-export const Class = core.stc(base.Class);
+export const ClassDeclaration = core.stc(base.ClassDeclaration);
 export const ClassConstructor = core.stc(base.ClassConstructor);
 export const ClassMember = core.stc(base.ClassMember);
 export const ClassMethod = core.stc(base.ClassMethod);
-export const Enum = core.stc(base.Enum);
+export const EnumDeclaration = core.stc(base.EnumDeclaration);
 export const EnumMember = core.stc(base.EnumMember);
 export const Parameter = core.stc(base.Parameter);
 export const Parameters = core.stc(base.Parameters);

package/src/modifiers.ts

@@ -1,51 +1,48 @@
 // the possible C# access modifiers
 // https://learn.microsoft.com/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers
-export type AccessModifier =
-  | "public"
-  | "protected"
-  | "private"
-  | "internal"
-  | "protected-internal"
-  | "private-protected"
-  | "file";
 
-// maps the above access modifier value to its C# syntax.
-// note that the C# keyword includes a trailing space
-const accessModifierLookup: Record<AccessModifier, string> = {
-  public: "public ",
-  protected: "protected ",
-  private: "private ",
-  internal: "internal ",
-  "protected-internal": "protected internal ",
-  "private-protected": "private protected ",
-  file: "file ",
-};
-
-// returns the C# syntax for the specified access modifier.
-// if no access modifier is specified, the empty string is returned.
-export function getAccessModifier(accessModifier?: AccessModifier): string {
-  return accessModifier ? accessModifierLookup[accessModifier] : "";
+/** Access modifiers.  */
+export interface AccessModifiers {
+  readonly public?: boolean;
+  readonly protected?: boolean;
+  readonly private?: boolean;
+  readonly internal?: boolean;
+  readonly file?: boolean;
 }
 
-export type MethodModifier = "abstract" | "sealed" | "static" | "virtual";
+export function getAccessModifier(data: AccessModifiers): string {
+  return [
+    data.public && "public",
+    data.protected && "protected",
+    data.private && "private",
+    data.internal && "internal",
+    data.file && "file",
+  ]
+    .filter((x) => x)
+    .join(" ");
+}
 
-// maps the above method modifier value to its C# syntax.
-// note that the C# keyword includes a trailing space
-const methodModifierLookup: Record<MethodModifier, string> = {
-  abstract: "abstract ",
-  sealed: "sealed ",
-  static: "static ",
-  virtual: "virtual ",
-};
+/** Method modifiers. Can only be one. */
+export interface MethodModifiers {
+  readonly abstract?: boolean;
+  readonly sealed?: boolean;
+  readonly static?: boolean;
+  readonly virtual?: boolean;
+}
 
-// returns the C# syntax for the specified method modifier.
-// if no method modifier is specified, the empty string is returned.
-export function getMethodModifier(methodModifier?: MethodModifier): string {
-  return methodModifier ? methodModifierLookup[methodModifier] : "";
+export function getMethodModifier(data: MethodModifiers): string {
+  return [
+    data.abstract && "abstract",
+    data.sealed && "sealed",
+    data.static && "static",
+    data.virtual && "virtual",
+  ]
+    .filter((x) => x)
+    .join(" ");
 }
 
 export function getAsyncModifier(async?: boolean): string {
-  return async ? "async " : "";
+  return async ? "async" : "";
 }
 
 /** Resolve the modifier prefix */
@@ -53,5 +50,5 @@ export function computeModifiersPrefix(
   modifiers: Array<string | undefined>,
 ): string {
   const resolved = modifiers.filter((x) => x);
-  return resolved.length > 0 ? resolved.join("") : "";
+  return resolved.length > 0 ? resolved.join(" ") + " " : "";
 }