@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/@vitest/mocker/auto-register.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/@vitest/mocker/auto-register.js

@@ -0,0 +1,9 @@
+import { M as ModuleMockerServerInterceptor } from './chunk-interceptor-native.js';
+import { registerModuleMocker } from './register.js';
+import './chunk-mocker.js';
+import './index.js';
+import './chunk-registry.js';
+import './chunk-pathe.M-eThtNZ.js';
+import '../spy/index.js';
+
+registerModuleMocker(() => new ModuleMockerServerInterceptor());

package/dist/@vitest/mocker/automock.d.ts

@@ -0,0 +1,12 @@
+import MagicString from '../../vendor/magic-string.mjs';
+
+interface AutomockOptions {
+	/**
+	* @default "__vitest_mocker__"
+	*/
+	globalThisAccessor?: string;
+}
+declare function automockModule(code: string, mockType: "automock" | "autospy", parse: (code: string) => any, options?: AutomockOptions): MagicString;
+
+export { automockModule };
+export type { AutomockOptions };

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

@@ -0,0 +1 @@
+export { a as automockModule } from './chunk-automock.js';

package/dist/@vitest/mocker/browser.d.ts

@@ -0,0 +1,53 @@
+import { M as ModuleMockerInterceptor } from './mocker.d-TnKRhz7N.js';
+export { C as CompilerHintsOptions, b as ModuleMocker, a as ModuleMockerCompilerHints, d as ModuleMockerConfig, e as ModuleMockerRPC, R as ResolveIdResult, f as ResolveMockResult, c as createCompilerHints } from './mocker.d-TnKRhz7N.js';
+import { StartOptions, SetupWorker } from 'msw/browser';
+import { M as MockerRegistry, a as MockedModule } from './types.d-B8CCKmHt.js';
+import '../spy/index.js';
+import './index.d-C-sLYZi-.js';
+
+interface ModuleMockerMSWInterceptorOptions {
+	/**
+	* The identifier to access the globalThis object in the worker.
+	* This will be injected into the script as is, so make sure it's a valid JS expression.
+	* @example
+	* ```js
+	* // globalThisAccessor: '__my_variable__' produces:
+	* globalThis[__my_variable__]
+	* // globalThisAccessor: 'Symbol.for('secret:mocks')' produces:
+	* globalThis[Symbol.for('secret:mocks')]
+	* // globalThisAccessor: '"__vitest_mocker__"' (notice quotes) produces:
+	* globalThis["__vitest_mocker__"]
+	* ```
+	* @default `"__vitest_mocker__"`
+	*/
+	globalThisAccessor?: string;
+	/**
+	* Options passed down to `msw.setupWorker().start(options)`
+	*/
+	mswOptions?: StartOptions;
+	/**
+	* A pre-configured `msw.setupWorker` instance.
+	*/
+	mswWorker?: SetupWorker;
+}
+declare class ModuleMockerMSWInterceptor implements ModuleMockerInterceptor {
+	private readonly options;
+	protected readonly mocks: MockerRegistry;
+	private startPromise;
+	private worker;
+	constructor(options?: ModuleMockerMSWInterceptorOptions);
+	register(module: MockedModule): Promise<void>;
+	delete(url: string): Promise<void>;
+	invalidate(): Promise<void>;
+	private resolveManualMock;
+	protected init(): Promise<SetupWorker>;
+}
+
+declare class ModuleMockerServerInterceptor implements ModuleMockerInterceptor {
+	register(module: MockedModule): Promise<void>;
+	delete(id: string): Promise<void>;
+	invalidate(): Promise<void>;
+}
+
+export { ModuleMockerInterceptor, ModuleMockerMSWInterceptor, ModuleMockerServerInterceptor };
+export type { ModuleMockerMSWInterceptorOptions };

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

