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

package/dist/src/typescript/components/value-expression.d.ts

@@ -0,0 +1,19 @@
+import { Children } from "@alloy-js/core";
+import { Value } from "@typespec/compiler";
+/**
+ * Properties for the {@link ValueExpression} component.
+ */
+interface ValueExpressionProps {
+    /**
+     * The TypeSpec value to be converted to a JavaScript expression.
+     */
+    value: Value;
+}
+/**
+ * Generates a JavaScript value expression from a TypeSpec value.
+ * @param props properties for the value expression
+ * @returns {@link Children} representing the JavaScript value expression
+ */
+export declare function ValueExpression(props: Readonly<ValueExpressionProps>): Children;
+export {};
+//# sourceMappingURL=value-expression.d.ts.map

package/dist/src/typescript/components/value-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-expression.d.ts","sourceRoot":"","sources":["../../../../src/typescript/components/value-expression.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAkB,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;GAEG;AACH,UAAU,oBAAoB;IAC5B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,QAAQ,CAoC/E"}

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

@@ -0,0 +1,72 @@
+import { memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import * as ts from "@alloy-js/typescript";
+import { compilerAssert } from "@typespec/compiler";
+
+/**
+ * Properties for the {@link ValueExpression} component.
+ */
+
+/**
+ * Generates a JavaScript value expression from a TypeSpec value.
+ * @param props properties for the value expression
+ * @returns {@link Children} representing the JavaScript value expression
+ */
+export function ValueExpression(props) {
+  switch (props.value.valueKind) {
+    case "StringValue":
+    case "BooleanValue":
+    case "NullValue":
+      return _$createComponent(ts.ValueExpression, {
+        get jsValue() {
+          return props.value.value;
+        }
+      });
+    case "NumericValue":
+      if (props.value.value.asNumber()) {
+        return _$createComponent(ts.ValueExpression, {
+          get jsValue() {
+            return props.value.value.asNumber();
+          }
+        });
+      }
+      compilerAssert(props.value.value.isInteger, "BigInt value must be an integer", props.value);
+      return _$createComponent(ts.ValueExpression, {
+        get jsValue() {
+          return props.value.value.asBigInt();
+        }
+      });
+    case "ArrayValue":
+      return _$createComponent(ts.ArrayExpression, {
+        get jsValue() {
+          return props.value.values.map(v => _$createComponent(ValueExpression, {
+            value: v
+          }));
+        }
+      });
+    case "ScalarValue":
+      compilerAssert(props.value.value.name === "fromISO", `Unsupported scalar constructor ${props.value.value.name}`, props.value);
+      return _$createComponent(ValueExpression, {
+        get value() {
+          return props.value.value.args[0];
+        }
+      });
+    case "ObjectValue":
+      const jsProperties = {};
+      for (const [key, value] of props.value.properties) {
+        jsProperties[key] = ValueExpression({
+          value: value.value
+        });
+      }
+      return _$createComponent(ts.ObjectExpression, {
+        jsValue: jsProperties
+      });
+    case "EnumValue":
+      return _$createComponent(ts.ValueExpression, {
+        get jsValue() {
+          return props.value.value.value ?? props.value.value.name;
+        }
+      });
+  }
+}
+//# sourceMappingURL=value-expression.js.map

package/dist/src/typescript/components/value-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-expression.js","names":["ts","compilerAssert","ValueExpression","props","value","valueKind","_$createComponent","jsValue","asNumber","isInteger","asBigInt","ArrayExpression","values","map","v","name","args","jsProperties","key","properties","ObjectExpression"],"sources":["../../../../src/typescript/components/value-expression.tsx"],"sourcesContent":[null],"mappings":";;AACA,OAAO,KAAKA,EAAE,MAAM,sBAAsB;AAC1C,SAASC,cAAc,QAAe,oBAAoB;;AAE1D;AACA;AACA;;AAQA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,eAAeA,CAACC,KAAqC,EAAY;EAC/E,QAAQA,KAAK,CAACC,KAAK,CAACC,SAAS;IAC3B,KAAK,aAAa;IAClB,KAAK,cAAc;IACnB,KAAK,WAAW;MACd,OAAAC,iBAAA,CAAQN,EAAE,CAACE,eAAe;QAAA,IAACK,OAAOA,CAAA;UAAA,OAAEJ,KAAK,CAACC,KAAK,CAACA,KAAK;QAAA;MAAA;IACvD,KAAK,cAAc;MACjB,IAAID,KAAK,CAACC,KAAK,CAACA,KAAK,CAACI,QAAQ,CAAC,CAAC,EAAE;QAChC,OAAAF,iBAAA,CAAQN,EAAE,CAACE,eAAe;UAAA,IAACK,OAAOA,CAAA;YAAA,OAAEJ,KAAK,CAACC,KAAK,CAACA,KAAK,CAACI,QAAQ,CAAC,CAAC;UAAA;QAAA;MAClE;MACAP,cAAc,CAACE,KAAK,CAACC,KAAK,CAACA,KAAK,CAACK,SAAS,EAAE,iCAAiC,EAAEN,KAAK,CAACC,KAAK,CAAC;MAC3F,OAAAE,iBAAA,CAAQN,EAAE,CAACE,eAAe;QAAA,IAACK,OAAOA,CAAA;UAAA,OAAEJ,KAAK,CAACC,KAAK,CAACA,KAAK,CAACM,QAAQ,CAAC,CAAC;QAAA;MAAA;IAClE,KAAK,YAAY;MACf,OAAAJ,iBAAA,CACGN,EAAE,CAACW,eAAe;QAAA,IACjBJ,OAAOA,CAAA;UAAA,OAAEJ,KAAK,CAACC,KAAK,CAACQ,MAAM,CAACC,GAAG,CAAEC,CAAC,IAAAR,iBAAA,CAC/BJ,eAAe;YAACE,KAAK,EAAEU;UAAC,EAC1B,CAAC;QAAA;MAAA;IAGR,KAAK,aAAa;MAChBb,cAAc,CACZE,KAAK,CAACC,KAAK,CAACA,KAAK,CAACW,IAAI,KAAK,SAAS,EACpC,kCAAkCZ,KAAK,CAACC,KAAK,CAACA,KAAK,CAACW,IAAI,EAAE,EAC1DZ,KAAK,CAACC,KACR,CAAC;MACD,OAAAE,iBAAA,CAAQJ,eAAe;QAAA,IAACE,KAAKA,CAAA;UAAA,OAAED,KAAK,CAACC,KAAK,CAACA,KAAK,CAACY,IAAI,CAAC,CAAC,CAAC;QAAA;MAAA;IAC1D,KAAK,aAAa;MAChB,MAAMC,YAAsC,GAAG,CAAC,CAAC;MACjD,KAAK,MAAM,CAACC,GAAG,EAAEd,KAAK,CAAC,IAAID,KAAK,CAACC,KAAK,CAACe,UAAU,EAAE;QACjDF,YAAY,CAACC,GAAG,CAAC,GAAGhB,eAAe,CAAC;UAAEE,KAAK,EAAEA,KAAK,CAACA;QAAM,CAAC,CAAC;MAC7D;MACA,OAAAE,iBAAA,CAAQN,EAAE,CAACoB,gBAAgB;QAACb,OAAO,EAAEU;MAAY;IACnD,KAAK,WAAW;MACd,OAAAX,iBAAA,CAAQN,EAAE,CAACE,eAAe;QAAA,IAACK,OAAOA,CAAA;UAAA,OAAEJ,KAAK,CAACC,KAAK,CAACA,KAAK,CAACA,KAAK,IAAID,KAAK,CAACC,KAAK,CAACA,KAAK,CAACW,IAAI;QAAA;MAAA;EACzF;AACF","ignoreList":[]}

package/dist/test/typescript/components/value-expression.test.d.ts

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

package/dist/test/typescript/components/value-expression.test.d.ts.map

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

package/dist/test/typescript/test-host.d.ts

@@ -8,4 +8,9 @@ export declare function createEmitterFrameworkTestRunner(options?: {
 export declare function getProgram(code: string, options?: {
     libraries: "Http"[];
 }): Promise<Program>;
+/**
+ * Initializes an empty program in the compiler.
+ * This is useful when you want to initialize the default TypeKits without any code.
+ */
+export declare function initEmptyProgram(): Promise<void>;
 //# sourceMappingURL=test-host.d.ts.map

package/dist/test/typescript/test-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-host.d.ts","sourceRoot":"","sources":["../../../test/typescript/test-host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAQ7C,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,0DASrD;AAED,wBAAsB,gCAAgC,CAAC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,iEAK7F;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,GACnD,OAAO,CAAC,OAAO,CAAC,CAUlB"}
+{"version":3,"file":"test-host.d.ts","sourceRoot":"","sources":["../../../test/typescript/test-host.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAQ7C,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,0DASrD;AAED,wBAAsB,gCAAgC,CAAC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,iEAK7F;AAED,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAA;CAAsB,GACnD,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEtD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.6.0-dev.1",
+  "version": "0.6.0-dev.2",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/typescript/components/value-expression.tsx

@@ -0,0 +1,56 @@
+import { Children } from "@alloy-js/core";
+import * as ts from "@alloy-js/typescript";
+import { compilerAssert, Value } from "@typespec/compiler";
+
+/**
+ * Properties for the {@link ValueExpression} component.
+ */
+interface ValueExpressionProps {
+  /**
+   * The TypeSpec value to be converted to a JavaScript expression.
+   */
+  value: Value;
+}
+
+/**
+ * Generates a JavaScript value expression from a TypeSpec value.
+ * @param props properties for the value expression
+ * @returns {@link Children} representing the JavaScript value expression
+ */
+export function ValueExpression(props: Readonly<ValueExpressionProps>): Children {
+  switch (props.value.valueKind) {
+    case "StringValue":
+    case "BooleanValue":
+    case "NullValue":
+      return <ts.ValueExpression jsValue={props.value.value} />;
+    case "NumericValue":
+      if (props.value.value.asNumber()) {
+        return <ts.ValueExpression jsValue={props.value.value.asNumber()} />;
+      }
+      compilerAssert(props.value.value.isInteger, "BigInt value must be an integer", props.value);
+      return <ts.ValueExpression jsValue={props.value.value.asBigInt()} />;
+    case "ArrayValue":
+      return (
+        <ts.ArrayExpression
+          jsValue={props.value.values.map((v) => (
+            <ValueExpression value={v} />
+          ))}
+        />
+      );
+    case "ScalarValue":
+      compilerAssert(
+        props.value.value.name === "fromISO",
+        `Unsupported scalar constructor ${props.value.value.name}`,
+        props.value,
+      );
+      return <ValueExpression value={props.value.value.args[0]} />;
+    case "ObjectValue":
+      const jsProperties: Record<string, Children> = {};
+      for (const [key, value] of props.value.properties) {
+        jsProperties[key] = ValueExpression({ value: value.value });
+      }
+      return <ts.ObjectExpression jsValue={jsProperties} />;
+    case "EnumValue":
+      return <ts.ValueExpression jsValue={props.value.value.value ?? props.value.value.name} />;
+  }
+}

package/test/typescript/components/value-expression.test.tsx

@@ -0,0 +1,236 @@
+import { Output, render } from "@alloy-js/core";
+import { dedent } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { EnumValue, Model, Namespace, Numeric, NumericValue, Value } 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: NumericValue = {
+      entityKind: "Value",
+      valueKind: "NumericValue",
+      value: Numeric(digits),
+    } as NumericValue;
+
+    await testValueExpression(value, `${digits}n`);
+  });
+
+  it("throws on invalid numbers", async () => {
+    const digits = "123456789123456789.112233445566778899";
+    const value: NumericValue = {
+      entityKind: "Value",
+      valueKind: "NumericValue",
+      value: Numeric(digits),
+    } as NumericValue;
+
+    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,
+  } as Value;
+  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: [],
+  } as unknown as Value;
+  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)],
+  } as Value;
+  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 as 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 as 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 as 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 as 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 as 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,
+    } as EnumValue,
+    `"Red"`,
+  );
+
+  const green = colors?.members.get("Green");
+  assert.exists(green, "unable to find Green enum member");
+  await testValueExpression(
+    {
+      valueKind: "EnumValue",
+      value: green,
+    } as EnumValue,
+    `3`,
+  );
+});
+
+/**
+ * Helper that renders a value expression and checks the output against the expected value.
+ */
+async function testValueExpression(value: Value, expected: string) {
+  const prefix = "const val = ";
+  const res = render(
+    <Output>
+      <SourceFile path="test.ts">
+        {prefix}
+        <ValueExpression value={value} />
+      </SourceFile>
+    </Output>,
+  );
+  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: Model): Value {
+  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 as Value;
+}

package/test/typescript/test-host.ts

@@ -39,3 +39,11 @@ export async function getProgram(
   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(): Promise<void> {
+  await getProgram("");
+}