vitest-plugin-vis 2.4.4 → 3.0.0

package/src/server/snapshot_path.ts

@@ -1,27 +1,29 @@
 import ci from 'is-ci'
+import { platform } from 'node:process'
 import type { VisOptions } from '../config/types.ts'
 import { SNAPSHOT_ROOT_DIR } from '../shared/constants.ts'
 import { trimCommonFolder } from '../shared/trim_common_folder.ts'
-import type { PartialBrowserCommandContext } from './vis_context.types.ts'
+import type { PartialBrowserCommandContext } from './vis_server_context.types.ts'
 
-export function resolveSnapshotRootDir(suite: PartialBrowserCommandContext, options: VisOptions) {
-	if (!options.snapshotRootDir) return getSnapshotRootDir(SNAPSHOT_ROOT_DIR, options.platform)
+export function resolveSnapshotRootDir(browserCommandContext: PartialBrowserCommandContext, options: VisOptions) {
+	if (!options.snapshotRootDir) return getSnapshotRootDir(SNAPSHOT_ROOT_DIR)
 	const snapshotRootDir = options.snapshotRootDir
-	if (typeof snapshotRootDir === 'string') return getSnapshotRootDir(snapshotRootDir, options.platform!)
+	if (typeof snapshotRootDir === 'string') return getSnapshotRootDir(snapshotRootDir)
 	return snapshotRootDir({
 		ci,
-		browserName: suite.provider.browserName,
-		providerName: suite.provider.name,
-		platform: process.platform,
-		screenshotFailures: suite.provider.options?.screenshotFailures,
-		screenshotDirectory: suite.provider.options?.screenshotDirectory,
+		browserName: browserCommandContext.provider.browserName,
+		providerName: browserCommandContext.provider.name,
+		platform,
+		screenshotFailures: browserCommandContext.provider.options?.screenshotFailures,
+		screenshotDirectory: browserCommandContext.provider.options?.screenshotDirectory,
 	})
 }
 
-function getSnapshotRootDir(snapshotRootDir: string, platform: string | undefined = process.platform) {
+function getSnapshotRootDir(snapshotRootDir: string) {
 	return `${snapshotRootDir}/${ci ? platform : 'local'}`
 }
-export function getSnapshotSubpath(suiteName: string, options: Pick<VisOptions, 'customizeSnapshotSubpath'>) {
-	const customizeSnapshotSubpath = options.customizeSnapshotSubpath ?? trimCommonFolder
-	return customizeSnapshotSubpath(suiteName)
+
+export function getSnapshotSubpath(suiteName: string, options: Pick<VisOptions, 'snapshotSubpath'>) {
+	const customizeSnapshotSubpath = options.snapshotSubpath ?? (({ subpath }) => trimCommonFolder(subpath))
+	return customizeSnapshotSubpath({ subpath: suiteName })
 }

package/src/server/snapshot_writer.ts

@@ -0,0 +1,22 @@
+import { dirname } from 'pathe'
+import { file } from './externals/file.ts'
+
+export interface SnapshotWriter {
+	writeBase64(filePath: string, data: string): Promise<void>
+	writeBuffer(filePath: string, data: Buffer): Promise<void>
+}
+
+export function createSnapshotWriter({ mkdirp, writeFile } = file): SnapshotWriter {
+	return {
+		async writeBase64(filePath: string, data: string) {
+			await mkdirp(dirname(filePath))
+			await writeFile(filePath, data, { encoding: 'base64' })
+		},
+		async writeBuffer(filePath, data) {
+			await mkdirp(dirname(filePath))
+			await writeFile(filePath, data)
+		},
+	}
+}
+
+export const snapshotWriter = createSnapshotWriter()

package/src/server/suite.ts

@@ -0,0 +1,96 @@
+import { join, relative } from 'pathe'
+import type { VisOptions } from '../config/types.ts'
+import { BASELINE_DIR, DIFF_DIR, RESULT_DIR } from '../shared/constants.ts'
+import { getProjectName, getProjectRoot } from './project.ts'
+import { getSnapshotSubpath, resolveSnapshotRootDir } from './snapshot_path.ts'
+import { getVisOption } from './vis_options.ts'
+import { deps } from './vis_server_context.deps.ts'
+import type { PartialBrowserCommandContext, VisSuite, VisSuites } from './vis_server_context.types.ts'
+
+const suites: VisSuites = {}
+
+/**
+ * Setup suite is called on each test file's beforeAll hook.
+ * Test files include vitest test files and storybook story files.
+ * It needs to make sure there is no race condition between the test files.
+ */
+export async function setupSuite(browserContext: PartialBrowserCommandContext) {
+	const suiteId = getSuiteId(browserContext)
+	const visOptions = getVisOption(browserContext)
+
+	if (!suites[suiteId]) {
+		suites[suiteId] = createSuite(browserContext, visOptions)
+	}
+
+	const suite = await suites[suiteId]
+
+	const { taskSubpath, baselineDir, diffDir, resultDir, tasks } = createModule(
+		suite,
+		browserContext.testPath,
+		visOptions,
+	)
+	suite.modules[taskSubpath] = { baselineDir, diffDir, resultDir, tasks }
+
+	await Promise.allSettled([deps.rimraf(diffDir), deps.rimraf(resultDir)])
+	return {
+		comparisonMethod: visOptions.comparisonMethod,
+		diffOptions: visOptions.diffOptions,
+		failureThreshold: visOptions.failureThreshold,
+		failureThresholdType: visOptions.failureThresholdType,
+		snapshotKey: visOptions.snapshotKey,
+		subject: visOptions.subject,
+		timeout: visOptions.timeout,
+	}
+}
+
+/**
+ * Suite ID also contains the project name to make it unique
+ * across different projects.
+ */
+export function getSuiteId(context: {
+	project: { config: { root: string; name: string }; vite: { config: { test?: { name?: string | undefined } } } }
+}) {
+	return `${getProjectName(context)}/${context.project.config.name}`
+}
+
+async function createSuite(
+	browserContext: PartialBrowserCommandContext,
+	visOptions: Pick<VisOptions, 'snapshotRootDir' | 'subject'>,
+) {
+	const snapshotRootDir = resolveSnapshotRootDir(browserContext, visOptions)
+	const projectRoot = getProjectRoot(browserContext)
+
+	const state = {
+		projectRoot,
+		testTimeout: browserContext.project.config.testTimeout,
+		hookTimeout: browserContext.project.config.hookTimeout,
+		snapshotRootDir,
+		snapshotBaselineDir: join(snapshotRootDir, BASELINE_DIR),
+		snapshotResultDir: join(snapshotRootDir, RESULT_DIR),
+		snapshotDiffDir: join(snapshotRootDir, DIFF_DIR),
+		snapshotRootPath: join(projectRoot, snapshotRootDir),
+		subject: visOptions.subject,
+		modules: {},
+	}
+	await Promise.allSettled([deps.rimraf(join(state.snapshotDiffDir)), deps.rimraf(join(state.snapshotResultDir))])
+	return state
+}
+
+export function createModule(state: VisSuite, testPath: string, options: Pick<VisOptions, 'snapshotSubpath'>) {
+	const taskSubpath = getTaskSubpath(state, testPath, options)
+	return {
+		taskSubpath,
+		baselineDir: join(state.snapshotBaselineDir, taskSubpath),
+		resultDir: join(state.snapshotResultDir, taskSubpath),
+		diffDir: join(state.snapshotDiffDir, taskSubpath),
+		tasks: {},
+	}
+}
+
+export function getTaskSubpath(state: VisSuite, testPath: string, options: Pick<VisOptions, 'snapshotSubpath'>) {
+	return getSnapshotSubpath(relative(state.projectRoot, testPath), options)
+}
+
+export function getSuite(context: PartialBrowserCommandContext) {
+	return suites[getSuiteId(context)]!
+}

package/src/server/vis_options.ts

@@ -0,0 +1,27 @@
+import type { VisOptions } from '../config/types.ts'
+import { assertSnapshotKeyWithoutDash } from '../shared/asserts.ts'
+import { getProjectName } from './project.ts'
+
+const DEFAULT_PROJECT_NAME = '__default'
+
+const visOptions: Record<string, VisOptions<any> | undefined> = {}
+
+export function setVisOption(
+	userConfig: { test?: { name?: string | undefined } | undefined },
+	options: VisOptions<any> | undefined,
+) {
+	assertSnapshotKeyWithoutDash(options?.snapshotKey)
+
+	const name = userConfig.test?.name
+	const id = name ?? DEFAULT_PROJECT_NAME
+
+	visOptions[id] = options
+}
+
+export function getVisOption(context: {
+	project: { vite: { config: { test?: { name?: string | undefined } } } }
+}) {
+	const id = getProjectName(context) ?? DEFAULT_PROJECT_NAME
+
+	return visOptions[id] ?? {}
+}

package/src/server/{vis_context.ctx.ts → vis_server_context.deps.ts}

@@ -2,7 +2,7 @@
 import ci from 'is-ci'
 import { rimraf } from 'rimraf'
 
-export const ctx = {
+export const deps = {
 	rimraf,
 	getSnapshotPlatform() {
 		return ci ? process.platform : 'local'

package/src/server/vis_server_context.logic.ts

@@ -0,0 +1,112 @@
+import { basename, join, resolve } from 'pathe'
+import { pick } from 'type-plus'
+import type { ImageSnapshotKeyOptions } from '../client-api.ts'
+import type { ImageSnapshotResult } from './commands/load_image_snapshot_results.ts'
+import { file } from './externals/file.ts'
+import { getSuite, getTaskSubpath } from './suite.ts'
+import { getVisOption } from './vis_options.ts'
+import type { PartialBrowserCommandContext } from './vis_server_context.types.ts'
+
+export function createVisServerContext() {
+	const context = {
+		async getSnapshotResults(browserContext: PartialBrowserCommandContext, taskId: string) {
+			const suiteInfo = await context.getSuiteInfo(browserContext, taskId)
+			const baselines = await file.glob(join(suiteInfo.projectRoot, suiteInfo.baselineDir, `${suiteInfo.taskId}-*.png`))
+			const results = await file.glob(join(suiteInfo.projectRoot, suiteInfo.resultDir, `${suiteInfo.taskId}-*.png`))
+			const diffs = await file.glob(join(suiteInfo.projectRoot, suiteInfo.diffDir, `${suiteInfo.taskId}-*.png`))
+
+			const r: ImageSnapshotResult[] = []
+			await Promise.all(
+				baselines.map(async (baselinePath) => {
+					const filename = basename(baselinePath)
+					const resultPath = results.find((r) => r.endsWith(filename))
+					const diffPath = diffs.find((d) => d.endsWith(filename))
+
+					const baselineBuffer = await file.tryReadFile(baselinePath)
+					const resultBuffer = await file.tryReadFile(resultPath)
+					const diffBuffer = await file.tryReadFile(diffPath)
+					r.push({
+						filename,
+						baseline: baselineBuffer?.toString('base64'),
+						result: resultBuffer?.toString('base64'),
+						diff: diffBuffer?.toString('base64'),
+					})
+				}),
+			)
+			return r
+		},
+		async getSnapshotInfo(
+			browserContext: PartialBrowserCommandContext,
+			taskId: string,
+			options?: ImageSnapshotKeyOptions,
+		) {
+			const suiteInfo = await context.getSuiteInfo(browserContext, taskId)
+			const snapshotFilename = context.getSnapshotFilename(browserContext, suiteInfo, options?.snapshotKey)
+
+			const { baselineDir, resultDir, diffDir, task } = suiteInfo
+
+			task.count = task.count + 1
+			const baselinePath = join(baselineDir, snapshotFilename)
+			const resultPath = join(resultDir, snapshotFilename)
+			const diffPath = join(diffDir, snapshotFilename)
+
+			return {
+				...pick(
+					getVisOption(browserContext),
+					'comparisonMethod',
+					'diffOptions',
+					'failureThreshold',
+					'failureThresholdType',
+					'timeout',
+				),
+				baselinePath,
+				resultPath,
+				diffPath,
+			}
+		},
+
+		async getTaskCount(browserContext: PartialBrowserCommandContext, taskId: string) {
+			return (await context.getSuiteInfo(browserContext, taskId)).task.count
+		},
+		async hasImageSnapshot(
+			browserContext: PartialBrowserCommandContext,
+			taskId: string,
+			snapshotKey: string | undefined,
+		) {
+			const info = await context.getSuiteInfo(browserContext, taskId)
+
+			return file.existFile(
+				resolve(info.projectRoot, info.baselineDir, context.getSnapshotFilename(browserContext, info, snapshotKey)),
+			)
+		},
+		getSnapshotFilename(
+			browserContext: PartialBrowserCommandContext,
+			info: { taskId: string; task: { count: number } },
+			snapshotKey: string | undefined,
+		) {
+			if (snapshotKey) return `${info.taskId}-${snapshotKey}.png`
+			const visOptions = getVisOption(browserContext)
+			if (typeof visOptions.snapshotKey === 'string') {
+				return `${info.taskId}-${visOptions.snapshotKey}.png`
+			}
+			return `${info.taskId}-${info.task.count}.png`
+		},
+		async getSuiteInfo(browserContext: PartialBrowserCommandContext, taskId: string) {
+			const projectState = await getSuite(browserContext)
+			const visOptions = getVisOption(browserContext)
+			const moduleId = getTaskSubpath(projectState, browserContext.testPath, visOptions)
+			const m = projectState.modules[moduleId]!
+			const task = (m.tasks[taskId] = m.tasks[taskId] ?? { count: 1 })
+			return {
+				projectRoot: projectState.projectRoot,
+				suiteId: moduleId,
+				taskId,
+				baselineDir: m.baselineDir,
+				resultDir: m.resultDir,
+				diffDir: m.diffDir,
+				task,
+			}
+		},
+	}
+	return context
+}

package/src/server/vis_server_context.ts

@@ -0,0 +1,3 @@
+import { createVisServerContext } from './vis_server_context.logic.ts'
+
+export const visServerContext = createVisServerContext()

package/src/server/{vis_context.types.ts → vis_server_context.types.ts}

@@ -1,8 +1,8 @@
-export type VisState = {
-	[projectPath: string]: Promise<VisProjectState>
+export type VisSuites = {
+	[projectPath: string]: Promise<VisSuite>
 }
 
-export type VisProjectState = {
+export type VisSuite = {
 	projectRoot: string
 	testTimeout: number
 	hookTimeout: number
@@ -11,8 +11,8 @@ export type VisProjectState = {
 	snapshotResultDir: string
 	snapshotDiffDir: string
 	snapshotRootPath: string
-	subjectDataTestId: string | undefined
-	suites: Record<
+	subject: string | undefined
+	modules: Record<
 		string,
 		{
 			baselineDir: string

package/src/server-utils.ts

@@ -0,0 +1,2 @@
+export * from './shared/constants.ts'
+export * from './shared/trim_common_folder.ts'

package/src/setup.ts

@@ -2,8 +2,8 @@
 import './client/expect/extend.ts'
 import './client/page/extend.ts'
 
-export * from './setup/vis.ts'
+export * from './client/setup/vis.ts'
 
 // This is exported for main/app boundary separation
 // They can co-exist in the same export file thanks to ESM.
-export * from './setup/create_vis.ts'
+export * from './client/setup/create_vis.ts'

package/src/shared/asserts.ts

@@ -0,0 +1,5 @@
+export function assertSnapshotKeyWithoutDash(snapshotKey: string | undefined) {
+	if (snapshotKey?.includes('-')) {
+		throw new Error('Snapshot key cannot contain dash')
+	}
+}

package/src/shared/types.ts

@@ -1,6 +1,6 @@
 import type pixelMatch from 'pixelmatch'
-import type { Options as SsimOptions } from 'ssim.js'
-import type { getCurrentTest } from 'vitest/suite'
+import type { Options as SsimDiffOptions } from 'ssim.js'
+import type { SnapshotMeta } from '../client/snapshot_meta.ts'
 import type { NAME } from './constants.ts'
 
 export interface ImageSnapshotTimeoutOptions {
@@ -12,18 +12,11 @@ export interface ImageSnapshotTimeoutOptions {
 	timeout?: number | undefined
 }
 
-export interface ImageSnapshotIdOptions {
+export interface ImageSnapshotKeyOptions {
 	/**
-	 * Customize the snapshot id. This is used as the filename of the snapshot: `${snapshotId}.png`
-	 *
-	 * @param id The id of the snapshot.
-	 * @param index The index of the snapshot.
+	 * Customize the `snapshotKey` of the snapshot.
 	 */
-	customizeSnapshotId?: (context: {
-		id: string
-		index: number
-		isAutoSnapshot: boolean
-	}) => string
+	snapshotKey?: string | undefined
 }
 
 export type ComparisonMethod = 'pixel' | 'ssim'
@@ -48,32 +41,37 @@ export type SsimComparisonOptions<M = 'ssim'> = {
 	/**
 	 * Custom options passed to 'ssim'
 	 */
-	diffOptions?: Partial<SsimOptions> | undefined
+	diffOptions?: Partial<SsimDiffOptions> | undefined
 }
+
+export type { SsimDiffOptions }
+
 export type PixelComparisonOptions<M = 'pixel'> = {
 	comparisonMethod?: M | undefined
 	/**
 	 * Custom options passed to 'pixelmatch'
 	 */
-	diffOptions?: Parameters<typeof pixelMatch>[5] | undefined
+	diffOptions?: PixelDiffOptions | undefined
 }
 
+export type PixelDiffOptions = Parameters<typeof pixelMatch>[5]
+
 export type ImageSnapshotCompareOptions<M extends ComparisonMethod = 'pixel'> = (M extends 'ssim'
 	? SsimComparisonOptions<M>
 	: PixelComparisonOptions<M>) &
 	FailureThresholdOptions
 
-export type AutoSnapshotOptions = {
+export type ImageSnapshotSubjectOptions = {
 	/**
-	 * Specify the data-testid of the subject element. Default is `subject`.
+	 * Specify the query of the subject element.
 	 *
-	 * If the test does not have an element with the specified data-testid,
+	 * If the test does not have an element with the specified query,
 	 * the `body` element will be used.
 	 */
-	subjectDataTestId?: string | undefined
+	subject?: string | undefined
 }
 export type ToMatchImageSnapshotOptions<M extends ComparisonMethod = 'pixel'> = ImageSnapshotTimeoutOptions &
-	ImageSnapshotIdOptions &
+	ImageSnapshotKeyOptions &
 	ImageSnapshotCompareOptions<M> & {
 		/**
 		 * Expect the matcher to fail.
@@ -82,8 +80,12 @@ export type ToMatchImageSnapshotOptions<M extends ComparisonMethod = 'pixel'> =
 		expectToFail?: boolean | undefined
 	}
 
-export type SnapshotMeta<M extends ComparisonMethod> = ToMatchImageSnapshotOptions<M> &
-	AutoSnapshotOptions & {
-		enable?: boolean | undefined
-		[key: string]: unknown
+export interface PageImageSnapshotOptions {
+	fullPage?: boolean | undefined
+}
+
+export type SnapshotTestMeta = {
+	meta: {
+		[NAME]?: SnapshotMeta<ComparisonMethod>
 	}
+}

package/src/testing/stubBrowserCommandContext.ts

@@ -1,26 +1,16 @@
 import { stub } from 'type-plus'
 import type { BrowserCommandContext } from 'vitest/node'
-import type { PartialBrowserCommandContext } from '../server/vis_context.types.ts'
+import type { PartialBrowserCommandContext } from '../server/vis_server_context.types.ts'
 
 export const stubBrowserCommandContext = stub.build<BrowserCommandContext>({})
 
 export function createStubPartialBrowserCommandContext({ root, testPath }: { root: string; testPath: string }) {
 	return stub.build<PartialBrowserCommandContext>({
 		project: {
-			config: {
-				root,
-			},
-			vite: {
-				config: {
-					test: {
-						name: 'subject',
-					},
-				},
-			},
-		},
-		provider: {
-			options: {},
+			config: { root },
+			vite: { config: { test: { name: 'subject' } } },
 		},
+		provider: { options: {} },
 		testPath,
 	})
 }

package/src/testing/stubSuite.ts

@@ -0,0 +1,38 @@
+import { resolve } from 'pathe'
+import { requiredDeep, type RecursivePartial } from 'type-plus'
+import type { UserConfig } from 'vite'
+import type { BrowserCommandContext } from 'vitest/node'
+import { stubBrowserCommandContext } from './stubBrowserCommandContext.ts'
+import { stubUserConfig } from './stubUserConfig.ts'
+
+export function stubSuite(
+	partialUserConfig: RecursivePartial<UserConfig> = {},
+	partialBrowserCommandContext: RecursivePartial<BrowserCommandContext> = {},
+) {
+	const root = resolve(import.meta.dirname, '../..')
+	const userConfig = stubUserConfig({
+		root,
+		...partialUserConfig,
+	})
+	const browserCommandContext = stubBrowserCommandContext(
+		requiredDeep<RecursivePartial<BrowserCommandContext>>(
+			{
+				project: {
+					config: { root },
+					vite: {
+						config: {
+							test: {
+								name: partialUserConfig.test?.name,
+							},
+						},
+					},
+				},
+			},
+			partialBrowserCommandContext,
+		),
+	)
+	return {
+		userConfig,
+		browserCommandContext,
+	}
+}

package/src/testing/stubUserConfig.ts

@@ -0,0 +1,6 @@
+import { stub } from 'type-plus'
+import type { UserConfig } from 'vite'
+
+export const stubUserConfig = stub.build<UserConfig & { configFile: string }>((stub) => ({
+	...stub,
+}))

package/esm/client/image_snapshot_matcher.d.ts

@@ -1,11 +0,0 @@
-import type { BrowserCommands } from '@vitest/browser/context';
-import type { ImageSnapshotNextIndexCommand } from '../commands.ts';
-import type { PrepareImageSnapshotComparisonCommand } from '../server/commands/prepare_image_snapshot_comparison.ts';
-import type { ToMatchImageSnapshotOptions } from '../shared/types.ts';
-import type { CurrentTest } from './vitest_suite_proxy.ts';
-export declare function imageSnapshotMatcher(commands: BrowserCommands & PrepareImageSnapshotComparisonCommand & ImageSnapshotNextIndexCommand): (test: CurrentTest & {}, subject: any, options?: ToMatchImageSnapshotOptions<any>) => Promise<void>;
-/**
- * @deprecated internalized. Use `matchImageSnapshot` directly instead.
- */
-export declare function parseImageSnapshotSubject(subject: any): any;
-//# sourceMappingURL=image_snapshot_matcher.d.ts.map

package/esm/client/image_snapshot_matcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"image_snapshot_matcher.d.ts","sourceRoot":"","sources":["../../src/client/image_snapshot_matcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AAG9D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,yDAAyD,CAAA;AAGpH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAA;AAOrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAE1D,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,eAAe,GAAG,qCAAqC,GAAG,6BAA6B,UAG1F,WAAW,GAAG,EAAE,WACb,GAAG,YACF,2BAA2B,CAAC,GAAG,CAAC,mBAqE3C;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,GAAG,OAOrD"}

package/esm/client/image_snapshot_matcher.js

@@ -1,80 +0,0 @@
-import dedent from 'dedent';
-import { resolve } from 'pathe';
-import { isBase64String } from "../shared/base64.js";
-import { compareImage } from "../shared/compare_image.js";
-import { alignImagesToSameSize } from "./align_images.js";
-import { toDataURL, toImageData } from "./image_data.js";
-import { prettifyOptions } from "./image_snapshot_matcher.logic.js";
-import { convertElementToCssSelector } from "./selector.js";
-import { toTaskId } from "./task_id.js";
-import { server } from "./vitest_browser_context_proxy.js";
-export function imageSnapshotMatcher(commands) {
-    return async function matchImageSnapshot(test, subject, options) {
-        const isAutoSnapshot = !!test.meta.vis?.isAutoSnapshot;
-        const taskId = toTaskId(test);
-        const info = await commands.prepareImageSnapshotComparison(taskId, parseImageSnapshotSubject(subject), isAutoSnapshot, options?.customizeSnapshotId
-            ? await parseImageSnapshotOptions(commands, taskId, isAutoSnapshot, options)
-            : options);
-        if (!info)
-            return;
-        options = { ...info, ...options };
-        const baselineImage = await toImageData(info.baseline);
-        const resultImage = await toImageData(info.result);
-        const [baselineAlignedImage, resultAlignedImage] = alignImagesToSameSize(baselineImage, resultImage);
-        const { width, height } = baselineAlignedImage;
-        const diffImage = new ImageData(width, height);
-        const { pass, diffAmount } = compareImage(baselineAlignedImage.data, resultAlignedImage.data, diffImage.data, width, height, options);
-        if (pass) {
-            if (options?.expectToFail) {
-                throw new Error(dedent `Snapshot \`${taskId}\` matched but expected to fail.
-
-							Options:    ${prettifyOptions(options)}
-							Diff:       ${options.failureThresholdType === 'percent' ? `${diffAmount}%` : `${diffAmount} pixels`}
-
-							Expected:   ${resolve(info.projectRoot, info.baselinePath)}
-							Actual:     ${resolve(info.projectRoot, info.resultPath)}`);
-            }
-            return;
-        }
-        if (server.config.snapshotOptions.updateSnapshot === 'all' && !options?.expectToFail) {
-            await writeSnapshot(commands, resolve(info.projectRoot, info.baselinePath), resultImage);
-            return;
-        }
-        await writeSnapshot(commands, resolve(info.projectRoot, info.diffPath), diffImage);
-        throw new Error(dedent `Snapshot \`${taskId}\` mismatched
-
-					${options?.failureThreshold
-            ? options?.failureThresholdType === 'percent'
-                ? `Expected image to match within ${options.failureThreshold}% but was differ by ${diffAmount}%.`
-                : `Expected image to match within ${options.failureThreshold} pixels but was differ by ${diffAmount} pixels.`
-            : `Expected image to match but was differ by ${options?.failureThresholdType === 'percent' ? `${diffAmount}%` : `${diffAmount} pixels`}.`}
-
-					Options:    ${prettifyOptions(options)}
-
-					Expected:   ${resolve(info.projectRoot, info.baselinePath)}
-					Actual:     ${resolve(info.projectRoot, info.resultPath)}
-					Difference: ${resolve(info.projectRoot, info.diffPath)}`);
-    };
-}
-/**
- * @deprecated internalized. Use `matchImageSnapshot` directly instead.
- */
-export function parseImageSnapshotSubject(subject) {
-    if (subject instanceof Element)
-        return convertElementToCssSelector(subject);
-    if (subject?.['selector'])
-        return subject['selector'];
-    if (isBase64String(subject))
-        return subject;
-    throw new Error(`'toMatchImageSnapshot()' expects the subject to be an element, locator, or image encoded in base64 string, but got: ${subject}`);
-}
-async function writeSnapshot(commands, path, image) {
-    const content = (await toDataURL(image)).split(',')[1];
-    return commands.writeFile(path, content, { encoding: 'base64' });
-}
-async function parseImageSnapshotOptions(commands, taskId, isAutoSnapshot, options) {
-    const index = await commands.imageSnapshotNextIndex(taskId);
-    const { customizeSnapshotId, ...rest } = options;
-    const snapshotFileId = customizeSnapshotId({ id: taskId, index, isAutoSnapshot });
-    return { ...rest, snapshotFileId };
-}

package/esm/client/image_snapshot_matcher.logic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"image_snapshot_matcher.logic.d.ts","sourceRoot":"","sources":["../../src/client/image_snapshot_matcher.logic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAA;AAErE,wBAAgB,eAAe,CAAC,OAAO,EAAE,2BAA2B,CAAC,GAAG,CAAC,GAAG,SAAS,UAWpF"}