first commit

node_modules/@vitest/snapshot/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-Present VoidZero Inc. and Vitest contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@vitest/snapshot/README.md

@@ -0,0 +1,84 @@
+# @vitest/snapshot
+
+Lightweight implementation of Jest's snapshots.
+
+## Usage
+
+```js
+import { SnapshotClient } from '@vitest/snapshot'
+import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment'
+import { SnapshotManager } from '@vitest/snapshot/manager'
+
+const client = new SnapshotClient({
+  // you need to provide your own equality check implementation if you use it
+  // this function is called when `.toMatchSnapshot({ property: 1 })` is called
+  isEqual: (received, expected) =>
+    equals(received, expected, [iterableEquality, subsetEquality]),
+})
+
+// class that implements snapshot saving and reading
+// by default uses fs module, but you can provide your own implementation depending on the environment
+const environment = new NodeSnapshotEnvironment()
+
+// you need to implement this yourselves,
+// this depends on your runner
+function getCurrentFilepath() {
+  return '/file.spec.js'
+}
+function getCurrentTestName() {
+  return 'test1'
+}
+
+// example for inline snapshots, nothing is required to support regular snapshots,
+// just call `assert` with `isInline: false`
+function wrapper(received) {
+  function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+    client.assert({
+      received,
+      message,
+      isInline: true,
+      inlineSnapshot,
+      filepath: getCurrentFilepath(),
+      name: getCurrentTestName(),
+    })
+  }
+  return {
+    // the name is hard-coded, it should be inside another function, so Vitest can find the actual test file where it was called (parses call stack trace + 2)
+    // you can override this behaviour in SnapshotState's `_inferInlineSnapshotStack` method by providing your own SnapshotState to SnapshotClient constructor
+    toMatchInlineSnapshot: (...args) => __INLINE_SNAPSHOT__(...args),
+  }
+}
+
+const options = {
+  updateSnapshot: 'new',
+  snapshotEnvironment: environment,
+}
+
+await client.startCurrentRun(
+  getCurrentFilepath(),
+  getCurrentTestName(),
+  options
+)
+
+// this will save snapshot to a file which is returned by "snapshotEnvironment.resolvePath"
+client.assert({
+  received: 'some text',
+  isInline: false,
+})
+
+// uses "pretty-format", so it requires quotes
+// also naming is hard-coded when parsing test files
+wrapper('text 1').toMatchInlineSnapshot()
+wrapper('text 2').toMatchInlineSnapshot('"text 2"')
+
+const result = await client.finishCurrentRun() // this saves files and returns SnapshotResult
+
+// you can use manager to manage several clients
+const manager = new SnapshotManager(options)
+manager.add(result)
+
+// do something
+// and then read the summary
+
+console.log(manager.summary)
+```

node_modules/@vitest/snapshot/dist/environment.d-DHdQ1Csl.d.ts

@@ -0,0 +1,22 @@
+interface ParsedStack {
+	method: string;
+	file: string;
+	line: number;
+	column: number;
+}
+
+interface SnapshotEnvironment {
+	getVersion: () => string;
+	getHeader: () => string;
+	resolvePath: (filepath: string) => Promise<string>;
+	resolveRawPath: (testPath: string, rawPath: string) => Promise<string>;
+	saveSnapshotFile: (filepath: string, snapshot: string) => Promise<void>;
+	readSnapshotFile: (filepath: string) => Promise<string | null>;
+	removeSnapshotFile: (filepath: string) => Promise<void>;
+	processStackTrace?: (stack: ParsedStack) => ParsedStack;
+}
+interface SnapshotEnvironmentOptions {
+	snapshotsDirName?: string;
+}
+
+export type { ParsedStack as P, SnapshotEnvironment as S, SnapshotEnvironmentOptions as a };

node_modules/@vitest/snapshot/dist/environment.d.ts

@@ -0,0 +1,16 @@
+import { S as SnapshotEnvironment, a as SnapshotEnvironmentOptions } from './environment.d-DHdQ1Csl.js';
+
+declare class NodeSnapshotEnvironment implements SnapshotEnvironment {
+	private options;
+	constructor(options?: SnapshotEnvironmentOptions);
+	getVersion(): string;
+	getHeader(): string;
+	resolveRawPath(testPath: string, rawPath: string): Promise<string>;
+	resolvePath(filepath: string): Promise<string>;
+	prepareDirectory(dirPath: string): Promise<void>;
+	saveSnapshotFile(filepath: string, snapshot: string): Promise<void>;
+	readSnapshotFile(filepath: string): Promise<string | null>;
+	removeSnapshotFile(filepath: string): Promise<void>;
+}
+
+export { NodeSnapshotEnvironment, SnapshotEnvironment };

