@alloy-js/csharp 0.18.0-dev.17 → 0.18.0-dev.18

package/dist/src/components/type-parameters/type-parameter-constraints.test.js

@@ -0,0 +1,67 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { expect, it } from "vitest";
+import { TypeParameterConstraints } from "./type-parameter-constraints.js";
+it("renders nothing if there is no constraints", () => {
+  expect(_$createComponent(TypeParameterConstraints, {
+    parameters: ["A", "B"]
+  })).toRenderTo(``);
+});
+it("renders inline if there is only one", () => {
+  expect(["code()", _$createComponent(TypeParameterConstraints, {
+    parameters: [{
+      name: "A",
+      constraints: "string"
+    }]
+  })]).toRenderTo(`
+    code() where A : string
+  `);
+});
+it("renders multiple constraints", () => {
+  expect(["code()", _$createComponent(TypeParameterConstraints, {
+    parameters: [{
+      name: "A",
+      constraints: ["string", "int"]
+    }]
+  })]).toRenderTo(`
+    code() where A : string, int
+  `);
+});
+it("renders newline if constraint is very long", () => {
+  expect(["code()", _$createComponent(TypeParameterConstraints, {
+    parameters: [{
+      name: "ThisIsQuiteALongName",
+      constraints: "VeryLongBuilderFactorySingletonThatShouldBeSplit"
+    }]
+  })]).toRenderTo(`
+    code()
+      where ThisIsQuiteALongName : VeryLongBuilderFactorySingletonThatShouldBeSplit
+  `);
+});
+it("renders multiple constraints on new lines if they are very long", () => {
+  expect(["code()", _$createComponent(TypeParameterConstraints, {
+    parameters: [{
+      name: "A",
+      constraints: ["IVeryLongBuilderFactorySingletonThatShouldBeSplitA", "IVeryLongBuilderFactorySingletonThatShouldBeSplitB"]
+    }]
+  })]).toRenderTo(`
+    code()
+      where A :
+        IVeryLongBuilderFactorySingletonThatShouldBeSplitA,
+        IVeryLongBuilderFactorySingletonThatShouldBeSplitB
+  `);
+});
+it("declare type parameters using parameters", () => {
+  expect(["code()", _$createComponent(TypeParameterConstraints, {
+    parameters: [{
+      name: "A",
+      constraints: "string"
+    }, {
+      name: "B",
+      constraints: "string"
+    }]
+  })]).toRenderTo(`
+    code()
+      where A : string
+      where B : string
+  `);
+});

package/dist/src/components/type-parameters/type-parameter.d.ts

@@ -0,0 +1,20 @@
+import { Children, Refkey } from "@alloy-js/core";
+/**
+ * Information for a TypeScript generic type parameter.
+ */
+export interface TypeParameterProps {
+    /**
+     * The name of the type parameter.
+     */
+    readonly name: string;
+    /**
+     * The parameter constraint
+     */
+    readonly constraints?: Children | Children[];
+    /**
+     * A refkey or array of refkeys for this type parameter.
+     */
+    readonly refkey?: Refkey | Refkey[];
+}
+export declare function TypeParameter(props: TypeParameterProps): Children;
+//# sourceMappingURL=type-parameter.d.ts.map

package/dist/src/components/type-parameters/type-parameter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-parameter.d.ts","sourceRoot":"","sources":["../../../../src/components/type-parameters/type-parameter.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAA6B,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAK7E;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAC;IAE7C;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACrC;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,YAStD"}

package/dist/src/components/type-parameters/type-parameter.js

@@ -0,0 +1,22 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { MemberDeclaration, refkey } from "@alloy-js/core";
+import { useCSharpNamePolicy } from "../../name-policy.js";
+import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
+import { useCSharpScope } from "../../symbols/scopes.js";
+
+/**
+ * Information for a TypeScript generic type parameter.
+ */
+
+export function TypeParameter(props) {
+  const name = useCSharpNamePolicy().getName(props.name, "type-parameter");
+  const scope = useCSharpScope();
+  const symbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(props.name)
+  });
+  return _$createComponent(MemberDeclaration, {
+    symbol: symbol,
+    children: name
+  });
+}

