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

package/dist/test/testing/snippet-extractor-typescript.test.js

@@ -0,0 +1,161 @@
+import { d } from "@alloy-js/core/testing";
+import { beforeEach, describe, expect, it } from "vitest";
+import { createSnipperExtractor, createTypeScriptExtractorConfig } from "../../src/testing/index.js";
+describe("TypeScript Snippet Extractor", () => {
+  let extractor;
+  beforeEach(() => {
+    extractor = createSnipperExtractor(createTypeScriptExtractorConfig());
+  });
+  it("should extract a class", async () => {
+    const content = d`
+    function bar(): number {
+      return 1;
+    }
+    class Foo {
+       constructor() {
+          console.log("Hello");
+       }
+    }
+    `;
+    const snippet = extractor.getClass(content, "Foo");
+    expect(snippet).toBe(d`
+      class Foo {
+         constructor() {
+            console.log("Hello");
+         }
+      }
+      `);
+  });
+  it("should extract an exported class", async () => {
+    const content = d`
+    function bar(): number {
+      return 1;
+    }
+    export class Foo {
+       constructor() {
+          console.log("Hello");
+       }
+    }
+    `;
+    const snippet = extractor.getClass(content, "Foo");
+    expect(snippet).toBe(d`
+      export class Foo {
+         constructor() {
+            console.log("Hello");
+         }
+      }
+      `);
+  });
+  it("should extract a  class that extends another", async () => {
+    const content = d`
+    export class Bar {
+       constructor() {
+          console.log("Hello");
+       }
+    }
+    export class Foo extends Bar {
+       constructor() {
+          console.log("Hello");
+       }
+    }
+    `;
+    const snippet = extractor.getClass(content, "Foo");
+    expect(snippet).toBe(d`
+      export class Foo extends Bar {
+         constructor() {
+            console.log("Hello");
+         }
+      }
+      `);
+  });
+  it("should extract a  class that implements an interface", async () => {
+    const content = d`
+    export interface MyFoo {
+        bar(): number;
+    }
+    export class Foo implements MyFoo {
+       constructor() {
+        console.log("Hello");
+       }
+      
+       bar() {
+        return 1;
+       }
+    }
+    `;
+    const snippet = extractor.getClass(content, "Foo");
+    expect(snippet).toBe(d`
+    export class Foo implements MyFoo {
+       constructor() {
+        console.log("Hello");
+       }
+      
+       bar() {
+        return 1;
+       }
+    }
+      `);
+  });
+  it("should extract a  generic class", async () => {
+    const content = d`
+    export interface MyFoo {
+        bar(): number;
+    }
+    class Box<Type> {
+      contents: Type;
+      constructor(value: Type) {
+        this.contents = value;
+      }
+    }
+    `;
+    const snippet = extractor.getClass(content, "Box");
+    expect(snippet).toBe(d`
+      class Box<Type> {
+        contents: Type;
+        constructor(value: Type) {
+          this.contents = value;
+        }
+      }
+      `);
+  });
+});
+describe("TypeScript Snippet Extractor - Enums", () => {
+  let extractor;
+  beforeEach(() => {
+    extractor = createSnipperExtractor(createTypeScriptExtractorConfig());
+  });
+  it("should extract a basic enum", async () => {
+    const content = d`
+      enum Direction {
+        Up,
+        Down,
+        Left,
+        Right
+      }
+    `;
+    const snippet = extractor.getEnum(content, "Direction");
+    expect(snippet).toBe(d`
+      enum Direction {
+        Up,
+        Down,
+        Left,
+        Right
+      }
+    `);
+  });
+  it("should extract an exported enum", async () => {
+    const content = d`
+      export enum Status {
+        Active,
+        Inactive
+      }
+    `;
+    const snippet = extractor.getEnum(content, "Status");
+    expect(snippet).toBe(d`
+      export enum Status {
+        Active,
+        Inactive
+      }
+    `);
+  });
+});

package/dist/test/typescript/components/arrow-function.test.js

