@granite-js/vitest 1.0.20

package/dist/index.js

@@ -0,0 +1,524 @@
+import { n as REACT_NATIVE_ASSET_MODULE_ID_PATTERN, t as REACT_NATIVE_ASSET_EXTENSIONS } from "./assets-DoucBOz0.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as vite from "vitest/node";
+import { createHash } from "node:crypto";
+import transform from "fast-flow-transform";
+
+//#region src/transpile.ts
+const REACT_NATIVE_TRANSFORM_EXTENSIONS = [
+	".js",
+	".jsx",
+	".ts",
+	".tsx"
+];
+const REACT_NATIVE_TRANSFORM_ALLOWLIST = [
+	"react-native",
+	"jest-react-native",
+	"@react-native",
+	"@react-native-community"
+];
+function normalizePath(filename) {
+	return filename.replace(/\\/g, "/");
+}
+function isWithinPackageRoots(filename, packageRoots) {
+	const normalizedFilename = normalizePath(path.resolve(filename));
+	return packageRoots.some((packageRoot) => {
+		const normalizedPackageRoot = normalizePath(path.resolve(packageRoot));
+		return normalizedFilename === normalizedPackageRoot || normalizedFilename.startsWith(`${normalizedPackageRoot}/`);
+	});
+}
+function shouldTransformReactNativeFile(filename, packageRoots = []) {
+	const normalized = normalizePath(filename);
+	const isReactNativeSource = packageRoots.length > 0 ? isWithinPackageRoots(normalized, packageRoots) : normalized.includes("/react-native/") || normalized.includes("/@react-native/");
+	return /\.(?:js|jsx|ts|tsx)$/.test(normalized) && !normalized.includes("/Renderer/implementations/") && isReactNativeSource;
+}
+function shouldInlineReactNativeDependency(filename, packageRoots = []) {
+	const normalized = normalizePath(filename);
+	if (packageRoots.length > 0) return isWithinPackageRoots(normalized, packageRoots);
+	return REACT_NATIVE_TRANSFORM_ALLOWLIST.some((allowlistEntry) => normalized.includes(`/${allowlistEntry}/`));
+}
+async function transformReactNativeSource(sourcePath, source) {
+	return (await transform({
+		filename: sourcePath,
+		source,
+		dialect: "flow-detect",
+		format: "compact",
+		comments: false,
+		reactRuntimeTarget: "19",
+		sourcemap: false
+	})).code;
+}
+
+//#endregion
+//#region src/mirror.ts
+const DEFAULT_PLATFORM = "ios";
+const GRANITE_VITEST_RN_CACHE_DIRECTORY = "vitest-react-native-cache";
+const GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY = "entries";
+const GRANITE_VITEST_RN_PACKAGES_DIRECTORY = "packages";
+const REACT_NATIVE_PLATFORMS = [
+	"android",
+	"ios",
+	"native"
+];
+const GRANITE_VITEST_RN_CACHE_GC_LOCK_FILENAME = ".gc.lock";
+const GRANITE_VITEST_RN_CACHE_METADATA_FILENAME = "meta.json";
+const GRANITE_VITEST_RN_CACHE_TMP_PREFIX = ".tmp-";
+const GRANITE_VITEST_RN_CACHE_MAX_AGE_MS = 10080 * 60 * 1e3;
+const GRANITE_VITEST_RN_CACHE_MAX_SIZE_BYTES = 1024 * 1024 * 1024;
+const GRANITE_VITEST_RN_TEMP_ENTRY_MAX_AGE_MS = 3600 * 1e3;
+const DEFAULT_VITEST_CACHE_DIRECTORY = ".vitest";
+const MIRROR_CACHE_KEY_VERSION = "v1";
+const currentMirrorModulePath = fs.realpathSync(fileURLToPath(import.meta.url));
+const currentMirrorModuleDirectory = path.dirname(currentMirrorModulePath);
+function getFastFlowTransformVersion() {
+	const fastFlowTransformEntryPath = createRequire(import.meta.url).resolve("fast-flow-transform");
+	const fastFlowTransformPackageRoot = path.dirname(path.dirname(fastFlowTransformEntryPath));
+	const fastFlowTransformPackageJsonPath = path.join(fastFlowTransformPackageRoot, "package.json");
+	return JSON.parse(fs.readFileSync(fastFlowTransformPackageJsonPath, "utf8")).version ?? "unknown";
+}
+function getPackageManifestDependencyNames(packageManifest) {
+	return Object.keys({
+		...packageManifest.dependencies ?? {},
+		...packageManifest.devDependencies ?? {},
+		...packageManifest.optionalDependencies ?? {},
+		...packageManifest.peerDependencies ?? {}
+	}).sort();
+}
+function shouldMirrorReactNativeDependency(packageName) {
+	return packageName === "jest-react-native" || packageName.startsWith("@react-native/") || packageName.startsWith("@react-native-community/");
+}
+function hashDirectoryContents(hasher, rootPath, currentPath = rootPath) {
+	const entries = fs.readdirSync(currentPath, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+	for (const entry of entries) {
+		const entryPath = path.join(currentPath, entry.name);
+		if (entry.isDirectory()) {
+			hashDirectoryContents(hasher, rootPath, entryPath);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		hasher.update(path.relative(rootPath, entryPath));
+		hasher.update("\0");
+		hasher.update(fs.readFileSync(entryPath));
+		hasher.update("\0");
+	}
+}
+function hashImplementationFiles() {
+	const hasher = createHash("sha256");
+	const extension = path.extname(currentMirrorModulePath);
+	const implementationFiles = [currentMirrorModulePath, path.join(currentMirrorModuleDirectory, `transpile${extension}`)].filter((implementationFile, index, allFiles) => {
+		if (!fs.existsSync(implementationFile)) return false;
+		return allFiles.indexOf(implementationFile) === index;
+	}).sort();
+	for (const implementationFile of implementationFiles) {
+		hasher.update(path.basename(implementationFile));
+		hasher.update("\0");
+		hasher.update(fs.readFileSync(implementationFile));
+		hasher.update("\0");
+	}
+	return hasher.digest("hex");
+}
+function collectMirroredReactNativePackageNames(workspacePackageManifest, reactNativePackageManifest) {
+	const packageNames = /* @__PURE__ */ new Set();
+	for (const dependencyName of Object.keys(reactNativePackageManifest.dependencies ?? {})) if (dependencyName.startsWith("@react-native/")) packageNames.add(dependencyName);
+	for (const dependencyName of getPackageManifestDependencyNames(workspacePackageManifest)) if (dependencyName !== "react-native" && shouldMirrorReactNativeDependency(dependencyName)) packageNames.add(dependencyName);
+	return [...packageNames].sort();
+}
+function getMirroredReactNativePackages(workspaceRoot) {
+	const reactNativeRoot = resolvePackageRoot("react-native", workspaceRoot);
+	const workspacePackageManifest = JSON.parse(fs.readFileSync(path.join(workspaceRoot, "package.json"), "utf8"));
+	const reactNativePackageManifest = JSON.parse(fs.readFileSync(path.join(reactNativeRoot, "package.json"), "utf8"));
+	const workspaceDependencyNames = new Set(getPackageManifestDependencyNames(workspacePackageManifest));
+	return collectMirroredReactNativePackageNames(workspacePackageManifest, reactNativePackageManifest).map((packageName) => ({
+		packageName,
+		requireRoot: workspaceDependencyNames.has(packageName) ? workspaceRoot : reactNativeRoot
+	}));
+}
+function computeReactNativeMirrorCacheKey(workspaceRoot) {
+	const hasher = createHash("sha256");
+	const packageRoots = resolveReactNativePackageRoots(workspaceRoot).sort();
+	const transformImplementationHash = hashImplementationFiles();
+	const transformDependencyVersions = { fastFlowTransform: getFastFlowTransformVersion() };
+	hasher.update(`granite-vitest-rn-cache:${MIRROR_CACHE_KEY_VERSION}`);
+	hasher.update("\0");
+	hasher.update(`fast-flow-transform:${transformDependencyVersions.fastFlowTransform}`);
+	hasher.update("\0");
+	hasher.update(`transform:${transformImplementationHash}`);
+	hasher.update("\0");
+	for (const packageRoot of packageRoots) {
+		hasher.update(path.basename(packageRoot));
+		hasher.update("\0");
+		hashDirectoryContents(hasher, packageRoot);
+	}
+	return {
+		cacheKey: hasher.digest("hex"),
+		packageRoots,
+		transformDependencyVersions,
+		transformImplementationHash
+	};
+}
+function getDirectorySize(targetPath) {
+	const stat = fs.statSync(targetPath);
+	if (stat.isFile()) return stat.size;
+	if (!stat.isDirectory()) return 0;
+	return fs.readdirSync(targetPath, { withFileTypes: true }).reduce((totalSize, entry) => {
+		const entryPath = path.join(targetPath, entry.name);
+		if (entry.isDirectory() || entry.isFile()) return totalSize + getDirectorySize(entryPath);
+		return totalSize;
+	}, 0);
+}
+function readMirrorCacheMetadata(entryRoot) {
+	const metadataPath = path.join(entryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
+	if (!fs.existsSync(metadataPath)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(metadataPath, "utf8"));
+	} catch {
+		return null;
+	}
+}
+function withMirrorCacheGcLock(workspaceRoot, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY), callback) {
+	const cacheRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY);
+	const lockPath = path.join(cacheRoot, GRANITE_VITEST_RN_CACHE_GC_LOCK_FILENAME);
+	fs.mkdirSync(cacheRoot, { recursive: true });
+	let lockHandle = null;
+	try {
+		lockHandle = fs.openSync(lockPath, "wx");
+	} catch (error) {
+		if (error.code === "EEXIST") return;
+		throw error;
+	}
+	try {
+		callback();
+	} finally {
+		if (lockHandle != null) {
+			fs.closeSync(lockHandle);
+			fs.rmSync(lockPath, {
+				force: true,
+				recursive: true
+			});
+		}
+	}
+}
+function gcReactNativeMirrorCache(workspaceRoot, activeCacheKey, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY)) {
+	withMirrorCacheGcLock(workspaceRoot, resolvedCacheDir, () => {
+		const entriesRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY);
+		if (!fs.existsSync(entriesRoot)) return;
+		const now = Date.now();
+		const retainedEntries = [];
+		for (const entry of fs.readdirSync(entriesRoot, { withFileTypes: true })) {
+			if (!entry.isDirectory()) continue;
+			const entryRoot = path.join(entriesRoot, entry.name);
+			if (entry.name.startsWith(GRANITE_VITEST_RN_CACHE_TMP_PREFIX)) {
+				if (now - fs.statSync(entryRoot).mtimeMs > GRANITE_VITEST_RN_TEMP_ENTRY_MAX_AGE_MS) fs.rmSync(entryRoot, {
+					force: true,
+					recursive: true
+				});
+				continue;
+			}
+			if (entry.name === activeCacheKey) {
+				const activeMetadata = readMirrorCacheMetadata(entryRoot);
+				retainedEntries.push({
+					cacheKey: entry.name,
+					entryRoot,
+					lastAccessedAtMs: activeMetadata == null ? now : Date.parse(activeMetadata.lastAccessedAt),
+					sizeBytes: activeMetadata?.sizeBytes ?? getDirectorySize(path.join(entryRoot, GRANITE_VITEST_RN_PACKAGES_DIRECTORY))
+				});
+				continue;
+			}
+			const metadata = readMirrorCacheMetadata(entryRoot);
+			const packagesRoot = path.join(entryRoot, GRANITE_VITEST_RN_PACKAGES_DIRECTORY);
+			if (metadata == null || !fs.existsSync(packagesRoot)) {
+				fs.rmSync(entryRoot, {
+					force: true,
+					recursive: true
+				});
+				continue;
+			}
+			const lastAccessedAtMs = Date.parse(metadata.lastAccessedAt);
+			if (Number.isNaN(lastAccessedAtMs) || now - lastAccessedAtMs > GRANITE_VITEST_RN_CACHE_MAX_AGE_MS) {
+				fs.rmSync(entryRoot, {
+					force: true,
+					recursive: true
+				});
+				continue;
+			}
+			retainedEntries.push({
+				cacheKey: entry.name,
+				entryRoot,
+				lastAccessedAtMs,
+				sizeBytes: metadata.sizeBytes
+			});
+		}
+		let totalSizeBytes = retainedEntries.reduce((totalSize, entry) => totalSize + entry.sizeBytes, 0);
+		for (const entry of retainedEntries.filter((cacheEntry) => cacheEntry.cacheKey !== activeCacheKey).sort((left, right) => left.lastAccessedAtMs - right.lastAccessedAtMs)) {
+			if (totalSizeBytes <= GRANITE_VITEST_RN_CACHE_MAX_SIZE_BYTES) break;
+			fs.rmSync(entry.entryRoot, {
+				force: true,
+				recursive: true
+			});
+			totalSizeBytes -= entry.sizeBytes;
+		}
+	});
+}
+function resolvePackageRoot(packageName, requireRoot) {
+	const packageJsonPath = createRequire(path.join(requireRoot, "package.json")).resolve(`${packageName}/package.json`);
+	return path.dirname(packageJsonPath);
+}
+function resolveReactNativePackageRoots(workspaceRoot) {
+	return [resolvePackageRoot("react-native", workspaceRoot), ...getMirroredReactNativePackages(workspaceRoot).map(({ packageName, requireRoot }) => resolvePackageRoot(packageName, requireRoot))];
+}
+async function mirrorFile(sourcePath, destinationPath, packageRoots) {
+	fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+	if (shouldTransformReactNativeFile(sourcePath, packageRoots)) {
+		const source = fs.readFileSync(sourcePath, "utf8");
+		try {
+			const transformed = await transformReactNativeSource(sourcePath, source);
+			fs.writeFileSync(destinationPath, transformed);
+			return;
+		} catch {
+			fs.writeFileSync(destinationPath, source);
+			return;
+		}
+	}
+	fs.copyFileSync(sourcePath, destinationPath);
+}
+async function mirrorTree(sourceRoot, destinationRoot, packageRoots) {
+	const entries = fs.readdirSync(sourceRoot, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+	for (const entry of entries) {
+		const sourcePath = path.join(sourceRoot, entry.name);
+		const destinationPath = path.join(destinationRoot, entry.name);
+		if (entry.isDirectory()) {
+			await mirrorTree(sourcePath, destinationPath, packageRoots);
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		await mirrorFile(sourcePath, destinationPath, packageRoots);
+	}
+}
+function synthesizeDefaultPlatformFiles(destinationRoot) {
+	const platformFallbackOrder = [
+		DEFAULT_PLATFORM,
+		"native",
+		...REACT_NATIVE_PLATFORMS.filter((platform) => platform !== DEFAULT_PLATFORM && platform !== "native")
+	];
+	const platformPriority = new Map(platformFallbackOrder.map((platform, index) => [platform, index]));
+	const fallbackCandidates = [];
+	function collectCandidates(currentRoot) {
+		const entries = fs.readdirSync(currentRoot, { withFileTypes: true });
+		for (const entry of entries) {
+			const entryPath = path.join(currentRoot, entry.name);
+			if (entry.isDirectory()) {
+				collectCandidates(entryPath);
+				continue;
+			}
+			const match = entry.name.match(new RegExp(`^(.*)\\.(${REACT_NATIVE_PLATFORMS.join("|")})\\.(js|jsx|ts|tsx)$`));
+			if (match == null) continue;
+			const [, basename, platform, extension] = match;
+			if (basename == null || platform == null || extension == null) continue;
+			fallbackCandidates.push({
+				sourcePath: entryPath,
+				fallbackPath: path.join(currentRoot, `${basename}.${extension}`),
+				priority: platformPriority.get(platform) ?? platformFallbackOrder.length
+			});
+		}
+	}
+	collectCandidates(destinationRoot);
+	fallbackCandidates.sort((left, right) => left.priority - right.priority).forEach(({ sourcePath, fallbackPath }) => {
+		if (!fs.existsSync(fallbackPath)) fs.copyFileSync(sourcePath, fallbackPath);
+	});
+}
+async function buildReactNativeMirror(workspaceRoot, resolvedCacheDir = path.join(workspaceRoot, DEFAULT_VITEST_CACHE_DIRECTORY)) {
+	const cacheEntry = computeReactNativeMirrorCacheKey(workspaceRoot);
+	const entriesRoot = path.join(resolvedCacheDir, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY);
+	const entryRoot = path.join(entriesRoot, cacheEntry.cacheKey);
+	const packagesRoot = path.join(entryRoot, GRANITE_VITEST_RN_PACKAGES_DIRECTORY);
+	const metadataPath = path.join(entryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
+	fs.mkdirSync(entriesRoot, { recursive: true });
+	if (fs.existsSync(entryRoot) && (!fs.existsSync(packagesRoot) || !fs.existsSync(metadataPath))) fs.rmSync(entryRoot, {
+		force: true,
+		recursive: true
+	});
+	if (fs.existsSync(packagesRoot) && fs.existsSync(metadataPath)) {
+		const metadata = readMirrorCacheMetadata(entryRoot);
+		if (metadata != null) {
+			metadata.lastAccessedAt = (/* @__PURE__ */ new Date()).toISOString();
+			fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+		}
+		gcReactNativeMirrorCache(workspaceRoot, cacheEntry.cacheKey, resolvedCacheDir);
+		return packagesRoot;
+	}
+	const temporaryEntryRoot = path.join(entriesRoot, `${GRANITE_VITEST_RN_CACHE_TMP_PREFIX}${process.pid}-${Date.now()}-${cacheEntry.cacheKey}`);
+	const temporaryPackagesRoot = path.join(temporaryEntryRoot, GRANITE_VITEST_RN_PACKAGES_DIRECTORY);
+	const temporaryMetadataPath = path.join(temporaryEntryRoot, GRANITE_VITEST_RN_CACHE_METADATA_FILENAME);
+	fs.rmSync(temporaryEntryRoot, {
+		force: true,
+		recursive: true
+	});
+	fs.mkdirSync(temporaryPackagesRoot, { recursive: true });
+	try {
+		await mirrorTree(resolvePackageRoot("react-native", workspaceRoot), path.join(temporaryPackagesRoot, "react-native"), cacheEntry.packageRoots);
+		for (const { packageName, requireRoot } of getMirroredReactNativePackages(workspaceRoot)) await mirrorTree(resolvePackageRoot(packageName, requireRoot), path.join(temporaryPackagesRoot, ...packageName.split("/")), cacheEntry.packageRoots);
+		synthesizeDefaultPlatformFiles(temporaryPackagesRoot);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		fs.writeFileSync(temporaryMetadataPath, JSON.stringify({
+			cacheKey: cacheEntry.cacheKey,
+			createdAt: now,
+			lastAccessedAt: now,
+			packageRoots: cacheEntry.packageRoots,
+			sizeBytes: getDirectorySize(temporaryPackagesRoot),
+			transformDependencyVersions: cacheEntry.transformDependencyVersions,
+			transformImplementationHash: cacheEntry.transformImplementationHash
+		}, null, 2));
+		try {
+			fs.renameSync(temporaryEntryRoot, entryRoot);
+		} catch (error) {
+			const errorCode = error.code;
+			if (errorCode !== "EEXIST" && errorCode !== "ENOTEMPTY") throw error;
+		}
+	} finally {
+		fs.rmSync(temporaryEntryRoot, {
+			force: true,
+			recursive: true
+		});
+	}
+	if (fs.existsSync(packagesRoot) && fs.existsSync(metadataPath)) {
+		const metadata = readMirrorCacheMetadata(entryRoot);
+		if (metadata != null) {
+			metadata.lastAccessedAt = (/* @__PURE__ */ new Date()).toISOString();
+			fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+		}
+		gcReactNativeMirrorCache(workspaceRoot, cacheEntry.cacheKey, resolvedCacheDir);
+		return packagesRoot;
+	}
+	throw new Error(`Failed to materialize React Native mirror cache at ${entryRoot}`);
+}
+
+//#endregion
+//#region src/reactNative.ts
+const PLATFORM_RESOLUTION_ORDER = [
+	DEFAULT_PLATFORM,
+	"native",
+	...REACT_NATIVE_PLATFORMS.filter((platform) => platform !== DEFAULT_PLATFORM && platform !== "native")
+];
+const PLATFORM_EXTENSION_SUFFIXES = [
+	"tsx",
+	"ts",
+	"jsx",
+	"js"
+];
+const REACT_NATIVE_RESOLVE_EXTENSIONS = [
+	...PLATFORM_RESOLUTION_ORDER.flatMap((platform) => PLATFORM_EXTENSION_SUFFIXES.map((extension) => `.${platform}.${extension}`)),
+	".tsx",
+	".ts",
+	".jsx",
+	".js",
+	".json"
+];
+const REACT_NATIVE_EXPORT_CONDITIONS = ["require", "react-native"];
+const JEST_LIKE_TEST_PATTERNS = [
+	"**/__tests__/**/*.test.{js,jsx,ts,tsx}",
+	"**/__tests__/**/*.spec.{js,jsx,ts,tsx}",
+	"**/?(*.)test.{js,jsx,ts,tsx}",
+	"**/?(*.)spec.{js,jsx,ts,tsx}"
+];
+const currentFilePath = fs.realpathSync(fileURLToPath(import.meta.url));
+const currentDirectory = path.dirname(currentFilePath);
+function getSetupFileExtension() {
+	const extension = path.extname(currentFilePath);
+	if (extension === ".ts" || extension === ".mts") return ".ts";
+	return ".js";
+}
+function resolveReactNativeSetupFiles() {
+	const extension = getSetupFileExtension();
+	return [path.join(currentDirectory, `reactNativeRuntime${extension}`), path.join(currentDirectory, `setup${extension}`)];
+}
+function reactNative() {
+	return {
+		enforce: "pre",
+		name: "granite-react-native",
+		async config(conf) {
+			const workspaceRoot = conf.root ?? conf.test?.root ?? process.cwd();
+			const cacheDir = conf.cacheDir ?? ".vitest";
+			const reactNativeMirrorRoot = await buildReactNativeMirror(workspaceRoot, path.isAbsolute(cacheDir) ? cacheDir : path.join(workspaceRoot, cacheDir));
+			const resolve = {
+				alias: [
+					{
+						find: /^react-native$/,
+						replacement: path.join(reactNativeMirrorRoot, "react-native", "index.js")
+					},
+					{
+						find: /^react-native\/(.*)$/,
+						replacement: path.join(reactNativeMirrorRoot, "react-native", "$1")
+					},
+					{
+						find: /^@react-native\/(.*)$/,
+						replacement: path.join(reactNativeMirrorRoot, "@react-native", "$1")
+					},
+					{
+						find: /^@react-native-community\/([^/]+)$/,
+						replacement: path.join(reactNativeMirrorRoot, "@react-native-community", "$1")
+					},
+					{
+						find: /^@react-native-community\/([^/]+)\/(.*)$/,
+						replacement: path.join(reactNativeMirrorRoot, "@react-native-community", "$1", "$2")
+					},
+					{
+						find: /^jest-react-native$/,
+						replacement: path.join(reactNativeMirrorRoot, "jest-react-native")
+					},
+					{
+						find: /^jest-react-native\/(.*)$/,
+						replacement: path.join(reactNativeMirrorRoot, "jest-react-native", "$1")
+					}
+				],
+				conditions: [...REACT_NATIVE_EXPORT_CONDITIONS],
+				extensions: [...REACT_NATIVE_RESOLVE_EXTENSIONS]
+			};
+			const commonConfig = {
+				define: { "globalThis.__GRANITE_VITEST_RN_CACHE_ROOT__": JSON.stringify(reactNativeMirrorRoot) },
+				resolve,
+				test: {
+					environment: "node",
+					globals: true,
+					include: [...JEST_LIKE_TEST_PATTERNS],
+					setupFiles: resolveReactNativeSetupFiles()
+				}
+			};
+			if ("rolldownVersion" in vite) return {
+				oxc: { jsx: {
+					importSource: "react",
+					runtime: "automatic"
+				} },
+				...commonConfig
+			};
+			return {
+				esbuild: {
+					jsx: "automatic",
+					jsxImportSource: "react"
+				},
+				...commonConfig
+			};
+		},
+		load(id) {
+			if (!REACT_NATIVE_ASSET_MODULE_ID_PATTERN.test(id)) return;
+			const asset = { testUri: path.relative(currentDirectory, id.replace(/[?#].*$/, "")).replace(/\\/g, "/") };
+			return [
+				`const asset = ${JSON.stringify(asset)};`,
+				"export const testUri = asset.testUri;",
+				"export default asset;"
+			].join("\n");
+		}
+	};
+}
+
+//#endregion
+//#region src/index.ts
+var src_default = {
+	reactNative,
+	resolveReactNativeSetupFiles
+};
+
+//#endregion
+export { DEFAULT_PLATFORM, GRANITE_VITEST_RN_CACHE_DIRECTORY, GRANITE_VITEST_RN_CACHE_ENTRIES_DIRECTORY, GRANITE_VITEST_RN_PACKAGES_DIRECTORY, JEST_LIKE_TEST_PATTERNS, REACT_NATIVE_ASSET_EXTENSIONS, REACT_NATIVE_EXPORT_CONDITIONS, REACT_NATIVE_PLATFORMS, REACT_NATIVE_RESOLVE_EXTENSIONS, REACT_NATIVE_TRANSFORM_ALLOWLIST, REACT_NATIVE_TRANSFORM_EXTENSIONS, buildReactNativeMirror, src_default as default, reactNative, resolvePackageRoot, resolveReactNativePackageRoots, resolveReactNativeSetupFiles, shouldInlineReactNativeDependency, shouldTransformReactNativeFile, synthesizeDefaultPlatformFiles };

package/dist/reactNativeRuntime.d.ts

@@ -0,0 +1,9 @@
+import "@react-native/js-polyfills/error-guard";
+import * as react from "react";
+
+//#region src/reactNativeRuntime.d.ts
+type ReactModule = typeof react;
+declare function createMockHostComponent(React: ReactModule, displayName: string, hostType: string, instanceMethods?: Record<string, unknown>, realComponent?: any): any;
+declare function createMockNativeComponent(React: ReactModule, viewName: string): any;
+//#endregion
+export { createMockHostComponent, createMockNativeComponent };