@typespec/emitter-framework 0.6.0-dev.4 → 0.6.0-dev.6

package/dist/test/typescript/components/union-declaration.test.js

@@ -0,0 +1,205 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Output, render } from "@alloy-js/core";
+import { SourceFile } from "@alloy-js/typescript";
+import { format } from "prettier";
+import { assert, describe, expect, it } from "vitest";
+import { UnionDeclaration } from "../../../src/typescript/components/union-declaration.js";
+import { UnionExpression } from "../../../src/typescript/components/union-expression.js";
+import { getProgram } from "../test-host.js";
+describe("Typescript Union Declaration", () => {
+  describe("Union not bound to Typespec Types", () => {
+    it("creates a union declaration", async () => {
+      const res = render(_$createComponent(Output, {
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.ts",
+            get children() {
+              return _$createComponent(UnionDeclaration, {
+                name: "MyUnion",
+                children: "\"red\" | \"blue\""
+              });
+            }
+          });
+        }
+      }));
+      const testFile = res.contents.find(file => file.path === "test.ts");
+      assert(testFile, "test.ts file not rendered");
+      const actualContent = await format(testFile.contents, {
+        parser: "typescript"
+      });
+      const expectedContent = await format(`type MyUnion = "red" | "blue"`, {
+        parser: "typescript"
+      });
+      expect(actualContent).toBe(expectedContent);
+    });
+  });
+  describe("Union bound to Typespec Types", () => {
+    describe("Bound to Union", () => {
+      it("creates a union declaration", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        union TestUnion {
+          one: "one",
+          two: "two"
+        }
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const union = Array.from(namespace.unions.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(UnionDeclaration, {
+                  type: union
+                });
+              }
+            });
+          }
+        }));
+        const testFile = res.contents.find(file => file.path === "test.ts");
+        assert(testFile, "test.ts file not rendered");
+        const actualContent = await format(testFile.contents, {
+          parser: "typescript"
+        });
+        const expectedContent = await format(`type TestUnion = "one" | "two"`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("creates a union declaration with name override", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        union TestUnion {
+          one: "one",
+          two: "two"
+        }
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const union = Array.from(namespace.unions.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(UnionDeclaration, {
+                  "export": true,
+                  type: union,
+                  name: "MyUnion"
+                });
+              }
+            });
+          }
+        }));
+        const testFile = res.contents.find(file => file.path === "test.ts");
+        assert(testFile, "test.ts file not rendered");
+        const actualContent = await format(testFile.contents, {
+          parser: "typescript"
+        });
+        const expectedContent = await format(`export type MyUnion = "one" | "two"`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("creates a union declaration with extra children", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        union TestUnion {
+          one: "one",
+          two: "two"
+        }
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const union = Array.from(namespace.unions.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(UnionDeclaration, {
+                  type: union,
+                  children: "\"three\""
+                });
+              }
+            });
+          }
+        }));
+        const testFile = res.contents.find(file => file.path === "test.ts");
+        assert(testFile, "test.ts file not rendered");
+        const actualContent = await format(testFile.contents, {
+          parser: "typescript"
+        });
+        const expectedContent = await format(`type TestUnion = "one" | "two" | "three"`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("renders an union expression", async () => {
+        const program = await getProgram(`
+          namespace DemoService;
+          union TestUnion {
+            one: "one",
+            two: "two"
+          }
+          `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const union = Array.from(namespace.unions.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return ["let x: ", _$createComponent(UnionExpression, {
+                  type: union
+                }), " = \"one\";"];
+              }
+            });
+          }
+        }));
+        const testFile = res.contents.find(file => file.path === "test.ts");
+        assert(testFile, "test.ts file not rendered");
+        const actualContent = await format(testFile.contents, {
+          parser: "typescript"
+        });
+        const expectedContent = await format(`let x:"one" | "two" = "one"`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+    });
+    describe("Bound to Enum", () => {
+      it("creates a union declaration", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        enum TestEnum {
+          one: "one",
+          two: "two"
+        }
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const union = Array.from(namespace.enums.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(UnionDeclaration, {
+                  type: union
+                });
+              }
+            });
+          }
+        }));
+        const testFile = res.contents.find(file => file.path === "test.ts");
+        assert(testFile, "test.ts file not rendered");
+        const actualContent = await format(testFile.contents, {
+          parser: "typescript"
+        });
+        const expectedContent = await format(`type TestEnum = "one" | "two"`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+    });
+  });
+});

package/dist/test/typescript/components/value-expression.test.js