@@ -0,0 +1,88 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Output, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { beforeEach, describe, it } from "vitest";
+import { ArrowFunction } from "../../../src/typescript/components/arrow-function.js";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+describe("arrow functions with a `type` prop", () => {
+  let runner;
+  beforeEach(async () => {
+    runner = await createEmitterFrameworkTestRunner();
+  });
+  it("creates a function", async () => {
+    const {
+      getName
+    } = await runner.compile(`
+      @test op getName(id: string): string;
+    `);
+    const res = render(_$createComponent(Output, {
+      get children() {
+        return _$createComponent(SourceFile, {
+          path: "test.ts",
+          get children() {
+            return _$createComponent(ArrowFunction, {
+              type: getName,
+              children: "console.log(\"Hello!\");"
+            });
+          }
+        });
+      }
+    }));
+    assertFileContents(res, d`
+        (id: string): string => {
+          console.log("Hello!");
+        }
+      `);
+  });
+  it("creates an async function", async () => {
+    const {
+      getName
+    } = await runner.compile(`
+      @test op getName(id: string): string;
+    `);
+    const res = render(_$createComponent(Output, {
+      get children() {
+        return _$createComponent(SourceFile, {
+          path: "test.ts",
+          get children() {
+            return _$createComponent(ArrowFunction, {
+              async: true,
+              type: getName
+            });
+          }
+        });
+      }
+    }));
+    assertFileContents(res, d`
+        async (id: string): Promise<string> => {}
+      `);
+  });
+  it("can append extra parameters with raw params provided", async () => {
+    const {
+      getName
+    } = await runner.compile(`
+      @test op getName(id: string): string;
+    `);
+    const res = render(_$createComponent(Output, {
+      get children() {
+        return _$createComponent(SourceFile, {
+          path: "test.ts",
+          get children() {
+            return _$createComponent(ArrowFunction, {
+              type: getName,
+              parameters: [{
+                name: "additionalParam",
+                type: "number"
+              }]
+            });
+          }
+        });
+      }
+    }));
+    assertFileContents(res, d`
+        (additionalParam: number, id: string): string => {}
+      `);
+  });
+});

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

@@ -0,0 +1,118 @@
+import { createComponent as _$createComponent, memo as _$memo } from "@alloy-js/core/jsx-runtime";
+import { List, refkey, StatementList } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import { EnumDeclaration } from "../../../src/typescript/components/enum-declaration.js";
+import { getEmitOutput } from "../../utils.js";
+describe("Typescript Enum Declaration", () => {
+  it("takes an enum type parameter", async () => {
+    const code = `
+      enum Foo {
+        one: 1,
+        two: 2,
+        three: 3
+      }
+    `;
+    const output = await getEmitOutput(code, program => {
+      const Foo = program.resolveTypeReference("Foo")[0];
+      return _$createComponent(EnumDeclaration, {
+        type: Foo
+      });
+    });
+    expect(output).toBe(d`
+      enum Foo {
+        one = 1,
+        two = 2,
+        three = 3
+      }
+    `);
+  });
+  it("takes a union type parameter", async () => {
+    const code = `
+      union Foo {
+        one: 1,
+        two: 2,
+        three: 3
+      }
+    `;
+    const output = await getEmitOutput(code, program => {
+      const Foo = program.resolveTypeReference("Foo")[0];
+      return _$createComponent(EnumDeclaration, {
+        type: Foo
+      });
+    });
+    expect(output).toBe(d`
+      enum Foo {
+        one = 1,
+        two = 2,
+        three = 3
+      }
+    `);
+  });
+  it("can be referenced", async () => {
+    const code = `
+      enum Foo {
+        one: 1,
+        two: 2,
+        three: 3
+      }
+    `;
+    const output = await getEmitOutput(code, program => {
+      const Foo = program.resolveTypeReference("Foo")[0];
+      return _$createComponent(List, {
+        hardline: true,
+        get children() {
+          return [_$createComponent(EnumDeclaration, {
+            type: Foo
+          }), _$createComponent(StatementList, {
+            get children() {
+              return [_$memo(() => refkey(Foo)), _$memo(() => refkey(Foo.members.get("one")))];
+            }
+          })];
+        }
+      });
+    });
+    expect(output).toBe(d`
+      enum Foo {
+        one = 1,
+        two = 2,
+        three = 3
+      }
+      Foo;
+      Foo.one;
+    `);
+  });
+  it("can be referenced using union", async () => {
+    const code = `
+      union Foo {
+        one: 1,
+        two: 2,
+        three: 3
+      }
+    `;
+    const output = await getEmitOutput(code, program => {
+      const Foo = program.resolveTypeReference("Foo")[0];
+      return _$createComponent(List, {
+        hardline: true,
+        get children() {
+          return [_$createComponent(EnumDeclaration, {
+            type: Foo
+          }), _$createComponent(StatementList, {
+            get children() {
+              return [_$memo(() => refkey(Foo)), _$memo(() => refkey(Foo.variants.get("one")))];
+            }
+          })];
+        }
+      });
+    });
+    expect(output).toBe(d`
+      enum Foo {
+        one = 1,
+        two = 2,
+        three = 3
+      }
+      Foo;
+      Foo.one;
+    `);
+  });
+});

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

