@typespec/emitter-framework 0.10.0-dev.0 → 0.10.0-dev.2

package/src/typescript/components/union/declaration.test.tsx

@@ -0,0 +1,264 @@
+import { Output } from "#core/index.js";
+import { Tester } from "#test/test-host.js";
+import type { Children } from "@alloy-js/core";
+import { SourceFile } from "@alloy-js/typescript";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, expect, it } from "vitest";
+import { InterfaceDeclaration } from "../../index.js";
+import { UnionDeclaration } from "./declaration.jsx";
+
+let tester: TesterInstance;
+
+function Wrapper(props: { children: Children }) {
+  return (
+    <Output program={tester.program}>
+      <SourceFile path="test.ts">{props.children}</SourceFile>
+    </Output>
+  );
+}
+
+beforeEach(async () => {
+  tester = await Tester.createInstance();
+});
+
+it("creates a union declaration (not bound to Typespec Types)", async () => {
+  await tester.compile("");
+  expect(
+    <Wrapper>
+      <UnionDeclaration name="MyUnion">"red" | "blue"</UnionDeclaration>
+    </Wrapper>,
+  ).toRenderTo(`type MyUnion = "red" | "blue";`);
+});
+
+it("creates a union declaration (bound to union)", async () => {
+  const { TestUnion } = await tester.compile(t.code`
+    namespace DemoService;
+    union ${t.union("TestUnion")} {
+      one: "one",
+      two: "two"
+    }
+  `);
+  expect(
+    <Wrapper>
+      <UnionDeclaration type={TestUnion} />
+    </Wrapper>,
+  ).toRenderTo(`type TestUnion = "one" | "two";`);
+});
+
+it("creates a union declaration with JSDoc", async () => {
+  const { TestUnion } = await tester.compile(t.code`
+    namespace DemoService;
+    /**
+     * Test Union
+     */
+    union ${t.union("TestUnion")} {
+      one: "one",
+      two: "two"
+    }
+  `);
+  expect(
+    <Wrapper>
+      <UnionDeclaration type={TestUnion} />
+    </Wrapper>,
+  ).toRenderTo(`/**
+ * Test Union
+ */
+type TestUnion = "one" | "two";`);
+});
+
+it("creates a union declaration with name override", async () => {
+  const { TestUnion } = await tester.compile(t.code`
+    namespace DemoService;
+    union ${t.union("TestUnion")} {
+      one: "one",
+      two: "two"
+    }
+  `);
+  expect(
+    <Wrapper>
+      <UnionDeclaration export type={TestUnion} name="MyUnion" />
+    </Wrapper>,
+  ).toRenderTo(`export type MyUnion = "one" | "two";`);
+});
+
+it("creates a union declaration with extra children", async () => {
+  const { TestUnion } = await tester.compile(t.code`
+    namespace DemoService;
+    union ${t.union("TestUnion")} {
+      one: "one",
+      two: "two"
+    }
+  `);
+  expect(
+    <Wrapper>
+      <UnionDeclaration type={TestUnion}>"three"</UnionDeclaration>
+    </Wrapper>,
+  ).toRenderTo(`type TestUnion = "one" | "two" | "three";`);
+});
+
+it("renders a discriminated union", async () => {
+  const { TestUnion } = await tester.compile(t.code`
+    namespace DemoService;
+    @discriminated
+    union ${t.union("TestUnion")} {
+      one: { oneItem: true },
+      two: true
+    }
+  `);
+  expect(
+    <Wrapper>
+      <UnionDeclaration type={TestUnion} />
+    </Wrapper>,
+  ).toRenderTo(`type TestUnion = {
+  kind: "one";
+  value: {
+    oneItem: true;
+  };
+} | {
+  kind: "two";
+  value: true;
+};`);
+});
+
+it("renders a discriminated union with custom properties", async () => {
+  const { TestUnion } = await tester.compile(t.code`
+    namespace DemoService;
+    @discriminated(#{ discriminatorPropertyName: "dataKind", envelopePropertyName: "data" })
+    union ${t.union("TestUnion")} {
+      one: { oneItem: true },
+      two: true
+    }
+  `);
+  expect(
+    <Wrapper>
+      <UnionDeclaration type={TestUnion} />
+    </Wrapper>,
+  ).toRenderTo(`type TestUnion = {
+  dataKind: "one";
+  data: {
+    oneItem: true;
+  };
+} | {
+  dataKind: "two";
+  data: true;
+};`);
+});
+
+it("renders a discriminated union with named models", async () => {
+  const { Pet, Cat, Dog } = await tester.compile(t.code`
+    namespace DemoService;
+    model ${t.model("Cat")} {
+      name: string;
+      meow: boolean;
+    }
+    model ${t.model("Dog")} {
+      name: string;
+      bark: boolean;
+    }
+    @discriminated
+    union ${t.union("Pet")} {
+      cat: Cat,
+      dog: Dog,
+    }
+  `);
+  expect(
+    <Wrapper>
+      <InterfaceDeclaration type={Cat} />
+      <hbr />
+      <InterfaceDeclaration type={Dog} />
+      <hbr />
+      <UnionDeclaration type={Pet} />
+    </Wrapper>,
+  ).toRenderTo(`interface Cat {
+  name: string;
+  meow: boolean;
+}
+interface Dog {
+  name: string;
+  bark: boolean;
+}
+type Pet = {
+  kind: "cat";
+  value: Cat;
+} | {
+  kind: "dog";
+  value: Dog;
+};`);
+});
+
+it("renders named discriminated union (no envelope)", async () => {
+  const { Pet, Cat, Dog } = await tester.compile(t.code`
+    namespace DemoService;
+    model ${t.model("Cat")} {
+      name: string;
+      meow: boolean;
+    }
+    model ${t.model("Dog")} {
+      name: string;
+      bark: boolean;
+    }
+    @discriminated(#{ envelope: "none", discriminatorPropertyName: "dataKind" })
+    union ${t.union("Pet")} {
+      cat: Cat,
+      dog: Dog,
+    }
+  `);
+  expect(
+    <Wrapper>
+      <InterfaceDeclaration type={Cat} />
+      <hbr />
+      <InterfaceDeclaration type={Dog} />
+      <hbr />
+      <UnionDeclaration type={Pet} />
+    </Wrapper>,
+  ).toRenderTo(`interface Cat {
+  name: string;
+  meow: boolean;
+}
+interface Dog {
+  name: string;
+  bark: boolean;
+}
+type Pet = {
+  dataKind: "cat"
+} & Cat | {
+  dataKind: "dog"
+} & Dog;`);
+});
+
+it("renders anonymous discriminated union (no envelope)", async () => {
+  const { TestUnion } = await tester.compile(t.code`
+    namespace DemoService;
+    @discriminated(#{ envelope: "none", discriminatorPropertyName: "dataKind" })
+    union ${t.union("TestUnion")} {
+      one: { oneItem: true },
+      two: { secondItem: false }
+    }
+  `);
+  expect(
+    <Wrapper>
+      <UnionDeclaration type={TestUnion} />
+    </Wrapper>,
+  ).toRenderTo(`type TestUnion = {
+  dataKind: "one";
+  oneItem: true;
+} | {
+  dataKind: "two";
+  secondItem: false;
+};`);
+});
+
+it("creates a union declaration (bound to enum)", async () => {
+  const { TestEnum } = await tester.compile(t.code`
+    namespace DemoService;
+    enum ${t.enum("TestEnum")} {
+      one: "one",
+      two: "two"
+    }
+  `);
+  expect(
+    <Wrapper>
+      <UnionDeclaration type={TestEnum} />
+    </Wrapper>,
+  ).toRenderTo(`type TestEnum = "one" | "two";`);
+});

