hermes-transform 0.28.1 → 0.29.0

package/dist/src/generated/special-case-node-types.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _Comment = require("./special-case-node-types/Comment");
+
+Object.keys(_Comment).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Comment[key]) return;
+  exports[key] = _Comment[key];
+});
+
+var _DeclareExportDeclaration = require("./special-case-node-types/DeclareExportDeclaration");
+
+Object.keys(_DeclareExportDeclaration).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _DeclareExportDeclaration[key]) return;
+  exports[key] = _DeclareExportDeclaration[key];
+});
+
+var _ExportNamedDeclaration = require("./special-case-node-types/ExportNamedDeclaration");
+
+Object.keys(_ExportNamedDeclaration).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ExportNamedDeclaration[key]) return;
+  exports[key] = _ExportNamedDeclaration[key];
+});
+
+var _Literal = require("./special-case-node-types/Literal");
+
+Object.keys(_Literal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Literal[key]) return;
+  exports[key] = _Literal[key];
+});
+
+var _ObjectTypeProperty = require("./special-case-node-types/ObjectTypeProperty");
+
+Object.keys(_ObjectTypeProperty).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ObjectTypeProperty[key]) return;
+  exports[key] = _ObjectTypeProperty[key];
+});
+
+var _misc = require("./special-case-node-types/misc");
+
+Object.keys(_misc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _misc[key]) return;
+  exports[key] = _misc[key];
+});
+
+var _Property = require("./special-case-node-types/Property");
+
+Object.keys(_Property).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _Property[key]) return;
+  exports[key] = _Property[key];
+});
+
+var _DeclareHook = require("./special-case-node-types/DeclareHook");
+
+Object.keys(_DeclareHook).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _DeclareHook[key]) return;
+  exports[key] = _DeclareHook[key];
+});

package/dist/src/index.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and 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.traverseWithContext = exports.traverse = exports.transform = exports.t = exports.print = exports.parse = exports.makeCommentOwnLine = exports.cloneJSDocCommentsToNewNode = exports.asDetachedNode = exports.SimpleTraverser = void 0;
+
+var _hermesParser = require("hermes-parser");
+
+exports.SimpleTraverser = _hermesParser.SimpleTraverser;
+
+var _traverse = require("./traverse/traverse");
+
+exports.traverse = _traverse.traverse;
+exports.traverseWithContext = _traverse.traverseWithContext;
+
+var _transform = require("./transform/transform");
+
+exports.transform = _transform.transform;
+
+var _parse = require("./transform/parse");
+
+exports.parse = _parse.parse;
+
+var _print = require("./transform/print");
+
+exports.print = _print.print;
+
+var _t = _interopRequireWildcard(require("./generated/node-types"));
+
+exports.t = _t;
+
+var _detachedNode = require("./detachedNode");
+
+exports.asDetachedNode = _detachedNode.asDetachedNode;
+
+var _comments = require("./transform/comments/comments");
+
+exports.cloneJSDocCommentsToNewNode = _comments.cloneJSDocCommentsToNewNode;
+exports.makeCommentOwnLine = _comments.makeCommentOwnLine;
+
+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; }

package/dist/src/transform/Errors.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnexpectedTransformationState = exports.NodeIsMutatedError = exports.NodeIsDeletedError = exports.InvalidStatementError = exports.InvalidReplacementError = exports.InvalidRemovalError = exports.InvalidInsertionError = void 0;
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+class NodeIsDeletedError extends Error {}
+
+exports.NodeIsDeletedError = NodeIsDeletedError;
+
+class NodeIsMutatedError extends Error {}
+
+exports.NodeIsMutatedError = NodeIsMutatedError;
+
+class InvalidInsertionError extends Error {}
+
+exports.InvalidInsertionError = InvalidInsertionError;
+
+class UnexpectedTransformationState extends Error {}
+
+exports.UnexpectedTransformationState = UnexpectedTransformationState;
+
+class InvalidStatementError extends Error {}
+
+exports.InvalidStatementError = InvalidStatementError;
+
+class InvalidRemovalError extends Error {}
+
+exports.InvalidRemovalError = InvalidRemovalError;
+
+class InvalidReplacementError extends Error {}
+
+exports.InvalidReplacementError = InvalidReplacementError;