@@ -0,0 +1,199 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Output, render } from "@alloy-js/core";
+import { dedent } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { Numeric } from "@typespec/compiler";
+import { $ } from "@typespec/compiler/experimental/typekit";
+import { assert, beforeAll, describe, expect, it } from "vitest";
+import { ValueExpression } from "../../../src/typescript/components/value-expression.js";
+import { getProgram, initEmptyProgram } from "../test-host.js";
+beforeAll(async () => {
+  await initEmptyProgram();
+});
+it("renders strings", async () => {
+  const value = $.value.createString("test");
+  await testValueExpression(value, `"test"`);
+});
+describe("numeric values", () => {
+  it("renders integers", async () => {
+    const value = $.value.createNumeric(42);
+    await testValueExpression(value, `42`);
+  });
+  it("renders decimals", async () => {
+    const value = $.value.createNumeric(42.5);
+    await testValueExpression(value, `42.5`);
+  });
+  it("renders bigints", async () => {
+    const digits = "1234567890123456789012345678901234567890";
+    const value = {
+      entityKind: "Value",
+      valueKind: "NumericValue",
+      value: Numeric(digits)
+    };
+    await testValueExpression(value, `${digits}n`);
+  });
+  it("throws on invalid numbers", async () => {
+    const digits = "123456789123456789.112233445566778899";
+    const value = {
+      entityKind: "Value",
+      valueKind: "NumericValue",
+      value: Numeric(digits)
+    };
+    await expect(testValueExpression(value, ``)).rejects.toThrow("BigInt value must be an integer");
+  });
+});
+it("renders booleans", async () => {
+  const value = $.value.createBoolean(true);
+  await testValueExpression(value, `true`);
+});
+it("renders nulls", async () => {
+  const value = {
+    entityKind: "Value",
+    valueKind: "NullValue",
+    value: null
+  };
+  await testValueExpression(value, `null`);
+});
+it("renders empty arrays", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const value = {
+    entityKind: "Value",
+    valueKind: "ArrayValue",
+    values: []
+  };
+  await testValueExpression(value, `[]`);
+});
+it("renders arrays with mixed values", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const value = {
+    entityKind: "Value",
+    valueKind: "ArrayValue",
+    values: [$.value.createString("foo"), $.value.createNumeric(42), $.value.createBoolean(true)]
+  };
+  await testValueExpression(value, `["foo", 42, true]`);
+});
+it("renders scalars", async () => {
+  const program = await getProgram(`
+      namespace DemoService;
+      model DateRange {
+        @encode("rfc7231")
+        minDate: utcDateTime = utcDateTime.fromISO("2024-02-15T18:36:03Z");
+      }
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const dateRange = namespace.models.get("DateRange");
+  const minDate = dateRange?.properties.get("minDate")?.defaultValue;
+  assert.exists(minDate, "unable to find minDate property");
+  await testValueExpression(minDate, `"2024-02-15T18:36:03Z"`);
+});
+it("throws on unsupported scalar", async () => {
+  const program = await getProgram(`
+      namespace DemoService;
+
+      scalar ipv4 extends string {
+        init fromInt(value: uint32);
+      }
+
+      @example (#{ip: ipv4.fromInt(2130706433)})
+      model IpAddress {
+        ip: ipv4;
+      }
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const model = namespace.models.get("IpAddress");
+  assert.exists(model, "unable to find IpAddress model");
+  const value = getExampleValue(model);
+  await expect(testValueExpression(value, ``)).rejects.toThrow(/Unsupported scalar constructor fromInt/);
+});
+it("renders empty objects", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const program = await getProgram(`
+      namespace DemoService;
+      @example(#{})
+      model ObjectValue {};
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const model = namespace.models.get("ObjectValue");
+  assert.exists(model, "unable to find ObjectValue model");
+  const value = getExampleValue(model);
+  await testValueExpression(value, `{}`);
+});
+it("renders objects with properties", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const program = await getProgram(`
+      namespace DemoService;
+      @example(#{a: 5, b: "foo", c: true})
+      model ObjectValue {
+        a: int32;
+        b: string;
+        c: boolean;
+      };
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const model = namespace.models.get("ObjectValue");
+  assert.exists(model, "unable to find ObjectValue model");
+  const value = getExampleValue(model);
+  await testValueExpression(value, dedent(`
+      {
+        a: 5,
+        b: "foo",
+        c: true,
+      }`));
+});
+it("renders enums", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const program = await getProgram(`
+      namespace DemoService;
+      enum Color {
+        Red,
+        Green: 3,
+        Blue
+      }
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const colors = namespace.enums.get("Color");
+  assert.exists(colors, "unable to find Color enum");
+  const red = colors?.members.get("Red");
+  assert.exists(red, "unable to find Red enum member");
+  await testValueExpression({
+    valueKind: "EnumValue",
+    value: red
+  }, `"Red"`);
+  const green = colors?.members.get("Green");
+  assert.exists(green, "unable to find Green enum member");
+  await testValueExpression({
+    valueKind: "EnumValue",
+    value: green
+  }, `3`);
+});
+
+/**
+ * Helper that renders a value expression and checks the output against the expected value.
+ */
+async function testValueExpression(value, expected) {
+  const prefix = "const val = ";
+  const res = render(_$createComponent(Output, {
+    get children() {
+      return _$createComponent(SourceFile, {
+        path: "test.ts",
+        get children() {
+          return [prefix, _$createComponent(ValueExpression, {
+            value: value
+          })];
+        }
+      });
+    }
+  }));
+  const testFile = res.contents.find(file => file.path === "test.ts");
+  assert.exists(testFile, "test.ts file not rendered");
+  assert.equal(testFile.contents, `${prefix}${expected}`, "test.ts file contents do not match expected");
+}
+
+/**
+ * Extracts the value marked with the @example decorator from a model.
+ */
+function getExampleValue(model) {
+  const decorator = model?.decorators.find(d => d.definition?.name === "@example");
+  assert.exists(decorator?.args[0]?.value, "unable to find example decorator");
+  return decorator.args[0].value;
+}

package/dist/test/typescript/test-host.js

@@ -0,0 +1,40 @@
+import { createTestHost, createTestWrapper, expectDiagnosticEmpty } from "@typespec/compiler/testing";
+import { HttpTestLibrary } from "@typespec/http/testing";
+export async function createTypespecCliTestHost(options = {
+  libraries: []
+}) {
+  const libraries = [];
+  if (options.libraries.includes("Http")) {
+    libraries.push(HttpTestLibrary);
+  }
+  return createTestHost({
+    libraries
+  });
+}
+export async function createEmitterFrameworkTestRunner(options = {}) {
+  const host = await createTypespecCliTestHost();
+  return createTestWrapper(host, {
+    autoUsings: options.autoUsings
+  });
+}
+export async function getProgram(code, options = {
+  libraries: []
+}) {
+  const host = await createTypespecCliTestHost(options);
+  const wrapper = createTestWrapper(host, {
+    compilerOptions: {
+      noEmit: true
+    }
+  });
+  const [_, diagnostics] = await wrapper.compileAndDiagnose(code);
+  expectDiagnosticEmpty(diagnostics);
+  return wrapper.program;
+}
+
+/**
+ * Initializes an empty program in the compiler.
+ * This is useful when you want to initialize the default TypeKits without any code.
+ */
+export async function initEmptyProgram() {
+  await getProgram("");
+}

package/dist/test/utils.js

@@ -0,0 +1,18 @@
+import { render } from "@alloy-js/core";
+import { Output } from "@alloy-js/core/stc";
+import { SourceFile } from "@alloy-js/typescript/stc";
+import { assert } from "vitest";
+import { getProgram } from "./typescript/test-host.js";
+export async function getEmitOutput(tspCode, cb) {
+  const program = await getProgram(tspCode);
+  const res = render(Output().children(SourceFile({
+    path: "test.ts"
+  }).children(cb(program))));
+  const testFile = res.contents.find(file => file.path === "test.ts");
+  return testFile.contents;
+}
+export function assertFileContents(res, contents) {
+  const testFile = res.contents.find(file => file.path === "test.ts");
+  assert(testFile, "test.ts file not rendered");
+  assert.equal(testFile.contents, contents);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.6.0-dev.4",
+  "version": "0.6.0-dev.6",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -26,12 +26,10 @@
     "@typespec/rest": "^0.68.0 || >=0.69.0-dev <0.69.0"
   },
   "devDependencies": {
-    "@alloy-js/babel-preset": "^0.2.0",
+    "@alloy-js/cli": "^0.11.0",
+    "@alloy-js/rollup-plugin": "^0.1.0",
     "@alloy-js/core": "^0.11.0",
     "@alloy-js/typescript": "^0.11.0",
-    "@babel/cli": "^7.24.8",
-    "@babel/core": "^7.26.10",
-    "@rollup/plugin-babel": "^6.0.4",
     "@types/minimist": "^1.2.5",
     "@typespec/compiler": "^1.0.0-rc.0",
     "@typespec/http": "^1.0.0-rc.0",
@@ -50,13 +48,10 @@
   },
   "dependencies": {},
   "scripts": {
-    "build-src": "babel src -d dist/src --extensions .ts,.tsx",
-    "build": "tsc -p . && pnpm build-src",
+    "build": "alloy build",
     "clean": "rimraf ./dist",
     "format": "prettier . --write",
-    "watch-src": "babel src -d dist/src --extensions .ts,.tsx --watch",
-    "watch-tsc": "tsc -p . --watch",
-    "watch": "concurrently --kill-others \"pnpm watch-tsc\" \"pnpm watch-src\"",
+    "watch": "alloy build --watch",
     "test": "vitest run",
     "test:ui": "vitest --ui",
     "test:watch": "vitest -w",

package/src/typescript/components/interface-method.tsx

@@ -29,9 +29,7 @@ export function InterfaceMethod(props: Readonly<InterfaceMethodProps>) {
     ["returnType", "parameters"],
   );
 
-  const name = props.name
-    ? props.name
-    : ts.useTSNamePolicy().getName(efProps.type.name, "function");
+  const name = props.name ?? ts.useTSNamePolicy().getName(efProps.type.name, "function");
   const returnType = props.returnType ?? <TypeExpression type={getReturnType(efProps.type)} />;
   const allParameters = buildParameterDescriptors(efProps.type.parameters, {
     params: props.parameters,
@@ -41,10 +39,10 @@ export function InterfaceMethod(props: Readonly<InterfaceMethodProps>) {
   return (
     <ts.InterfaceMethod
       {...forwardProps}
+      {...updateProps}
       name={name}
       returnType={returnType}
       parameters={allParameters}
-      {...updateProps}
     />
   );
 }