package/dist/src/components/type-parameters/type-parameters.d.ts

@@ -0,0 +1,17 @@
+import { TypeParameterProps } from "./type-parameter.jsx";
+export declare const typeParametersTag: unique symbol;
+export interface TypeParametersProps {
+    /** Parameters */
+    parameters: (TypeParameterProps | string)[];
+}
+/**
+ * Represent type parameters
+ *
+ * @example
+ * ```ts
+ * <A, B extends string>
+ * ```
+ */
+export declare const TypeParameters: import("@alloy-js/core").Component<TypeParametersProps> & Required<Pick<import("@alloy-js/core").Component<TypeParametersProps>, "tag">>;
+export declare function normalizeParameters(parameters: (TypeParameterProps | string)[]): TypeParameterProps[];
+//# sourceMappingURL=type-parameters.d.ts.map

package/dist/src/components/type-parameters/type-parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-parameters.d.ts","sourceRoot":"","sources":["../../../../src/components/type-parameters/type-parameters.tsx"],"names":[],"mappings":"AACA,OAAO,EAAiB,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAEzE,eAAO,MAAM,iBAAiB,eAAuC,CAAC;AAEtE,MAAM,WAAW,mBAAmB;IAClC,iBAAiB;IACjB,UAAU,EAAE,CAAC,kBAAkB,GAAG,MAAM,CAAC,EAAE,CAAC;CAC7C;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,0IA4B1B,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,CAAC,kBAAkB,GAAG,MAAM,CAAC,EAAE,GAC1C,kBAAkB,EAAE,CAOtB"}

package/dist/src/components/type-parameters/type-parameters.js

@@ -0,0 +1,65 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { For, Indent, taggedComponent } from "@alloy-js/core";
+import { TypeParameter } from "./type-parameter.js";
+export const typeParametersTag = Symbol.for("csharp.type-parameters");
+/**
+ * Represent type parameters
+ *
+ * @example
+ * ```ts
+ * <A, B extends string>
+ * ```
+ */
+export const TypeParameters = taggedComponent(typeParametersTag, function TypeParameters(props) {
+  const typeParameters = normalizeParameters(props.parameters);
+
+  // const typeParameters = normalizeAndDeclareParameters(props.parameters);
+
+  // onCleanup(() => {
+  //   for (const param of typeParameters) {
+  //     param.symbol.delete();
+  //   }
+  // });
+
+  return ["<", _$createIntrinsic("group", {
+    get children() {
+      return _$createComponent(Indent, {
+        softline: true,
+        get children() {
+          return [_$createComponent(For, {
+            each: typeParameters,
+            comma: true,
+            line: true,
+            children: param => _$createComponent(TypeParameter, param)
+          }), _$createIntrinsic("ifBreak", {
+            children: ","
+          })];
+        }
+      });
+    }
+  }), ">"];
+});
+export function normalizeParameters(parameters) {
+  return parameters.map(param => {
+    if (typeof param === "string") {
+      return {
+        name: param
+      };
+    }
+    return param;
+  });
+}
+
+// export function declareParameter(
+//   parameters: TypeParameterProps[],
+// ): TypeParameterProps[] {
+//   return parameters.map((param) => {
+//     return {
+//       ...param,
+//       symbol: new CSharpOutputSymbol(entry[0], {
+//         scope: thisClassScope,
+//         refkeys: entry[1],
+//       }),
+//     };
+//   });
+// }

package/dist/src/components/type-parameters/type-parameters.test.d.ts

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

package/dist/src/components/type-parameters/type-parameters.test.d.ts.map

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

package/dist/src/components/type-parameters/type-parameters.test.js

