You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
108 lines
2.7 KiB
108 lines
2.7 KiB
"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"); |
|
} |
|
} |