@alloy-js/csharp 0.18.0-dev.16 → 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/src/components/var/declaration.d.ts

@@ -0,0 +1,35 @@
+import { Children, DeclarationProps, Refkey } from "@alloy-js/core";
+/** Props for {@link VarDeclaration} component */
+export interface VarDeclarationProps extends Omit<DeclarationProps, "nameKind"> {
+    /** Variable name */
+    name: string;
+    /** Type of the variable declaration. If not specified, defaults to "var" */
+    type?: Children;
+    /** Variable refkey */
+    refkey?: Refkey;
+    /** Variable value */
+    children?: Children;
+}
+/**
+ * Render a variable declaration
+ *
+ * @example with var
+ * ```tsx
+ * <VarDeclaration name="myVar">42</VarDeclaration>
+ * ```
+ * This will render:
+ * ```csharp
+ * var myVar = 42;
+ * ```
+ *
+ * @example with type
+ * ```tsx
+ * <VarDeclaration name="myVar" type="int">42</VarDeclaration>
+ * ```
+ * This will render:
+ * ```csharp
+ * int myVar = 42;
+ * ```
+ */
+export declare function VarDeclaration(props: VarDeclarationProps): Children;
+//# sourceMappingURL=declaration.d.ts.map

package/dist/src/components/var/declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.d.ts","sourceRoot":"","sources":["../../../../src/components/var/declaration.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAQ,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI1E,iDAAiD;AACjD,MAAM,WAAW,mBACf,SAAQ,IAAI,CAAC,gBAAgB,EAAE,UAAU,CAAC;IAC1C,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,sBAAsB;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qBAAqB;IACrB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,mBAAmB,YAQxD"}

package/dist/src/components/var/declaration.js

@@ -0,0 +1,40 @@
+import { memo as _$memo, createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Name } from "@alloy-js/core";
+import { useCSharpNamePolicy } from "../../name-policy.js";
+import { Declaration } from "../Declaration.js";
+
+/** Props for {@link VarDeclaration} component */
+
+/**
+ * Render a variable declaration
+ *
+ * @example with var
+ * ```tsx
+ * <VarDeclaration name="myVar">42</VarDeclaration>
+ * ```
+ * This will render:
+ * ```csharp
+ * var myVar = 42;
+ * ```
+ *
+ * @example with type
+ * ```tsx
+ * <VarDeclaration name="myVar" type="int">42</VarDeclaration>
+ * ```
+ * This will render:
+ * ```csharp
+ * int myVar = 42;
+ * ```
+ */
+export function VarDeclaration(props) {
+  const name = useCSharpNamePolicy().getName(props.name, "variable");
+  return _$createComponent(Declaration, {
+    name: name,
+    get refkey() {
+      return props.refkey;
+    },
+    get children() {
+      return [_$memo(() => props.type ?? "var"), " ", _$createComponent(Name, {}), " = ", _$memo(() => props.children), ";"];
+    }
+  });
+}

package/dist/src/components/var/declaration.test.d.ts

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

package/dist/src/components/var/declaration.test.d.ts.map

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

package/dist/src/components/var/declaration.test.js

@@ -0,0 +1,73 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { List, refkey } from "@alloy-js/core";
+import { expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.js";
+import { SourceFile } from "../SourceFile.js";
+import { VarDeclaration } from "./declaration.js";
+it("declares var without type", () => {
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(VarDeclaration, {
+        name: "testVar",
+        children: "42"
+      });
+    }
+  })).toRenderTo(`
+      var testVar = 42;
+  `);
+});
+it("declares var with type", () => {
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(VarDeclaration, {
+        name: "testVar",
+        type: "int",
+        children: "42"
+      });
+    }
+  })).toRenderTo(`
+      int testVar = 42;
+  `);
+});
+it("name variables camel case", () => {
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(VarDeclaration, {
+        name: "test_var",
+        children: "42"
+      });
+    }
+  })).toRenderTo(`
+      var testVar = 42;
+  `);
+});
+it("links refkey", () => {
+  const key = refkey();
+  expect(_$createComponent(TestNamespace, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "test.cs",
+        get children() {
+          return _$createComponent(List, {
+            get children() {
+              return [_$createComponent(VarDeclaration, {
+                name: "testVar",
+                refkey: key,
+                children: "42"
+              }), _$createComponent(VarDeclaration, {
+                name: "testVar2",
+                children: key
+              })];
+            }
+          });
+        }
+      });
+    }
+  })).toRenderTo(`
+      namespace TestCode
+      {
+        var testVar = 42;
+        var testVar2 = testVar;
+      }
+  `);
+});

package/dist/src/name-policy.d.ts

@@ -1,5 +1,5 @@
 import * as core from "@alloy-js/core";
-export type CSharpElements = "class" | "constant" | "enum" | "enum-member" | "function" | "interface" | "record" | "class-member-private" | "class-member-public" | "class-method" | "class-property" | "parameter" | "type-parameter";
+export type CSharpElements = "class" | "constant" | "variable" | "enum" | "enum-member" | "function" | "interface" | "record" | "class-member-private" | "class-member-public" | "class-method" | "class-property" | "parameter" | "type-parameter";
 export declare function createCSharpNamePolicy(): core.NamePolicy<CSharpElements>;
 export declare function useCSharpNamePolicy(): core.NamePolicy<CSharpElements>;
 //# sourceMappingURL=name-policy.d.ts.map

package/dist/src/name-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"name-policy.d.ts","sourceRoot":"","sources":["../../src/name-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AAIvC,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,UAAU,GACV,MAAM,GACN,aAAa,GACb,UAAU,GACV,WAAW,GACX,QAAQ,GACR,sBAAsB,GACtB,qBAAqB,GACrB,cAAc,GACd,gBAAgB,GAChB,WAAW,GACX,gBAAgB,CAAC;AAGrB,wBAAgB,sBAAsB,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAmBxE;AAGD,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAErE"}
+{"version":3,"file":"name-policy.d.ts","sourceRoot":"","sources":["../../src/name-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAC;AAIvC,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,UAAU,GACV,UAAU,GACV,MAAM,GACN,aAAa,GACb,UAAU,GACV,WAAW,GACX,QAAQ,GACR,sBAAsB,GACtB,qBAAqB,GACrB,cAAc,GACd,gBAAgB,GAChB,WAAW,GACX,gBAAgB,CAAC;AAGrB,wBAAgB,sBAAsB,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAmBxE;AAGD,wBAAgB,mBAAmB,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAErE"}

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, {