hermes-transform 0.5.0 → 0.8.0

package/dist/transform/comments/prettier/main/comments.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.

package/dist/transform/comments/prettier/utils/get-last.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -8,8 +8,6 @@
  */
 'use strict';
 
-var getLast = function getLast(arr) {
-  return arr[arr.length - 1];
-};
+const getLast = arr => arr[arr.length - 1];
 
 module.exports = getLast;

package/dist/transform/comments/prettier/utils/get-last.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.

package/dist/transform/getTransformedAST.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -26,9 +26,7 @@ var _TransformContext = require("./TransformContext");
 
 var _comments = require("./comments/comments");
 
-var _AddLeadingComments = require("./mutations/AddLeadingComments");
-
-var _AddTrailingComments = require("./mutations/AddTrailingComments");
+var _AddComments = require("./mutations/AddComments");
 
 var _CloneCommentsTo = require("./mutations/CloneCommentsTo");
 
@@ -36,123 +34,102 @@ 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");
 
-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 getTransformedAST(code, visitors) {
-  var _parseForESLint = (0, _hermesEslint.parseForESLint)(code, {
+  const {
+    ast,
+    scopeManager
+  } = (0, _hermesEslint.parseForESLint)(code, {
     sourceType: 'module'
-  }),
-      ast = _parseForESLint.ast,
-      scopeManager = _parseForESLint.scopeManager; // attach comments before mutation. this will ensure that as nodes are
+  }); // attach comments before mutation. this will ensure that as nodes are
   // cloned / moved around - comments remain in the correct place with respect to the node
 
-
   (0, _comments.attachComments)(ast.comments, ast, code); // traverse the AST and colllect the mutations
 
-  var transformContext = (0, _TransformContext.getTransformContext)();
-  (0, _traverse.traverseWithContext)(ast, scopeManager, function () {
-    return transformContext;
-  }, visitors); // apply the mutations to the AST
-
-  var mutationContext = new _MutationContext.MutationContext(code);
-  var removeCommentMutations = [];
-
-  var _iterator = _createForOfIteratorHelper(transformContext.mutations),
-      _step;
-
-  try {
-    var _loop = function _loop() {
-      var mutation = _step.value;
-
-      var mutationRoot = function () {
-        switch (mutation.type) {
-          case 'insertStatement':
-            {
-              return (0, _InsertStatement.performInsertStatementMutation)(mutationContext, mutation);
-            }
-
-          case 'replaceNode':
-            {
-              return (0, _ReplaceNode.performReplaceNodeMutation)(mutationContext, mutation);
-            }
-
-          case 'replaceStatementWithMany':
-            {
-              return (0, _ReplaceStatementWithMany.performReplaceStatementWithManyMutation)(mutationContext, mutation);
-            }
-
-          case 'removeStatement':
-            {
-              return (0, _RemoveStatement.performRemoveStatementMutation)(mutationContext, mutation);
-            }
-
-          case 'removeComment':
-            {
-              // these are handled later
-              removeCommentMutations.push(mutation);
-              return null;
-            }
-
-          case 'addLeadingComments':
-            {
-              return (0, _AddLeadingComments.performAddLeadingCommentsMutation)(mutationContext, mutation);
-            }
-
-          case 'addTrailingComments':
-            {
-              return (0, _AddTrailingComments.performAddTrailingCommentsMutation)(mutationContext, mutation);
-            }
-
-          case 'cloneCommentsTo':
-            {
-              return (0, _CloneCommentsTo.performCloneCommentsToMutation)(mutationContext, mutation);
-            }
-        }
-      }(); // ensure the subtree's parent pointers are correct
-      // this is required for two reasons:
-      // 1) The userland transform is just JS - so there's nothing stopping them
-      //    from doing anything dodgy. The flow types have some enforcement, but
-      //    ofc that can just be ignored with a suppression.
-      // 2) Shallow clones are a necessary evil in the transform because they
-      //    allow codemods to do simple changes to just one node without the
-      //    weight that comes with deeply cloning the entire AST.
-      //    However we can't update the parent pointers of the cloned node's
-      //    children until the mutation step or else we would be mutating
-      //    real AST nodes and potentially break the traverse step.
-      //
-      // Being strict here just helps us ensure we keep everything in sync
-
-
-      if (mutationRoot) {
-        (0, _detachedNode.updateAllParentPointers)(mutationRoot);
+  const transformContext = (0, _TransformContext.getTransformContext)();
+  (0, _traverse.traverseWithContext)(code, ast, scopeManager, () => transformContext, visitors); // apply the mutations to the AST
+
+  const mutationContext = new _MutationContext.MutationContext(code);
+  const removeCommentMutations = [];
+
+  for (const mutation of transformContext.mutations) {
+    const mutationRoot = (() => {
+      switch (mutation.type) {
+        case 'insertStatement':
+          {
+            return (0, _InsertStatement.performInsertStatementMutation)(mutationContext, mutation);
+          }
+
+        case 'replaceNode':
+          {
+            return (0, _ReplaceNode.performReplaceNodeMutation)(mutationContext, mutation);
+          }
+
+        case 'replaceStatementWithMany':
+          {
+            return (0, _ReplaceStatementWithMany.performReplaceStatementWithManyMutation)(mutationContext, mutation);
+          }
+
+        case 'removeNode':
+          {
+            return (0, _RemoveNode.performRemoveNodeMutation)(mutationContext, mutation);
+          }
+
+        case 'removeStatement':
+          {
+            return (0, _RemoveStatement.performRemoveStatementMutation)(mutationContext, mutation);
+          }
+
+        case 'removeComment':
+          {
+            // these are handled later
+            removeCommentMutations.push(mutation);
+            return null;
+          }
+
+        case 'addComments':
+          {
+            return (0, _AddComments.performAddCommentsMutation)(mutationContext, mutation);
+          }
+
+        case 'cloneCommentsTo':
+          {
+            return (0, _CloneCommentsTo.performCloneCommentsToMutation)(mutationContext, mutation);
+          }
       }
-    };
-
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      _loop();
-    } // remove the comments
-    // this is done at the end because it requires a complete traversal of the AST
-    // so that we can find relevant node's attachment array
+    })(); // ensure the subtree's parent pointers are correct
+    // this is required for two reasons:
+    // 1) The userland transform is just JS - so there's nothing stopping them
+    //    from doing anything dodgy. The flow types have some enforcement, but
+    //    ofc that can just be ignored with a suppression.
+    // 2) Shallow clones are a necessary evil in the transform because they
+    //    allow codemods to do simple changes to just one node without the
+    //    weight that comes with deeply cloning the entire AST.
+    //    However we can't update the parent pointers of the cloned node's
+    //    children until the mutation step or else we would be mutating
+    //    real AST nodes and potentially break the traverse step.
+    //
+    // Being strict here just helps us ensure we keep everything in sync
+
+
+    if (mutationRoot) {
+      (0, _detachedNode.updateAllParentPointers)(mutationRoot);
+    }
+  } // remove the comments
+  // this is done at the end because it requires a complete traversal of the AST
+  // so that we can find relevant node's attachment array
 
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
 
   (0, _RemoveComment.performRemoveCommentMutations)(ast, removeCommentMutations);
   return {
-    ast: ast,
+    ast,
     astWasMutated: transformContext.astWasMutated,
     mutatedCode: mutationContext.code
   };

package/dist/transform/getTransformedAST.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -11,8 +11,7 @@
 'use strict';
 
 import type {ESNode, Program} from 'hermes-estree';
-import type {Visitor} from '../traverse/traverse';
-import type {TransformContext} from './TransformContext';
+import type {TransformVisitor} from './transform';
 import type {RemoveCommentMutation} from './mutations/RemoveComment';
 
 import {parseForESLint} from 'hermes-eslint';
@@ -21,18 +20,18 @@ import {traverseWithContext} from '../traverse/traverse';
 import {MutationContext} from './MutationContext';
 import {getTransformContext} from './TransformContext';
 import {attachComments} from './comments/comments';
-import {performAddLeadingCommentsMutation} from './mutations/AddLeadingComments';
-import {performAddTrailingCommentsMutation} from './mutations/AddTrailingComments';
+import {performAddCommentsMutation} from './mutations/AddComments';
 import {performCloneCommentsToMutation} from './mutations/CloneCommentsTo';
 import {performInsertStatementMutation} from './mutations/InsertStatement';
 import {performRemoveCommentMutations} from './mutations/RemoveComment';
+import {performRemoveNodeMutation} from './mutations/RemoveNode';
 import {performRemoveStatementMutation} from './mutations/RemoveStatement';
 import {performReplaceNodeMutation} from './mutations/ReplaceNode';
 import {performReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
 
 export function getTransformedAST(
   code: string,
-  visitors: Visitor<TransformContext>,
+  visitors: TransformVisitor,
 ): {
   ast: Program,
   astWasMutated: boolean,
@@ -48,7 +47,13 @@ export function getTransformedAST(
 
   // traverse the AST and colllect the mutations
   const transformContext = getTransformContext();
-  traverseWithContext(ast, scopeManager, () => transformContext, visitors);
+  traverseWithContext(
+    code,
+    ast,
+    scopeManager,
+    () => transformContext,
+    visitors,
+  );
 
   // apply the mutations to the AST
   const mutationContext = new MutationContext(code);
@@ -73,6 +78,10 @@ export function getTransformedAST(
           );
         }
 
+        case 'removeNode': {
+          return performRemoveNodeMutation(mutationContext, mutation);
+        }
+
         case 'removeStatement': {
           return performRemoveStatementMutation(mutationContext, mutation);
         }
@@ -83,12 +92,8 @@ export function getTransformedAST(
           return null;
         }
 
-        case 'addLeadingComments': {
-          return performAddLeadingCommentsMutation(mutationContext, mutation);
-        }
-
-        case 'addTrailingComments': {
-          return performAddTrailingCommentsMutation(mutationContext, mutation);
+        case 'addComments': {
+          return performAddCommentsMutation(mutationContext, mutation);
         }
 
         case 'cloneCommentsTo': {

package/dist/transform/mutations/AddComments.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAddCommentsMutation = createAddCommentsMutation;
+exports.performAddCommentsMutation = performAddCommentsMutation;
+
+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
+ */
+function createAddCommentsMutation(node, comments) {
+  if (comments.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'addComments',
+    comments,
+    node
+  };
+}
+
+function performAddCommentsMutation(mutationContext, mutation) {
+  for (const {
+    comment: originalComment,
+    placement
+  } of mutation.comments) {
+    const comment = (0, _comments.cloneComment)(originalComment);
+    mutationContext.appendCommentToSource(comment, placement);
+    (0, _comments.addComment)(mutation.node, comment, placement);
+  }
+
+  return null;
+}

package/dist/transform/mutations/AddComments.js.flow

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type {Comment, ESNode} from 'hermes-estree';
+import type {DetachedNode} from '../../detachedNode';
+import type {MutationContext} from '../MutationContext';
+import type {CommentPlacement} from '../comments/comments';
+
+import {addComment, cloneComment} from '../comments/comments';
+
+export type AddCommentsMutation = $ReadOnly<{
+  type: 'addComments',
+  comments: $ReadOnlyArray<{comment: Comment, placement: CommentPlacement}>,
+  node: ESNode | DetachedNode<ESNode>,
+}>;
+
+export function createAddCommentsMutation(
+  node: AddCommentsMutation['node'],
+  comments: AddCommentsMutation['comments'],
+): ?AddCommentsMutation {
+  if (comments.length === 0) {
+    return null;
+  }
+
+  return {
+    type: 'addComments',
+    comments,
+    node,
+  };
+}
+
+export function performAddCommentsMutation(
+  mutationContext: MutationContext,
+  mutation: AddCommentsMutation,
+): null {
+  for (const {comment: originalComment, placement} of mutation.comments) {
+    const comment = cloneComment(originalComment);
+    mutationContext.appendCommentToSource(comment, placement);
+    addComment(mutation.node, comment, placement);
+  }
+
+  return null;
+}

package/dist/transform/mutations/CloneCommentsTo.js

@@ -8,37 +8,29 @@ exports.performCloneCommentsToMutation = performCloneCommentsToMutation;
 
 var _comments = require("../comments/comments");
 
-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; }
-
+/**
+ * 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 createCloneCommentsToMutation(target, destination) {
   return {
     type: 'cloneCommentsTo',
-    target: target,
-    destination: destination
+    target,
+    destination
   };
 }
 
-function performCloneCommentsToMutation(mutationContext, mutation) {
-  var newComments = [];
-
-  var _iterator = _createForOfIteratorHelper((0, _comments.getCommentsForNode)(mutation.target)),
-      _step;
+function performCloneCommentsToMutation(_mutationContext, mutation) {
+  const newComments = [];
 
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var originalComment = _step.value;
-      var comment = (0, _comments.cloneCommentWithMarkers)(originalComment);
-      mutationContext.appendCommentToSource(comment);
-      newComments.push(comment);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  for (const originalComment of (0, _comments.getCommentsForNode)(mutation.target)) {
+    const comment = (0, _comments.cloneCommentWithMarkers)(originalComment);
+    newComments.push(comment);
   }
 
   (0, _comments.addCommentsToNode)(mutation.destination, newComments);

package/dist/transform/mutations/CloneCommentsTo.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -36,13 +36,12 @@ export function createCloneCommentsToMutation(
 }
 
 export function performCloneCommentsToMutation(
-  mutationContext: MutationContext,
+  _mutationContext: MutationContext,
   mutation: CloneCommentsToMutation,
 ): null {
   const newComments = [];
   for (const originalComment of getCommentsForNode(mutation.target)) {
     const comment = cloneCommentWithMarkers(originalComment);
-    mutationContext.appendCommentToSource(comment);
     newComments.push(comment);
   }
   addCommentsToNode(mutation.destination, newComments);

package/dist/transform/mutations/InsertStatement.js

@@ -1,7 +1,5 @@
 "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
 });
@@ -18,22 +16,19 @@ var _Errors = require("../Errors");
 
 var t = _interopRequireWildcard(require("../../generated/node-types"));
 
-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 _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 _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 _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 _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; }
 
+/**
+ * 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 createInsertStatementMutation(side, target, nodesToInsert) {
   if (nodesToInsert.length === 0) {
     return null;
@@ -41,34 +36,35 @@ function createInsertStatementMutation(side, target, nodesToInsert) {
 
   return {
     type: 'insertStatement',
-    side: side,
-    target: target,
-    nodesToInsert: nodesToInsert
+    side,
+    target,
+    nodesToInsert
   };
 }
 
 function performInsertStatementMutation(mutationContext, mutation) {
-  var insertionParent = (0, _getStatementParent.getStatementParent)(mutation.target); // enforce that if we are inserting module declarations - they are being inserted in a valid location
+  mutationContext.assertNotDeleted(mutation.target, `Attempted to insert ${mutation.side} a deleted ${mutation.target.type} node. This likely means that you attempted to mutate around the target after it was deleted/replaced.`);
+  const insertionParent = (0, _getStatementParent.getStatementParent)(mutation.target); // enforce that if we are inserting module declarations - they are being inserted in a valid location
 
   if (!(0, _isValidModuleDeclarationParent.isValidModuleDeclarationParent)(insertionParent.parent, mutation.nodesToInsert)) {
-    throw new _Errors.InvalidInsertionError("import/export cannot be inserted into a ".concat(insertionParent.parent.type, "."));
+    throw new _Errors.InvalidInsertionError(`import/export cannot be inserted into a ${insertionParent.parent.type}.`);
   }
 
   mutationContext.markMutation(insertionParent.parent, insertionParent.key);
 
   if (insertionParent.type === 'array') {
-    var _parent = insertionParent.parent;
+    const parent = insertionParent.parent;
 
     switch (mutation.side) {
       case 'before':
         {
-          _parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(_parent[insertionParent.key], insertionParent.targetIndex - 1, mutation.nodesToInsert);
+          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex, mutation.nodesToInsert);
           break;
         }
 
       case 'after':
         {
-          _parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(_parent[insertionParent.key], insertionParent.targetIndex + 1, mutation.nodesToInsert);
+          parent[insertionParent.key] = (0, _arrayUtils.insertInArray)(parent[insertionParent.key], insertionParent.targetIndex + 1, mutation.nodesToInsert);
           break;
         }
     }
@@ -76,15 +72,17 @@ function performInsertStatementMutation(mutationContext, mutation) {
     return insertionParent.parent;
   }
 
-  var statementsToInsert = // $FlowExpectedError[incompatible-cast] -- this is enforced by isValidModuleDeclarationParent above
+  const statementsToInsert = // $FlowExpectedError[incompatible-cast] -- this is enforced by isValidModuleDeclarationParent above
   mutation.nodesToInsert;
-  var parent = insertionParent.parent,
-      key = insertionParent.key; // $FlowExpectedError[prop-missing]
+  const {
+    parent,
+    key
+  } = insertionParent; // $FlowExpectedError[prop-missing]
 
-  var statementToWrap = parent[key]; // we need to wrap this key in a BlockStatement so we can insert the new statement
+  const statementToWrap = parent[key]; // we need to wrap this key in a BlockStatement so we can insert the new statement
 
-  var blockStatement = t.BlockStatement({
-    body: mutation.side === 'before' ? [].concat(_toConsumableArray(statementsToInsert), [statementToWrap]) : [statementToWrap].concat(_toConsumableArray(statementsToInsert)),
+  const blockStatement = t.BlockStatement({
+    body: mutation.side === 'before' ? [...statementsToInsert, statementToWrap] : [statementToWrap, ...statementsToInsert],
     parent: insertionParent.parent
   });
   insertionParent.parent[insertionParent.key] = blockStatement;

package/dist/transform/mutations/InsertStatement.js.flow

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -46,6 +46,11 @@ export function performInsertStatementMutation(
   mutationContext: MutationContext,
   mutation: InsertStatementMutation,
 ): ESNode {
+  mutationContext.assertNotDeleted(
+    mutation.target,
+    `Attempted to insert ${mutation.side} a deleted ${mutation.target.type} node. This likely means that you attempted to mutate around the target after it was deleted/replaced.`,
+  );
+
   const insertionParent = getStatementParent(mutation.target);
 
   // enforce that if we are inserting module declarations - they are being inserted in a valid location
@@ -70,7 +75,7 @@ export function performInsertStatementMutation(
       case 'before': {
         parent[insertionParent.key] = insertInArray(
           parent[insertionParent.key],
-          insertionParent.targetIndex - 1,
+          insertionParent.targetIndex,
           mutation.nodesToInsert,
         );
         break;