hermes-transform 0.5.0

package/dist/transform/transform.js.flow

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {Visitor} from '../traverse/traverse';
+import type {TransformContext} from './TransformContext';
+
+import * as prettier from 'prettier';
+import {getTransformedAST} from './getTransformedAST';
+import {SimpleTraverser} from '../traverse/SimpleTraverser';
+
+export type Visitors = Visitor<TransformContext>;
+
+export function transform(
+  originalCode: string,
+  visitors: Visitor<TransformContext>,
+  prettierOptions: {...} = {},
+): string {
+  const {ast, astWasMutated, mutatedCode} = getTransformedAST(
+    originalCode,
+    visitors,
+  );
+
+  if (!astWasMutated) {
+    return originalCode;
+  }
+
+  // prettier fully expects the parent pointers are NOT set and
+  // certain cases can crash due to prettier infinite-looping
+  // whilst naively traversing the parent property
+  // https://github.com/prettier/prettier/issues/11793
+  SimpleTraverser.traverse(ast, {
+    enter(node) {
+      // $FlowExpectedError[cannot-write]
+      delete node.parent;
+    },
+    leave() {},
+  });
+
+  // we need to delete the comments prop or else prettier will do
+  // its own attachment pass after the mutation and duplicate the
+  // comments on each node, borking the output
+  // $FlowExpectedError[cannot-write]
+  delete ast.comments;
+
+  return prettier.format(mutatedCode, {
+    ...prettierOptions,
+    parser() {
+      return ast;
+    },
+  });
+}

package/dist/traverse/NodeEventGenerator.js