@@ -0,0 +1,91 @@
+export { M as ModuleMocker, c as createCompilerHints } from './chunk-mocker.js';
+import { M as MockerRegistry } from './chunk-registry.js';
+import { c as createManualModuleSource, a as cleanUrl } from './chunk-utils.js';
+export { M as ModuleMockerServerInterceptor } from './chunk-interceptor-native.js';
+import './index.js';
+import './chunk-pathe.M-eThtNZ.js';
+
+class ModuleMockerMSWInterceptor {
+  mocks = new MockerRegistry();
+  startPromise;
+  worker;
+  constructor(options = {}) {
+    this.options = options;
+    if (!options.globalThisAccessor) {
+      options.globalThisAccessor = "\"__vitest_mocker__\"";
+    }
+  }
+  async register(module) {
+    await this.init();
+    this.mocks.add(module);
+  }
+  async delete(url) {
+    await this.init();
+    this.mocks.delete(url);
+  }
+  async invalidate() {
+    this.mocks.clear();
+  }
+  async resolveManualMock(mock) {
+    const exports$1 = Object.keys(await mock.resolve());
+    const text = createManualModuleSource(mock.url, exports$1, this.options.globalThisAccessor);
+    return new Response(text, { headers: { "Content-Type": "application/javascript" } });
+  }
+  async init() {
+    if (this.worker) {
+      return this.worker;
+    }
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    const worker = this.options.mswWorker;
+    this.startPromise = Promise.all([worker ? { setupWorker(handler) {
+      worker.use(handler);
+      return worker;
+    } } : import('msw/browser'), import('msw/core/http')]).then(([{ setupWorker }, { http }]) => {
+      const worker = setupWorker(http.get(/.+/, async ({ request }) => {
+        const path = cleanQuery(request.url.slice(location.origin.length));
+        if (!this.mocks.has(path)) {
+          return passthrough();
+        }
+        const mock = this.mocks.get(path);
+        switch (mock.type) {
+          case "manual": return this.resolveManualMock(mock);
+          case "automock":
+          case "autospy": return Response.redirect(injectQuery(path, `mock=${mock.type}`));
+          case "redirect": return Response.redirect(mock.redirect);
+          default: throw new Error(`Unknown mock type: ${mock.type}`);
+        }
+      }));
+      return worker.start(this.options.mswOptions).then(() => worker);
+    }).finally(() => {
+      this.worker = worker;
+      this.startPromise = undefined;
+    });
+    return await this.startPromise;
+  }
+}
+const trailingSeparatorRE = /[?&]$/;
+const timestampRE = /\bt=\d{13}&?\b/;
+const versionRE = /\bv=\w{8}&?\b/;
+function cleanQuery(url) {
+  return url.replace(timestampRE, "").replace(versionRE, "").replace(trailingSeparatorRE, "");
+}
+function passthrough() {
+  return new Response(null, {
+    status: 302,
+    statusText: "Passthrough",
+    headers: { "x-msw-intention": "passthrough" }
+  });
+}
+const replacePercentageRE = /%/g;
+function injectQuery(url, queryToInject) {
+  // encode percents for consistent behavior with pathToFileURL
+  // see #2614 for details
+  const resolvedUrl = new URL(url.replace(replacePercentageRE, "%25"), location.href);
+  const { search, hash } = resolvedUrl;
+  const pathname = cleanUrl(url);
+  return `${pathname}?${queryToInject}${search ? `&${search.slice(1)}` : ""}${hash ?? ""}`;
+}
+
+export { ModuleMockerMSWInterceptor };

package/dist/@vitest/mocker/chunk-automock.js

