Updating NPM dependencies

node_modules/@babel/traverse/lib/path/inference/index.js

@@ -26,6 +26,8 @@ function getTypeAnnotation() {
 }
 
 function _getTypeAnnotation() {
+  var _inferer;
+
   const node = this.node;
 
   if (!node) {
@@ -59,7 +61,7 @@ function _getTypeAnnotation() {
 
   inferer = inferers[this.parentPath.type];
 
-  if (inferer && inferer.validParent) {
+  if ((_inferer = inferer) == null ? void 0 : _inferer.validParent) {
     return this.parentPath.getTypeAnnotation();
   }
 }

node_modules/@babel/traverse/lib/path/inference/inferer-reference.js

@@ -50,9 +50,19 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
     }
   }
 
-  if (types.length) {
-    return t.createUnionTypeAnnotation(types);
+  if (!types.length) {
+    return;
   }
+
+  if (t.isTSTypeAnnotation(types[0]) && t.createTSUnionType) {
+    return t.createTSUnionType(types);
+  }
+
+  if (t.createFlowUnionType) {
+    return t.createFlowUnionType(types);
+  }
+
+  return t.createUnionTypeAnnotation(types);
 }
 
 function getConstantViolationsBefore(binding, path, functions) {
@@ -165,6 +175,20 @@ function getConditionalAnnotation(binding, path, name) {
   }
 
   if (types.length) {
+    if (t.isTSTypeAnnotation(types[0]) && t.createTSUnionType) {
+      return {
+        typeAnnotation: t.createTSUnionType(types),
+        ifStatement
+      };
+    }
+
+    if (t.createFlowUnionType) {
+      return {
+        typeAnnotation: t.createFlowUnionType(types),
+        ifStatement
+      };
+    }
+
     return {
       typeAnnotation: t.createUnionTypeAnnotation(types),
       ifStatement

node_modules/@babel/traverse/lib/path/inference/inferers.js

@@ -44,12 +44,14 @@ function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function VariableDeclarator() {
+  var _type;
+
   const id = this.get("id");
   if (!id.isIdentifier()) return;
   const init = this.get("init");
   let type = init.getTypeAnnotation();
 
-  if (type && type.type === "AnyTypeAnnotation") {
+  if (((_type = type) == null ? void 0 : _type.type) === "AnyTypeAnnotation") {
     if (init.isCallExpression() && init.get("callee").isIdentifier({
       name: "Array"
     }) && !init.scope.hasBinding("Array", true)) {
@@ -112,11 +114,31 @@ function BinaryExpression(node) {
 }
 
 function LogicalExpression() {
-  return t.createUnionTypeAnnotation([this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()]);
+  const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
+
+  if (t.isTSTypeAnnotation(argumentTypes[0]) && t.createTSUnionType) {
+    return t.createTSUnionType(argumentTypes);
+  }
+
+  if (t.createFlowUnionType) {
+    return t.createFlowUnionType(argumentTypes);
+  }
+
+  return t.createUnionTypeAnnotation(argumentTypes);
 }
 
 function ConditionalExpression() {
-  return t.createUnionTypeAnnotation([this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()]);
+  const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
+
+  if (t.isTSTypeAnnotation(argumentTypes[0]) && t.createTSUnionType) {
+    return t.createTSUnionType(argumentTypes);
+  }
+
+  if (t.createFlowUnionType) {
+    return t.createFlowUnionType(argumentTypes);
+  }
+
+  return t.createUnionTypeAnnotation(argumentTypes);
 }
 
 function SequenceExpression() {