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

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

@@ -40,6 +40,87 @@ describe("Typescript Function Declaration", () => {
         });
         expect(actualContent).toBe(expectedContent);
       });
+      it("creates a function with JSDoc", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        /**
+         * This is a test function
+         */
+        op getName(
+        @doc("This is the id")
+        id: string, name: string): string;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const res = render(_$createComponent(Output, {
+          program: program,
+          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(`
+          /**
+           * This is a test function
+           * 
+           * @param {string} id - This is the id
+           * @param {string} name
+           */
+          function getName(id: string, name: string): string{}`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("creates a function with overridden JSDoc", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        /**
+         * This is a test function
+         */
+        op getName(id: string): string;`);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const operation = Array.from(namespace.operations.values())[0];
+        const res = render(_$createComponent(Output, {
+          program: program,
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(FunctionDeclaration, {
+                  doc: ["This is a custom description"],
+                  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(`
+          /**
+           * This is a custom description
+           *
+           * @param {string} id
+           */
+          function getName(id: string): string{}`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
       it("creates an async function", async () => {
         const program = await getProgram(`
         namespace DemoService;

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

@@ -8,6 +8,209 @@ import { InterfaceDeclaration } from "../../../src/typescript/components/interfa
 import { getProgram } from "../test-host.js";
 describe("Typescript Interface", () => {
   describe("Interface bound to Typespec Types", () => {
+    it("declares an interface with multi line docs, explicit docs passed", async () => {
+      const program = await getProgram(`
+          namespace DemoService;
+
+          /**
+           * This is a test
+           * with multiple lines
+           */
+          model Foo {
+            knownProp: string;
+          }
+          `);
+      const [namespace] = program.resolveTypeReference("DemoService");
+      const models = Array.from(namespace.models.values());
+      const res = render(_$createComponent(Output, {
+        program: program,
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.ts",
+            get children() {
+              return _$createComponent(List, {
+                hardline: true,
+                get children() {
+                  return models.map(model => _$createComponent(InterfaceDeclaration, {
+                    "export": true,
+                    type: model,
+                    doc: ["This is an overridden doc comment\nwith multiple lines"]
+                  }));
+                }
+              });
+            }
+          });
+        }
+      }));
+      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(`
+            /**
+             * This is an overridden doc comment
+             * with multiple lines
+             */
+            export interface Foo {
+              knownProp: string;
+            }
+            `, {
+        parser: "typescript"
+      });
+      expect(actualContent).toBe(expectedContent);
+    });
+    it("declares an interface with multi line docs", async () => {
+      const program = await getProgram(`
+          namespace DemoService;
+
+          /**
+           * This is a test
+           * with multiple lines
+           */
+          model Foo {
+            knownProp: string;
+          }
+          `);
+      const [namespace] = program.resolveTypeReference("DemoService");
+      const models = Array.from(namespace.models.values());
+      const res = render(_$createComponent(Output, {
+        program: program,
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.ts",
+            get children() {
+              return _$createComponent(List, {
+                hardline: true,
+                get children() {
+                  return models.map(model => _$createComponent(InterfaceDeclaration, {
+                    "export": true,
+                    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(`
+            /**
+             * This is a test
+             * with multiple lines
+             */
+            export interface Foo {
+              knownProp: string;
+            }
+            `, {
+        parser: "typescript"
+      });
+      expect(actualContent).toBe(expectedContent);
+    });
+    it("declares an interface with @doc", async () => {
+      const program = await getProgram(`
+          namespace DemoService;
+
+          @doc("This is a test")
+          model Foo {
+            knownProp: string;
+          }
+          `);
+      const [namespace] = program.resolveTypeReference("DemoService");
+      const models = Array.from(namespace.models.values());
+      const res = render(_$createComponent(Output, {
+        program: program,
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.ts",
+            get children() {
+              return _$createComponent(List, {
+                hardline: true,
+                get children() {
+                  return models.map(model => _$createComponent(InterfaceDeclaration, {
+                    "export": true,
+                    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(`
+            /**
+             * This is a test
+             */
+            export interface Foo {
+              knownProp: string;
+            }
+            `, {
+        parser: "typescript"
+      });
+      expect(actualContent).toBe(expectedContent);
+    });
+    it("declares an interface with doc", async () => {
+      const program = await getProgram(`
+          namespace DemoService;
+
+          /**
+           * This is a test
+           */
+          model Foo {
+            @doc("This is a known property")
+            knownProp: string;
+          }
+          `);
+      const [namespace] = program.resolveTypeReference("DemoService");
+      const models = Array.from(namespace.models.values());
+      const res = render(_$createComponent(Output, {
+        program: program,
+        get children() {
+          return _$createComponent(SourceFile, {
+            path: "test.ts",
+            get children() {
+              return _$createComponent(List, {
+                hardline: true,
+                get children() {
+                  return models.map(model => _$createComponent(InterfaceDeclaration, {
+                    "export": true,
+                    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(`
+            /**
+             * This is a test
+             */
+            export interface Foo {
+              /**
+               * This is a known property
+               */
+              knownProp: string;
+            }
+            `, {
+        parser: "typescript"
+      });
+      expect(actualContent).toBe(expectedContent);
+    });
     describe("Bound to Model", () => {
       it("creates an interface that extends a model for Record spread", async () => {
         const program = await getProgram(`
@@ -681,8 +884,19 @@ describe("Typescript Interface", () => {
         const program = await getProgram(`
         namespace DemoService;
     
+        /**
+         * Operations for Widget
+         */
         interface WidgetOperations {
-          op getName(id: string): Widget;
+          /**
+           * Get the name of the widget
+           */
+          op getName(
+            /**
+             * The id of the widget
+             */
+             id: string
+          ): Widget;
         }
 
         model Widget {
@@ -718,14 +932,23 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents, {
           parser: "typescript"
         });
-        const expectedContent = await format(`export interface WidgetOperations {
-          getName(id: string): Widget;
-        }
-        export interface Widget {
-          id: string;
-          weight: number;
-          color: "blue" | "red";
-        }`, {
+        const expectedContent = await format(`
+          /**
+           * Operations for Widget
+           */
+          export interface WidgetOperations {
+            /**
+             * Get the name of the widget
+             * 
+             * @param {string} id - The id of the widget
+             */
+            getName(id: string): Widget;
+          }
+          export interface Widget {
+            id: string;
+            weight: number;
+            color: "blue" | "red";
+          }`, {
           parser: "typescript"
         });
         expect(actualContent).toBe(expectedContent);

package/dist/test/typescript/components/type-alias-declaration.test.js

@@ -40,6 +40,81 @@ describe("Typescript Type Alias Declaration", () => {
         });
         expect(actualContent).toBe(expectedContent);
       });
+      it("creates a type alias declaration with JSDoc", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        /**
+         * Type to represent a date
+         */
+        scalar MyDate extends utcDateTime;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const scalar = Array.from(namespace.scalars.values())[0];
+        const res = render(_$createComponent(Output, {
+          program: program,
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(TypeAliasDeclaration, {
+                  type: scalar
+                });
+              }
+            });
+          }
+        }));
+        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 to represent a date
+           */
+          type MyDate = Date;`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
+      it("can override JSDoc", async () => {
+        const program = await getProgram(`
+        namespace DemoService;
+        /**
+         * Type to represent a date
+         */
+        scalar MyDate extends utcDateTime;
+        `);
+        const [namespace] = program.resolveTypeReference("DemoService");
+        const scalar = Array.from(namespace.scalars.values())[0];
+        const res = render(_$createComponent(Output, {
+          program: program,
+          get children() {
+            return _$createComponent(SourceFile, {
+              path: "test.ts",
+              get children() {
+                return _$createComponent(TypeAliasDeclaration, {
+                  doc: "Overridden Doc",
+                  type: scalar
+                });
+              }
+            });
+          }
+        }));
+        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(`
+          /**
+           * Overridden Doc
+           */
+          type MyDate = Date;`, {
+          parser: "typescript"
+        });
+        expect(actualContent).toBe(expectedContent);
+      });
       it("creates a type alias declaration for a utcDateTime with unixTimeStamp encoding", async () => {
         const program = await getProgram(`
         namespace DemoService;