@typespec/emitter-framework 0.8.0-dev.2 → 0.8.0-dev.3

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

@@ -1,18 +1,26 @@
-import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
 import { render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
 import { SourceFile } from "@alloy-js/typescript";
-import { format } from "prettier";
-import { assert, describe, expect, it } from "vitest";
+import { beforeEach, describe, it } from "vitest";
 import { Output } from "../../../src/core/components/output.js";
 import { UnionDeclaration } from "../../../src/typescript/components/union-declaration.js";
 import { UnionExpression } from "../../../src/typescript/components/union-expression.js";
-import { getProgram } from "../test-host.js";
+import { InterfaceDeclaration } from "../../../src/typescript/index.js";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
 describe("Typescript Union Declaration", () => {
+  let runner;
+  beforeEach(async () => {
+    runner = await createEmitterFrameworkTestRunner();
+  });
   describe("Union not bound to Typespec Types", () => {
     it("creates a union declaration", async () => {
-      const program = await getProgram("");
+      await runner.compile(``);
       const res = render(_$createComponent(Output, {
-        program: program,
+        get program() {
+          return runner.program;
+        },
         get children() {
           return _$createComponent(SourceFile, {
             path: "test.ts",
@@ -25,188 +33,432 @@ describe("Typescript Union Declaration", () => {
           });
         }
       }));
-      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);
+      assertFileContents(res, d`
+          type MyUnion = "red" | "blue";
+        `);
     });
   });
   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 {
+          TestUnion
+        } = await runner.compile(`
+          namespace DemoService;
+          @test union TestUnion {
+            one: "one",
+            two: "two"
+          }
         `);
-        const [namespace] = program.resolveTypeReference("DemoService");
-        const union = Array.from(namespace.unions.values())[0];
         const res = render(_$createComponent(Output, {
-          program: program,
+          get program() {
+            return runner.program;
+          },
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
               get children() {
                 return _$createComponent(UnionDeclaration, {
-                  type: union
+                  type: TestUnion
                 });
               }
             });
           }
         }));
-        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);
+        assertFileContents(res, d`
+            type TestUnion = "one" | "two";
+          `);
+      });
+      it("creates a union declaration with JSDoc", async () => {
+        const {
+          TestUnion
+        } = await runner.compile(`
+          namespace DemoService;
+          /**
+           * Test Union
+           */
+          @test union TestUnion {
+            one: "one",
+            two: "two"
+          }
+        `);
+        const res = render(_$createComponent(Output, {
+          get program() {
+            return runner.program;
+          },
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(UnionDeclaration, {
+                  type: TestUnion
+                });
+              }
+            });
+          }
+        }));
+        assertFileContents(res, d`
+            /**
+             * Test Union
+             */
+            type TestUnion = "one" | "two";
+          `);
       });
       it("creates a union declaration with name override", async () => {
-        const program = await getProgram(`
-        namespace DemoService;
-        union TestUnion {
-          one: "one",
-          two: "two"
-        }
+        const {
+          TestUnion
+        } = await runner.compile(`
+          namespace DemoService;
+          @test union TestUnion {
+            one: "one",
+            two: "two"
+          }
         `);
-        const [namespace] = program.resolveTypeReference("DemoService");
-        const union = Array.from(namespace.unions.values())[0];
         const res = render(_$createComponent(Output, {
-          program: program,
+          get program() {
+            return runner.program;
+          },
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
               get children() {
                 return _$createComponent(UnionDeclaration, {
                   "export": true,
-                  type: union,
+                  type: TestUnion,
                   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);
+        assertFileContents(res, d`
+            export type MyUnion = "one" | "two";
+          `);
       });
       it("creates a union declaration with extra children", async () => {
-        const program = await getProgram(`
-        namespace DemoService;
-        union TestUnion {
-          one: "one",
-          two: "two"
-        }
+        const {
+          TestUnion
+        } = await runner.compile(`
+          namespace DemoService;
+          @test union TestUnion {
+            one: "one",
+            two: "two"
+          }
         `);
-        const [namespace] = program.resolveTypeReference("DemoService");
-        const union = Array.from(namespace.unions.values())[0];
         const res = render(_$createComponent(Output, {
-          program: program,
+          get program() {
+            return runner.program;
+          },
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
               get children() {
                 return _$createComponent(UnionDeclaration, {
-                  type: union,
+                  type: TestUnion,
                   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);
+        assertFileContents(res, d`
+            type TestUnion = "one" | "two" | "three";
+          `);
       });
-      it("renders an union expression", async () => {
-        const program = await getProgram(`
+      it("renders a union expression", async () => {
+        const {
+          TestUnion
+        } = await runner.compile(`
           namespace DemoService;
-          union TestUnion {
+          @test union TestUnion {
             one: "one",
             two: "two"
           }
-          `);
-        const [namespace] = program.resolveTypeReference("DemoService");
-        const union = Array.from(namespace.unions.values())[0];
+        `);
         const res = render(_$createComponent(Output, {
-          program: program,
+          get program() {
+            return runner.program;
+          },
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
               get children() {
                 return ["let x: ", _$createComponent(UnionExpression, {
-                  type: union
+                  type: TestUnion
                 }), " = \"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"
+        assertFileContents(res, d`
+            let x: "one" | "two" = "one";
+          `);
+      });
+      describe("Discriminated Union", () => {
+        it("renders a discriminated union", async () => {
+          const {
+            TestUnion
+          } = await runner.compile(`
+            namespace DemoService;
+            @discriminated
+            @test union TestUnion {
+              one: { oneItem: true },
+              two: true
+            }
+          `);
+          const res = render(_$createComponent(Output, {
+            get program() {
+              return runner.program;
+            },
+            get children() {
+              return _$createComponent(SourceFile, {
+                path: "test.ts",
+                get children() {
+                  return _$createComponent(UnionDeclaration, {
+                    type: TestUnion
+                  });
+                }
+              });
+            }
+          }));
+          assertFileContents(res, d`
+              type TestUnion = {
+                kind: "one";
+                value: {
+                  oneItem: true;
+                };
+              } | {
+                kind: "two";
+                value: true;
+              };
+          `);
         });
-        const expectedContent = await format(`let x:"one" | "two" = "one"`, {
-          parser: "typescript"
+      });
+      it("renders a discriminated union with custom properties", async () => {
+        const {
+          TestUnion
+        } = await runner.compile(`
+          namespace DemoService;
+            @discriminated(#{ discriminatorPropertyName: "dataKind", envelopePropertyName: "data" })
+            @test union TestUnion {
+              one: { oneItem: true },
+              two: true
+            }
+          `);
+        const res = render(_$createComponent(Output, {
+          get program() {
+            return runner.program;
+          },
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(UnionDeclaration, {
+                  type: TestUnion
+                });
+              }
+            });
+          }
+        }));
+        assertFileContents(res, d`
+            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 runner.compile(`
+            namespace DemoService;
+            @test model Cat {
+              name: string;
+              meow: boolean;
+            }
+
+            @test model Dog {
+              name: string;
+              bark: boolean;
+            }
+
+            @discriminated
+            @test union Pet {
+              cat: Cat,
+              dog: Dog,
+            }
+          `);
+        const res = render(_$createComponent(Output, {
+          get program() {
+            return runner.program;
+          },
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return [_$createComponent(InterfaceDeclaration, {
+                  type: Cat
+                }), _$createIntrinsic("hbr", {}), _$createComponent(InterfaceDeclaration, {
+                  type: Dog
+                }), _$createIntrinsic("hbr", {}), _$createComponent(UnionDeclaration, {
+                  type: Pet
+                })];
+              }
+            });
+          }
+        }));
+        assertFileContents(res, d`
+            interface Cat {
+              name: string;
+              meow: boolean;
+            }
+            interface Dog {
+              name: string;
+              bark: boolean;
+            }
+            type Pet = {
+              kind: "cat";
+              value: Cat;
+            } | {
+              kind: "dog";
+              value: Dog;
+            };
+          `);
+      });
+      describe("Discriminated Union with no envelope", () => {
+        it("renders named discriminated union", async () => {
+          const {
+            Pet,
+            Cat,
+            Dog
+          } = await runner.compile(`
+            namespace DemoService;
+
+            @test model Cat {
+              name: string;
+              meow: boolean;
+            }
+
+            @test model Dog {
+              name: string;
+              bark: boolean;
+            }
+
+            @discriminated(#{ envelope: "none", discriminatorPropertyName: "dataKind" })
+            @test union Pet {
+              cat: Cat,
+              dog: Dog,
+            }
+          `);
+          const res = render(_$createComponent(Output, {
+            get program() {
+              return runner.program;
+            },
+            get children() {
+              return _$createComponent(SourceFile, {
+                path: "test.ts",
+                get children() {
+                  return [_$createComponent(InterfaceDeclaration, {
+                    type: Cat
+                  }), _$createIntrinsic("hbr", {}), _$createComponent(InterfaceDeclaration, {
+                    type: Dog
+                  }), _$createIntrinsic("hbr", {}), _$createComponent(UnionDeclaration, {
+                    type: Pet
+                  })];
+                }
+              });
+            }
+          }));
+          assertFileContents(res, d`
+              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", async () => {
+          const {
+            TestUnion
+          } = await runner.compile(`
+            namespace DemoService;
+            @discriminated(#{ envelope: "none", discriminatorPropertyName: "dataKind" })
+            @test union TestUnion {
+              one: { oneItem: true },
+              two: { secondItem: false }
+            }
+          `);
+          const res = render(_$createComponent(Output, {
+            get program() {
+              return runner.program;
+            },
+            get children() {
+              return _$createComponent(SourceFile, {
+                path: "test.ts",
+                get children() {
+                  return _$createComponent(UnionDeclaration, {
+                    type: TestUnion
+                  });
+                }
+              });
+            }
+          }));
+          assertFileContents(res, d`
+              type TestUnion = {
+                dataKind: "one";
+                oneItem: true;
+              } | {
+                dataKind: "two";
+                secondItem: false;
+              };
+            `);
         });
-        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 {
+          TestEnum
+        } = await runner.compile(`
+          namespace DemoService;
+          @test enum TestEnum {
+            one: "one",
+            two: "two"
+          }
         `);
-        const [namespace] = program.resolveTypeReference("DemoService");
-        const union = Array.from(namespace.enums.values())[0];
         const res = render(_$createComponent(Output, {
-          program: program,
+          get program() {
+            return runner.program;
+          },
           get children() {
             return _$createComponent(SourceFile, {
               path: "test.ts",
               get children() {
                 return _$createComponent(UnionDeclaration, {
-                  type: union
+                  type: TestEnum
                 });
               }
             });
           }
         }));
-        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);
+        assertFileContents(res, d`
+            type TestEnum = "one" | "two";
+          `);
       });
     });
   });

package/package.json

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

package/src/typescript/components/enum-declaration.tsx

@@ -28,13 +28,22 @@ export function EnumDeclaration(props: EnumDeclarationProps) {
   const refkeys = declarationRefkeys(props.refkey, props.type);
   const name = props.name ?? ts.useTSNamePolicy().getName(props.type.name!, "enum");
   const members = Array.from(type.members.entries());
+  const doc = props.doc ?? $.type.getDoc(type);
 
   return (
-    <ts.EnumDeclaration name={name} refkey={refkeys} default={props.default} export={props.export}>
+    <ts.EnumDeclaration
+      doc={doc}
+      name={name}
+      refkey={refkeys}
+      default={props.default}
+      export={props.export}
+    >
       <ay.For each={members} joiner={",\n"}>
         {([key, value]) => {
+          const memberDoc = $.type.getDoc(value);
           return (
             <EnumMember
+              doc={memberDoc}
               type={value}
               refkey={
                 $.union.is(props.type) ? efRefkey(props.type.variants.get(key)) : efRefkey(value)
@@ -49,12 +58,14 @@ export function EnumDeclaration(props: EnumDeclarationProps) {
 
 export interface EnumMemberProps {
   type: TspEnumMember;
+  doc?: ay.Children;
   refkey?: ay.Refkey;
 }
 
 export function EnumMember(props: EnumMemberProps) {
   return (
     <ts.EnumMember
+      doc={props.doc}
       name={props.type.name}
       jsValue={props.type.value ?? props.type.name}
       refkey={props.refkey}

package/src/typescript/components/function-declaration.tsx

@@ -1,5 +1,6 @@
 import * as ts from "@alloy-js/typescript";
 import { Model, Operation } from "@typespec/compiler";
+import { useTsp } from "../../core/index.js";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";
 import { declarationRefkeys } from "../utils/refkey.js";
 import { TypeExpression } from "./type-expression.js";
@@ -21,6 +22,8 @@ export type FunctionDeclarationProps =
  * provided will take precedence.
  */
 export function FunctionDeclaration(props: FunctionDeclarationProps) {
+  const { $ } = useTsp();
+
   if (!isTypedFunctionDeclarationProps(props)) {
     return <ts.FunctionDeclaration {...props} />;
   }
@@ -40,8 +43,10 @@ export function FunctionDeclaration(props: FunctionDeclarationProps) {
     params: props.parameters,
     mode: props.parametersMode,
   });
+  const doc = props.doc ?? $.type.getDoc(props.type);
   return (
     <ts.FunctionDeclaration
+      doc={doc}
       refkey={refkeys}
       name={name}
       async={props.async}
@@ -49,8 +54,8 @@ export function FunctionDeclaration(props: FunctionDeclarationProps) {
       export={props.export}
       kind={props.kind}
       returnType={returnType}
+      parameters={allParameters}
     >
-      <ts.FunctionDeclaration.Parameters parameters={allParameters} />
       {props.children}
     </ts.FunctionDeclaration>
   );

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

@@ -45,9 +45,11 @@ export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
   const refkeys = declarationRefkeys(props.refkey, props.type);
 
   const extendsType = props.extends ?? getExtendsType($, props.type);
+  const doc = props.doc ?? $.type.getDoc(props.type);
 
   return (
     <ts.InterfaceDeclaration
+      doc={doc}
       default={props.default}
       export={props.export}
       kind={props.kind}
@@ -154,7 +156,7 @@ function InterfaceBody(props: TypedInterfaceDeclarationProps): Children {
 
   return (
     <>
-      <ay.For each={validTypeMembers} line {...enderProp}>
+      <ay.For each={validTypeMembers} semicolon line {...enderProp}>
         {(typeMember) => {
           return <InterfaceMember type={typeMember} />;
         }}