package/dist/src/transform/MutationContext.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MutationContext = void 0;
+
+var _Errors = require("./Errors");
+
+var _comments = require("./comments/comments");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+class MutationContext {
+  // TODO - do we care about this? Arrays are pretty safe to concurrently mutate
+  constructor(code) {
+    this._deletedNodes = new Set();
+    this._mutatedKeys = new Map();
+    this._mutatedArrays = new Map();
+    this.code = void 0;
+    this.code = code;
+  }
+  /**
+   * Marks a node and its entire subtree as deleted.
+   */
+
+
+  markDeletion(node) {
+    this._deletedNodes.add(node);
+  }
+  /**
+   * Marks the key of the node as having been mutated.
+   */
+
+
+  markMutation(node, key) {
+    var _map$get$add, _map$get;
+
+    this.assertNotDeleted(node, `Attempted to mutate a \`${node.type}.${key}\` on a deleted node.`);
+    this.assertNotMutated(node, key, `Attempted to mutate a \`${node.type}.${key}\` when it has already been mutated.`);
+    const map = Array.isArray( // $FlowExpectedError[prop-missing]
+    node[key]) ? this._mutatedArrays : this._mutatedKeys;
+    map.set(node, (_map$get$add = (_map$get = map.get(node)) == null ? void 0 : _map$get.add(key)) != null ? _map$get$add : new Set([key]));
+  }
+  /**
+   * Throws if the node has been deleted
+   */
+
+
+  assertNotDeleted(node, message) {
+    if (this._deletedNodes.has(node)) {
+      throw new _Errors.NodeIsDeletedError(message);
+    }
+  }
+  /**
+   * Throws if the key of the node has been mutated
+   */
+
+
+  assertNotMutated(node, key, message) {
+    var _this$_mutatedKeys$ge;
+
+    if (((_this$_mutatedKeys$ge = this._mutatedKeys.get(node)) == null ? void 0 : _this$_mutatedKeys$ge.has(key)) === true) {
+      throw new _Errors.NodeIsMutatedError(message);
+    }
+  }
+
+  appendCommentToSource(comment, placement) {
+    this.code = (0, _comments.appendCommentToSource)(this.code, comment, placement);
+  }
+
+}
+
+exports.MutationContext = MutationContext;

