@typespec/emitter-framework 0.9.0-dev.1 → 0.9.0-dev.2

package/dist/src/csharp/components/class-declaration.d.ts

@@ -0,0 +1,9 @@
+import * as ay from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { Interface, Model } from "@typespec/compiler";
+export interface ClassDeclarationProps extends Omit<cs.ClassProps, "name"> {
+    name?: string;
+    type: Model | Interface;
+}
+export declare function ClassDeclaration(props: ClassDeclarationProps): ay.Children;
+//# sourceMappingURL=class-declaration.d.ts.map

package/dist/src/csharp/components/class-declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-declaration.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/class-declaration.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAKtD,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC;CACzB;AAUD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,EAAE,CAAC,QAAQ,CAgB1E"}

package/dist/src/csharp/components/class-declaration.js

@@ -0,0 +1,97 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import * as ay from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { useTsp } from "../../core/index.js";
+import { TypeExpression } from "./type-expression.js";
+import { declarationRefkeys } from "./utils/refkey.js";
+export function ClassDeclaration(props) {
+  const {
+    $
+  } = useTsp();
+  const namePolicy = cs.useCSharpNamePolicy();
+  const className = props.name ?? namePolicy.getName(props.type.name, "class");
+  const refkeys = declarationRefkeys(props.refkey, props.type)[0]; // TODO: support multiple refkeys for declarations in alloy
+
+  return [_$createComponent(cs.Class, {
+    name: className,
+    get accessModifier() {
+      return props.accessModifier;
+    },
+    refkey: refkeys,
+    get children() {
+      return [_$memo(() => _$memo(() => !!$.model.is(props.type))() && _$createComponent(ClassProperties, {
+        get type() {
+          return props.type;
+        }
+      })), _$memo(() => _$memo(() => props.type.kind === "Interface")() && _$createComponent(ClassMethods, {
+        get type() {
+          return props.type;
+        }
+      }))];
+    }
+  })];
+}
+function ClassProperties(props) {
+  const namePolicy = cs.useCSharpNamePolicy();
+  const classProperties = [];
+  for (const [name, prop] of props.type.properties) {
+    classProperties.push([_$createComponent(cs.ClassMember, {
+      get name() {
+        return namePolicy.getName(name, "class-member-public");
+      },
+      get type() {
+        return _$createComponent(TypeExpression, {
+          get type() {
+            return prop.type;
+          }
+        });
+      },
+      accessModifier: "public"
+    }), " ", _$createComponent(ay.Block, {
+      newline: true,
+      get children() {
+        return _$createComponent(ay.StatementList, {
+          children: ["get", "set"]
+        });
+      }
+    })]);
+  }
+  return _$createComponent(ay.For, {
+    each: classProperties,
+    hardline: true,
+    children: c => c
+  });
+}
+function ClassMethods(props) {
+  const namePolicy = cs.useCSharpNamePolicy();
+  const abstractMethods = [];
+  for (const [name, prop] of props.type.operations) {
+    abstractMethods.push(_$createComponent(cs.ClassMethod, {
+      get name() {
+        return namePolicy.getName(name, "class-method");
+      },
+      methodModifier: "abstract",
+      get parameters() {
+        return [...prop.parameters.properties.entries()].map(([name, prop]) => {
+          return {
+            name: namePolicy.getName(name, "type-parameter"),
+            type: _$createComponent(TypeExpression, {
+              get type() {
+                return prop.type;
+              }
+            })
+          };
+        });
+      },
+      accessModifier: "public",
+      get returns() {
+        return _$createComponent(TypeExpression, {
+          get type() {
+            return prop.returnType;
+          }
+        });
+      }
+    }));
+  }
+  return [abstractMethods];
+}

package/dist/src/csharp/components/enum-declaration.d.ts

@@ -0,0 +1,9 @@
+import * as ay from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { Enum, Union } from "@typespec/compiler";
+export interface EnumDeclarationProps extends Omit<cs.EnumProps, "name"> {
+    name?: string;
+    type: Union | Enum;
+}
+export declare function EnumDeclaration(props: EnumDeclarationProps): ay.Children;
+//# sourceMappingURL=enum-declaration.d.ts.map

package/dist/src/csharp/components/enum-declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-declaration.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/enum-declaration.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAKjD,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,CAAC;IACtE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;CACpB;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,EAAE,CAAC,QAAQ,CAmCxE"}

package/dist/src/csharp/components/enum-declaration.js

