| "use strict"; |
| |
| exports.__esModule = true; |
| exports.createUnionTypeAnnotation = createUnionTypeAnnotation; |
| exports.removeTypeDuplicates = removeTypeDuplicates; |
| exports.createTypeAnnotationBasedOnTypeof = createTypeAnnotationBasedOnTypeof; |
| |
| var _index = require("./index"); |
| |
| var t = _interopRequireWildcard(_index); |
| |
| function _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; } } |
| |
| function createUnionTypeAnnotation(types) { |
| var flattened = removeTypeDuplicates(types); |
| |
| if (flattened.length === 1) { |
| return flattened[0]; |
| } else { |
| return t.unionTypeAnnotation(flattened); |
| } |
| } |
| |
| function removeTypeDuplicates(nodes) { |
| var generics = {}; |
| var bases = {}; |
| |
| var typeGroups = []; |
| |
| var types = []; |
| |
| for (var i = 0; i < nodes.length; i++) { |
| var node = nodes[i]; |
| if (!node) continue; |
| |
| if (types.indexOf(node) >= 0) { |
| continue; |
| } |
| |
| if (t.isAnyTypeAnnotation(node)) { |
| return [node]; |
| } |
| |
| if (t.isFlowBaseAnnotation(node)) { |
| bases[node.type] = node; |
| continue; |
| } |
| |
| if (t.isUnionTypeAnnotation(node)) { |
| if (typeGroups.indexOf(node.types) < 0) { |
| nodes = nodes.concat(node.types); |
| typeGroups.push(node.types); |
| } |
| continue; |
| } |
| |
| if (t.isGenericTypeAnnotation(node)) { |
| var name = node.id.name; |
| |
| if (generics[name]) { |
| var existing = generics[name]; |
| if (existing.typeParameters) { |
| if (node.typeParameters) { |
| existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params)); |
| } |
| } else { |
| existing = node.typeParameters; |
| } |
| } else { |
| generics[name] = node; |
| } |
| |
| continue; |
| } |
| |
| types.push(node); |
| } |
| |
| for (var type in bases) { |
| types.push(bases[type]); |
| } |
| |
| for (var _name in generics) { |
| types.push(generics[_name]); |
| } |
| |
| return types; |
| } |
| |
| function createTypeAnnotationBasedOnTypeof(type) { |
| if (type === "string") { |
| return t.stringTypeAnnotation(); |
| } else if (type === "number") { |
| return t.numberTypeAnnotation(); |
| } else if (type === "undefined") { |
| return t.voidTypeAnnotation(); |
| } else if (type === "boolean") { |
| return t.booleanTypeAnnotation(); |
| } else if (type === "function") { |
| return t.genericTypeAnnotation(t.identifier("Function")); |
| } else if (type === "object") { |
| return t.genericTypeAnnotation(t.identifier("Object")); |
| } else if (type === "symbol") { |
| return t.genericTypeAnnotation(t.identifier("Symbol")); |
| } else { |
| throw new Error("Invalid typeof value"); |
| } |
| } |