ptoect

node_modules/@vitest/coverage-v8/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { V8CoverageProvider } from './provider.js';
+import 'vitest/coverage';
+import 'vitest';
+import 'vitest/node';
+
+declare const _default: {
+    getProvider(): Promise<V8CoverageProvider>;
+    startCoverage(): void;
+    takeCoverage(): Promise<unknown>;
+    stopCoverage(): void;
+};
+
+export { _default as default };

node_modules/@vitest/coverage-v8/dist/index.js

@@ -0,0 +1,54 @@
+import inspector from 'node:inspector';
+import { provider } from 'std-env';
+
+const session = new inspector.Session();
+function startCoverage() {
+  session.connect();
+  session.post("Profiler.enable");
+  session.post("Profiler.startPreciseCoverage", {
+    callCount: true,
+    detailed: true
+  });
+}
+async function takeCoverage() {
+  return new Promise((resolve, reject) => {
+    session.post("Profiler.takePreciseCoverage", async (error, coverage) => {
+      if (error)
+        return reject(error);
+      const result = coverage.result.filter(filterResult);
+      resolve({ result });
+    });
+    if (provider === "stackblitz")
+      resolve({ result: [] });
+  });
+}
+function stopCoverage() {
+  session.post("Profiler.stopPreciseCoverage");
+  session.post("Profiler.disable");
+  session.disconnect();
+}
+function filterResult(coverage) {
+  if (!coverage.url.startsWith("file://"))
+    return false;
+  if (coverage.url.includes("/node_modules/"))
+    return false;
+  return true;
+}
+
+var coverage = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  startCoverage: startCoverage,
+  stopCoverage: stopCoverage,
+  takeCoverage: takeCoverage
+});
+
+var index = {
+  ...coverage,
+  async getProvider() {
+    const name = "./provider.js";
+    const { V8CoverageProvider } = await import(name);
+    return new V8CoverageProvider();
+  }
+};
+
+export { index as default };

node_modules/@vitest/coverage-v8/dist/provider.d.ts

@@ -0,0 +1,41 @@
+import { BaseCoverageProvider } from 'vitest/coverage';
+import { CoverageProvider, AfterSuiteRunMeta, ReportContext, ResolvedCoverageOptions } from 'vitest';
+import { Vitest } from 'vitest/node';
+
+interface TestExclude {
+    new (opts: {
+        cwd?: string | string[];
+        include?: string | string[];
+        exclude?: string | string[];
+        extension?: string | string[];
+        excludeNodeModules?: boolean;
+        relativePath?: boolean;
+    }): {
+        shouldInstrument: (filePath: string) => boolean;
+        glob: (cwd: string) => Promise<string[]>;
+    };
+}
+type Options = ResolvedCoverageOptions<'v8'>;
+type Filename = string;
+type CoverageFilesByTransformMode = Record<AfterSuiteRunMeta['transformMode'], Filename[]>;
+type ProjectName = NonNullable<AfterSuiteRunMeta['projectName']> | typeof DEFAULT_PROJECT;
+declare const DEFAULT_PROJECT: unique symbol;
+declare class V8CoverageProvider extends BaseCoverageProvider implements CoverageProvider {
+    name: string;
+    ctx: Vitest;
+    options: Options;
+    testExclude: InstanceType<TestExclude>;
+    coverageFiles: Map<ProjectName, CoverageFilesByTransformMode>;
+    coverageFilesDirectory: string;
+    pendingPromises: Promise<void>[];
+    initialize(ctx: Vitest): void;
+    resolveOptions(): Options;
+    clean(clean?: boolean): Promise<void>;
+    onAfterSuiteRun({ coverage, transformMode, projectName }: AfterSuiteRunMeta): void;
+    reportCoverage({ allTestsRun }?: ReportContext): Promise<void>;
+    private getUntestedFiles;
+    private getSources;
+    private convertCoverage;
+}
+
+export { V8CoverageProvider };