@@ -0,0 +1,354 @@
+import MagicString from '../../vendor/magic-string.mjs';
+import { walk } from '../../vendor/estree-walker.mjs';
+
+const isNodeInPatternWeakSet = new WeakSet();
+function setIsNodeInPattern(node) {
+  return isNodeInPatternWeakSet.add(node);
+}
+function isNodeInPattern(node) {
+  return isNodeInPatternWeakSet.has(node);
+}
+/**
+* Same logic from \@vue/compiler-core & \@vue/compiler-sfc
+* Except this is using acorn AST
+*/
+function esmWalker(root, { onIdentifier, onImportMeta, onDynamicImport, onCallExpression }) {
+  const parentStack = [];
+  const varKindStack = [];
+  const scopeMap = new WeakMap();
+  const identifiers = [];
+  const setScope = (node, name) => {
+    let scopeIds = scopeMap.get(node);
+    if (scopeIds && scopeIds.has(name)) {
+      return;
+    }
+    if (!scopeIds) {
+      scopeIds = new Set();
+      scopeMap.set(node, scopeIds);
+    }
+    scopeIds.add(name);
+  };
+  function isInScope(name, parents) {
+    return parents.some((node) => {
+      var _scopeMap$get;
+      return node && ((_scopeMap$get = scopeMap.get(node)) === null || _scopeMap$get === void 0 ? void 0 : _scopeMap$get.has(name));
+    });
+  }
+  function handlePattern(p, parentScope) {
+    if (p.type === "Identifier") {
+      setScope(parentScope, p.name);
+    } else if (p.type === "RestElement") {
+      handlePattern(p.argument, parentScope);
+    } else if (p.type === "ObjectPattern") {
+      p.properties.forEach((property) => {
+        if (property.type === "RestElement") {
+          setScope(parentScope, property.argument.name);
+        } else {
+          handlePattern(property.value, parentScope);
+        }
+      });
+    } else if (p.type === "ArrayPattern") {
+      p.elements.forEach((element) => {
+        if (element) {
+          handlePattern(element, parentScope);
+        }
+      });
+    } else if (p.type === "AssignmentPattern") {
+      handlePattern(p.left, parentScope);
+    } else {
+      setScope(parentScope, p.name);
+    }
+  }
+  walk(root, {
+    enter(node, parent) {
+      if (node.type === "ImportDeclaration") {
+        return this.skip();
+      }
+      // track parent stack, skip for "else-if"/"else" branches as acorn nests
+      // the ast within "if" nodes instead of flattening them
+      if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) {
+        parentStack.unshift(parent);
+      }
+      // track variable declaration kind stack used by VariableDeclarator
+      if (node.type === "VariableDeclaration") {
+        varKindStack.unshift(node.kind);
+      }
+      if (node.type === "CallExpression") {
+        onCallExpression === null || onCallExpression === void 0 ? void 0 : onCallExpression(node);
+      }
+      if (node.type === "MetaProperty" && node.meta.name === "import") {
+        onImportMeta === null || onImportMeta === void 0 ? void 0 : onImportMeta(node);
+      } else if (node.type === "ImportExpression") {
+        onDynamicImport === null || onDynamicImport === void 0 ? void 0 : onDynamicImport(node);
+      }
+      if (node.type === "Identifier") {
+        if (!isInScope(node.name, parentStack) && isRefIdentifier(node, parent, parentStack)) {
+          // record the identifier, for DFS -> BFS
+          identifiers.push([node, parentStack.slice(0)]);
+        }
+      } else if (node.type === "ClassDeclaration" && node.id) {
+        // A class declaration name could shadow an import, so add its name to the parent scope
+        const parentScope = findParentScope(parentStack);
+        if (parentScope) {
+          setScope(parentScope, node.id.name);
+        }
+      } else if (node.type === "ClassExpression" && node.id) {
+        // A class expression name could shadow an import, so add its name to the scope
+        setScope(node, node.id.name);
+      } else if (isFunctionNode(node)) {
+        // If it is a function declaration, it could be shadowing an import
+        // Add its name to the scope so it won't get replaced
+        if (node.type === "FunctionDeclaration") {
+          const parentScope = findParentScope(parentStack);
+          if (parentScope) {
+            setScope(parentScope, node.id.name);
+          }
+        }
+        // walk function expressions and add its arguments to known identifiers
+        // so that we don't prefix them
+        node.params.forEach((p) => {
+          if (p.type === "ObjectPattern" || p.type === "ArrayPattern") {
+            handlePattern(p, node);
+            return;
+          }
+          walk(p.type === "AssignmentPattern" ? p.left : p, { enter(child, parent) {
+            // skip params default value of destructure
+            if ((parent === null || parent === void 0 ? void 0 : parent.type) === "AssignmentPattern" && (parent === null || parent === void 0 ? void 0 : parent.right) === child) {
+              return this.skip();
+            }
+            if (child.type !== "Identifier") {
+              return;
+            }
+            // do not record as scope variable if is a destructuring keyword
+            if (isStaticPropertyKey(child, parent)) {
+              return;
+            }
+            // do not record if this is a default value
+            // assignment of a destructuring variable
+            if ((parent === null || parent === void 0 ? void 0 : parent.type) === "TemplateLiteral" && (parent === null || parent === void 0 ? void 0 : parent.expressions.includes(child)) || (parent === null || parent === void 0 ? void 0 : parent.type) === "CallExpression" && (parent === null || parent === void 0 ? void 0 : parent.callee) === child) {
+              return;
+            }
+            setScope(node, child.name);
+          } });
+        });
+      } else if (node.type === "Property" && parent.type === "ObjectPattern") {
+        // mark property in destructuring pattern
+        setIsNodeInPattern(node);
+      } else if (node.type === "VariableDeclarator") {
+        const parentFunction = findParentScope(parentStack, varKindStack[0] === "var");
+        if (parentFunction) {
+          handlePattern(node.id, parentFunction);
+        }
+      } else if (node.type === "CatchClause" && node.param) {
+        handlePattern(node.param, node);
+      }
+    },
+    leave(node, parent) {
+      // untrack parent stack from above
+      if (parent && !(parent.type === "IfStatement" && node === parent.alternate)) {
+        parentStack.shift();
+      }
+      if (node.type === "VariableDeclaration") {
+        varKindStack.shift();
+      }
+    }
+  });
+  // emit the identifier events in BFS so the hoisted declarations
+  // can be captured correctly
+  identifiers.forEach(([node, stack]) => {
+    if (!isInScope(node.name, stack)) {
+      const parent = stack[0];
+      const grandparent = stack[1];
+      const hasBindingShortcut = isStaticProperty(parent) && parent.shorthand && (!isNodeInPattern(parent) || isInDestructuringAssignment(parent, parentStack));
+      const classDeclaration = parent.type === "PropertyDefinition" && (grandparent === null || grandparent === void 0 ? void 0 : grandparent.type) === "ClassBody" || parent.type === "ClassDeclaration" && node === parent.superClass;
+      const classExpression = parent.type === "ClassExpression" && node === parent.id;
+      onIdentifier === null || onIdentifier === void 0 ? void 0 : onIdentifier(node, {
+        hasBindingShortcut,
+        classDeclaration,
+        classExpression
+      }, stack);
+    }
+  });
+}
+function isRefIdentifier(id, parent, parentStack) {
+  // declaration id
+  if (parent.type === "CatchClause" || (parent.type === "VariableDeclarator" || parent.type === "ClassDeclaration") && parent.id === id) {
+    return false;
+  }
+  if (isFunctionNode(parent)) {
+    // function declaration/expression id
+    if (parent.id === id) {
+      return false;
+    }
+    // params list
+    if (parent.params.includes(id)) {
+      return false;
+    }
+  }
+  // class method name
+  if (parent.type === "MethodDefinition" && !parent.computed) {
+    return false;
+  }
+  // property key
+  if (isStaticPropertyKey(id, parent)) {
+    return false;
+  }
+  // object destructuring pattern
+  if (isNodeInPattern(parent) && parent.value === id) {
+    return false;
+  }
+  // non-assignment array destructuring pattern
+  if (parent.type === "ArrayPattern" && !isInDestructuringAssignment(parent, parentStack)) {
+    return false;
+  }
+  // member expression property
+  if (parent.type === "MemberExpression" && parent.property === id && !parent.computed) {
+    return false;
+  }
+  if (parent.type === "ExportSpecifier") {
+    return false;
+  }
+  // is a special keyword but parsed as identifier
+  if (id.name === "arguments") {
+    return false;
+  }
+  return true;
+}
+function isStaticProperty(node) {
+  return node && node.type === "Property" && !node.computed;
+}
+function isStaticPropertyKey(node, parent) {
+  return isStaticProperty(parent) && parent.key === node;
+}
+const functionNodeTypeRE = /Function(?:Expression|Declaration)$|Method$/;
+function isFunctionNode(node) {
+  return functionNodeTypeRE.test(node.type);
+}
+const blockNodeTypeRE = /^BlockStatement$|^For(?:In|Of)?Statement$/;
+function isBlock(node) {
+  return blockNodeTypeRE.test(node.type);
+}
+function findParentScope(parentStack, isVar = false) {
+  return parentStack.find(isVar ? isFunctionNode : isBlock);
+}
+function isInDestructuringAssignment(parent, parentStack) {
+  if (parent && (parent.type === "Property" || parent.type === "ArrayPattern")) {
+    return parentStack.some((i) => i.type === "AssignmentExpression");
+  }
+  return false;
+}
+function getArbitraryModuleIdentifier(node) {
+  return node.type === "Identifier" ? node.name : node.raw;
+}
+
+// TODO: better source map replacement
+function automockModule(code, mockType, parse, options = {}) {
+  const globalThisAccessor = options.globalThisAccessor || "\"__vitest_mocker__\"";
+  const ast = parse(code);
+  const m = new MagicString(code);
+  const allSpecifiers = [];
+  let importIndex = 0;
+  for (const _node of ast.body) {
+    if (_node.type === "ExportAllDeclaration") {
+      throw new Error(`automocking files with \`export *\` is not supported in browser mode because it cannot be statically analysed`);
+    }
+    if (_node.type === "ExportNamedDeclaration") {
+      const node = _node;
+      const declaration = node.declaration;
+      function traversePattern(expression) {
+        // export const test = '1'
+        if (expression.type === "Identifier") {
+          allSpecifiers.push({ name: expression.name });
+        } else if (expression.type === "ArrayPattern") {
+          expression.elements.forEach((element) => {
+            if (!element) {
+              return;
+            }
+            traversePattern(element);
+          });
+        } else if (expression.type === "ObjectPattern") {
+          expression.properties.forEach((property) => {
+            // export const { ...rest } = {}
+            if (property.type === "RestElement") {
+              traversePattern(property);
+            } else if (property.type === "Property") {
+              traversePattern(property.value);
+            } else ;
+          });
+        } else if (expression.type === "RestElement") {
+          traversePattern(expression.argument);
+        } else if (expression.type === "AssignmentPattern") {
+          throw new Error(`AssignmentPattern is not supported. Please open a new bug report.`);
+        } else if (expression.type === "MemberExpression") {
+          throw new Error(`MemberExpression is not supported. Please open a new bug report.`);
+        } else ;
+      }
+      if (declaration) {
+        if (declaration.type === "FunctionDeclaration") {
+          allSpecifiers.push({ name: declaration.id.name });
+        } else if (declaration.type === "VariableDeclaration") {
+          declaration.declarations.forEach((declaration) => {
+            traversePattern(declaration.id);
+          });
+        } else if (declaration.type === "ClassDeclaration") {
+          allSpecifiers.push({ name: declaration.id.name });
+        } else ;
+        m.remove(node.start, declaration.start);
+      }
+      const specifiers = node.specifiers || [];
+      const source = node.source;
+      if (!source && specifiers.length) {
+        specifiers.forEach((specifier) => {
+          allSpecifiers.push({
+            alias: getArbitraryModuleIdentifier(specifier.exported),
+            name: getArbitraryModuleIdentifier(specifier.local)
+          });
+        });
+        m.remove(node.start, node.end);
+      } else if (source && specifiers.length) {
+        const importNames = [];
+        specifiers.forEach((specifier) => {
+          const importedName = `__vitest_imported_${importIndex++}__`;
+          importNames.push([getArbitraryModuleIdentifier(specifier.local), importedName]);
+          allSpecifiers.push({
+            name: importedName,
+            alias: getArbitraryModuleIdentifier(specifier.exported)
+          });
+        });
+        const importString = `import { ${importNames.map(([name, alias]) => `${name} as ${alias}`).join(", ")} } from '${source.value}'`;
+        m.overwrite(node.start, node.end, importString);
+      }
+    }
+    if (_node.type === "ExportDefaultDeclaration") {
+      const node = _node;
+      const declaration = node.declaration;
+      allSpecifiers.push({
+        name: "__vitest_default",
+        alias: "default"
+      });
+      m.overwrite(node.start, declaration.start, `const __vitest_default = `);
+    }
+  }
+  const moduleObject = `
+const __vitest_current_es_module__ = {
+  __esModule: true,
+  ${allSpecifiers.map(({ name }) => `["${name}"]: ${name},`).join("\n  ")}
+}
+const __vitest_mocked_module__ = globalThis[${globalThisAccessor}].mockObject(__vitest_current_es_module__, "${mockType}")
+`;
+  const assigning = allSpecifiers.map(({ name }, index) => {
+    return `const __vitest_mocked_${index}__ = __vitest_mocked_module__["${name}"]`;
+  }).join("\n");
+  const redeclarations = allSpecifiers.map(({ name, alias }, index) => {
+    return `  __vitest_mocked_${index}__ as ${alias || name},`;
+  }).join("\n");
+  const specifiersExports = `
+export {
+${redeclarations}
+}
+`;
+  m.append(moduleObject + assigning + specifiersExports);
+  return m;
+}
+
+export { automockModule as a, esmWalker as e };

package/dist/@vitest/mocker/chunk-interceptor-native.js

@@ -0,0 +1,15 @@
+import { r as rpc } from './chunk-mocker.js';
+
+class ModuleMockerServerInterceptor {
+  async register(module) {
+    await rpc("vitest:interceptor:register", module.toJSON());
+  }
+  async delete(id) {
+    await rpc("vitest:interceptor:delete", id);
+  }
+  async invalidate() {
+    await rpc("vitest:interceptor:invalidate");
+  }
+}
+
+export { ModuleMockerServerInterceptor as M };