@@ -0,0 +1,26 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.js";
+import { TypeParameters } from "./type-parameters.js";
+it("declare type parameters using parameters names", () => {
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(TypeParameters, {
+        parameters: ["A", "B"]
+      });
+    }
+  })).toRenderTo(`<A, B>`);
+});
+it("declare type parameters using parameters", () => {
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(TypeParameters, {
+        parameters: [{
+          name: "A"
+        }, {
+          name: "B"
+        }]
+      });
+    }
+  })).toRenderTo(`<A, B>`);
+});

package/dist/test/class-declaration.test.js

@@ -1,9 +1,10 @@
 import { createComponent as _$createComponent, mergeProps as _$mergeProps, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
 import * as core from "@alloy-js/core";
+import { List, refkey } from "@alloy-js/core";
 import * as coretest from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import * as csharp from "../src/index.js";
-import { ClassDeclaration, ClassMember } from "../src/index.js";
+import { ClassDeclaration, ClassMember, Property, SourceFile } from "../src/index.js";
 import * as utils from "./utils.js";
 it("declares class with no members", () => {
   expect(_$createComponent(utils.TestNamespace, {
@@ -251,41 +252,86 @@ it("uses refkeys for members, params, and return type", () => {
     }
   `);
 });
-it("declares class with generic parameters", () => {
-  const typeParameters = {
-    T: core.refkey(),
-    U: core.refkey()
-  };
-  const res = utils.toSourceText(_$createComponent(csharp.ClassDeclaration, {
-    "public": true,
-    name: "TestClass",
-    typeParameters: typeParameters,
-    get children() {
-      return [_$createComponent(csharp.ClassMember, {
-        "public": true,
-        name: "memberOne",
-        get type() {
-          return typeParameters.T;
-        }
-      }), ";", _$createIntrinsic("hbr", {}), _$createComponent(csharp.ClassMember, {
-        "private": true,
-        name: "memberTwo",
-        get type() {
-          return typeParameters.U;
-        }
-      }), ";"];
-    }
-  }));
-  expect(res).toBe(coretest.d`
-    namespace TestCode
-    {
+describe("with type parameters", () => {
+  it("reference parameters", () => {
+    const typeParameters = [{
+      name: "T",
+      refkey: refkey()
+    }, {
+      name: "U",
+      refkey: refkey()
+    }];
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(SourceFile, {
+          path: "Test.cs",
+          get children() {
+            return _$createComponent(ClassDeclaration, {
+              "public": true,
+              name: "TestClass",
+              typeParameters: typeParameters,
+              get children() {
+                return _$createComponent(List, {
+                  get children() {
+                    return [_$createComponent(Property, {
+                      name: "PropA",
+                      get type() {
+                        return typeParameters[0].refkey;
+                      },
+                      get: true,
+                      set: true
+                    }), _$createComponent(Property, {
+                      name: "PropB",
+                      get type() {
+                        return typeParameters[1].refkey;
+                      },
+                      get: true,
+                      set: true
+                    })];
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    })).toRenderTo(`
+      namespace TestCode
+      {
         public class TestClass<T, U>
         {
-            public T MemberOne;
-            private U memberTwo;
+          T PropA { get; set; }
+          U PropB { get; set; }
         }
-    }
-  `);
+      }
+    `);
+  });
+  it("defines with constraints", () => {
+    const typeParameters = [{
+      name: "T",
+      constraints: "IFoo"
+    }, {
+      name: "U",
+      constraints: "IBar"
+    }];
+    expect(_$createComponent(utils.TestNamespace, {
+      get children() {
+        return _$createComponent(ClassDeclaration, {
+          "public": true,
+          name: "TestClass",
+          typeParameters: typeParameters,
+          children: "// Body"
+        });
+      }
+    })).toRenderTo(`
+      public class TestClass<T, U>
+        where T : IFoo
+        where U : IBar
+      {
+        // Body
+      }
+    `);
+  });
 });
 it("declares class with invalid members", () => {
   const decl = _$createComponent(csharp.ClassDeclaration, {