@@ -0,0 +1,52 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import * as ay from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { useTsp } from "../../core/index.js";
+import { reportDiagnostic } from "../../lib.js";
+import { declarationRefkeys, efRefkey } from "./utils/refkey.js";
+export function EnumDeclaration(props) {
+  const {
+    $
+  } = useTsp();
+  let type;
+  if ($.union.is(props.type)) {
+    if (!$.union.isValidEnum(props.type)) {
+      throw new Error("The provided union type cannot be represented as an enum");
+    }
+    type = $.enum.createFromUnion(props.type);
+  } else {
+    type = props.type;
+  }
+  if (!props.type.name) {
+    reportDiagnostic($.program, {
+      code: "type-declaration-missing-name",
+      target: props.type
+    });
+  }
+  const refkeys = declarationRefkeys(props.refkey, props.type)[0]; // TODO: support multiple refkeys for declarations in alloy
+  const name = props.name ?? cs.useCSharpNamePolicy().getName(props.type.name, "enum");
+  const members = Array.from(type.members.entries());
+  return _$createComponent(cs.Enum, {
+    name: name,
+    refkey: refkeys,
+    get accessModifier() {
+      return props.accessModifier ?? "public";
+    },
+    get children() {
+      return _$createComponent(ay.For, {
+        each: members,
+        joiner: ",\n",
+        children: ([key, value]) => {
+          return _$createComponent(cs.EnumMember, {
+            get name() {
+              return cs.useCSharpNamePolicy().getName(key, "enum-member");
+            },
+            get refkey() {
+              return _$memo(() => !!$.union.is(props.type))() ? efRefkey(props.type.variants.get(key)) : efRefkey(value);
+            }
+          });
+        }
+      });
+    }
+  });
+}

package/dist/src/csharp/components/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./class-declaration.jsx";
+export * from "./enum-declaration.jsx";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/csharp/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC"}

package/dist/src/csharp/components/index.js

@@ -0,0 +1,2 @@
+export * from "./class-declaration.js";
+export * from "./enum-declaration.js";

package/dist/src/csharp/components/type-expression.d.ts

@@ -0,0 +1,11 @@
+import { Children } from "@alloy-js/core";
+import { IntrinsicType, Scalar, Type } from "@typespec/compiler";
+import { Typekit } from "@typespec/compiler/typekit";
+export interface TypeExpressionProps {
+    type: Type;
+}
+export declare function TypeExpression(props: TypeExpressionProps): Children;
+declare const intrinsicNameToCSharpType: Map<string, string | null>;
+export declare function getScalarIntrinsicExpression($: Typekit, type: Scalar | IntrinsicType): string | null;
+export { intrinsicNameToCSharpType };
+//# sourceMappingURL=type-expression.d.ts.map

package/dist/src/csharp/components/type-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-expression.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/type-expression.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAKrD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,GAAG,QAAQ,CASnE;AAED,QAAA,MAAM,yBAAyB,4BAqC7B,CAAC;AAEH,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,OAAO,EACV,IAAI,EAAE,MAAM,GAAG,aAAa,GAC3B,MAAM,GAAG,IAAI,CAoBf;AA0BD,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/src/csharp/components/type-expression.js

@@ -0,0 +1,129 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Reference } from "@alloy-js/csharp";
+import { useTsp } from "../../core/index.js";
+import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
+import { efRefkey } from "./utils/refkey.js";
+export function TypeExpression(props) {
+  const {
+    $
+  } = useTsp();
+  if (isDeclaration($, props.type)) {
+    return _$createComponent(Reference, {
+      get refkey() {
+        return efRefkey(props.type);
+      }
+    });
+  }
+  if ($.scalar.is(props.type)) {
+    return getScalarIntrinsicExpression($, props.type);
+  }
+  throw new Error("not implemented");
+}
+const intrinsicNameToCSharpType = new Map([
+// Core types
+["unknown", "object"],
+// Matches C#'s `object`
+["string", "string"],
+// Matches C#'s `string`
+["boolean", "bool"],
+// Matches C#'s `bool`
+["null", "null"],
+// Matches C#'s `null`
+["void", "void"],
+// Matches C#'s `void`
+["never", null],
+// No direct equivalent in C#
+["bytes", "byte[]"],
+// Matches C#'s `byte[]`
+
+// Numeric types
+["numeric", "decimal"],
+// Parent type for all numeric types, use most precise
+["integer", "int"],
+// Broad integer category, maps to `int`
+["float", "float"],
+// Broad float category, maps to `float`
+["decimal", "decimal"],
+// Broad decimal category, maps to `decimal`
+["decimal128", "decimal"],
+// C#'s decimal is 128-bit
+["int64", "long"],
+// 64-bit signed integer
+["int32", "int"],
+// 32-bit signed integer
+["int16", "short"],
+// 16-bit signed integer
+["int8", "sbyte"],
+// 8-bit signed integer
+["safeint", "int"],
+// Safe integer, use int as default
+["uint64", "ulong"],
+// 64-bit unsigned integer
+["uint32", "uint"],
+// 32-bit unsigned integer
+["uint16", "ushort"],
+// 16-bit unsigned integer
+["uint8", "byte"],
+// 8-bit unsigned integer
+["float32", "float"],
+// 32-bit floating point
+["float64", "double"],
+// 64-bit floating point
+
+// Date and time types
+["plainDate", "DateOnly"],
+// Use .NET 6+ DateOnly for plain calendar dates
+["plainTime", "TimeOnly"],
+// Use .NET 6+ TimeOnly for plain clock times
+["utcDateTime", "DateTimeOffset"],
+// Use DateTimeOffset for UTC date-times
+["offsetDateTime", "DateTimeOffset"],
+// Use DateTimeOffset for timezone-specific date-times
+["duration", "TimeSpan"],
+// Duration as TimeSpan
+
+// String types
+["url", "Uri"] // Matches C#'s `Uri`
+]);
+export function getScalarIntrinsicExpression($, type) {
+  let intrinsicName;
+  if ($.scalar.isUtcDateTime(type) || $.scalar.extendsUtcDateTime(type)) {
+    return "DateTimeOffset";
+  }
+  if ($.scalar.is(type)) {
+    intrinsicName = $.scalar.getStdBase(type)?.name ?? "";
+  } else {
+    intrinsicName = type.name;
+  }
+  const csType = intrinsicNameToCSharpType.get(intrinsicName);
+  if (!csType) {
+    reportTypescriptDiagnostic($.program, {
+      code: "typescript-unsupported-scalar",
+      target: type
+    });
+    return "object"; // Fallback to object if unsupported
+  }
+  return csType;
+}
+function isDeclaration($, type) {
+  switch (type.kind) {
+    case "Namespace":
+    case "Interface":
+    case "Enum":
+    case "Operation":
+    case "EnumMember":
+      return true;
+    case "UnionVariant":
+      return false;
+    case "Model":
+      if ($.array.is(type) || $.record.is(type)) {
+        return false;
+      }
+      return Boolean(type.name);
+    case "Union":
+      return Boolean(type.name);
+    default:
+      return false;
+  }
+}
+export { intrinsicNameToCSharpType };