@@ -0,0 +1,246 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Output, 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 { FunctionDeclaration } from "../../../src/typescript/components/function-declaration.js";
+import { getProgram } from "../test-host.js";
+describe("Typescript Function Declaration", () => {
+  describe("Function bound to Typespec Types", () => {
+    describe("Bound to Operation", () => {
+      it("creates a function", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        op getName(id: string): string;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(FunctionDeclaration, {
+                  type: operation
+                });
+              }
+            });
+          }
+        }));
+        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(`function getName(id: string): string{}`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("creates an async function", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        op getName(id: string): string;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(FunctionDeclaration, {
+                  async: true,
+                  type: operation
+                });
+              }
+            });
+          }
+        }));
+        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(d`async function getName(id: string): Promise<string> {
+          
+          
+          }`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("exports a function", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        op getName(id: string): string;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(FunctionDeclaration, {
+                  "export": true,
+                  type: operation
+                });
+              }
+            });
+          }
+        }));
+        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 function getName(id: string): string{}`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("can override name", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        op getName(id: string): string;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(FunctionDeclaration, {
+                  name: "newName",
+                  type: operation
+                });
+              }
+            });
+          }
+        }));
+        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(`function newName(id: string): string{}`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("can append extra parameters with raw params provided", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        op createPerson(id: string): string;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(FunctionDeclaration, {
+                  type: operation,
+                  parameters: [{
+                    name: "name",
+                    type: "string"
+                  }, {
+                    name: "age",
+                    type: "number"
+                  }]
+                });
+              }
+            });
+          }
+        }));
+        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(`function createPerson(name: string, age: number, id: string): string{}`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it.skip("can override parameters with an array of ModelProperties", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        op createPerson(id: string): string;
+
+        model Foo {
+          name: string;
+          age: int32;
+        }
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const model = Array.from(namespace.models.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(FunctionDeclaration, {
+                  type: operation,
+                  get children() {
+                    return _$createComponent(FunctionDeclaration.Parameters, {
+                      type: model
+                    });
+                  }
+                });
+              }
+            });
+          }
+        }));
+        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(`function createPerson(name: string, age: number): string{}`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("can render function body", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        op createPerson(id: string): string;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const res = render(_$createComponent(Output, {
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(FunctionDeclaration, {
+                  "export": true,
+                  type: operation,
+                  children: "const message = \"Hello World!\"; console.log(message);"
+                });
+              }
+            });
+          }
+        }));
+        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 function createPerson(id: string): string {
+               const message = "Hello World!";
+               console.log(message);
+           }`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,88 @@
+import { createComponent as _$createComponent } from "@alloy-js/core/jsx-runtime";
+import { Output, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { beforeEach, describe, it } from "vitest";
+import { FunctionExpression } from "../../../src/typescript/components/function-expression.js";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+describe("function expressions with a `type` prop", () => {
+  let runner;
+  beforeEach(async () => {
+    runner = await createEmitterFrameworkTestRunner();
+  });
+  it("creates a function", async () => {
+    const {
+      getName
+    } = await runner.compile(`
+      @test op getName(id: string): string;
+    `);
+    const res = render(_$createComponent(Output, {
+      get children() {
+        return _$createComponent(SourceFile, {
+          path: "test.ts",
+          get children() {
+            return _$createComponent(FunctionExpression, {
+              type: getName,
+              children: "console.log(\"Hello!\");"
+            });
+          }
+        });
+      }
+    }));
+    assertFileContents(res, d`
+        function (id: string): string {
+          console.log("Hello!");
+        }
+      `);
+  });
+  it("creates an async function", async () => {
+    const {
+      getName
+    } = await runner.compile(`
+      @test op getName(id: string): string;
+    `);
+    const res = render(_$createComponent(Output, {
+      get children() {
+        return _$createComponent(SourceFile, {
+          path: "test.ts",
+          get children() {
+            return _$createComponent(FunctionExpression, {
+              async: true,
+              type: getName
+            });
+          }
+        });
+      }
+    }));
+    assertFileContents(res, d`
+        async function (id: string): Promise<string> {}
+      `);
+  });
+  it("can append extra parameters with raw params provided", async () => {
+    const {
+      getName
+    } = await runner.compile(`
+      @test op getName(id: string): string;
+    `);
+    const res = render(_$createComponent(Output, {
+      get children() {
+        return _$createComponent(SourceFile, {
+          path: "test.ts",
+          get children() {
+            return _$createComponent(FunctionExpression, {
+              type: getName,
+              parameters: [{
+                name: "additionalParam",
+                type: "number"
+              }]
+            });
+          }
+        });
+      }
+    }));
+    assertFileContents(res, d`
+        function (additionalParam: number, id: string): string {}
+      `);
+  });
+});