UEA-Prodem

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,88 @@
+# @vitest/snapshot
+
+[![NPM version](https://img.shields.io/npm/v/@vitest/snapshot?color=a1b858&label=)](https://npmx.dev/package/@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)
+```
+
+[GitHub](https://github.com/vitest-dev/vitest/tree/main/packages/snapshot) | [Documentation](https://vitest.dev/guide/snapshot)

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

@@ -0,0 +1,17 @@
+import { ParsedStack } from '@vitest/utils';
+
+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 { SnapshotEnvironment as S, SnapshotEnvironmentOptions as a };

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

@@ -0,0 +1,17 @@
+import { S as SnapshotEnvironment, a as SnapshotEnvironmentOptions } from './environment.d-DOJxxZV9.js';
+import '@vitest/utils';
+
+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 { isAbsolute, resolve, 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,74 @@
+import { S as SnapshotState, a as SnapshotStateOptions, b as SnapshotResult, R as RawSnapshotInfo, D as DomainSnapshotAdapter } from './rawSnapshot.d-D_X3-62x.js';
+export { c as DomainMatchResult, d as SnapshotData, e as SnapshotMatchOptions, f as SnapshotSerializer, g as SnapshotSummary, h as SnapshotUpdateState, U as UncheckedSnapshot } from './rawSnapshot.d-D_X3-62x.js';
+import { Plugin, Plugins } from '@vitest/pretty-format';
+export { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
+import '@vitest/utils';
+
+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;
+	assertionName?: string;
+}
+interface AssertDomainOptions extends Omit<AssertOptions, "received"> {
+	received: unknown;
+	adapter: DomainSnapshotAdapter<any, any>;
+}
+interface AssertDomainPollOptions extends Omit<AssertDomainOptions, "received"> {
+	poll: () => Promise<unknown> | unknown;
+	timeout?: number;
+	interval?: number;
+}
+/** Same shape as expect.extend custom matcher result (SyncExpectationResult from @vitest/expect) */
+interface MatchResult {
+	pass: boolean;
+	message: () => string;
+	actual?: unknown;
+	expected?: unknown;
+}
+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;
+	match(options: AssertOptions): MatchResult;
+	assert(options: AssertOptions): void;
+	matchDomain(options: AssertDomainOptions): MatchResult;
+	pollMatchDomain(options: AssertDomainPollOptions): Promise<MatchResult>;
+	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 { DomainSnapshotAdapter, SnapshotClient, SnapshotResult, SnapshotState, SnapshotStateOptions, addSerializer, getSerializers, stripSnapshotIndentation };
+export type { MatchResult };

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

@@ -0,0 +1,19 @@
+import { a as SnapshotStateOptions, g as SnapshotSummary, b as SnapshotResult } from './rawSnapshot.d-D_X3-62x.js';
+import '@vitest/pretty-format';
+import '@vitest/utils';
+import './environment.d-DOJxxZV9.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, isAbsolute, resolve } 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-D_X3-62x.d.ts

@@ -0,0 +1,205 @@
+import { OptionsReceived, Plugin } from '@vitest/pretty-format';
+import { ParsedStack } from '@vitest/utils';
+import { S as SnapshotEnvironment } from './environment.d-DOJxxZV9.js';
+
+interface DomainMatchResult {
+	pass: boolean;
+	message?: string;
+	/**
+	* The captured value viewed through the template's lens.
+	*
+	* Where the template uses patterns (e.g. regexes) or omits details,
+	* the resolved string adopts those patterns. Where the template doesn't
+	* match, the resolved string uses literal captured values instead.
+	*
+	* Used for two purposes:
+	* - **Diff display** (actual side): compared against `expected`
+	*   so the diff highlights only genuine mismatches, not pattern-vs-literal noise.
+	* - **Snapshot update** (`--update`): written as the new snapshot content,
+	*   preserving user-edited patterns from matched regions while incorporating
+	*   actual values for mismatched regions.
+	*
+	* When omitted, falls back to `render(capture(received))` (the raw rendered value).
+	*/
+	resolved?: string;
+	/**
+	* The stored template re-rendered as a string, representing what the user
+	* originally wrote or last saved.
+	*
+	* Used as the expected side in diff display.
+	*
+	* When omitted, falls back to the raw snapshot string from the snap file
+	* or inline snapshot.
+	*/
+	expected?: string;
+}
+interface DomainSnapshotAdapter<
+	Captured = unknown,
+	Expected = unknown
+> {
+	name: string;
+	capture: (received: unknown) => Captured;
+	render: (captured: Captured) => string;
+	parseExpected: (input: string) => Expected;
+	match: (captured: Captured, expected: Expected) => DomainMatchResult;
+}
+
+/**
+* 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;
+}
+interface ExpectedSnapshot {
+	key: string;
+	count: number;
+	data?: string;
+	markAsChecked: () => void;
+}
+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 snapshotUpdateState(): SnapshotUpdateState;
+	get environment(): SnapshotEnvironment;
+	markSnapshotsAsCheckedForTest(testName: string): void;
+	clearTest(testId: string): void;
+	protected _inferInlineSnapshotStack(stacks: ParsedStack[]): ParsedStack | null;
+	private _addSnapshot;
+	private _resolveKey;
+	private _resolveInlineStack;
+	private _reconcile;
+	save(): Promise<SaveStatus>;
+	getUncheckedCount(): number;
+	getUncheckedKeys(): Array<string>;
+	removeUncheckedKeys(): void;
+	probeExpectedSnapshot(options: Pick<SnapshotMatchOptions, "testName" | "testId" | "isInline" | "inlineSnapshot">): ExpectedSnapshot;
+	match({ testId, testName, received, key, inlineSnapshot, isInline, error, rawSnapshot, assertionName }: SnapshotMatchOptions): SnapshotReturnOptions;
+	processDomainSnapshot({ testId, received, expectedSnapshot, matchResult, isInline, error, assertionName }: ProcessDomainSnapshotOptions): SnapshotReturnOptions;
+	pack(): Promise<SnapshotResult>;
+}
+
+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;
+	assertionName?: string;
+}
+interface ProcessDomainSnapshotOptions {
+	testId: string;
+	received: string;
+	expectedSnapshot: ExpectedSnapshot;
+	matchResult?: DomainMatchResult;
+	isInline?: boolean;
+	assertionName?: string;
+	error?: Error;
+}
+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 { SnapshotState as S };
+export type { DomainSnapshotAdapter as D, RawSnapshotInfo as R, UncheckedSnapshot as U, SnapshotStateOptions as a, SnapshotResult as b, DomainMatchResult as c, SnapshotData as d, SnapshotMatchOptions as e, SnapshotSerializer as f, SnapshotSummary as g, SnapshotUpdateState as h };

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,59 @@
+{
+  "name": "@vitest/snapshot",
+  "type": "module",
+  "version": "4.1.8",
+  "description": "Vitest snapshot manager",
+  "license": "MIT",
+  "funding": "https://opencollective.com/vitest",
+  "homepage": "https://vitest.dev/guide/snapshot",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitest-dev/vitest.git",
+    "directory": "packages/snapshot"
+  },
+  "bugs": {
+    "url": "https://github.com/vitest-dev/vitest/issues"
+  },
+  "keywords": [
+    "vitest",
+    "test",
+    "snapshot"
+  ],
+  "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.1.8",
+    "@vitest/utils": "4.1.8"
+  },
+  "devDependencies": {
+    "@types/natural-compare": "^1.4.3",
+    "natural-compare": "^1.4.0"
+  },
+  "scripts": {
+    "build": "premove dist && rollup -c",
+    "dev": "rollup -c --watch"
+  }
+}