flow-parser 0.318.0 → 0.319.0

package/oxidized/oxidized-src/index.js

@@ -0,0 +1,220 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  parse: true,
+  mutateESTreeASTForPrettier: true,
+  Transforms: true,
+  FlowVisitorKeys: true,
+  astArrayMutationHelpers: true,
+  astNodeMutationHelpers: true
+};
+exports.mutateESTreeASTForPrettier = exports.astNodeMutationHelpers = exports.astArrayMutationHelpers = exports.Transforms = void 0;
+exports.parse = parse;
+
+var FlowParser = _interopRequireWildcard(require("./FlowParser"));
+
+var _ESTreeVisitorKeys = _interopRequireDefault(require("./generated/ESTreeVisitorKeys"));
+
+exports.FlowVisitorKeys = _ESTreeVisitorKeys.default;
+
+var TransformComponentSyntax = _interopRequireWildcard(require("./estree/TransformComponentSyntax"));
+
+var TransformEnumSyntax = _interopRequireWildcard(require("./estree/TransformEnumSyntax"));
+
+var TransformMatchSyntax = _interopRequireWildcard(require("./estree/TransformMatchSyntax"));
+
+var TransformRecordSyntax = _interopRequireWildcard(require("./estree/TransformRecordSyntax"));
+
+var StripFlowTypesForBabel = _interopRequireWildcard(require("./estree/StripFlowTypesForBabel"));
+
+var TransformESTreeToBabel = _interopRequireWildcard(require("./babel/TransformESTreeToBabel"));
+
+var StripFlowTypes = _interopRequireWildcard(require("./estree/StripFlowTypes"));
+
+var _ParserOptions = require("./ParserOptions");
+
+Object.keys(_ParserOptions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ParserOptions[key]) return;
+  exports[key] = _ParserOptions[key];
+});
+
+var _SimpleTraverser = require("./traverse/SimpleTraverser");
+
+Object.keys(_SimpleTraverser).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTraverser[key]) return;
+  exports[key] = _SimpleTraverser[key];
+});
+
+var _SimpleTransform = require("./transform/SimpleTransform");
+
+Object.keys(_SimpleTransform).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTransform[key]) return;
+  exports[key] = _SimpleTransform[key];
+});
+
+var _getVisitorKeys = require("./traverse/getVisitorKeys");
+
+Object.keys(_getVisitorKeys).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _getVisitorKeys[key]) return;
+  exports[key] = _getVisitorKeys[key];
+});
+
+var _astArrayMutationHelpers = _interopRequireWildcard(require("./transform/astArrayMutationHelpers"));
+
+exports.astArrayMutationHelpers = _astArrayMutationHelpers;
+
+var _astNodeMutationHelpers = _interopRequireWildcard(require("./transform/astNodeMutationHelpers"));
+
+exports.astNodeMutationHelpers = _astNodeMutationHelpers;
+
+var _mutateESTreeASTForPrettier = _interopRequireDefault(require("./utils/mutateESTreeASTForPrettier"));
+
+exports.mutateESTreeASTForPrettier = _mutateESTreeASTForPrettier.default;
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    return {
+      default: obj
+    };
+  }
+
+  var cache = _getRequireWildcardCache(nodeInterop);
+
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+
+  for (var key in obj) {
+    if (key !== "default" && 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;
+}
+
+const DEFAULTS = {
+  flow: 'detect'
+};
+
+function getOptions(opts) {
+  const options = { ...DEFAULTS,
+    ...(opts != null ? opts : {})
+  };
+
+  if (options.flow !== 'all' && options.flow !== 'detect') {
+    throw new Error('flow option must be "all" or "detect"');
+  }
+
+  if (options.sourceType === 'unambiguous') {
+    delete options.sourceType;
+  } else if (options.sourceType != null && options.sourceType !== 'script' && options.sourceType !== 'module') {
+    throw new Error('sourceType option must be "script", "module", or "unambiguous" if set');
+  }
+
+  if (options.enableExperimentalComponentSyntax == null) {
+    options.enableExperimentalComponentSyntax = true;
+  }
+
+  if (options.enableExperimentalFlowMatchSyntax == null) {
+    options.enableExperimentalFlowMatchSyntax = true;
+  }
+
+  if (options.enableExperimentalFlowRecordSyntax == null) {
+    options.enableExperimentalFlowRecordSyntax = true;
+  }
+
+  options.enableRecords = options.enableExperimentalFlowRecordSyntax;
+
+  if (options.enableEnums == null) {
+    options.enableEnums = true;
+  }
+
+  if (options.enableExperimentalDecorators == null) {
+    options.enableExperimentalDecorators = true;
+  }
+
+  options.tokens = options.tokens === true;
+  options.allowReturnOutsideFunction = options.allowReturnOutsideFunction === true;
+  return options;
+}
+
+function parse(code, opts) {
+  var _options$transformOpt, _options$transformOpt2;
+
+  const options = getOptions(opts);
+
+  if (options.flow === 'all') {
+    options.enableTypes = true;
+  } else {
+    options.enableTypesPragmaDetection = true;
+  }
+
+  const estreeAST = FlowParser.parse(code, options);
+
+  if (options.babel !== true) {
+    return estreeAST;
+  }
+
+  const loweredESTreeAST = [(_options$transformOpt = options.transformOptions) != null && (_options$transformOpt2 = _options$transformOpt.TransformEnumSyntax) != null && _options$transformOpt2.enable ? TransformEnumSyntax.transformProgram : null, TransformMatchSyntax.transformProgram, TransformComponentSyntax.transformProgram, TransformRecordSyntax.transformProgram, StripFlowTypesForBabel.transformProgram].reduce((ast, transform) => {
+    var _transform;
+
+    return (_transform = transform == null ? void 0 : transform(ast, options)) != null ? _transform : ast;
+  }, estreeAST);
+  return TransformESTreeToBabel.transformProgram(loweredESTreeAST, options);
+}
+
+const Transforms = {
+  transformEnumSyntax: TransformEnumSyntax.transformProgram,
+  transformMatchSyntax: TransformMatchSyntax.transformProgram,
+  transformComponentSyntax: TransformComponentSyntax.transformProgram,
+  transformRecordSyntax: TransformRecordSyntax.transformProgram,
+  stripFlowTypesForBabel: StripFlowTypesForBabel.transformProgram,
+  stripFlowTypes: StripFlowTypes.transformProgram
+};
+exports.Transforms = Transforms;

package/oxidized/oxidized-src/transform/SimpleTransform.js

@@ -0,0 +1,95 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SimpleTransform = void 0;
+
+var _SimpleTraverser = require("../traverse/SimpleTraverser");
+
+var _astNodeMutationHelpers = require("./astNodeMutationHelpers");
+
+function setParentPointer(node, parent) {
+  if (parent != null) {
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        item.parent = parent;
+      }
+    } else {
+      node.parent = parent;
+    }
+  }
+}
+
+class SimpleTransform {
+  transform(rootNode, options) {
+    let resultRootNode = rootNode;
+
+    _SimpleTraverser.SimpleTraverser.traverse(rootNode, {
+      enter: (node, parent) => {
+        setParentPointer(node, parent);
+        const resultNode = options.transform(node);
+
+        if (resultNode !== node) {
+          let traversedResultNode = null;
+
+          if (resultNode != null) {
+            setParentPointer(resultNode, parent);
+
+            if (Array.isArray(resultNode)) {
+              traversedResultNode = resultNode.map(item => this.transform(item, options)).filter(item => item != null);
+            } else {
+              traversedResultNode = this.transform(resultNode, options);
+            }
+          }
+
+          if (parent == null) {
+            if (node !== rootNode) {
+              throw new Error('SimpleTransform infra error: Parent not set on non root node, this should not be possible');
+            }
+
+            if (Array.isArray(traversedResultNode)) {
+              throw new Error('SimpleTransform: invalid array result for root node');
+            } else {
+              resultRootNode = traversedResultNode;
+            }
+          } else if (traversedResultNode == null) {
+            (0, _astNodeMutationHelpers.removeNodeOnParent)(node, parent, options.visitorKeys);
+          } else {
+            (0, _astNodeMutationHelpers.replaceNodeOnParent)(node, parent, traversedResultNode, options.visitorKeys);
+            setParentPointer(traversedResultNode, parent);
+          }
+
+          throw _SimpleTraverser.SimpleTraverser.Skip;
+        }
+      },
+
+      leave(_node) {},
+
+      visitorKeys: options.visitorKeys
+    });
+
+    return resultRootNode;
+  }
+
+  static transform(node, options) {
+    return new SimpleTransform().transform(node, options);
+  }
+
+  static transformProgram(program, options) {
+    const result = SimpleTransform.transform(program, options);
+
+    if ((result == null ? void 0 : result.type) === 'Program') {
+      return result;
+    }
+
+    throw new Error('SimpleTransform.transformProgram: Expected program node.');
+  }
+
+  static nodeWith(node, overrideProps, visitorKeys) {
+    return (0, _astNodeMutationHelpers.nodeWith)(node, overrideProps, visitorKeys);
+  }
+
+}
+
+exports.SimpleTransform = SimpleTransform;

