hermes-transform 0.5.0

package/dist/traverse/NodeEventGenerator.js.flow

@@ -0,0 +1,406 @@
+/**
+ * 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 {ESNode} from 'hermes-estree';
+import type {ESQueryOptions, Selector} from './esquery';
+import type {SafeEmitter} from './SafeEmitter';
+
+import {VisitorKeys} from 'hermes-eslint';
+import * as esquery from './esquery';
+
+type ParsedSelector = $ReadOnly<{
+  /** The string that was parsed into this selector */
+  rawSelector: string,
+  /** `true` if this should be emitted when exiting the node rather than when entering */
+  isExit: boolean,
+  /** An object (from esquery) describing the matching behavior of the selector */
+  parsedSelector: Selector,
+  /** A list of node types that could possibly cause the selector to match, or `null` if all node types could cause a match */
+  listenerTypes: ?Array<ESNode['type']>,
+  /** The total number of classes, pseudo-classes, and attribute queries in this selector */
+  attributeCount: number,
+  /** The total number of identifier queries in this selector */
+  identifierCount: number,
+}>;
+
+const ESQUERY_OPTIONS: ESQueryOptions = Object.freeze({
+  visitorKeys: VisitorKeys,
+  fallback: node => {
+    throw new Error(`No visitor keys found for node type "${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<T>(...arrays: Array<Array<T>>): Array<T> {
+  return [...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<T>(...arrays: Array<Array<T>>): Array<T> {
+  if (arrays.length === 0) {
+    return [];
+  }
+
+  let result = [...new Set(arrays[0])];
+
+  for (const array of arrays.slice(1)) {
+    result = result.filter(x => array.includes(x));
+  }
+  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: Selector): ?Array<ESNode['type']> {
+  switch (parsedSelector.type) {
+    case 'identifier':
+      if (!(parsedSelector.value in VisitorKeys)) {
+        throw new Error(`Unexpected selector ${parsedSelector.value}`);
+      }
+      // $FlowExpectedError[incompatible-return]
+      return [parsedSelector.value];
+
+    case 'matches': {
+      const typesForComponents = parsedSelector.selectors.map(getPossibleTypes);
+      const typesForComponentsNonNull = typesForComponents.filter(Boolean);
+
+      if (typesForComponents.length === typesForComponentsNonNull.length) {
+        return union(...typesForComponentsNonNull);
+      }
+      return null;
+    }
+
+    case 'compound': {
+      const 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(...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: Selector): number {
+  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(
+        (sum, childSelector) => 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: Selector): number {
+  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(
+        (sum, childSelector) => 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: ParsedSelector,
+  selectorB: ParsedSelector,
+): number {
+  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: string): Selector {
+  try {
+    return esquery.parse(rawSelector.replace(/:exit$/u, ''));
+  } catch (err) {
+    if (
+      err.location &&
+      err.location.start &&
+      typeof err.location.start.offset === 'number'
+    ) {
+      throw new SyntaxError(
+        `Syntax error in selector "${rawSelector}" at position ${err.location.start.offset}: ${err.message}`,
+      );
+    }
+    throw err;
+  }
+}
+
+const selectorCache = new Map<string, ParsedSelector>();
+
+/**
+ * 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: string): ParsedSelector {
+  const cachedSelector = selectorCache.get(rawSelector);
+  if (cachedSelector) {
+    return cachedSelector;
+  }
+
+  const parsedSelector = tryParseSelector(rawSelector);
+
+  const result: ParsedSelector = {
+    rawSelector,
+    isExit: rawSelector.endsWith(':exit'),
+    parsedSelector,
+    listenerTypes: getPossibleTypes(parsedSelector),
+    attributeCount: countClassAttributes(parsedSelector),
+    identifierCount: countIdentifiers(parsedSelector),
+  };
+
+  selectorCache.set(rawSelector, result);
+  return result;
+}
+
+/**
+ * The event generator for AST nodes.
+ */
+export class NodeEventGenerator {
+  +emitter: SafeEmitter;
+  +_currentAncestry: Array<ESNode> = [];
+  +_enterSelectorsByNodeType: Map<ESNode['type'], Array<ParsedSelector>> =
+    new Map();
+  +_exitSelectorsByNodeType: Map<ESNode['type'], Array<ParsedSelector>> =
+    new Map();
+  +_anyTypeEnterSelectors: Array<ParsedSelector> = [];
+  +_anyTypeExitSelectors: Array<ParsedSelector> = [];
+
+  /**
+   * @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`.)
+   */
+  constructor(emitter: SafeEmitter) {
+    this.emitter = emitter;
+
+    emitter.eventNames().forEach(rawSelector => {
+      const selector = parseSelector(rawSelector);
+
+      if (selector.listenerTypes) {
+        const typeMap = selector.isExit
+          ? this._exitSelectorsByNodeType
+          : this._enterSelectorsByNodeType;
+
+        selector.listenerTypes.forEach(nodeType => {
+          const selectors = typeMap.get(nodeType);
+          if (!selectors) {
+            typeMap.set(nodeType, [selector]);
+          } else {
+            selectors.push(selector);
+          }
+        });
+      } else {
+        const selectors = selector.isExit
+          ? this._anyTypeExitSelectors
+          : this._anyTypeEnterSelectors;
+
+        selectors.push(selector);
+      }
+    });
+
+    this._anyTypeEnterSelectors.sort(compareSpecificity);
+    this._anyTypeExitSelectors.sort(compareSpecificity);
+    this._enterSelectorsByNodeType.forEach(selectorList =>
+      selectorList.sort(compareSpecificity),
+    );
+    this._exitSelectorsByNodeType.forEach(selectorList =>
+      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
+   */
+  _applySelector(node: ESNode, selector: ParsedSelector): void {
+    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
+   */
+  _applySelectors(node: ESNode, isExit: boolean): void {
+    const selectorsByNodeType =
+      (isExit
+        ? this._exitSelectorsByNodeType
+        : this._enterSelectorsByNodeType
+      ).get(node.type) || [];
+    const 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.
+     */
+    let selectorsByTypeIndex = 0;
+    let 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.
+   */
+  enterNode(node: ESNode): void {
+    this._applySelectors(node, false);
+    this._currentAncestry.unshift(node);
+  }
+
+  /**
+   * Emits an event of leaving AST node.
+   * @param node A node which was left.
+   */
+  leaveNode(node: ESNode): void {
+    this._currentAncestry.shift();
+    this._applySelectors(node, true);
+  }
+}

package/dist/traverse/SafeEmitter.js

@@ -0,0 +1,70 @@
+/**
+ * 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';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SafeEmitter = void 0;
+
+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; }
+
+/**
+ * Creates an object which can listen for and emit events.
+ * This is similar to the EventEmitter API in Node's standard library, but it has a few differences.
+ * The goal is to allow multiple modules to attach arbitrary listeners to the same emitter, without
+ * letting the modules know about each other at all.
+ * 1. It has no special keys like `error` and `newListener`, which would allow modules to detect when
+ * another module throws an error or registers a listener.
+ * 2. It calls listener functions without any `this` value. (`EventEmitter` calls listeners with a
+ * `this` value of the emitter instance, which would give listeners access to other listeners.)
+ */
+var SafeEmitter = /*#__PURE__*/function () {
+  function SafeEmitter() {
+    _classCallCheck(this, SafeEmitter);
+
+    _defineProperty(this, "listeners", Object.create(null));
+  }
+
+  _createClass(SafeEmitter, [{
+    key: "on",
+    value: function on(eventName, listener) {
+      if (eventName in this.listeners) {
+        this.listeners[eventName].push(listener);
+      } else {
+        this.listeners[eventName] = [listener];
+      }
+    }
+  }, {
+    key: "emit",
+    value: function emit(eventName, node) {
+      if (eventName in this.listeners) {
+        this.listeners[eventName].forEach(function (listener) {
+          return listener(node);
+        });
+      }
+    }
+  }, {
+    key: "eventNames",
+    value: function eventNames() {
+      return Object.keys(this.listeners);
+    }
+  }]);
+
+  return SafeEmitter;
+}();
+
+exports.SafeEmitter = SafeEmitter;

package/dist/traverse/SafeEmitter.js.flow

@@ -0,0 +1,46 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict';
+
+import type {ESNode} from 'hermes-estree';
+
+export type EmitterListener = (node: ESNode) => void;
+
+/**
+ * Creates an object which can listen for and emit events.
+ * This is similar to the EventEmitter API in Node's standard library, but it has a few differences.
+ * The goal is to allow multiple modules to attach arbitrary listeners to the same emitter, without
+ * letting the modules know about each other at all.
+ * 1. It has no special keys like `error` and `newListener`, which would allow modules to detect when
+ * another module throws an error or registers a listener.
+ * 2. It calls listener functions without any `this` value. (`EventEmitter` calls listeners with a
+ * `this` value of the emitter instance, which would give listeners access to other listeners.)
+ */
+export class SafeEmitter {
+  // $FlowExpectedError[incompatible-type] - Object.create is always typed as returning `mixed`
+  +listeners: {[string]: Array<EmitterListener>} = Object.create(null);
+
+  on(eventName: string, listener: EmitterListener): void {
+    if (eventName in this.listeners) {
+      this.listeners[eventName].push(listener);
+    } else {
+      this.listeners[eventName] = [listener];
+    }
+  }
+  emit(eventName: string, node: ESNode): void {
+    if (eventName in this.listeners) {
+      this.listeners[eventName].forEach(listener => listener(node));
+    }
+  }
+  eventNames(): Array<string> {
+    return Object.keys(this.listeners);
+  }
+}

package/dist/traverse/SimpleTraverser.js

@@ -0,0 +1,149 @@
+/**
+ * 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';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SimpleTraverserSkip = exports.SimpleTraverserBreak = exports.SimpleTraverser = void 0;
+
+var _getVisitorKeys = require("../getVisitorKeys");
+
+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 _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 _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; }
+
+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; }
+
+/**
+ * Can be thrown within the traversal "enter" function to prevent the traverser
+ * from traversing the node any further, essentially culling the remainder of the
+ * AST branch
+ */
+var SimpleTraverserSkip = new Error();
+/**
+ * Can be thrown at any point during the traversal to immediately stop traversal
+ * entirely.
+ */
+
+exports.SimpleTraverserSkip = SimpleTraverserSkip;
+var SimpleTraverserBreak = new Error();
+/**
+ * A very simple traverser class to traverse AST trees.
+ */
+
+exports.SimpleTraverserBreak = SimpleTraverserBreak;
+
+var SimpleTraverser = /*#__PURE__*/function () {
+  function SimpleTraverser() {
+    _classCallCheck(this, SimpleTraverser);
+  }
+
+  _createClass(SimpleTraverser, [{
+    key: "traverse",
+    value:
+    /**
+     * Traverse the given AST tree.
+     * @param node The root node to traverse.
+     * @param options The option object.
+     */
+    function traverse(node, options) {
+      try {
+        this._traverse(node, null, options);
+      } catch (ex) {
+        if (ex === SimpleTraverserBreak) {
+          return;
+        }
+
+        throw ex;
+      }
+    }
+    /**
+     * Traverse the given AST tree recursively.
+     * @param node The current node.
+     * @param parent The parent node.
+     * @private
+     */
+
+  }, {
+    key: "_traverse",
+    value: function _traverse(node, parent, options) {
+      if (!(0, _getVisitorKeys.isNode)(node)) {
+        return;
+      }
+
+      try {
+        options.enter(node, parent);
+      } catch (ex) {
+        if (ex === SimpleTraverserSkip) {
+          return;
+        }
+
+        throw ex;
+      }
+
+      var keys = (0, _getVisitorKeys.getVisitorKeys)(node);
+
+      var _iterator = _createForOfIteratorHelper(keys),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var key = _step.value;
+          // $FlowExpectedError[prop-missing]
+          var child = node[key];
+
+          if (Array.isArray(child)) {
+            for (var j = 0; j < child.length; ++j) {
+              this._traverse(child[j], node, options);
+            }
+          } else {
+            this._traverse(child, node, options);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+
+      try {
+        options.leave(node, parent);
+      } catch (ex) {
+        if (ex === SimpleTraverserSkip) {
+          return;
+        }
+
+        throw ex;
+      }
+    }
+    /**
+     * Traverse the given AST tree.
+     * @param node The root node to traverse.
+     * @param options The option object.
+     */
+
+  }], [{
+    key: "traverse",
+    value: function traverse(node, options) {
+      new SimpleTraverser().traverse(node, options);
+    }
+  }]);
+
+  return SimpleTraverser;
+}();
+
+exports.SimpleTraverser = SimpleTraverser;