@@ -0,0 +1,427 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NodeEventGenerator = void 0;
+
+var _hermesEslint = require("hermes-eslint");
+
+var esquery = _interopRequireWildcard(require("./esquery"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(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; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+var ESQUERY_OPTIONS = Object.freeze({
+  visitorKeys: _hermesEslint.VisitorKeys,
+  fallback: function fallback(node) {
+    throw new Error("No visitor keys found for node type \"".concat(node.type, "\"."));
+  }
+});
+/**
+ * Computes the union of one or more arrays
+ * @param arrays One or more arrays to union
+ * @returns The union of the input arrays
+ */
+
+function union() {
+  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrays[_key] = arguments[_key];
+  }
+
+  return _toConsumableArray(new Set(arrays.flat()));
+}
+/**
+ * Computes the intersection of one or more arrays
+ * @param arrays One or more arrays to intersect
+ * @returns The intersection of the input arrays
+ */
+
+
+function intersection() {
+  for (var _len2 = arguments.length, arrays = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    arrays[_key2] = arguments[_key2];
+  }
+
+  if (arrays.length === 0) {
+    return [];
+  }
+
+  var result = _toConsumableArray(new Set(arrays[0]));
+
+  var _iterator = _createForOfIteratorHelper(arrays.slice(1)),
+      _step;
+
+  try {
+    var _loop = function _loop() {
+      var array = _step.value;
+      result = result.filter(function (x) {
+        return array.includes(x);
+      });
+    };
+
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return result;
+}
+/**
+ * Gets the possible types of a selector
+ * @param parsedSelector An object (from esquery) describing the matching behavior of the selector
+ * @returns The node types that could possibly trigger this selector, or `null` if all node types could trigger it
+ */
+
+
+function getPossibleTypes(parsedSelector) {
+  switch (parsedSelector.type) {
+    case 'identifier':
+      if (!(parsedSelector.value in _hermesEslint.VisitorKeys)) {
+        throw new Error("Unexpected selector ".concat(parsedSelector.value));
+      } // $FlowExpectedError[incompatible-return]
+
+
+      return [parsedSelector.value];
+
+    case 'matches':
+      {
+        var typesForComponents = parsedSelector.selectors.map(getPossibleTypes);
+        var typesForComponentsNonNull = typesForComponents.filter(Boolean);
+
+        if (typesForComponents.length === typesForComponentsNonNull.length) {
+          return union.apply(void 0, _toConsumableArray(typesForComponentsNonNull));
+        }
+
+        return null;
+      }
+
+    case 'compound':
+      {
+        var _typesForComponents = parsedSelector.selectors.map(getPossibleTypes).filter(Boolean); // If all of the components could match any type, then the compound could also match any type.
+
+
+        if (!_typesForComponents.length) {
+          return null;
+        }
+        /*
+         * If at least one of the components could only match a particular type, the compound could only match
+         * the intersection of those types.
+         */
+
+
+        return intersection.apply(void 0, _toConsumableArray(_typesForComponents));
+      }
+
+    case 'child':
+    case 'descendant':
+    case 'sibling':
+    case 'adjacent':
+      return getPossibleTypes(parsedSelector.right);
+
+    case 'class':
+      if (parsedSelector.name === 'function') {
+        return ['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'];
+      }
+
+      return null;
+
+    default:
+      return null;
+  }
+}
+/**
+ * Counts the number of class, pseudo-class, and attribute queries in this selector
+ * @param parsedSelector An object (from esquery) describing the selector's matching behavior
+ * @returns The number of class, pseudo-class, and attribute queries in this selector
+ */
+
+
+function countClassAttributes(parsedSelector) {
+  switch (parsedSelector.type) {
+    case 'child':
+    case 'descendant':
+    case 'sibling':
+    case 'adjacent':
+      return countClassAttributes(parsedSelector.left) + countClassAttributes(parsedSelector.right);
+
+    case 'compound':
+    case 'not':
+    case 'matches':
+      return parsedSelector.selectors.reduce(function (sum, childSelector) {
+        return sum + countClassAttributes(childSelector);
+      }, 0);
+
+    case 'attribute':
+    case 'field':
+    case 'nth-child':
+    case 'nth-last-child':
+      return 1;
+
+    default:
+      return 0;
+  }
+}
+/**
+ * Counts the number of identifier queries in this selector
+ * @param parsedSelector An object (from esquery) describing the selector's matching behavior
+ * @returns The number of identifier queries
+ */
+
+
+function countIdentifiers(parsedSelector) {
+  switch (parsedSelector.type) {
+    case 'child':
+    case 'descendant':
+    case 'sibling':
+    case 'adjacent':
+      return countIdentifiers(parsedSelector.left) + countIdentifiers(parsedSelector.right);
+
+    case 'compound':
+    case 'not':
+    case 'matches':
+      return parsedSelector.selectors.reduce(function (sum, childSelector) {
+        return sum + countIdentifiers(childSelector);
+      }, 0);
+
+    case 'identifier':
+      return 1;
+
+    default:
+      return 0;
+  }
+}
+/**
+ * Compares the specificity of two selector objects, with CSS-like rules.
+ * @param selectorA An AST selector descriptor
+ * @param selectorB Another AST selector descriptor
+ * @returns
+ * a value less than 0 if selectorA is less specific than selectorB
+ * a value greater than 0 if selectorA is more specific than selectorB
+ * a value less than 0 if selectorA and selectorB have the same specificity, and selectorA <= selectorB alphabetically
+ * a value greater than 0 if selectorA and selectorB have the same specificity, and selectorA > selectorB alphabetically
+ */
+
+
+function compareSpecificity(selectorA, selectorB) {
+  return selectorA.attributeCount - selectorB.attributeCount || selectorA.identifierCount - selectorB.identifierCount || (selectorA.rawSelector <= selectorB.rawSelector ? -1 : 1);
+}
+/**
+ * Parses a raw selector string, and throws a useful error if parsing fails.
+ * @param rawSelector A raw AST selector
+ * @returns An object (from esquery) describing the matching behavior of this selector
+ * @throws An error if the selector is invalid
+ */
+
+
+function tryParseSelector(rawSelector) {
+  try {
+    return esquery.parse(rawSelector.replace(/:exit$/, ''));
+  } catch (err) {
+    if (err.location && err.location.start && typeof err.location.start.offset === 'number') {
+      throw new SyntaxError("Syntax error in selector \"".concat(rawSelector, "\" at position ").concat(err.location.start.offset, ": ").concat(err.message));
+    }
+
+    throw err;
+  }
+}
+
+var selectorCache = new Map();
+/**
+ * Parses a raw selector string, and returns the parsed selector along with specificity and type information.
+ * @param rawSelector A raw AST selector
+ * @returns A selector descriptor
+ */
+
+function parseSelector(rawSelector) {
+  var cachedSelector = selectorCache.get(rawSelector);
+
+  if (cachedSelector) {
+    return cachedSelector;
+  }
+
+  var parsedSelector = tryParseSelector(rawSelector);
+  var result = {
+    rawSelector: rawSelector,
+    isExit: rawSelector.endsWith(':exit'),
+    parsedSelector: parsedSelector,
+    listenerTypes: getPossibleTypes(parsedSelector),
+    attributeCount: countClassAttributes(parsedSelector),
+    identifierCount: countIdentifiers(parsedSelector)
+  };
+  selectorCache.set(rawSelector, result);
+  return result;
+}
+/**
+ * The event generator for AST nodes.
+ */
+
+
+var NodeEventGenerator = /*#__PURE__*/function () {
+  /**
+   * @param emitter
+   * An SafeEmitter which is the destination of events. This emitter must already
+   * have registered listeners for all of the events that it needs to listen for.
+   * (See lib/linter/safe-emitter.js for more details on `SafeEmitter`.)
+   */
+  function NodeEventGenerator(emitter) {
+    var _this = this;
+
+    _classCallCheck(this, NodeEventGenerator);
+
+    _defineProperty(this, "emitter", void 0);
+
+    _defineProperty(this, "_currentAncestry", []);
+
+    _defineProperty(this, "_enterSelectorsByNodeType", new Map());
+
+    _defineProperty(this, "_exitSelectorsByNodeType", new Map());
+
+    _defineProperty(this, "_anyTypeEnterSelectors", []);
+
+    _defineProperty(this, "_anyTypeExitSelectors", []);
+
+    this.emitter = emitter;
+    emitter.eventNames().forEach(function (rawSelector) {
+      var selector = parseSelector(rawSelector);
+
+      if (selector.listenerTypes) {
+        var typeMap = selector.isExit ? _this._exitSelectorsByNodeType : _this._enterSelectorsByNodeType;
+        selector.listenerTypes.forEach(function (nodeType) {
+          var selectors = typeMap.get(nodeType);
+
+          if (!selectors) {
+            typeMap.set(nodeType, [selector]);
+          } else {
+            selectors.push(selector);
+          }
+        });
+      } else {
+        var selectors = selector.isExit ? _this._anyTypeExitSelectors : _this._anyTypeEnterSelectors;
+        selectors.push(selector);
+      }
+    });
+
+    this._anyTypeEnterSelectors.sort(compareSpecificity);
+
+    this._anyTypeExitSelectors.sort(compareSpecificity);
+
+    this._enterSelectorsByNodeType.forEach(function (selectorList) {
+      return selectorList.sort(compareSpecificity);
+    });
+
+    this._exitSelectorsByNodeType.forEach(function (selectorList) {
+      return selectorList.sort(compareSpecificity);
+    });
+  }
+  /**
+   * Checks a selector against a node, and emits it if it matches
+   * @param node The node to check
+   * @param selector An AST selector descriptor
+   * @private
+   */
+
+
+  _createClass(NodeEventGenerator, [{
+    key: "_applySelector",
+    value: function _applySelector(node, selector) {
+      if (esquery.matches(node, selector.parsedSelector, this._currentAncestry, ESQUERY_OPTIONS)) {
+        this.emitter.emit(selector.rawSelector, node);
+      }
+    }
+    /**
+     * Applies all appropriate selectors to a node, in specificity order
+     * @param node The node to check
+     * @param isExit `false` if the node is currently being entered, `true` if it's currently being exited
+     * @private
+     */
+
+  }, {
+    key: "_applySelectors",
+    value: function _applySelectors(node, isExit) {
+      var selectorsByNodeType = (isExit ? this._exitSelectorsByNodeType : this._enterSelectorsByNodeType).get(node.type) || [];
+      var anyTypeSelectors = isExit ? this._anyTypeExitSelectors : this._anyTypeEnterSelectors;
+      /*
+       * selectorsByNodeType and anyTypeSelectors were already sorted by specificity in the constructor.
+       * Iterate through each of them, applying selectors in the right order.
+       */
+
+      var selectorsByTypeIndex = 0;
+      var anyTypeSelectorsIndex = 0;
+
+      while (selectorsByTypeIndex < selectorsByNodeType.length || anyTypeSelectorsIndex < anyTypeSelectors.length) {
+        if (selectorsByTypeIndex >= selectorsByNodeType.length || anyTypeSelectorsIndex < anyTypeSelectors.length && compareSpecificity(anyTypeSelectors[anyTypeSelectorsIndex], selectorsByNodeType[selectorsByTypeIndex]) < 0) {
+          this._applySelector(node, anyTypeSelectors[anyTypeSelectorsIndex++]);
+        } else {
+          this._applySelector(node, selectorsByNodeType[selectorsByTypeIndex++]);
+        }
+      }
+    }
+    /**
+     * Emits an event of entering AST node.
+     * @param node A node which was entered.
+     */
+
+  }, {
+    key: "enterNode",
+    value: function enterNode(node) {
+      this._applySelectors(node, false);
+
+      this._currentAncestry.unshift(node);
+    }
+    /**
+     * Emits an event of leaving AST node.
+     * @param node A node which was left.
+     */
+
+  }, {
+    key: "leaveNode",
+    value: function leaveNode(node) {
+      this._currentAncestry.shift();
+
+      this._applySelectors(node, true);
+    }
+  }]);
+
+  return NodeEventGenerator;
+}();
+
+exports.NodeEventGenerator = NodeEventGenerator;