package/dist/src/transform/TransformContext.js

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTransformContext = getTransformContext;
+
+var _detachedNode = require("../detachedNode");
+
+var _hermesParser = require("hermes-parser");
+
+var _comments = require("./comments/comments");
+
+var _AddComments = require("./mutations/AddComments");
+
+var _CloneCommentsTo = require("./mutations/CloneCommentsTo");
+
+var _InsertStatement = require("./mutations/InsertStatement");
+
+var _RemoveComment = require("./mutations/RemoveComment");
+
+var _RemoveNode = require("./mutations/RemoveNode");
+
+var _RemoveStatement = require("./mutations/RemoveStatement");
+
+var _ReplaceNode = require("./mutations/ReplaceNode");
+
+var _ReplaceStatementWithMany = require("./mutations/ReplaceStatementWithMany");
+
+var _ModifyNodeInPlace = require("./mutations/ModifyNodeInPlace");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+function getTransformContext() {
+  /**
+   * The mutations in order of collection.
+   */
+  const mutations = [];
+
+  function pushMutation(mutation) {
+    if (mutation != null) {
+      mutations.push(mutation);
+    }
+  }
+
+  const cloneAPIs = {
+    // $FlowFixMe[incompatible-exact]
+    shallowCloneNode: node => {
+      if (node == null) {
+        return null;
+      }
+
+      return (0, _detachedNode.shallowCloneNode)(node, {});
+    },
+    shallowCloneNodeWithOverrides: (node, newProps = {}) => {
+      if (node == null) {
+        return null;
+      }
+
+      return (0, _detachedNode.shallowCloneNode)(node, newProps);
+    },
+    // $FlowFixMe[incompatible-exact]
+    shallowCloneArray: nodes => {
+      if (nodes == null) {
+        return null;
+      }
+
+      return nodes.map(node_ => {
+        const node = node_;
+
+        if (node == null) {
+          // $FlowExpectedError[incompatible-return]
+          return node;
+        }
+
+        return (0, _detachedNode.shallowCloneNode)(node, {});
+      });
+    },
+    // $FlowFixMe[incompatible-exact]
+    deepCloneNode: node => {
+      if (node == null) {
+        return null;
+      }
+
+      return (0, _detachedNode.deepCloneNode)(node, {});
+    },
+    deepCloneNodeWithOverrides: (node, newProps = {}) => {
+      if (node == null) {
+        return null;
+      }
+
+      return (0, _detachedNode.deepCloneNode)(node, newProps);
+    }
+  };
+  const commentAPIs = {
+    getComments: node => {
+      return [...(0, _comments.getCommentsForNode)(node)];
+    },
+    getLeadingComments: node => {
+      return (0, _comments.getCommentsForNode)(node).filter(_comments.isLeadingComment);
+    },
+    getTrailingComments: node => {
+      return (0, _comments.getCommentsForNode)(node).filter(_comments.isTrailingComment);
+    },
+    cloneCommentsTo: (target, destination) => {
+      pushMutation((0, _CloneCommentsTo.createCloneCommentsToMutation)(target, destination));
+    },
+    addLeadingComments: (node, comments) => {
+      pushMutation((0, _AddComments.createAddCommentsMutation)(node, toArray(comments).map(comment => ({
+        comment,
+        placement: _comments.CommentPlacement.LEADING_OWN_LINE
+      }))));
+    },
+    addLeadingInlineComments: (node, comments) => {
+      pushMutation((0, _AddComments.createAddCommentsMutation)(node, toArray(comments).map(comment => ({
+        comment,
+        placement: _comments.CommentPlacement.LEADING_INLINE
+      }))));
+    },
+    addTrailingComments: (node, comments) => {
+      pushMutation((0, _AddComments.createAddCommentsMutation)(node, toArray(comments).map(comment => ({
+        comment,
+        placement: _comments.CommentPlacement.TRAILING_OWN_LINE
+      }))));
+    },
+    addTrailingInlineComments: (node, comments) => {
+      pushMutation((0, _AddComments.createAddCommentsMutation)(node, toArray(comments).map(comment => ({
+        comment,
+        placement: _comments.CommentPlacement.TRAILING_INLINE
+      }))));
+    },
+    removeComments: comments => {
+      toArray(comments).forEach(comment => {
+        pushMutation((0, _RemoveComment.createRemoveCommentMutation)(comment));
+      });
+    }
+  };
+  const insertAPIs = {
+    insertAfterStatement: (target, nodesToInsert) => {
+      pushMutation((0, _InsertStatement.createInsertStatementMutation)('after', target, toArray(nodesToInsert).map(n => (0, _detachedNode.asDetachedNode)(n, {
+        useDeepClone: true
+      }))));
+    },
+    insertBeforeStatement: (target, nodesToInsert) => {
+      pushMutation((0, _InsertStatement.createInsertStatementMutation)('before', target, toArray(nodesToInsert).map(n => (0, _detachedNode.asDetachedNode)(n, {
+        useDeepClone: true
+      }))));
+    }
+  };
+  const removeAPIs = {
+    removeNode: node => {
+      pushMutation((0, _RemoveNode.createRemoveNodeMutation)(node));
+    },
+    removeStatement: node => {
+      pushMutation((0, _RemoveStatement.createRemoveStatementMutation)(node));
+    }
+  };
+  const replaceAPIs = {
+    replaceNode: (target, nodeToReplaceWith, options) => {
+      pushMutation((0, _ReplaceNode.createReplaceNodeMutation)(target, (0, _detachedNode.asDetachedNode)(nodeToReplaceWith), options));
+    },
+    replaceStatementWithMany: (target, nodesToReplaceWith, options) => {
+      pushMutation((0, _ReplaceStatementWithMany.createReplaceStatementWithManyMutation)(target, nodesToReplaceWith.map(n => (0, _detachedNode.asDetachedNode)(n)), options));
+    }
+  };
+  const modifyAPIs = {
+    modifyNodeInPlace: (target, newProps) => {
+      const detachedProps = {};
+
+      for (const [key, value] of Object.entries(newProps)) {
+        if ((0, _hermesParser.isNode)(value)) {
+          // $FlowFixMe[incompatible-type]
+          const node = value;
+          detachedProps[key] = (0, _detachedNode.asDetachedNode)(node);
+        } else {
+          detachedProps[key] = value;
+        }
+      }
+
+      pushMutation((0, _ModifyNodeInPlace.createModifyNodeInPlaceMutation)(target, detachedProps));
+    }
+  };
+  return {
+    mutations,
+
+    // $FlowExpectedError[unsafe-getters-setters]
+    get astWasMutated() {
+      return mutations.length > 0;
+    },
+
+    ...cloneAPIs,
+    ...commentAPIs,
+    ...insertAPIs,
+    ...modifyAPIs,
+    ...removeAPIs,
+    ...replaceAPIs
+  };
+}
+
+function toArray(thing) {
+  if (Array.isArray(thing)) {
+    return thing;
+  }
+
+  return [thing];
+}