node_modules/@vitest/snapshot/dist/environment.js

@@ -0,0 +1,40 @@
+import { promises, existsSync } from 'node:fs';
+import { resolve, isAbsolute, dirname, join, basename } from 'pathe';
+
+class NodeSnapshotEnvironment {
+	constructor(options = {}) {
+		this.options = options;
+	}
+	getVersion() {
+		return "1";
+	}
+	getHeader() {
+		return `// Snapshot v${this.getVersion()}`;
+	}
+	async resolveRawPath(testPath, rawPath) {
+		return isAbsolute(rawPath) ? rawPath : resolve(dirname(testPath), rawPath);
+	}
+	async resolvePath(filepath) {
+		return join(join(dirname(filepath), this.options.snapshotsDirName ?? "__snapshots__"), `${basename(filepath)}.snap`);
+	}
+	async prepareDirectory(dirPath) {
+		await promises.mkdir(dirPath, { recursive: true });
+	}
+	async saveSnapshotFile(filepath, snapshot) {
+		await promises.mkdir(dirname(filepath), { recursive: true });
+		await promises.writeFile(filepath, snapshot, "utf-8");
+	}
+	async readSnapshotFile(filepath) {
+		if (!existsSync(filepath)) {
+			return null;
+		}
+		return promises.readFile(filepath, "utf-8");
+	}
+	async removeSnapshotFile(filepath) {
+		if (existsSync(filepath)) {
+			await promises.unlink(filepath);
+		}
+	}
+}
+
+export { NodeSnapshotEnvironment };

node_modules/@vitest/snapshot/dist/index.d.ts

