vitest-plugin-vis 2.4.3 → 3.0.0

package/src/client/actions/match_image_snapshot_action.ts

@@ -0,0 +1,32 @@
+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 { assertSnapshotKeyWithoutDash } from '../../shared/asserts.ts'
+import { isBase64String } from '../../shared/base64.ts'
+import type { ToMatchImageSnapshotOptions } from '../../shared/types.ts'
+import { compareImageSnapshot } from '../compare_image_snapshot.ts'
+import { convertElementToCssSelector } from '../selector.ts'
+
+export async function matchImageSnapshotAction(
+	commands: BrowserCommands & PrepareImageSnapshotComparisonCommand & ImageSnapshotNextIndexCommand,
+	taskId: string,
+	subject: any,
+	options?: ToMatchImageSnapshotOptions<any>,
+) {
+	assertSnapshotKeyWithoutDash(options?.snapshotKey)
+
+	const info = await commands.prepareImageSnapshotComparison(taskId, parseImageSnapshotSubject(subject), options)
+
+	if (!info) return
+
+	return compareImageSnapshot(commands, taskId, info, options)
+}
+
+function parseImageSnapshotSubject(subject: any) {
+	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}`,
+	)
+}

package/src/client/actions/match_page_image_snapshot_action.ts

@@ -0,0 +1,20 @@
+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 { assertSnapshotKeyWithoutDash } from '../../shared/asserts.ts'
+import type { ToMatchImageSnapshotOptions } from '../../shared/types.ts'
+import { compareImageSnapshot } from '../compare_image_snapshot.ts'
+
+export async function matchPageImageSnapshotAction(
+	commands: BrowserCommands & PrepareImageSnapshotComparisonCommand & ImageSnapshotNextIndexCommand,
+	taskId: string,
+	options?: ToMatchImageSnapshotOptions<any>,
+) {
+	assertSnapshotKeyWithoutDash(options?.snapshotKey)
+
+	const info = await commands.preparePageImageSnapshotComparison(taskId, options)
+
+	if (!info) return
+
+	return compareImageSnapshot(commands, taskId, info, options)
+}

package/src/client/auto_snapshot_options.ts

@@ -0,0 +1,71 @@
+import { assertSnapshotKeyWithoutDash } from '../shared/asserts.ts'
+import { NAME } from '../shared/constants.ts'
+import type { ComparisonMethod } from '../shared/types.ts'
+import { ctx } from './ctx.ts'
+import type { SnapshotMeta } from './snapshot_meta.ts'
+
+type Suite = { meta: Record<string, any>; suite?: Suite | undefined }
+
+export type MetaTask =
+	| {
+			file?: { meta: Record<string, any> } | undefined
+			suite?: Suite | undefined
+			meta: Record<string, any>
+	  }
+	| undefined
+
+/**
+ * Set the snapshot options for auto snapshot.
+ *
+ * ```ts
+ * beforeAll(() => setAutoSnapshotOptions(...))
+ * beforeEach(() => setAutoSnapshotOptions(...))
+ *
+ * it('...', () => {
+ *   setAutoSnapshotOptions(...)
+ * })
+ * ```
+ */
+export function setAutoSnapshotOptions<M extends ComparisonMethod>(meta: SnapshotMeta<M> | boolean): void {
+	if (typeof meta === 'object') {
+		assertSnapshotKeyWithoutDash(meta.snapshotKey)
+	}
+
+	const task = getTask()
+	if (!task) return
+
+	task.meta[NAME] = {
+		...task.meta[NAME],
+		...parseMeta(meta),
+	}
+}
+
+function getTask(): MetaTask | undefined {
+	return ctx.getCurrentTest() ?? (ctx.getCurrentSuite()?.tasks?.[0] as any)?.file
+}
+
+function parseMeta<M extends ComparisonMethod>(meta: boolean | SnapshotMeta<M>): SnapshotMeta<M> {
+	return typeof meta === 'boolean' ? ({ enable: meta } as any) : { enable: true, ...meta }
+}
+
+export function extractAutoSnapshotOptions<M extends SnapshotMeta<any> = SnapshotMeta<any>>(
+	task: MetaTask,
+): M | undefined {
+	if (!task) return
+
+	const list: any[] = []
+	let current = task
+	while (current?.suite) {
+		list.unshift(current.suite.meta)
+		current = current.suite
+	}
+	list.unshift(task.file?.meta)
+	list.push(task.meta)
+	return list.reduce(
+		(acc, cur) => {
+			const meta = cur?.[NAME]
+			return meta ? Object.assign({}, acc, meta) : acc
+		},
+		{ enable: false },
+	)
+}

package/src/client/compare_image_snapshot.ts

@@ -0,0 +1,84 @@
+import type { BrowserCommands } from '@vitest/browser/context'
+import dedent from 'dedent'
+import { resolve } from 'pathe'
+import type { ImageSnapshotNextIndexCommand } from '../commands.ts'
+import type {
+	ImageSnapshotComparisonInfo,
+	PrepareImageSnapshotComparisonCommand,
+} from '../server/commands/prepare_image_snapshot_comparison.ts'
+import { compareImage } from '../shared/compare_image.ts'
+import type { ToMatchImageSnapshotOptions } from '../shared/types.ts'
+import { alignImagesToSameSize } from './align_images.ts'
+import { prettifyOptions } from './compare_image_snapshot.logic.ts'
+import { toDataURL, toImageData } from './image_data.ts'
+import { server } from './vitest_browser_context_proxy.ts'
+
+export async function compareImageSnapshot(
+	commands: BrowserCommands & PrepareImageSnapshotComparisonCommand & ImageSnapshotNextIndexCommand,
+	taskId: string,
+	info: ImageSnapshotComparisonInfo,
+	options?: ToMatchImageSnapshotOptions<any>,
+) {
+	options = { ...info, ...options } as any
+
+	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`}.`
+					}${
+						baselineImage.width !== resultImage.width || baselineImage.height !== resultImage.height
+							? `\nThe image size changed from ${baselineImage.width}x${baselineImage.height} to ${resultImage.width}x${resultImage.height}.`
+							: ''
+					}
+
+					Options:    ${prettifyOptions(options)}
+
+					Expected:   ${resolve(info.projectRoot, info.baselinePath)}
+					Actual:     ${resolve(info.projectRoot, info.resultPath)}
+					Difference: ${resolve(info.projectRoot, info.diffPath)}`,
+	)
+}
+
+async function writeSnapshot(commands: BrowserCommands, path: string, image: ImageData) {
+	const content = (await toDataURL(image)).split(',')[1]!
+	return commands.writeFile(path, content, { encoding: 'base64' })
+}

