"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");
|
}
|
}
|
