Merge pull request #150 from moroine/feature/mongodb

Improve flowgen

Author: orta

src/__tests__/__snapshots__/interface-exports.spec.ts.snap

@@ -6,3 +6,12 @@ exports[`should handle exported interfaces 1`] = `
 }
 "
 `;
+
+exports[`should handle exported interfaces within a module 1`] = `
+"declare module \\"my-module\\" {
+  declare export interface UnaryFunction<T, R> {
+    (source: T): R;
+  }
+}
+"
+`;

src/__tests__/__snapshots__/interfaces.spec.ts.snap

@@ -63,6 +63,21 @@ exports[`should handle interface merging 2`] = `
 "
 `;
 
+exports[`should handle mutli-extends pattern 1`] = `
+"declare interface Shape {
+  color: string;
+}
+declare interface PenStroke {
+  penWidth: number;
+}
+declare type Square = {
+  sideLength: number,
+  ...
+} & Shape &
+  PenStroke;
+"
+`;
+
 exports[`should handle single interface 1`] = `
 "declare interface User {
   firstName: string;

src/__tests__/__snapshots__/utility-types.spec.ts.snap

@@ -1,5 +1,32 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`should handle Omit type 1`] = `
+"declare type A = $Diff<
+  {
+    a: string,
+    b: number,
+    ...
+  },
+  { a: any }
+>;
+declare type B = $Diff<
+  {
+    a: string,
+    b: number,
+    ...
+  },
+  { a: any, b: any }
+>;
+declare type O = {
+  a: string,
+  b: number,
+  ...
+};
+declare type U = \\"a\\";
+declare type C = $Diff<O, { [key: U]: any }>;
+"
+`;
+
 exports[`should handle utility types 1`] = `
 "declare type A = $ReadOnly<{
   a: number,

src/__tests__/interface-exports.spec.ts

@@ -10,3 +10,15 @@ it("should handle exported interfaces", () => {
   expect(beautify(result)).toMatchSnapshot();
   expect(result).toBeValidFlowTypeDeclarations();
 });
+
+it("should handle exported interfaces within a module", () => {
+  const ts = `declare module "my-module" {
+    export interface UnaryFunction<T, R> {
+      (source: T): R;
+    }
+  }
+`;
+  const result = compiler.compileDefinitionString(ts, { quiet: true });
+  expect(beautify(result)).toMatchSnapshot();
+  expect(result).toBeValidFlowTypeDeclarations();
+});

src/__tests__/interfaces.spec.ts

@@ -230,3 +230,21 @@ interface ArrayBinding {
   expect(beautify(result)).toMatchSnapshot();
   expect(result).toBeValidFlowTypeDeclarations();
 });
+
+it("should handle mutli-extends pattern", () => {
+  const ts = `
+interface Shape {
+  color: string;
+}
+
+interface PenStroke {
+  penWidth: number;
+}
+interface Square extends Shape, PenStroke {
+  sideLength: number;
+}
+`;
+  const result = compiler.compileDefinitionString(ts);
+  expect(beautify(result)).toMatchSnapshot();
+  expect(result).toBeValidFlowTypeDeclarations();
+});

src/__tests__/utility-types.spec.ts

@@ -30,3 +30,17 @@ type F2<T, U> = Record<T, U>
   expect(beautify(result)).toMatchSnapshot();
   expect(result).toBeValidFlowTypeDeclarations();
 });
+
+it("should handle Omit type", () => {
+  const ts = `
+type A = Omit<{ a: string, b: number }, "a">
+type B = Omit<{ a: string, b: number }, "a" | "b">
+
+type O = { a: string, b: number };
+type U = "a";
+type C = Omit<O, U>;
+`;
+  const result = compiler.compileDefinitionString(ts, { quiet: true });
+  expect(beautify(result)).toMatchSnapshot();
+  expect(result).toBeValidFlowTypeDeclarations();
+});

src/printers/declarations.ts

@@ -190,6 +190,8 @@ const interfaceHeritageClause = type => {
     if (typeof name === "function") {
       // @ts-expect-error todo(flow->ts)
       return name(type.typeArguments);
+    } else {
+      return name;
     }
   } else {
     return printers.node.printType(type);

src/printers/identifiers.ts

@@ -3,6 +3,31 @@
 import * as printers from "./index";
 import { opts } from "../options";
 import { withEnv } from "../env";
+import ts from "typescript";
+
+const Record = ([key, value]: [any, any], isInexact = opts().inexact) => {
+  const valueType = printers.node.printType(value);
+
+  switch (key.kind) {
+    case ts.SyntaxKind.LiteralType:
+      return `{ ${printers.node.printType(key)}: ${valueType}${
+        isInexact ? ", ..." : ""
+      }}`;
+    case ts.SyntaxKind.UnionType:
+      if (key.types.every(t => t.kind === ts.SyntaxKind.LiteralType)) {
+        const fields = key.types.reduce((acc, t) => {
+          acc += `${printers.node.printType(t)}: ${valueType},\n`;
+          return acc;
+        }, "");
+        return `{ ${fields}${isInexact ? "..." : ""}}`;
+      }
+    // Fallthrough
+    default:
+      return `{[key: ${printers.node.printType(key)}]: ${valueType}${
+        isInexact ? ", ..." : ""
+      }}`;
+  }
+};
 
 const identifiers = Object.create(null);
 Object.assign(identifiers, {
@@ -22,11 +47,12 @@ Object.assign(identifiers, {
       typeArguments[0],
     )}>`;
   },
-  Record: ([key, value]: [any, any]) => {
-    const isInexact = opts().inexact;
-    return `{[key: ${printers.node.printType(key)}]: ${printers.node.printType(
-      value,
-    )}${isInexact ? ", ..." : ""}}`;
+  Record,
+  Omit: ([obj, keys]: [any, any]) => {
+    return `$Diff<${printers.node.printType(obj)},${Record(
+      [keys, { kind: ts.SyntaxKind.AnyKeyword }],
+      false,
+    )}>`;
   },
 });