package/src/typescript/components/{union-declaration.tsx → union/declaration.tsx}

@@ -1,10 +1,10 @@
+import { declarationRefkeys } from "#typescript/utils/refkey.js";
 import { type Children } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import type { Enum, Union } from "@typespec/compiler";
-import { useTsp } from "../../core/context/tsp-context.js";
-import { reportDiagnostic } from "../../lib.js";
-import { declarationRefkeys } from "../utils/refkey.js";
-import { UnionExpression } from "./union-expression.js";
+import { useTsp } from "../../../core/context/tsp-context.js";
+import { reportDiagnostic } from "../../../lib.js";
+import { UnionExpression } from "./expression.jsx";
 
 export interface TypedUnionDeclarationProps extends Omit<ts.TypeDeclarationProps, "name"> {
   type: Union | Enum;

package/src/typescript/components/union/expression.test.tsx

@@ -0,0 +1,42 @@
+import { Output } from "#core/index.js";
+import { Tester } from "#test/test-host.js";
+import { t } from "@typespec/compiler/testing";
+import { expect, it } from "vitest";
+import { UnionExpression } from "./expression.jsx";
+
+it("renders a union expression", async () => {
+  const { program, TestUnion } = await Tester.compile(t.code`
+    union ${t.union("TestUnion")} {
+      one: "one",
+      two: "two"
+    }
+  `);
+
+  expect(
+    <Output program={program}>
+      <UnionExpression type={TestUnion} />
+    </Output>,
+  ).toRenderTo(`"one" | "two"`);
+});
+
+it("renders a union expression without conflicting names", async () => {
+  const { program, TestUnion } = await Tester.compile(t.code`
+    union ${t.union("TestUnion")} {
+      {common: "one"},
+      {common: "one", two: "two"}
+    }
+  `);
+
+  expect(
+    <Output program={program}>
+      <UnionExpression type={TestUnion} />
+    </Output>,
+  ).toRenderTo(`
+    {
+      common: "one";
+    } | {
+      common: "one";
+      two: "two";
+    }
+  `);
+});

package/src/typescript/components/{union-expression.tsx → union/expression.tsx}

@@ -7,9 +7,9 @@ import {
   type Union,
   type UnionVariant,
 } from "@typespec/compiler";
-import { useTsp } from "../../core/context/tsp-context.js";
-import { efRefkey } from "../utils/refkey.js";
-import { TypeExpression } from "./type-expression.jsx";
+import { useTsp } from "../../../core/context/tsp-context.js";
+import { efRefkey } from "../../utils/refkey.js";
+import { TypeExpression } from "../type-expression.jsx";
 
 export interface UnionExpressionProps {
   type: Union | Enum;

package/vitest.config.ts

@@ -1,6 +1,6 @@
 import alloyPlugin from "@alloy-js/rollup-plugin";
 import { defineConfig, mergeConfig } from "vitest/config";
-import { defaultTypeSpecVitestConfig } from "../../vitest.workspace.js";
+import { defaultTypeSpecVitestConfig } from "../../vitest.config.js";
 
 export default mergeConfig(
   defaultTypeSpecVitestConfig,

package/dist/src/typescript/components/union-declaration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"union-declaration.d.ts","sourceRoot":"","sources":["../../../../src/typescript/components/union-declaration.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAC3C,OAAO,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAMtD,MAAM,WAAW,0BAA2B,SAAQ,IAAI,CAAC,EAAE,CAAC,oBAAoB,EAAE,MAAM,CAAC;IACvF,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACnB,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,qBAAqB,GAAG,0BAA0B,GAAG,EAAE,CAAC,oBAAoB,CAAC;AAEzF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,YAuB5D"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"union-expression.d.ts","sourceRoot":"","sources":["../../../../src/typescript/components/union-expression.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAa,MAAM,gBAAgB,CAAC;AAE1D,OAAO,EAEL,KAAK,IAAI,EAET,KAAK,KAAK,EAEX,MAAM,oBAAoB,CAAC;AAK5B,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED,wBAAgB,eAAe,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,oBAAoB,YA+CvE"}

package/dist/test/typescript/components/union-declaration.test.d.ts

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

package/dist/test/typescript/components/union-declaration.test.d.ts.map

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