{"version":3,"names":["arrowFunctionExpression","assertExpression","assignmentExpression","blockStatement","callExpression","cloneNode","expressionStatement","isAssignmentExpression","isCallExpression","isExpression","isIdentifier","isSequenceExpression","isSuper","thisExpression","insertBefore","nodes_","_assertUnremoved","nodes","_verifyNodeList","parentPath","isExpressionStatement","isLabeledStatement","isExportNamedDeclaration","isExportDefaultDeclaration","isDeclaration","isNodeType","isJSXElement","isForStatement","key","node","push","replaceExpressionWithStatements","Array","isArray","container","_containerInsertBefore","isStatementOrBlock","shouldInsertCurrentNode","expression","replaceWith","unshiftContainer","Error","_containerInsert","from","updateSiblingKeys","length","paths","splice","i","to","path","getSibling","context","queue","pushContext","contexts","_getQueueContexts","setScope","debug","maybeQueue","_containerInsertAfter","last","arr","isHiddenInSequenceExpression","parent","expressions","isAlmostConstantAssignment","scope","left","blockScope","getBlockParent","hasOwnBinding","name","getOwnBinding","constantViolations","insertAfter","get","map","isPattern","unshift","callee","isPure","isMethod","computed","temp","generateDeclaredUidIdentifier","pushContainer","fromIndex","incrementBy","pathCache","msg","type","NodePath","listKey","setContext","verifiedNodes","replaceWithMultiple","hoist","hoister","PathHoister","run"],"sources":["../../src/path/modification.ts"],"sourcesContent":["// This file contains methods that modify the path/node in some ways.\n\nimport { path as pathCache } from \"../cache\";\nimport PathHoister from \"./lib/hoister\";\nimport NodePath from \"./index\";\nimport {\n  arrowFunctionExpression,\n  assertExpression,\n  assignmentExpression,\n  blockStatement,\n  callExpression,\n  cloneNode,\n  expressionStatement,\n  isAssignmentExpression,\n  isCallExpression,\n  isExpression,\n  isIdentifier,\n  isSequenceExpression,\n  isSuper,\n  thisExpression,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type Scope from \"../scope\";\n\n/**\n * Insert the provided nodes before the current one.\n */\n\nexport function insertBefore(\n  this: NodePath,\n  nodes_: t.Node | t.Node[],\n): NodePath[] {\n  this._assertUnremoved();\n\n  const nodes = this._verifyNodeList(nodes_);\n\n  const { parentPath } = this;\n\n  if (\n    parentPath.isExpressionStatement() ||\n    parentPath.isLabeledStatement() ||\n    parentPath.isExportNamedDeclaration() ||\n    (parentPath.isExportDefaultDeclaration() && this.isDeclaration())\n  ) {\n    return parentPath.insertBefore(nodes);\n  } else if (\n    (this.isNodeType(\"Expression\") && !this.isJSXElement()) ||\n    (parentPath.isForStatement() && this.key === \"init\")\n  ) {\n    if (this.node) nodes.push(this.node);\n    // @ts-expect-error todo(flow->ts): check that nodes is an array of statements\n    return this.replaceExpressionWithStatements(nodes);\n  } else if (Array.isArray(this.container)) {\n    return this._containerInsertBefore(nodes);\n  } else if (this.isStatementOrBlock()) {\n    const node = this.node as t.Statement;\n    const shouldInsertCurrentNode =\n      node &&\n      (!this.isExpressionStatement() ||\n        (node as t.ExpressionStatement).expression != null);\n\n    this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));\n    return (this as NodePath<t.BlockStatement>).unshiftContainer(\n      \"body\",\n      // @ts-expect-error Fixme: refine nodes to t.BlockStatement[\"body\"] when this is a BlockStatement path\n      nodes,\n    );\n  } else {\n    throw new Error(\n      \"We don't know what to do with this node type. \" +\n        \"We were previously a Statement but we can't fit in here?\",\n    );\n  }\n}\n\nexport function _containerInsert<N extends t.Node>(\n  this: NodePath,\n  from: number,\n  nodes: N[],\n): NodePath<N>[] {\n  this.updateSiblingKeys(from, nodes.length);\n\n  const paths: NodePath<N>[] = [];\n\n  // @ts-expect-error todo(flow->ts): this.container could be a NodePath\n  this.container.splice(from, 0, ...nodes);\n  for (let i = 0; i < nodes.length; i++) {\n    const to = from + i;\n    const path = this.getSibling(to) as NodePath<N>;\n    paths.push(path);\n\n    if (this.context && this.context.queue) {\n      path.pushContext(this.context);\n    }\n  }\n\n  const contexts = this._getQueueContexts();\n\n  for (const path of paths) {\n    path.setScope();\n    path.debug(\"Inserted.\");\n\n    for (const context of contexts) {\n      context.maybeQueue(path, true);\n    }\n  }\n\n  return paths;\n}\n\nexport function _containerInsertBefore<N extends t.Node>(\n  this: NodePath,\n  nodes: N[],\n) {\n  return this._containerInsert(this.key as number, nodes);\n}\n\nexport function _containerInsertAfter<N extends t.Node>(\n  this: NodePath,\n  nodes: N[],\n) {\n  return this._containerInsert((this.key as number) + 1, nodes);\n}\n\nconst last = <T>(arr: T[]) => arr[arr.length - 1];\n\nfunction isHiddenInSequenceExpression(path: NodePath): boolean {\n  return (\n    isSequenceExpression(path.parent) &&\n    (last(path.parent.expressions) !== path.node ||\n      isHiddenInSequenceExpression(path.parentPath))\n  );\n}\n\nfunction isAlmostConstantAssignment(\n  node: t.Node,\n  scope: Scope,\n): node is t.AssignmentExpression & { left: t.Identifier } {\n  if (!isAssignmentExpression(node) || !isIdentifier(node.left)) {\n    return false;\n  }\n\n  // Not every scope can contain variables. For example, we might be in\n  // a ClassScope either in the ClassHeritage or in a computed key.\n  const blockScope = scope.getBlockParent();\n\n  // If the variable is defined in the current scope and only assigned here,\n  // we can be sure that its value won't change.\n  return (\n    blockScope.hasOwnBinding(node.left.name) &&\n    blockScope.getOwnBinding(node.left.name).constantViolations.length <= 1\n  );\n}\n\n/**\n * Insert the provided nodes after the current one. When inserting nodes after an\n * expression, ensure that the completion record is correct by pushing the current node.\n */\n\nexport function insertAfter(\n  this: NodePath,\n  nodes_: t.Node | t.Node[],\n): NodePath[] {\n  this._assertUnremoved();\n\n  if (this.isSequenceExpression()) {\n    return last(this.get(\"expressions\")).insertAfter(nodes_);\n  }\n\n  const nodes = this._verifyNodeList(nodes_);\n\n  const { parentPath } = this;\n  if (\n    parentPath.isExpressionStatement() ||\n    parentPath.isLabeledStatement() ||\n    parentPath.isExportNamedDeclaration() ||\n    (parentPath.isExportDefaultDeclaration() && this.isDeclaration())\n  ) {\n    return parentPath.insertAfter(\n      nodes.map(node => {\n        // Usually after an expression we can safely insert another expression:\n        //   A.insertAfter(B)\n        //     foo = A;  -> foo = (A, B);\n        // If A is an expression statement, it isn't safe anymore so we need to\n        // convert B to an expression statement\n        //     A;        -> A; B // No semicolon! It could break if followed by [!\n        return isExpression(node) ? expressionStatement(node) : node;\n      }),\n    );\n  } else if (\n    (this.isNodeType(\"Expression\") &&\n      !this.isJSXElement() &&\n      !parentPath.isJSXElement()) ||\n    (parentPath.isForStatement() && this.key === \"init\")\n  ) {\n    if (this.node) {\n      const node = this.node as t.Expression | t.VariableDeclaration;\n      let { scope } = this;\n\n      if (scope.path.isPattern()) {\n        assertExpression(node);\n\n        this.replaceWith(callExpression(arrowFunctionExpression([], node), []));\n        (this.get(\"callee.body\") as NodePath<t.Expression>).insertAfter(nodes);\n        return [this];\n      }\n\n      if (isHiddenInSequenceExpression(this)) {\n        nodes.unshift(node);\n      }\n      // We need to preserve the value of this expression.\n      else if (isCallExpression(node) && isSuper(node.callee)) {\n        nodes.unshift(node);\n        // `super(...)` always evaluates to `this`.\n        nodes.push(thisExpression());\n      } else if (isAlmostConstantAssignment(node, scope)) {\n        nodes.unshift(node);\n        nodes.push(cloneNode(node.left));\n      } else if (scope.isPure(node, true)) {\n        // Insert the nodes before rather than after; it's not observable.\n        nodes.push(node);\n      } else {\n        // Inserting after the computed key of a method should insert the\n        // temporary binding in the method's parent's scope.\n        if (parentPath.isMethod({ computed: true, key: node })) {\n          scope = scope.parent;\n        }\n        const temp = scope.generateDeclaredUidIdentifier();\n        nodes.unshift(\n          expressionStatement(\n            // @ts-expect-error todo(flow->ts): This can be a variable\n            // declaraion in the \"init\" of a for statement, but that's\n            // invalid here.\n            assignmentExpression(\"=\", cloneNode(temp), node),\n          ),\n        );\n        nodes.push(expressionStatement(cloneNode(temp)));\n      }\n    }\n    // @ts-expect-error todo(flow->ts): check that nodes is an array of statements\n    return this.replaceExpressionWithStatements(nodes);\n  } else if (Array.isArray(this.container)) {\n    return this._containerInsertAfter(nodes);\n  } else if (this.isStatementOrBlock()) {\n    const node = this.node as t.Statement;\n    const shouldInsertCurrentNode =\n      node &&\n      (!this.isExpressionStatement() ||\n        (node as t.ExpressionStatement).expression != null);\n\n    this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));\n    // @ts-expect-error Fixme: refine nodes to t.BlockStatement[\"body\"] when this is a BlockStatement path\n    return this.pushContainer(\"body\", nodes);\n  } else {\n    throw new Error(\n      \"We don't know what to do with this node type. \" +\n        \"We were previously a Statement but we can't fit in here?\",\n    );\n  }\n}\n\n/**\n * Update all sibling node paths after `fromIndex` by `incrementBy`.\n */\n\nexport function updateSiblingKeys(\n  this: NodePath,\n  fromIndex: number,\n  incrementBy: number,\n) {\n  if (!this.parent) return;\n\n  const paths = pathCache.get(this.parent);\n  for (const [, path] of paths) {\n    if (path.key >= fromIndex) {\n      path.key += incrementBy;\n    }\n  }\n}\n\nexport function _verifyNodeList<N extends t.Node>(\n  this: NodePath,\n  nodes: N | N[],\n): N[] {\n  if (!nodes) {\n    return [];\n  }\n\n  if (!Array.isArray(nodes)) {\n    nodes = [nodes];\n  }\n\n  for (let i = 0; i < nodes.length; i++) {\n    const node = nodes[i];\n    let msg;\n\n    if (!node) {\n      msg = \"has falsy node\";\n    } else if (typeof node !== \"object\") {\n      msg = \"contains a non-object node\";\n    } else if (!node.type) {\n      msg = \"without a type\";\n    } else if (node instanceof NodePath) {\n      msg = \"has a NodePath when it expected a raw object\";\n    }\n\n    if (msg) {\n      const type = Array.isArray(node) ? \"array\" : typeof node;\n      throw new Error(\n        `Node list ${msg} with the index of ${i} and type of ${type}`,\n      );\n    }\n  }\n\n  return nodes;\n}\n\nexport function unshiftContainer<N extends t.Node, K extends keyof N & string>(\n  this: NodePath<N>,\n  listKey: K,\n  nodes: N[K] extends (infer E)[]\n    ? E | E[]\n    : // todo: refine to t.Node[]\n      //  ? E extends t.Node\n      //    ? E | E[]\n      //    : never\n      never,\n) {\n  // todo: NodePaths<Nodes>\n  this._assertUnremoved();\n\n  // @ts-expect-error fixme\n  nodes = this._verifyNodeList(nodes);\n\n  // get the first path and insert our nodes before it, if it doesn't exist then it\n  // doesn't matter, our nodes will be inserted anyway\n  const path = NodePath.get({\n    parentPath: this,\n    parent: this.node,\n    container: this.node[listKey] as unknown as t.Node | t.Node[],\n    listKey,\n    key: 0,\n  }).setContext(this.context);\n\n  return path._containerInsertBefore(\n    // @ts-expect-error typings needed to narrow down nodes as t.Node[]\n    nodes,\n  );\n}\n\nexport function pushContainer<N extends t.Node, K extends keyof N & string>(\n  this: NodePath<N>,\n  listKey: K,\n  nodes: N[K] extends (infer E)[]\n    ? E | E[]\n    : // todo: refine to t.Node[]\n      //  ? E extends t.Node\n      //    ? E | E[]\n      //    : never\n      never,\n) {\n  this._assertUnremoved();\n\n  const verifiedNodes = this._verifyNodeList(\n    // @ts-expect-error refine typings\n    nodes,\n  );\n\n  // get an invisible path that represents the last node + 1 and replace it with our\n  // nodes, effectively inlining it\n\n  const container = this.node[listKey];\n  const path = NodePath.get({\n    parentPath: this,\n    parent: this.node,\n    container: container as unknown as t.Node | t.Node[],\n    listKey,\n    // @ts-expect-error TS cannot infer that container is t.Node[]\n    key: container.length,\n  }).setContext(this.context);\n\n  return path.replaceWithMultiple(verifiedNodes);\n}\n\n/**\n * Hoist the current node to the highest scope possible and return a UID\n * referencing it.\n */\nexport function hoist<T extends t.Node>(\n  this: NodePath<T>,\n  scope: Scope = this.scope,\n) {\n  const hoister = new PathHoister<T>(this, scope);\n  return hoister.run();\n}\n"],"mappings":"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"}