@voidzero-dev/vite-plus-test 0.1.9 → 0.1.10

package/dist/@vitest/mocker/node.js

@@ -2,6 +2,7 @@ import { a as cleanUrl, c as createManualModuleSource } from './chunk-utils.js';
 import { a as automockModule, e as esmWalker } from './chunk-automock.js';
 import MagicString from '../../vendor/magic-string.mjs';
 import { createFilter } from '@voidzero-dev/vite-plus-core';
+import { h as hoistMocks } from './chunk-hoistMocks.js';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path/posix';
 import { M as MockerRegistry, a as ManualMockedModule } from './chunk-registry.js';
@@ -10,6 +11,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { findMockRedirect } from './redirect.js';
 import { i as isAbsolute, j as join$1, r as resolve } from './chunk-pathe.M-eThtNZ.js';
 import 'node:module';
+import 'node:path';
+import './chunk-helpers.js';
 
 function automockPlugin(options = {}) {
   return {
@@ -49,6 +52,9 @@ function dynamicImportPlugin(options = {}) {
   };
 }
 function injectDynamicImport(code, id, parse, options = {}) {
+  if (code.includes("wrapDynamicImport")) {
+    return;
+  }
   const s = new MagicString(code);
   let ast;
   try {
@@ -80,295 +86,6 @@ function injectDynamicImport(code, id, parse, options = {}) {
   };
 }
 
-// AST walker module for ESTree compatible trees
-
-
-function makeTest(test) {
-  if (typeof test === "string")
-    { return function (type) { return type === test; } }
-  else if (!test)
-    { return function () { return true; } }
-  else
-    { return test }
-}
-
-var Found = function Found(node, state) { this.node = node; this.state = state; };
-
-// Find the innermost node of a given type that contains the given
-// position. Interface similar to findNodeAt.
-function findNodeAround(node, pos, test, baseVisitor, state) {
-  test = makeTest(test);
-  if (!baseVisitor) { baseVisitor = base; }
-  try {
-    (function c(node, st, override) {
-      var type = override || node.type;
-      if (node.start > pos || node.end < pos) { return }
-      baseVisitor[type](node, st, c);
-      if (test(type, node)) { throw new Found(node, st) }
-    })(node, state);
-  } catch (e) {
-    if (e instanceof Found) { return e }
-    throw e
-  }
-}
-
-function skipThrough(node, st, c) { c(node, st); }
-function ignore(_node, _st, _c) {}
-
-// Node walkers.
-
-var base = {};
-
-base.Program = base.BlockStatement = base.StaticBlock = function (node, st, c) {
-  for (var i = 0, list = node.body; i < list.length; i += 1)
-    {
-    var stmt = list[i];
-
-    c(stmt, st, "Statement");
-  }
-};
-base.Statement = skipThrough;
-base.EmptyStatement = ignore;
-base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression =
-  function (node, st, c) { return c(node.expression, st, "Expression"); };
-base.IfStatement = function (node, st, c) {
-  c(node.test, st, "Expression");
-  c(node.consequent, st, "Statement");
-  if (node.alternate) { c(node.alternate, st, "Statement"); }
-};
-base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); };
-base.BreakStatement = base.ContinueStatement = ignore;
-base.WithStatement = function (node, st, c) {
-  c(node.object, st, "Expression");
-  c(node.body, st, "Statement");
-};
-base.SwitchStatement = function (node, st, c) {
-  c(node.discriminant, st, "Expression");
-  for (var i = 0, list = node.cases; i < list.length; i += 1) {
-    var cs = list[i];
-
-    c(cs, st);
-  }
-};
-base.SwitchCase = function (node, st, c) {
-  if (node.test) { c(node.test, st, "Expression"); }
-  for (var i = 0, list = node.consequent; i < list.length; i += 1)
-    {
-    var cons = list[i];
-
-    c(cons, st, "Statement");
-  }
-};
-base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {
-  if (node.argument) { c(node.argument, st, "Expression"); }
-};
-base.ThrowStatement = base.SpreadElement =
-  function (node, st, c) { return c(node.argument, st, "Expression"); };
-base.TryStatement = function (node, st, c) {
-  c(node.block, st, "Statement");
-  if (node.handler) { c(node.handler, st); }
-  if (node.finalizer) { c(node.finalizer, st, "Statement"); }
-};
-base.CatchClause = function (node, st, c) {
-  if (node.param) { c(node.param, st, "Pattern"); }
-  c(node.body, st, "Statement");
-};
-base.WhileStatement = base.DoWhileStatement = function (node, st, c) {
-  c(node.test, st, "Expression");
-  c(node.body, st, "Statement");
-};
-base.ForStatement = function (node, st, c) {
-  if (node.init) { c(node.init, st, "ForInit"); }
-  if (node.test) { c(node.test, st, "Expression"); }
-  if (node.update) { c(node.update, st, "Expression"); }
-  c(node.body, st, "Statement");
-};
-base.ForInStatement = base.ForOfStatement = function (node, st, c) {
-  c(node.left, st, "ForInit");
-  c(node.right, st, "Expression");
-  c(node.body, st, "Statement");
-};
-base.ForInit = function (node, st, c) {
-  if (node.type === "VariableDeclaration") { c(node, st); }
-  else { c(node, st, "Expression"); }
-};
-base.DebuggerStatement = ignore;
-
-base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); };
-base.VariableDeclaration = function (node, st, c) {
-  for (var i = 0, list = node.declarations; i < list.length; i += 1)
-    {
-    var decl = list[i];
-
-    c(decl, st);
-  }
-};
-base.VariableDeclarator = function (node, st, c) {
-  c(node.id, st, "Pattern");
-  if (node.init) { c(node.init, st, "Expression"); }
-};
-
-base.Function = function (node, st, c) {
-  if (node.id) { c(node.id, st, "Pattern"); }
-  for (var i = 0, list = node.params; i < list.length; i += 1)
-    {
-    var param = list[i];
-
-    c(param, st, "Pattern");
-  }
-  c(node.body, st, node.expression ? "Expression" : "Statement");
-};
-
-base.Pattern = function (node, st, c) {
-  if (node.type === "Identifier")
-    { c(node, st, "VariablePattern"); }
-  else if (node.type === "MemberExpression")
-    { c(node, st, "MemberPattern"); }
-  else
-    { c(node, st); }
-};
-base.VariablePattern = ignore;
-base.MemberPattern = skipThrough;
-base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); };
-base.ArrayPattern = function (node, st, c) {
-  for (var i = 0, list = node.elements; i < list.length; i += 1) {
-    var elt = list[i];
-
-    if (elt) { c(elt, st, "Pattern"); }
-  }
-};
-base.ObjectPattern = function (node, st, c) {
-  for (var i = 0, list = node.properties; i < list.length; i += 1) {
-    var prop = list[i];
-
-    if (prop.type === "Property") {
-      if (prop.computed) { c(prop.key, st, "Expression"); }
-      c(prop.value, st, "Pattern");
-    } else if (prop.type === "RestElement") {
-      c(prop.argument, st, "Pattern");
-    }
-  }
-};
-
-base.Expression = skipThrough;
-base.ThisExpression = base.Super = base.MetaProperty = ignore;
-base.ArrayExpression = function (node, st, c) {
-  for (var i = 0, list = node.elements; i < list.length; i += 1) {
-    var elt = list[i];
-
-    if (elt) { c(elt, st, "Expression"); }
-  }
-};
-base.ObjectExpression = function (node, st, c) {
-  for (var i = 0, list = node.properties; i < list.length; i += 1)
-    {
-    var prop = list[i];
-
-    c(prop, st);
-  }
-};
-base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;
-base.SequenceExpression = function (node, st, c) {
-  for (var i = 0, list = node.expressions; i < list.length; i += 1)
-    {
-    var expr = list[i];
-
-    c(expr, st, "Expression");
-  }
-};
-base.TemplateLiteral = function (node, st, c) {
-  for (var i = 0, list = node.quasis; i < list.length; i += 1)
-    {
-    var quasi = list[i];
-
-    c(quasi, st);
-  }
-
-  for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1)
-    {
-    var expr = list$1[i$1];
-
-    c(expr, st, "Expression");
-  }
-};
-base.TemplateElement = ignore;
-base.UnaryExpression = base.UpdateExpression = function (node, st, c) {
-  c(node.argument, st, "Expression");
-};
-base.BinaryExpression = base.LogicalExpression = function (node, st, c) {
-  c(node.left, st, "Expression");
-  c(node.right, st, "Expression");
-};
-base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {
-  c(node.left, st, "Pattern");
-  c(node.right, st, "Expression");
-};
-base.ConditionalExpression = function (node, st, c) {
-  c(node.test, st, "Expression");
-  c(node.consequent, st, "Expression");
-  c(node.alternate, st, "Expression");
-};
-base.NewExpression = base.CallExpression = function (node, st, c) {
-  c(node.callee, st, "Expression");
-  if (node.arguments)
-    { for (var i = 0, list = node.arguments; i < list.length; i += 1)
-      {
-        var arg = list[i];
-
-        c(arg, st, "Expression");
-      } }
-};
-base.MemberExpression = function (node, st, c) {
-  c(node.object, st, "Expression");
-  if (node.computed) { c(node.property, st, "Expression"); }
-};
-base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {
-  if (node.declaration)
-    { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); }
-  if (node.source) { c(node.source, st, "Expression"); }
-};
-base.ExportAllDeclaration = function (node, st, c) {
-  if (node.exported)
-    { c(node.exported, st); }
-  c(node.source, st, "Expression");
-};
-base.ImportDeclaration = function (node, st, c) {
-  for (var i = 0, list = node.specifiers; i < list.length; i += 1)
-    {
-    var spec = list[i];
-
-    c(spec, st);
-  }
-  c(node.source, st, "Expression");
-};
-base.ImportExpression = function (node, st, c) {
-  c(node.source, st, "Expression");
-};
-base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore;
-
-base.TaggedTemplateExpression = function (node, st, c) {
-  c(node.tag, st, "Expression");
-  c(node.quasi, st, "Expression");
-};
-base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); };
-base.Class = function (node, st, c) {
-  if (node.id) { c(node.id, st, "Pattern"); }
-  if (node.superClass) { c(node.superClass, st, "Expression"); }
-  c(node.body, st);
-};
-base.ClassBody = function (node, st, c) {
-  for (var i = 0, list = node.body; i < list.length; i += 1)
-    {
-    var elt = list[i];
-
-    c(elt, st);
-  }
-};
-base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) {
-  if (node.computed) { c(node.key, st, "Expression"); }
-  if (node.value) { c(node.value, st, "Expression"); }
-};
-
 function hoistMocksPlugin(options = {}) {
   const filter = options.filter || createFilter(options.include, options.exclude);
   const { hoistableMockMethodNames = ["mock", "unmock"], dynamicImportMockMethodNames = [
@@ -390,7 +107,7 @@ function hoistMocksPlugin(options = {}) {
       if (!filter(id)) {
         return;
       }
-      return hoistMocks(code, id, this.parse, {
+      const s = hoistMocks(code, id, this.parse, {
         regexpHoistable,
         hoistableMockMethodNames,
         hoistedMethodNames,
@@ -398,304 +115,30 @@ function hoistMocksPlugin(options = {}) {
         dynamicImportMockMethodNames,
         ...options
       });
+      if (s) {
+        return {
+          code: s.toString(),
+          map: s.generateMap({
+            hires: "boundary",
+            source: cleanUrl(id)
+          })
+        };
+      }
     }
   };
 }
-const API_NOT_FOUND_ERROR = `There are some problems in resolving the mocks API.
-You may encounter this issue when importing the mocks API from another module other than 'vitest'.
-To fix this issue you can either:
-- import the mocks API directly from 'vitest'
-- enable the 'globals' options`;
-function API_NOT_FOUND_CHECK(names) {
-  return `\nif (${names.map((name) => `typeof globalThis["${name}"] === "undefined"`).join(" && ")}) ` + `{ throw new Error(${JSON.stringify(API_NOT_FOUND_ERROR)}) }\n`;
-}
-function isIdentifier(node) {
-  return node.type === "Identifier";
-}
-function getNodeTail(code, node) {
-  let end = node.end;
-  if (code[node.end] === ";") {
-    end += 1;
-  }
-  if (code[node.end] === "\n") {
-    return end + 1;
-  }
-  if (code[node.end + 1] === "\n") {
-    end += 1;
-  }
-  return end;
-}
-const regexpHoistable = /\b(?:vi|vitest)\s*\.\s*(?:mock|unmock|hoisted|doMock|doUnmock)\s*\(/;
-const hashbangRE = /^#!.*\n/;
-// this is a fork of Vite SSR transform
-function hoistMocks(code, id, parse, options = {}) {
-  var _hashbangRE$exec;
-  const needHoisting = (options.regexpHoistable || regexpHoistable).test(code);
-  if (!needHoisting) {
-    return;
-  }
-  const s = new MagicString(code);
-  let ast;
-  try {
-    ast = parse(code);
-  } catch (err) {
-    console.error(`Cannot parse ${id}:\n${err.message}.`);
-    return;
-  }
-  const { hoistableMockMethodNames = ["mock", "unmock"], dynamicImportMockMethodNames = [
-    "mock",
-    "unmock",
-    "doMock",
-    "doUnmock"
-  ], hoistedMethodNames = ["hoisted"], utilsObjectNames = ["vi", "vitest"], hoistedModule = "vitest" } = options;
-  // hoist at the start of the file, after the hashbang
-  let hoistIndex = ((_hashbangRE$exec = hashbangRE.exec(code)) === null || _hashbangRE$exec === void 0 ? void 0 : _hashbangRE$exec[0].length) ?? 0;
-  let hoistedModuleImported = false;
-  let uid = 0;
-  const idToImportMap = new Map();
-  const imports = [];
-  // this will transform import statements into dynamic ones, if there are imports
-  // it will keep the import as is, if we don't need to mock anything
-  // in browser environment it will wrap the module value with "vitest_wrap_module" function
-  // that returns a proxy to the module so that named exports can be mocked
-  function defineImport(importNode) {
-    const source = importNode.source.value;
-    // always hoist vitest import to top of the file, so
-    // "vi" helpers can access it
-    if (hoistedModule === source || source === "vite-plus/test" || source === "@voidzero-dev/vite-plus-test") {
-      hoistedModuleImported = true;
-      return;
-    }
-    const importId = `__vi_import_${uid++}__`;
-    imports.push({
-      id: importId,
-      node: importNode
-    });
-    return importId;
-  }
-  // 1. check all import statements and record id -> importName map
-  for (const node of ast.body) {
-    // import foo from 'foo' --> foo -> __import_foo__.default
-    // import { baz } from 'foo' --> baz -> __import_foo__.baz
-    // import * as ok from 'foo' --> ok -> __import_foo__
-    if (node.type === "ImportDeclaration") {
-      const importId = defineImport(node);
-      if (!importId) {
-        continue;
-      }
-      for (const spec of node.specifiers) {
-        if (spec.type === "ImportSpecifier") {
-          if (spec.imported.type === "Identifier") {
-            idToImportMap.set(spec.local.name, `${importId}.${spec.imported.name}`);
-          } else {
-            idToImportMap.set(spec.local.name, `${importId}[${JSON.stringify(spec.imported.value)}]`);
-          }
-        } else if (spec.type === "ImportDefaultSpecifier") {
-          idToImportMap.set(spec.local.name, `${importId}.default`);
-        } else {
-          // namespace specifier
-          idToImportMap.set(spec.local.name, importId);
-        }
-      }
-    }
-  }
-  const declaredConst = new Set();
-  const hoistedNodes = [];
-  function createSyntaxError(node, message) {
-    const _error = new SyntaxError(message);
-    Error.captureStackTrace(_error, createSyntaxError);
-    const serializedError = {
-      name: "SyntaxError",
-      message: _error.message,
-      stack: _error.stack
+// to keeb backwards compat
+function hoistMockAndResolve(code, id, parse, options = {}) {
+  const s = hoistMocks(code, id, parse, options);
+  if (s) {
+    return {
+      code: s.toString(),
+      map: s.generateMap({
+        hires: "boundary",
+        source: cleanUrl(id)
+      })
     };
-    if (options.codeFrameGenerator) {
-      serializedError.frame = options.codeFrameGenerator(node, id, code);
-    }
-    return serializedError;
-  }
-  function assertNotDefaultExport(node, error) {
-    var _findNodeAround;
-    const defaultExport = (_findNodeAround = findNodeAround(ast, node.start, "ExportDefaultDeclaration")) === null || _findNodeAround === void 0 ? void 0 : _findNodeAround.node;
-    if ((defaultExport === null || defaultExport === void 0 ? void 0 : defaultExport.declaration) === node || (defaultExport === null || defaultExport === void 0 ? void 0 : defaultExport.declaration.type) === "AwaitExpression" && defaultExport.declaration.argument === node) {
-      throw createSyntaxError(defaultExport, error);
-    }
-  }
-  function assertNotNamedExport(node, error) {
-    var _findNodeAround2;
-    const nodeExported = (_findNodeAround2 = findNodeAround(ast, node.start, "ExportNamedDeclaration")) === null || _findNodeAround2 === void 0 ? void 0 : _findNodeAround2.node;
-    if ((nodeExported === null || nodeExported === void 0 ? void 0 : nodeExported.declaration) === node) {
-      throw createSyntaxError(nodeExported, error);
-    }
-  }
-  function getVariableDeclaration(node) {
-    var _findNodeAround3, _declarationNode$decl;
-    const declarationNode = (_findNodeAround3 = findNodeAround(ast, node.start, "VariableDeclaration")) === null || _findNodeAround3 === void 0 ? void 0 : _findNodeAround3.node;
-    const init = declarationNode === null || declarationNode === void 0 || (_declarationNode$decl = declarationNode.declarations[0]) === null || _declarationNode$decl === void 0 ? void 0 : _declarationNode$decl.init;
-    if (init && (init === node || init.type === "AwaitExpression" && init.argument === node)) {
-      return declarationNode;
-    }
-  }
-  const usedUtilityExports = new Set();
-  esmWalker(ast, {
-    onIdentifier(id, info, parentStack) {
-      const binding = idToImportMap.get(id.name);
-      if (!binding) {
-        return;
-      }
-      if (info.hasBindingShortcut) {
-        s.appendLeft(id.end, `: ${binding}`);
-      } else if (info.classDeclaration) {
-        if (!declaredConst.has(id.name)) {
-          declaredConst.add(id.name);
-          // locate the top-most node containing the class declaration
-          const topNode = parentStack[parentStack.length - 2];
-          s.prependRight(topNode.start, `const ${id.name} = ${binding};\n`);
-        }
-      } else if (!info.classExpression) {
-        s.update(id.start, id.end, binding);
-      }
-    },
-    onCallExpression(node) {
-      if (node.callee.type === "MemberExpression" && isIdentifier(node.callee.object) && utilsObjectNames.includes(node.callee.object.name) && isIdentifier(node.callee.property)) {
-        const methodName = node.callee.property.name;
-        usedUtilityExports.add(node.callee.object.name);
-        if (hoistableMockMethodNames.includes(methodName)) {
-          const method = `${node.callee.object.name}.${methodName}`;
-          assertNotDefaultExport(node, `Cannot export the result of "${method}". Remove export declaration because "${method}" doesn\'t return anything.`);
-          const declarationNode = getVariableDeclaration(node);
-          if (declarationNode) {
-            assertNotNamedExport(declarationNode, `Cannot export the result of "${method}". Remove export declaration because "${method}" doesn\'t return anything.`);
-          }
-          // rewrite vi.mock(import('..')) into vi.mock('..')
-          if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && dynamicImportMockMethodNames.includes(node.callee.property.name)) {
-            const moduleInfo = node.arguments[0];
-            // vi.mock(import('./path')) -> vi.mock('./path')
-            if (moduleInfo.type === "ImportExpression") {
-              const source = moduleInfo.source;
-              s.overwrite(moduleInfo.start, moduleInfo.end, s.slice(source.start, source.end));
-            }
-            // vi.mock(await import('./path')) -> vi.mock('./path')
-            if (moduleInfo.type === "AwaitExpression" && moduleInfo.argument.type === "ImportExpression") {
-              const source = moduleInfo.argument.source;
-              s.overwrite(moduleInfo.start, moduleInfo.end, s.slice(source.start, source.end));
-            }
-          }
-          hoistedNodes.push(node);
-        } else if (dynamicImportMockMethodNames.includes(methodName)) {
-          const moduleInfo = node.arguments[0];
-          let source = null;
-          if (moduleInfo.type === "ImportExpression") {
-            source = moduleInfo.source;
-          }
-          if (moduleInfo.type === "AwaitExpression" && moduleInfo.argument.type === "ImportExpression") {
-            source = moduleInfo.argument.source;
-          }
-          if (source) {
-            s.overwrite(moduleInfo.start, moduleInfo.end, s.slice(source.start, source.end));
-          }
-        }
-        if (hoistedMethodNames.includes(methodName)) {
-          assertNotDefaultExport(node, "Cannot export hoisted variable. You can control hoisting behavior by placing the import from this file first.");
-          const declarationNode = getVariableDeclaration(node);
-          if (declarationNode) {
-            assertNotNamedExport(declarationNode, "Cannot export hoisted variable. You can control hoisting behavior by placing the import from this file first.");
-            // hoist "const variable = vi.hoisted(() => {})"
-            hoistedNodes.push(declarationNode);
-          } else {
-            var _findNodeAround4;
-            const awaitedExpression = (_findNodeAround4 = findNodeAround(ast, node.start, "AwaitExpression")) === null || _findNodeAround4 === void 0 ? void 0 : _findNodeAround4.node;
-            // hoist "await vi.hoisted(async () => {})" or "vi.hoisted(() => {})"
-            const moveNode = (awaitedExpression === null || awaitedExpression === void 0 ? void 0 : awaitedExpression.argument) === node ? awaitedExpression : node;
-            hoistedNodes.push(moveNode);
-          }
-        }
-      }
-    }
-  });
-  function getNodeName(node) {
-    const callee = node.callee || {};
-    if (callee.type === "MemberExpression" && isIdentifier(callee.property) && isIdentifier(callee.object)) {
-      return `${callee.object.name}.${callee.property.name}()`;
-    }
-    return "\"hoisted method\"";
-  }
-  function getNodeCall(node) {
-    if (node.type === "CallExpression") {
-      return node;
-    }
-    if (node.type === "VariableDeclaration") {
-      const { declarations } = node;
-      const init = declarations[0].init;
-      if (init) {
-        return getNodeCall(init);
-      }
-    }
-    if (node.type === "AwaitExpression") {
-      const { argument } = node;
-      if (argument.type === "CallExpression") {
-        return getNodeCall(argument);
-      }
-    }
-    return node;
-  }
-  function createError(outsideNode, insideNode) {
-    const outsideCall = getNodeCall(outsideNode);
-    const insideCall = getNodeCall(insideNode);
-    throw createSyntaxError(insideCall, `Cannot call ${getNodeName(insideCall)} inside ${getNodeName(outsideCall)}: both methods are hoisted to the top of the file and not actually called inside each other.`);
   }
-  // validate hoistedNodes doesn't have nodes inside other nodes
-  for (let i = 0; i < hoistedNodes.length; i++) {
-    const node = hoistedNodes[i];
-    for (let j = i + 1; j < hoistedNodes.length; j++) {
-      const otherNode = hoistedNodes[j];
-      if (node.start >= otherNode.start && node.end <= otherNode.end) {
-        throw createError(otherNode, node);
-      }
-      if (otherNode.start >= node.start && otherNode.end <= node.end) {
-        throw createError(node, otherNode);
-      }
-    }
-  }
-  // hoist vi.mock/vi.hoisted
-  for (const node of hoistedNodes) {
-    const end = getNodeTail(code, node);
-    // don't hoist into itself if it's already at the top
-    if (hoistIndex === end || hoistIndex === node.start) {
-      hoistIndex = end;
-    } else {
-      s.move(node.start, end, hoistIndex);
-    }
-  }
-  // hoist actual dynamic imports last so they are inserted after all hoisted mocks
-  for (const { node: importNode, id: importId } of imports) {
-    const source = importNode.source.value;
-    s.update(importNode.start, importNode.end, `const ${importId} = await import(${JSON.stringify(source)});\n`);
-    if (importNode.start === hoistIndex) {
-      // no need to hoist, but update hoistIndex to keep the order
-      hoistIndex = importNode.end;
-    } else {
-      // There will be an error if the module is called before it is imported,
-      // so the module import statement is hoisted to the top
-      s.move(importNode.start, importNode.end, hoistIndex);
-    }
-  }
-  if (!hoistedModuleImported && hoistedNodes.length) {
-    const utilityImports = [...usedUtilityExports];
-    // "vi" or "vitest" is imported from a module other than "vitest"
-    if (utilityImports.some((name) => idToImportMap.has(name))) {
-      s.prepend(API_NOT_FOUND_CHECK(utilityImports));
-    } else if (utilityImports.length) {
-      s.prepend(`import { ${[...usedUtilityExports].join(", ")} } from ${JSON.stringify(hoistedModule)}\n`);
-    }
-  }
-  return {
-    code: s.toString(),
-    map: s.generateMap({
-      hires: "boundary",
-      source: id
-    })
-  };
 }
 
 function interceptorPlugin(options = {}) {
@@ -793,9 +236,8 @@ class ServerMockResolver {
     const { id, fsPath, external } = await this.resolveMockId(rawId, importer);
     const resolvedUrl = this.normalizeResolveIdToUrl({ id }).url;
     if (options.mock === "factory") {
-      var _manifest$fsPath;
       const manifest = getViteDepsManifest(this.server.config);
-      const needsInterop = (manifest === null || manifest === void 0 || (_manifest$fsPath = manifest[fsPath]) === null || _manifest$fsPath === void 0 ? void 0 : _manifest$fsPath.needsInterop) ?? false;
+      const needsInterop = manifest?.[fsPath]?.needsInterop ?? false;
       return {
         mockType: "manual",
         resolvedId: id,
@@ -864,7 +306,7 @@ class ServerMockResolver {
     return this.resolveModule(rawId, resolved);
   }
   resolveModule(rawId, resolved) {
-    const id = (resolved === null || resolved === void 0 ? void 0 : resolved.id) || rawId;
+    const id = resolved?.id || rawId;
     const external = !isAbsolute(id) || isModuleDirectory(this.options, id) ? rawId : null;
     return {
       id,
@@ -963,4 +405,4 @@ function mockerPlugin(options = {}) {
   ];
 }
 
-export { ServerMockResolver, automockModule, automockPlugin, createManualModuleSource, dynamicImportPlugin, findMockRedirect, hoistMocks, hoistMocksPlugin, interceptorPlugin, mockerPlugin };
+export { ServerMockResolver, automockModule, automockPlugin, createManualModuleSource, dynamicImportPlugin, findMockRedirect, hoistMockAndResolve as hoistMocks, hoistMocksPlugin, interceptorPlugin, mockerPlugin };