@@ -0,0 +1,130 @@
+import { S as SnapshotStateOptions, a as SnapshotMatchOptions, b as SnapshotResult, R as RawSnapshotInfo } from './rawSnapshot.d-lFsMJFUd.js';
+export { c as SnapshotData, d as SnapshotSerializer, e as SnapshotSummary, f as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot.d-lFsMJFUd.js';
+import { S as SnapshotEnvironment, P as ParsedStack } from './environment.d-DHdQ1Csl.js';
+import { Plugin, Plugins } from '@vitest/pretty-format';
+
+/**
+* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+declare class DefaultMap<
+	K,
+	V
+> extends Map<K, V> {
+	private defaultFn;
+	constructor(defaultFn: (key: K) => V, entries?: Iterable<readonly [K, V]>);
+	get(key: K): V;
+}
+declare class CounterMap<K> extends DefaultMap<K, number> {
+	constructor();
+	_total: number | undefined;
+	valueOf(): number;
+	increment(key: K): void;
+	total(): number;
+}
+
+interface SnapshotReturnOptions {
+	actual: string;
+	count: number;
+	expected?: string;
+	key: string;
+	pass: boolean;
+}
+interface SaveStatus {
+	deleted: boolean;
+	saved: boolean;
+}
+declare class SnapshotState {
+	testFilePath: string;
+	snapshotPath: string;
+	private _counters;
+	private _dirty;
+	private _updateSnapshot;
+	private _snapshotData;
+	private _initialData;
+	private _inlineSnapshots;
+	private _inlineSnapshotStacks;
+	private _testIdToKeys;
+	private _rawSnapshots;
+	private _uncheckedKeys;
+	private _snapshotFormat;
+	private _environment;
+	private _fileExists;
+	expand: boolean;
+	private _added;
+	private _matched;
+	private _unmatched;
+	private _updated;
+	get added(): CounterMap<string>;
+	set added(value: number);
+	get matched(): CounterMap<string>;
+	set matched(value: number);
+	get unmatched(): CounterMap<string>;
+	set unmatched(value: number);
+	get updated(): CounterMap<string>;
+	set updated(value: number);
+	private constructor();
+	static create(testFilePath: string, options: SnapshotStateOptions): Promise<SnapshotState>;
+	get environment(): SnapshotEnvironment;
+	markSnapshotsAsCheckedForTest(testName: string): void;
+	clearTest(testId: string): void;
+	protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
+	private _addSnapshot;
+	save(): Promise<SaveStatus>;
+	getUncheckedCount(): number;
+	getUncheckedKeys(): Array<string>;
+	removeUncheckedKeys(): void;
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot }: SnapshotMatchOptions): SnapshotReturnOptions;
+	pack(): Promise<SnapshotResult>;
+}
+
+interface AssertOptions {
+	received: unknown;
+	filepath: string;
+	name: string;
+	/**
+	* Not required but needed for `SnapshotClient.clearTest` to implement test-retry behavior.
+	* @default name
+	*/
+	testId?: string;
+	message?: string;
+	isInline?: boolean;
+	properties?: object;
+	inlineSnapshot?: string;
+	error?: Error;
+	errorMessage?: string;
+	rawSnapshot?: RawSnapshotInfo;
+}
+interface SnapshotClientOptions {
+	isEqual?: (received: unknown, expected: unknown) => boolean;
+}
+declare class SnapshotClient {
+	private options;
+	snapshotStateMap: Map<string, SnapshotState>;
+	constructor(options?: SnapshotClientOptions);
+	setup(filepath: string, options: SnapshotStateOptions): Promise<void>;
+	finish(filepath: string): Promise<SnapshotResult>;
+	skipTest(filepath: string, testName: string): void;
+	clearTest(filepath: string, testId: string): void;
+	getSnapshotState(filepath: string): SnapshotState;
+	assert(options: AssertOptions): void;
+	assertRaw(options: AssertOptions): Promise<void>;
+	clear(): void;
+}
+
+declare function stripSnapshotIndentation(inlineSnapshot: string): string;
+
+/**
+* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+declare function addSerializer(plugin: Plugin): void;
+declare function getSerializers(): Plugins;
+
+export { SnapshotClient, SnapshotEnvironment, SnapshotMatchOptions, SnapshotResult, SnapshotState, SnapshotStateOptions, addSerializer, getSerializers, stripSnapshotIndentation };

node_modules/@vitest/snapshot/dist/manager.d.ts

@@ -0,0 +1,18 @@
+import { S as SnapshotStateOptions, e as SnapshotSummary, b as SnapshotResult } from './rawSnapshot.d-lFsMJFUd.js';
+import '@vitest/pretty-format';
+import './environment.d-DHdQ1Csl.js';
+
+declare class SnapshotManager {
+	options: Omit<SnapshotStateOptions, "snapshotEnvironment">;
+	summary: SnapshotSummary;
+	extension: string;
+	constructor(options: Omit<SnapshotStateOptions, "snapshotEnvironment">);
+	clear(): void;
+	add(result: SnapshotResult): void;
+	resolvePath<T = any>(testPath: string, context?: T): string;
+	resolveRawPath(testPath: string, rawPath: string): string;
+}
+declare function emptySummary(options: Omit<SnapshotStateOptions, "snapshotEnvironment">): SnapshotSummary;
+declare function addSnapshotResult(summary: SnapshotSummary, result: SnapshotResult): void;
+
+export { SnapshotManager, addSnapshotResult, emptySummary };

node_modules/@vitest/snapshot/dist/manager.js

@@ -0,0 +1,73 @@
+import { join, dirname, basename, resolve, isAbsolute } from 'pathe';
+
+class SnapshotManager {
+	summary;
+	extension = ".snap";
+	constructor(options) {
+		this.options = options;
+		this.clear();
+	}
+	clear() {
+		this.summary = emptySummary(this.options);
+	}
+	add(result) {
+		addSnapshotResult(this.summary, result);
+	}
+	resolvePath(testPath, context) {
+		const resolver = this.options.resolveSnapshotPath || (() => {
+			return join(join(dirname(testPath), "__snapshots__"), `${basename(testPath)}${this.extension}`);
+		});
+		const path = resolver(testPath, this.extension, context);
+		return path;
+	}
+	resolveRawPath(testPath, rawPath) {
+		return isAbsolute(rawPath) ? rawPath : resolve(dirname(testPath), rawPath);
+	}
+}
+function emptySummary(options) {
+	const summary = {
+		added: 0,
+		failure: false,
+		filesAdded: 0,
+		filesRemoved: 0,
+		filesRemovedList: [],
+		filesUnmatched: 0,
+		filesUpdated: 0,
+		matched: 0,
+		total: 0,
+		unchecked: 0,
+		uncheckedKeysByFile: [],
+		unmatched: 0,
+		updated: 0,
+		didUpdate: options.updateSnapshot === "all"
+	};
+	return summary;
+}
+function addSnapshotResult(summary, result) {
+	if (result.added) {
+		summary.filesAdded++;
+	}
+	if (result.fileDeleted) {
+		summary.filesRemoved++;
+	}
+	if (result.unmatched) {
+		summary.filesUnmatched++;
+	}
+	if (result.updated) {
+		summary.filesUpdated++;
+	}
+	summary.added += result.added;
+	summary.matched += result.matched;
+	summary.unchecked += result.unchecked;
+	if (result.uncheckedKeys && result.uncheckedKeys.length > 0) {
+		summary.uncheckedKeysByFile.push({
+			filePath: result.filepath,
+			keys: result.uncheckedKeys
+		});
+	}
+	summary.unmatched += result.unmatched;
+	summary.updated += result.updated;
+	summary.total += result.added + result.matched + result.unmatched + result.updated;
+}
+
+export { SnapshotManager, addSnapshotResult, emptySummary };

node_modules/@vitest/snapshot/dist/rawSnapshot.d-lFsMJFUd.d.ts

@@ -0,0 +1,61 @@
+import { OptionsReceived, Plugin } from '@vitest/pretty-format';
+import { S as SnapshotEnvironment } from './environment.d-DHdQ1Csl.js';
+
+type SnapshotData = Record<string, string>;
+type SnapshotUpdateState = "all" | "new" | "none";
+type SnapshotSerializer = Plugin;
+interface SnapshotStateOptions {
+	updateSnapshot: SnapshotUpdateState;
+	snapshotEnvironment: SnapshotEnvironment;
+	expand?: boolean;
+	snapshotFormat?: OptionsReceived;
+	resolveSnapshotPath?: (path: string, extension: string, context?: any) => string;
+}
+interface SnapshotMatchOptions {
+	testId: string;
+	testName: string;
+	received: unknown;
+	key?: string;
+	inlineSnapshot?: string;
+	isInline: boolean;
+	error?: Error;
+	rawSnapshot?: RawSnapshotInfo;
+}
+interface SnapshotResult {
+	filepath: string;
+	added: number;
+	fileDeleted: boolean;
+	matched: number;
+	unchecked: number;
+	uncheckedKeys: Array<string>;
+	unmatched: number;
+	updated: number;
+}
+interface UncheckedSnapshot {
+	filePath: string;
+	keys: Array<string>;
+}
+interface SnapshotSummary {
+	added: number;
+	didUpdate: boolean;
+	failure: boolean;
+	filesAdded: number;
+	filesRemoved: number;
+	filesRemovedList: Array<string>;
+	filesUnmatched: number;
+	filesUpdated: number;
+	matched: number;
+	total: number;
+	unchecked: number;
+	uncheckedKeysByFile: Array<UncheckedSnapshot>;
+	unmatched: number;
+	updated: number;
+}
+
+interface RawSnapshotInfo {
+	file: string;
+	readonly?: boolean;
+	content?: string;
+}
+
+export type { RawSnapshotInfo as R, SnapshotStateOptions as S, UncheckedSnapshot as U, SnapshotMatchOptions as a, SnapshotResult as b, SnapshotData as c, SnapshotSerializer as d, SnapshotSummary as e, SnapshotUpdateState as f };

node_modules/@vitest/snapshot/environment.d.ts

@@ -0,0 +1 @@
+export * from './dist/environment.js'

node_modules/@vitest/snapshot/manager.d.ts

@@ -0,0 +1 @@
+export * from './dist/manager.js'

node_modules/@vitest/snapshot/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@vitest/snapshot",
+  "type": "module",
+  "version": "4.0.15",
+  "description": "Vitest snapshot manager",
+  "license": "MIT",
+  "funding": "https://opencollective.com/vitest",
+  "homepage": "https://github.com/vitest-dev/vitest/tree/main/packages/snapshot#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/snapshot"
+  },
+  "bugs": {
+    "url": "https://github.com/vitest-dev/vitest/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./environment": {
+      "types": "./dist/environment.d.ts",
+      "default": "./dist/environment.js"
+    },
+    "./manager": {
+      "types": "./dist/manager.d.ts",
+      "default": "./dist/manager.js"
+    },
+    "./*": "./*"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "*.d.ts",
+    "dist"
+  ],
+  "dependencies": {
+    "magic-string": "^0.30.21",
+    "pathe": "^2.0.3",
+    "@vitest/pretty-format": "4.0.15"
+  },
+  "devDependencies": {
+    "@types/natural-compare": "^1.4.3",
+    "natural-compare": "^1.4.0",
+    "@vitest/utils": "4.0.15"
+  },
+  "scripts": {
+    "build": "premove dist && rollup -c",
+    "dev": "rollup -c --watch"
+  }
+}