1"use strict";
2
3exports.__esModule = true;
4exports.createUnionTypeAnnotation = createUnionTypeAnnotation;
5exports.removeTypeDuplicates = removeTypeDuplicates;
6exports.createTypeAnnotationBasedOnTypeof = createTypeAnnotationBasedOnTypeof;
7
8var _index = require("./index");
9
10var t = _interopRequireWildcard(_index);
11
12function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
13
14function createUnionTypeAnnotation(types) {
15  var flattened = removeTypeDuplicates(types);
16
17  if (flattened.length === 1) {
18    return flattened[0];
19  } else {
20    return t.unionTypeAnnotation(flattened);
21  }
22}
23
24function removeTypeDuplicates(nodes) {
25  var generics = {};
26  var bases = {};
27
28  var typeGroups = [];
29
30  var types = [];
31
32  for (var i = 0; i < nodes.length; i++) {
33    var node = nodes[i];
34    if (!node) continue;
35
36    if (types.indexOf(node) >= 0) {
37      continue;
38    }
39
40    if (t.isAnyTypeAnnotation(node)) {
41      return [node];
42    }
43
44    if (t.isFlowBaseAnnotation(node)) {
45      bases[node.type] = node;
46      continue;
47    }
48
49    if (t.isUnionTypeAnnotation(node)) {
50      if (typeGroups.indexOf(node.types) < 0) {
51        nodes = nodes.concat(node.types);
52        typeGroups.push(node.types);
53      }
54      continue;
55    }
56
57    if (t.isGenericTypeAnnotation(node)) {
58      var name = node.id.name;
59
60      if (generics[name]) {
61        var existing = generics[name];
62        if (existing.typeParameters) {
63          if (node.typeParameters) {
64            existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
65          }
66        } else {
67          existing = node.typeParameters;
68        }
69      } else {
70        generics[name] = node;
71      }
72
73      continue;
74    }
75
76    types.push(node);
77  }
78
79  for (var type in bases) {
80    types.push(bases[type]);
81  }
82
83  for (var _name in generics) {
84    types.push(generics[_name]);
85  }
86
87  return types;
88}
89
90function createTypeAnnotationBasedOnTypeof(type) {
91  if (type === "string") {
92    return t.stringTypeAnnotation();
93  } else if (type === "number") {
94    return t.numberTypeAnnotation();
95  } else if (type === "undefined") {
96    return t.voidTypeAnnotation();
97  } else if (type === "boolean") {
98    return t.booleanTypeAnnotation();
99  } else if (type === "function") {
100    return t.genericTypeAnnotation(t.identifier("Function"));
101  } else if (type === "object") {
102    return t.genericTypeAnnotation(t.identifier("Object"));
103  } else if (type === "symbol") {
104    return t.genericTypeAnnotation(t.identifier("Symbol"));
105  } else {
106    throw new Error("Invalid typeof value");
107  }
108}