package/oxidized/oxidized-src/transform/astArrayMutationHelpers.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrayIsEqual = arrayIsEqual;
+exports.insertInArray = insertInArray;
+exports.removeFromArray = removeFromArray;
+exports.replaceInArray = replaceInArray;
+
+function assertArrayBounds(array, index) {
+  if (index < 0 || index >= array.length) {
+    throw new Error(`Invalid Mutation: Tried to mutate an elements array with an out of bounds index. Index: ${index}, Array Size: ${array.length}`);
+  }
+}
+
+function arrayIsEqual(a1, a2) {
+  if (a1 === a2) {
+    return true;
+  }
+
+  if (a1.length !== a2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < a1.length; i++) {
+    if (a1[i] !== a2[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function insertInArray(array, index, elements) {
+  if (index === array.length) {
+    return array.concat(elements);
+  }
+
+  assertArrayBounds(array, index);
+  return array.slice(0, index).concat(elements).concat(array.slice(index));
+}
+
+function removeFromArray(array, index) {
+  assertArrayBounds(array, index);
+  return [...array.slice(0, index), ...array.slice(index + 1)];
+}
+
+function replaceInArray(array, index, elements) {
+  assertArrayBounds(array, index);
+  return array.slice(0, index).concat(elements).concat(array.slice(index + 1));
+}

package/oxidized/oxidized-src/transform/astNodeMutationHelpers.js

@@ -0,0 +1,142 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deepCloneNode = deepCloneNode;
+exports.nodeWith = nodeWith;
+exports.removeNodeOnParent = removeNodeOnParent;
+exports.replaceNodeOnParent = replaceNodeOnParent;
+exports.setParentPointersInDirectChildren = setParentPointersInDirectChildren;
+exports.shallowCloneNode = shallowCloneNode;
+exports.updateAllParentPointers = updateAllParentPointers;
+
+var _astArrayMutationHelpers = require("./astArrayMutationHelpers");
+
+var _getVisitorKeys = require("../traverse/getVisitorKeys");
+
+var _SimpleTraverser = require("../traverse/SimpleTraverser");
+
+function getParentKey(target, parent, visitorKeys) {
+  if (parent == null) {
+    throw new Error(`Expected parent node to be set on "${target.type}"`);
+  }
+
+  for (const key of (0, _getVisitorKeys.getVisitorKeys)(parent, visitorKeys)) {
+    if ((0, _getVisitorKeys.isNode)(parent[key])) {
+      if (parent[key] === target) {
+        return {
+          type: 'single',
+          node: parent,
+          key
+        };
+      }
+    } else if (Array.isArray(parent[key])) {
+      for (let i = 0; i < parent[key].length; i += 1) {
+        const current = parent[key][i];
+
+        if (current === target) {
+          return {
+            type: 'array',
+            node: parent,
+            key,
+            targetIndex: i
+          };
+        }
+      }
+    }
+  }
+
+  throw new Error(`Expected to find the ${target.type} as a direct child of the ${parent.type}.`);
+}
+
+function replaceNodeOnParent(originalNode, originalNodeParent, nodeToReplaceWith, visitorKeys) {
+  const replacementParent = getParentKey(originalNode, originalNodeParent, visitorKeys);
+  const parent = replacementParent.node;
+
+  if (replacementParent.type === 'array') {
+    parent[replacementParent.key] = (0, _astArrayMutationHelpers.replaceInArray)(parent[replacementParent.key], replacementParent.targetIndex, Array.isArray(nodeToReplaceWith) ? nodeToReplaceWith : [nodeToReplaceWith]);
+  } else {
+    if (Array.isArray(nodeToReplaceWith)) {
+      throw new Error(`Cannot insert array into non-array parent type: ${parent.type}`);
+    }
+
+    parent[replacementParent.key] = nodeToReplaceWith;
+  }
+}
+
+function removeNodeOnParent(originalNode, originalNodeParent, visitorKeys) {
+  const replacementParent = getParentKey(originalNode, originalNodeParent, visitorKeys);
+  const parent = replacementParent.node;
+
+  if (replacementParent.type === 'array') {
+    parent[replacementParent.key] = (0, _astArrayMutationHelpers.removeFromArray)(parent[replacementParent.key], replacementParent.targetIndex);
+  } else {
+    parent[replacementParent.key] = null;
+  }
+}
+
+function setParentPointersInDirectChildren(node, visitorKeys) {
+  for (const key of (0, _getVisitorKeys.getVisitorKeys)(node, visitorKeys)) {
+    if ((0, _getVisitorKeys.isNode)(node[key])) {
+      node[key].parent = node;
+    } else if (Array.isArray(node[key])) {
+      for (const child of node[key]) {
+        child.parent = node;
+      }
+    }
+  }
+}
+
+function updateAllParentPointers(node, visitorKeys) {
+  _SimpleTraverser.SimpleTraverser.traverse(node, {
+    enter(node, parent) {
+      node.parent = parent;
+    },
+
+    leave() {},
+
+    visitorKeys
+  });
+}
+
+function nodeWith(node, overrideProps, visitorKeys) {
+  const willBeUnchanged = Object.entries(overrideProps).every(([key, value]) => {
+    const node_ = node;
+
+    if (Array.isArray(value)) {
+      return Array.isArray(node_[key]) ? (0, _astArrayMutationHelpers.arrayIsEqual)(node_[key], value) : false;
+    }
+
+    return node_[key] === value;
+  });
+
+  if (willBeUnchanged) {
+    return node;
+  }
+
+  const newNode = { ...node,
+    ...overrideProps
+  };
+  setParentPointersInDirectChildren(newNode, visitorKeys);
+  return newNode;
+}
+
+function shallowCloneNode(node, visitorKeys) {
+  const newNode = { ...node
+  };
+  setParentPointersInDirectChildren(newNode, visitorKeys);
+  return newNode;
+}
+
+function deepCloneNode(node, visitorKeys) {
+  const clone = JSON.parse(JSON.stringify(node, (key, value) => {
+    if (key === 'parent') {
+      return undefined;
+    }
+
+    return value;
+  }));
+  updateAllParentPointers(clone, visitorKeys);
+  return clone;
+}