package/src/client/expect/to_match_image_snapshot.ts

@@ -1,8 +1,9 @@
 import { commands } from '@vitest/browser/context'
 import type { AsyncExpectationResult } from '@vitest/expect'
 import type { ToMatchImageSnapshotOptions } from '../../shared/types.ts'
+import { matchImageSnapshotAction } from '../actions/match_image_snapshot_action.ts'
 import { ctx } from '../ctx.ts'
-import { imageSnapshotMatcher } from '../image_snapshot_matcher.ts'
+import { toTaskId } from '../task_id.ts'
 import { success } from './expectation_result.ts'
 
 export function toMatchImageSnapshot(
@@ -21,9 +22,9 @@ export function toMatchImageSnapshot(
 	if (test.concurrent) {
 		throw new Error(
 			'`toMatchImageSnapshot()` cannot be called in a concurrent test because ' +
-				"concurrent tests run at the same time in the same iframe and affect each other's environment. ",
+				"concurrent tests run at the same time in the same iframe and affect each other's environment.",
 		)
 	}
 
-	return imageSnapshotMatcher(commands)(test, subject, options).then(() => success)
+	return matchImageSnapshotAction(commands, toTaskId(test), subject, options).then(() => success)
 }

package/src/client/image_snapshot_options.ts

@@ -0,0 +1,6 @@
+// import type { ToMatchImageSnapshotOptions } from '../shared/types.ts'
+
+// export function parseImageSnapshotOptions(taskId: string, options: ToMatchImageSnapshotOptions<any> | undefined) {
+// 	const { snapshotKey, ...rest } = options ?? {}
+// 	return snapshotKey ? { ...options, snapshotFileId: `${taskId}-${snapshotKey}` } : rest
+// }

package/src/client/page/augment.ts

@@ -1,5 +1,6 @@
 import type { HasImageSnapshotAction } from './has_image_snapshot.ts'
+import type { ToMatchImageSnapshotAction } from './to_match_image_snapshot.ts'
 
 declare module '@vitest/browser/context' {
-	interface BrowserPage extends HasImageSnapshotAction {}
+	interface BrowserPage extends HasImageSnapshotAction, ToMatchImageSnapshotAction {}
 }

package/src/client/page/extend.ts

@@ -1,5 +1,6 @@
 import { page } from '@vitest/browser/context'
 import './augment.ts'
 import { hasImageSnapshot } from './has_image_snapshot.ts'
+import { toMatchImageSnapshot } from './to_match_image_snapshot.ts'
 
-page.extend({ hasImageSnapshot })
+page.extend({ hasImageSnapshot, toMatchImageSnapshot })

package/src/client/page/has_image_snapshot.ts

@@ -1,16 +1,17 @@
 import { type BrowserPage, commands } from '@vitest/browser/context'
-import type { ImageSnapshotIdOptions } from '../../shared/types.ts'
+import type { ImageSnapshotKeyOptions } from '../../shared/types.ts'
+import { hasImageSnapshotAction } from '../actions/has_image_snapshot_action.ts'
 import { ctx } from '../ctx.ts'
 import { toTaskId } from '../task_id.ts'
 
 export interface HasImageSnapshotAction {
-	hasImageSnapshot(this: BrowserPage, options?: ImageSnapshotIdOptions | undefined): Promise<boolean>
+	/**
+	 * Check if the snapshot image exists.
+	 */
+	hasImageSnapshot(this: BrowserPage, options?: ImageSnapshotKeyOptions | undefined): Promise<boolean>
 }
 
-/**
- * Check if the snapshot image exists.
- */
-export function hasImageSnapshot(this: BrowserPage, options?: ImageSnapshotIdOptions | undefined) {
+export function hasImageSnapshot(this: BrowserPage, options?: ImageSnapshotKeyOptions | undefined) {
 	const test = ctx.getCurrentTest()
 	if (!test) {
 		throw new Error('`hasImageSnapshot()` must be called in a test.')
@@ -22,19 +23,5 @@ export function hasImageSnapshot(this: BrowserPage, options?: ImageSnapshotIdOpt
 				"concurrent tests run at the same time in the same iframe and affect each other's environment. ",
 		)
 	}
-	const taskId = toTaskId(test)
-	const isAutoSnapshot = !!test.meta.vis?.isAutoSnapshot
-	if (options?.customizeSnapshotId) {
-		return commands
-			.imageSnapshotNextIndex(taskId)
-			.then((index) =>
-				commands.hasImageSnapshot(
-					taskId,
-					options.customizeSnapshotId!({ id: taskId, index, isAutoSnapshot }),
-					isAutoSnapshot,
-				),
-			)
-	}
-
-	return commands.hasImageSnapshot(taskId, undefined, isAutoSnapshot)
+	return hasImageSnapshotAction(commands, toTaskId(test), options)
 }

package/src/client/page/to_match_image_snapshot.ts

@@ -0,0 +1,27 @@
+import { commands } from '@vitest/browser/context'
+import type { PageImageSnapshotOptions, ToMatchImageSnapshotOptions } from '../../shared/types.ts'
+import { matchPageImageSnapshotAction } from '../actions/match_page_image_snapshot_action.ts'
+import { ctx } from '../ctx.ts'
+import { toTaskId } from '../task_id.ts'
+
+export interface ToMatchPageImageSnapshotOptions extends ToMatchImageSnapshotOptions, PageImageSnapshotOptions {}
+
+export interface ToMatchImageSnapshotAction {
+	toMatchImageSnapshot(options?: ToMatchPageImageSnapshotOptions | undefined): Promise<void>
+}
+
+export function toMatchImageSnapshot(options?: ToMatchPageImageSnapshotOptions | undefined) {
+	const test = ctx.getCurrentTest()
+	if (!test) {
+		throw new Error('`toMatchImageSnapshot()` must be called in a test.')
+	}
+
+	if (test.concurrent) {
+		throw new Error(
+			'`toMatchImageSnapshot()` cannot be called in a concurrent test because ' +
+				"concurrent tests run at the same time in the same iframe and affect each other's environment.",
+		)
+	}
+
+	return matchPageImageSnapshotAction(commands, toTaskId(test), options)
+}

package/src/client/setup/create_vis.ts

@@ -0,0 +1,227 @@
+import dedent from 'dedent'
+import { afterEach, beforeAll } from 'vitest'
+import type { SetupVisSuiteCommand } from '../../server/commands/setup_vis_suite.ts'
+import type { ComparisonMethod } from '../../shared/types.ts'
+import { extractAutoSnapshotOptions, setAutoSnapshotOptions } from '../auto_snapshot_options.ts'
+import { ctx } from '../ctx.ts'
+import { shouldTakeSnapshot } from '../should_take_snapshot.ts'
+import type { SnapshotMeta } from '../snapshot_meta.ts'
+import { toTaskId } from '../task_id.ts'
+
+/**
+ * Visual test configuration on the client side.
+ */
+export type VisClientConfigurator<GM extends Record<string, any> | unknown = unknown> = {
+	/**
+	 * Setup the visual test configuration.
+	 *
+	 * @example
+	 * ```ts
+	 * // Setup with auto snapshot enabled
+	 * vis().setup({ auto: true })
+	 *
+	 * // Setup with auto snapshot disabled
+	 * vis().setup({ auto: false })
+	 *
+	 * // Same as `vis.setup({ auto: false })`
+	 * vis.setup()
+	 *
+	 * // Setup with auto snapshot determined by the test meta
+	 * vis.setup({
+	 * 	auto: async ({ meta }) => meta['darkOnly'],
+	 * })
+	 *
+	 * // Setup with multiple auto snapshots
+	 * vis.setup({
+	 *   auto: {
+	 *     async light() { document.body.classList.remove('dark') },
+	 *     async dark() { document.body.classList.add('dark') },
+	 *   }
+	 * })
+	 * ```
+	 */
+	setup(options?: {
+		auto?:
+			| boolean
+			| (<C extends ComparisonMethod, M extends Record<string, any> | unknown = unknown>(
+					options: SnapshotMeta<C> & M & GM,
+			  ) => boolean | Promise<boolean>)
+			| Record<
+					string,
+					| boolean
+					| (<C extends ComparisonMethod, M extends Record<string, any> | unknown = unknown>(
+							options: SnapshotMeta<C> & M & GM,
+					  ) => boolean | Promise<boolean>)
+			  >
+	}): void
+	/**
+	 * @deprecated Use `vis.setup()` instead.
+	 */
+	presets: {
+		/**
+		 * @deprecated Use `vis.setup()` instead.
+		 *
+		 * Enable visual testing.
+		 *
+		 * auto snapshot is turned off by default.
+		 * You can specify the test to take a snapshot during `afterEach()` hook with `setAutoSnapshotOptions()`.
+		 */
+		enable(): void
+		/**
+		 * @deprecated Use `vis.setup()` instead.
+		 *
+		 * Enable visual testing.
+		 *
+		 * `setAutoSnapshotOptions` will have no effect in this preset.
+		 */
+		manual(): void
+		/**
+		 * @deprecated Use `vis.setup()` instead.
+		 *
+		 * Enable automatic visual testing.
+		 *
+		 * This will take a snapshot after each test.
+		 */
+		auto(): void
+		/**
+		 * @deprecated Use `vis.setup()` instead.
+		 *
+		 * Enable automatic visual testing with multiple themes.
+		 *
+		 * This will take a snapshot after each test for each theme.
+		 *
+		 * @param themes A record of theme names and their setup functions.
+		 *
+		 * @example
+		 * ```ts
+		 * vis().presets.theme({
+		 *  light() { document.body.classList.add('light') },
+		 *  dark() { document.body.classList.add('dark') },
+		 * })
+		 * ```
+		 */
+		theme<C extends ComparisonMethod, M extends Record<string, any> | unknown = unknown>(
+			themes: Record<
+				string,
+				boolean | ((options: SnapshotMeta<C> & M & GM) => Promise<boolean> | Promise<void> | boolean | void)
+			>,
+		): void
+	}
+	beforeAll: {
+		setup(): Promise<void>
+	}
+	afterEach: {
+		matchImageSnapshot(): Promise<void>
+		matchPerTheme<C extends ComparisonMethod, M extends Record<string, any> | unknown = unknown>(
+			themes: Record<
+				string,
+				boolean | ((options: SnapshotMeta<C> & M & GM) => Promise<boolean> | Promise<void> | boolean | void)
+			>,
+		): () => Promise<void>
+	}
+}
+
+export function createVis<GM extends Record<string, any> | unknown = unknown>(commands: SetupVisSuiteCommand) {
+	let subject: string | undefined
+
+	const vis: VisClientConfigurator<GM> = {
+		setup(options) {
+			if (!options || options.auto === false) {
+				beforeAll(vis.beforeAll.setup)
+			} else {
+				beforeAll(async () => {
+					await vis.beforeAll.setup()
+					setAutoSnapshotOptions(true)
+				})
+			}
+
+			if (typeof options?.auto === 'function') {
+				afterEach(
+					vis.afterEach.matchPerTheme({
+						auto: options.auto,
+					}),
+				)
+			} else if (typeof options?.auto === 'object') {
+				afterEach(vis.afterEach.matchPerTheme(options.auto))
+			} else {
+				afterEach(vis.afterEach.matchImageSnapshot)
+			}
+		},
+		presets: {
+			enable() {
+				beforeAll(vis.beforeAll.setup)
+				afterEach(vis.afterEach.matchImageSnapshot)
+			},
+			manual() {
+				beforeAll(vis.beforeAll.setup)
+			},
+			auto() {
+				beforeAll(async () => {
+					await vis.beforeAll.setup()
+					setAutoSnapshotOptions(true)
+				})
+				afterEach(vis.afterEach.matchImageSnapshot)
+			},
+			theme(themes) {
+				beforeAll(async () => {
+					await vis.beforeAll.setup()
+					setAutoSnapshotOptions(true)
+				})
+				afterEach(vis.afterEach.matchPerTheme(themes))
+			},
+		},
+		beforeAll: {
+			async setup() {
+				subject = (await commands.setupVisSuite()).subject
+			},
+		},
+		afterEach: {
+			async matchImageSnapshot() {
+				return vis.afterEach.matchPerTheme({ async auto() {} })()
+			},
+			matchPerTheme(themes) {
+				return async function matchImageSnapshot() {
+					const test = ctx.getCurrentTest()
+					if ((test?.result?.errors?.length ?? 0) > 0) return
+
+					const meta = extractAutoSnapshotOptions(test)
+					if (!shouldTakeSnapshot(meta)) return
+					const errors: Array<[string, Error]> = []
+					for (const themeId in themes) {
+						try {
+							await new Promise((a) => setTimeout(a, 10))
+							const theme = themes[themeId]
+							const r = typeof theme === 'function' ? await theme(meta! as any) : theme
+							if (r === false) continue
+							await test!.context.expect(getSubject(meta?.subject ?? subject)).toMatchImageSnapshot({
+								...meta,
+								snapshotKey: meta?.snapshotKey ?? themeId,
+							})
+						} catch (error) {
+							errors.push([themeId, error as Error])
+						}
+					}
+					if (errors.length > 0) {
+						if (errors.length === 1) throw errors[0]![1]
+						const taskId = toTaskId(test!)
+						throw new AggregateError(
+							errors,
+							dedent`Snapshot \`${taskId}\` mismatched
+
+						${errors
+							.map(([themeId, error]) => {
+								return `Theme \`${themeId}\` failed: ${error.message}`
+							})
+							.join('\n\n')}`,
+						)
+					}
+				}
+			},
+		},
+	}
+	return vis
+}
+
+function getSubject(selectors: string | undefined) {
+	return selectors ? (document.querySelector(selectors) ?? document.body) : document.body
+}

package/src/client/setup/vis.ctx.ts

@@ -0,0 +1,33 @@
+import { commands } from '@vitest/browser/context'
+import { afterEach, beforeAll, beforeEach, vi, type Awaitable, type Suite } from 'vitest'
+
+export const ctx = {
+	beforeAll,
+	beforeEach,
+	afterEach,
+	commands,
+	mock() {
+		const beforeAllListeners: Array<(suite: Readonly<Suite | File>) => Awaitable<unknown>> = []
+		beforeEach(() => {
+			ctx.beforeAll = vi.fn((fn) => {
+				beforeAllListeners.push(fn)
+			})
+			ctx.beforeEach = vi.fn()
+			ctx.afterEach = vi.fn()
+			ctx.commands = {
+				setupVisSuite: vi.fn(),
+			} as any
+		})
+		afterEach(() => {
+			ctx.reset()
+		})
+		return {
+			beforeAllListeners,
+		}
+	},
+	reset() {
+		ctx.beforeAll = beforeAll
+		ctx.beforeEach = beforeEach
+		ctx.afterEach = afterEach
+	},
+}

package/src/client/should_take_snapshot.ts

@@ -1,15 +1,5 @@
-import type { SnapshotMeta } from '../shared/types.ts'
-import { ctx } from './ctx.ts'
-import { extractAutoSnapshotOptions } from './snapshot_options.ts'
+import type { SnapshotMeta } from './snapshot_meta.ts'
 
-/**
- * Determine should snapshot be taken.
- *
- * not story: false
- * no `snapshot` tag: false
- * disabled by `!snapshot` tag: false
- */
-export function shouldTakeSnapshot(meta?: SnapshotMeta<any> | undefined) {
-	const m = meta ?? extractAutoSnapshotOptions(ctx.getCurrentTest())
-	return document.body.childElementCount > 0 && m?.enable
+export function shouldTakeSnapshot(meta: SnapshotMeta<any> | undefined) {
+	return document.body.childElementCount > 0 && meta?.enable
 }

package/src/client/snapshot_meta.ts

@@ -0,0 +1,7 @@
+import type { ComparisonMethod, ImageSnapshotSubjectOptions, ToMatchImageSnapshotOptions } from '../shared/types.ts'
+
+export type SnapshotMeta<M extends ComparisonMethod> = ToMatchImageSnapshotOptions<M> &
+	ImageSnapshotSubjectOptions & {
+		enable?: boolean | undefined
+		[key: string]: unknown
+	}

package/src/client/task_id.ts

@@ -3,9 +3,6 @@ type Task = {
 	suite?: Task | undefined
 }
 
-/**
- * @deprecated not needed anymore. Use `matchImageSnapshot` directly instead.
- */
 export function toTaskId(task: Task) {
 	const l: any[] = []
 	let t = task

package/src/client/vitest_suite_proxy.ts

@@ -1,5 +1,4 @@
-import type { NAME } from '../shared/constants.ts'
-import type { SnapshotMeta } from '../shared/types.ts'
+import type { SnapshotTestMeta } from '../shared/types.ts'
 
 let vitestSuite: Awaited<typeof import('vitest/suite')>
 
@@ -9,9 +8,7 @@ if ((globalThis as any).__vitest_browser__) {
 	})
 }
 
-export type CurrentTest = ReturnType<typeof vitestSuite.getCurrentTest> & {
-	meta: { [NAME]?: SnapshotMeta<'pixel' | 'ssim'> & { isAutoSnapshot?: boolean | undefined } }
-}
+export type CurrentTest = ReturnType<typeof vitestSuite.getCurrentTest> & SnapshotTestMeta
 
 export const getCurrentTest = () => vitestSuite?.getCurrentTest() as CurrentTest
 export const getCurrentSuite = () => vitestSuite?.getCurrentSuite()

package/src/client-api.ts

@@ -0,0 +1,11 @@
+import './server/commands/augment.ts'
+
+export * from './client/actions/has_image_snapshot_action.ts'
+export * from './client/actions/load_image_snapshot_results_action.ts'
+export * from './client/actions/match_image_snapshot_action.ts'
+export { setAutoSnapshotOptions, type MetaTask } from './client/auto_snapshot_options.ts'
+export * from './client/expect/expectation_result.ts'
+export type * from './client/expect/to_match_image_snapshot.types.ts'
+export * from './client/task_id.ts'
+export * from './shared/constants.ts'
+export type * from './shared/types.ts'

package/src/commands.ts

@@ -1,5 +1,4 @@
 export * from './server/commands/has_image_snapshot.ts'
 export * from './server/commands/image_snapshot_next_index.ts'
-export * from './server/commands/match_image_snapshot.ts'
 export * from './server/commands/prepare_image_snapshot_comparison.ts'
 export * from './server/commands/setup_vis_suite.ts'