package/dist/src/csharp/components/utils/refkey.d.ts

@@ -0,0 +1,23 @@
+import { type Refkey } from "@alloy-js/core";
+/**
+ * A wrapper around `refkey` that uses a custom symbol to avoid collisions with
+ * other libraries that use `refkey`.
+ *
+ * @remarks
+ *
+ * The underlying refkey function is called with the {@link refKeyPrefix} symbol as the first argument.
+ *
+ * @param args The parameters of the refkey.
+ * @returns A refkey object that can be used to identify the value.
+ */
+export declare function efRefkey(...args: unknown[]): Refkey;
+/**
+ * Creates a refkey for a declaration by combining the provided refkey with an internal
+ * refkey generated from the provided arguments.
+ *
+ * @param refkey The refkey provided by the user to be passed as is.
+ * @param args The parameters of the refkey.
+ * @returns An array of refkeys that can be passed to an Alloy declaration.
+ */
+export declare function declarationRefkeys(refkey?: Refkey | Refkey[], ...args: unknown[]): Refkey[];
+//# sourceMappingURL=refkey.d.ts.map

package/dist/src/csharp/components/utils/refkey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refkey.d.ts","sourceRoot":"","sources":["../../../../../src/csharp/components/utils/refkey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAIjE;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAKnD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,CAK3F"}

package/dist/src/csharp/components/utils/refkey.js

@@ -0,0 +1,35 @@
+import { refkey as ayRefkey } from "@alloy-js/core";
+const refKeyPrefix = Symbol.for("emitter-framework:csharp");
+
+/**
+ * A wrapper around `refkey` that uses a custom symbol to avoid collisions with
+ * other libraries that use `refkey`.
+ *
+ * @remarks
+ *
+ * The underlying refkey function is called with the {@link refKeyPrefix} symbol as the first argument.
+ *
+ * @param args The parameters of the refkey.
+ * @returns A refkey object that can be used to identify the value.
+ */
+export function efRefkey(...args) {
+  if (args.length === 0) {
+    return ayRefkey(); // Generates a unique refkey
+  }
+  return ayRefkey(refKeyPrefix, ...args);
+}
+
+/**
+ * Creates a refkey for a declaration by combining the provided refkey with an internal
+ * refkey generated from the provided arguments.
+ *
+ * @param refkey The refkey provided by the user to be passed as is.
+ * @param args The parameters of the refkey.
+ * @returns An array of refkeys that can be passed to an Alloy declaration.
+ */
+export function declarationRefkeys(refkey, ...args) {
+  if (refkey) {
+    return [refkey, efRefkey(...args)].flat();
+  }
+  return [efRefkey(...args)];
+}

package/dist/src/csharp/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./components/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/csharp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/csharp/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC"}

package/dist/src/csharp/index.js

@@ -0,0 +1 @@
+export * from "./components/index.js";

package/dist/test/csharp/components/class-declaration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=class-declaration.test.d.ts.map

package/dist/test/csharp/components/class-declaration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-declaration.test.d.ts","sourceRoot":"","sources":["../../../../test/csharp/components/class-declaration.test.tsx"],"names":[],"mappings":""}