@multiplatform.one/config 6.0.0

package/lib/vite-BfDEN9iw.js

@@ -0,0 +1,369 @@
+import { t as discoverPublicPackageRoots } from "./workspacePublicPackages-BPzu1MKc.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { tamaguiPlugin } from "@tamagui/vite-plugin";
+import dotenv from "dotenv";
+import createExternal from "vite-plugin-external";
+import i18nextLoader from "vite-plugin-i18next-loader";
+
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../utils/src/dev.ts
+const logger = console;
+function lookupTamaguiModules(packageDirs, { log = true } = {}) {
+	const projectRoot = lookupProjectRoot();
+	const tamaguiModules = [...new Set(["tamagui", ...[...new Set([
+		projectRoot,
+		path.resolve(projectRoot, "app"),
+		path.resolve(projectRoot, "features"),
+		...packageDirs || []
+	])].map((packageDir) => {
+		const pkgPath = path.join(packageDir, "package.json");
+		if (!fs.existsSync(pkgPath)) return [];
+		try {
+			return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).tamaguiModules || [];
+		} catch (err) {
+			if (log) logger.error(err);
+			return [];
+		}
+	})])].flat();
+	if (log) logger.debug("tamaguiModules:", tamaguiModules.join(", "));
+	return tamaguiModules;
+}
+function resolveConfig(keys = []) {
+	return keys.reduce((acc, key) => {
+		if (process.env[key]) acc[key] = process.env[key];
+		return acc;
+	}, {});
+}
+let _projectRoot;
+function lookupProjectRoot() {
+	if (_projectRoot) return _projectRoot;
+	try {
+		const { stdout } = spawnSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" });
+		_projectRoot = stdout.trim();
+		return _projectRoot;
+	} catch {
+		_projectRoot = process.cwd();
+		return _projectRoot;
+	}
+}
+
+//#endregion
+//#region src/vite.ts
+/**
+* Creates a shared Vite configuration for multiplatform.one apps.
+*
+* This abstracts away the boilerplate that's typically duplicated across
+* app vite.config.ts files, including Tamagui plugin setup, i18n,
+* env variable loading, SSR configuration, and One framework integration.
+*
+* @example
+* ```ts
+* // apps/one/vite.config.ts
+* import { createViteConfig } from "@multiplatform.one/config/vite";
+* import { public as publicConfigKeys } from "../../features/config.json";
+*
+* export default createViteConfig({
+*   publicConfigKeys,
+*   one: { web: { deploy: "node", defaultRenderMode: "ssr" } },
+*   tamagui: { config: "./config/tamagui.config.ts" },
+*   i18n: { paths: ["../../features/i18n"] },
+* });
+* ```
+*/
+function createViteConfig(options = {}) {
+	const { projectRoot: _projectRoot, publicConfigKeys = [], tamagui = true, i18n = false, one = false, ssr, server, plugins: extraPlugins = [], externalReactRouter, ssrDeps, ssrEntries } = options;
+	const projectRoot = _projectRoot || findProjectRoot();
+	dotenv.config({ path: path.resolve(projectRoot, ".env") });
+	if (publicConfigKeys.length > 0) process.env.VITE_MP_CONFIG = JSON.stringify(resolveConfig(publicConfigKeys));
+	const vitePlugins = [];
+	vitePlugins.push(preferBuiltWorkspaceEntryPlugin());
+	if (one) {
+		vitePlugins.push(ssrReactNativeAliasPlugin());
+		vitePlugins.push(clientBrokenEsmPlugin());
+		registerNativeEngineIoBrowserTransports();
+		registerNativeWorkspaceEntries();
+	}
+	if (tamagui) {
+		const tamaguiOpts = typeof tamagui === "object" ? tamagui : {};
+		vitePlugins.push(tamaguiPlugin({
+			components: tamaguiOpts.components || lookupTamaguiModules([process.cwd()]),
+			config: tamaguiOpts.config || "./config/tamagui.config.ts",
+			outputCSS: tamaguiOpts.outputCSS || "./public/tamagui.css",
+			disableWatchTamaguiConfig: true
+		}));
+	}
+	if (i18n) {
+		const i18nOpts = typeof i18n === "object" ? i18n : {};
+		vitePlugins.push(i18nextLoader({
+			paths: i18nOpts.paths || ["../../features/i18n"],
+			namespaceResolution: i18nOpts.namespaceResolution || "basename"
+		}));
+	}
+	if (externalReactRouter !== false && one) vitePlugins.push(createExternal({ externals: { "react-router-dom": {} } }));
+	vitePlugins.push(...extraPlugins);
+	const defaultSsr = one ? {
+		noExternal: true,
+		optimizeDeps: {
+			entries: ssrEntries ?? ["routes/**/*.{ts,tsx}"],
+			include: [
+				"@tamagui/core",
+				"@tamagui/web",
+				"tamagui",
+				"@tamagui/toast",
+				"@tamagui/linear-gradient",
+				"react-i18next",
+				"i18next",
+				"@tanstack/react-store",
+				"@tanstack/store",
+				"void-elements",
+				"use-sync-external-store",
+				"use-sync-external-store/shim",
+				...ssrDeps?.include || []
+			],
+			exclude: [
+				"@react-native/assets-registry",
+				"@react-native-community/datetimepicker",
+				"socket.io-client",
+				"engine.io-client",
+				"xmlhttprequest-ssl",
+				"@tanstack/form-devtools",
+				"@tanstack/react-form-devtools",
+				...ssrDeps?.exclude || []
+			],
+			rolldownOptions: {
+				external: [
+					"@tanstack/form-devtools",
+					"@tanstack/react-form-devtools",
+					...ssrDeps?.external || []
+				],
+				shimMissingExports: true
+			}
+		},
+		external: [
+			"loglevel",
+			"@react-native/assets-registry",
+			"@react-native-community/datetimepicker",
+			"socket.io-client",
+			"engine.io-client",
+			"xmlhttprequest-ssl",
+			"@tanstack/form-devtools",
+			"@tanstack/react-form-devtools",
+			...ssrDeps?.external || [],
+			"@opentelemetry/semantic-conventions",
+			"@opentelemetry/api",
+			"@opentelemetry/sdk-trace-base",
+			"@opentelemetry/sdk-trace-node"
+		]
+	} : void 0;
+	const onePort = Number(process.env.ONE_PORT) || 3e3;
+	const defaultServer = {
+		allowedHosts: [
+			"localhost",
+			"127.0.0.1",
+			"app.localhost",
+			"app.test"
+		],
+		strictPort: true,
+		watch: { ignored: ["**/src-tauri/**"] },
+		...one ? { hmr: {
+			path: "/__vxrnhmr",
+			clientPort: onePort
+		} } : {},
+		...server
+	};
+	return {
+		css: { modules: { localsConvention: "camelCase" } },
+		build: { chunkSizeWarningLimit: 600 },
+		define: { "process.env.VITE_FRAPPE_ENABLED": JSON.stringify(process.env.VITE_FRAPPE_ENABLED === "true" ? "true" : "false") },
+		ssr: ssr || defaultSsr,
+		resolve: {
+			alias: {
+				"react.mjs": "react",
+				"react-compiler-runtime": "react/compiler-runtime"
+			},
+			dedupe: ["react-is"]
+		},
+		server: defaultServer,
+		envPrefix: ["VITE_", "TAURI_ENV_"],
+		plugins: vitePlugins
+	};
+}
+/**
+* Aliases react-native to react-native-web in the SSR environment.
+*
+* @react-navigation/native statically imports react-native, which causes
+* Rolldown's dep optimizer to load react-native/index.js — a file that contains
+* Flow-only syntax (`import typeof`, `as Type`) that Rolldown cannot parse.
+* Aliasing to react-native-web redirects those imports to the web-safe shim,
+* so the real react-native package is never touched during SSR bundling.
+*/
+function ssrReactNativeAliasPlugin() {
+	return {
+		name: "multiplatform-ssr-react-native-alias",
+		enforce: "post",
+		configResolved(config) {
+			const ssrEnv = config.environments?.ssr;
+			if (!ssrEnv?.resolve) return;
+			const alias = ssrEnv.resolve.alias ?? [];
+			if (!alias.some((a) => a.find === "react-native")) alias.push({
+				find: "react-native",
+				replacement: "react-native-web"
+			});
+			ssrEnv.resolve.alias = alias;
+		}
+	};
+}
+/**
+* Adds packages that have broken or missing ESM default exports to the client
+* environments pre-bundle. Rolldown resolves them via their "import" condition
+* and generates a proper ESM chunk with synthetic interop default export.
+*
+* use-latest-callback: type=commonjs, exports.import → esm.mjs, but vxrn's
+* client conditions (["vxrn-web"]) skip "import" and land on "default" →
+* lib/src/index.js (CJS, named-only). Pre-bundling forces the import condition.
+*/
+function clientBrokenEsmPlugin() {
+	return {
+		name: "multiplatform-client-broken-esm",
+		configResolved(config) {
+			const clientEnv = config.environments?.client;
+			if (!clientEnv?.optimizeDeps) return;
+			const extras = [
+				"use-latest-callback",
+				"escape-string-regexp",
+				"use-sync-external-store/with-selector",
+				"react-is",
+				"fast-deep-equal",
+				"color",
+				"query-string"
+			];
+			const include = clientEnv.optimizeDeps.include ?? [];
+			for (const dep of extras) if (!include.includes(dep)) include.push(dep);
+			clientEnv.optimizeDeps.include = include;
+		}
+	};
+}
+/**
+* Adds engine.io-client's `browser`-field transport redirect to vxrn's NATIVE
+* rolldown pipeline via its `globalThis.__vxrnAddNativePlugins` hook.
+*
+* socket.io-client -> engine.io-client/index.js statically imports its Node
+* transports (`./globals.node.js`, `./transports/{websocket,polling-xhr}.node.js`),
+* which pull `ws` + `xmlhttprequest-ssl` + Node globals. Those `.node` files also
+* contain raw ESM `import` syntax that Hermes can't even COMPILE, so the native
+* bundle dies at boot. engine.io's own `package.json` `browser` field already
+* redirects each `*.node.js` to a browser sibling that uses the global
+* `WebSocket` / `XMLHttpRequest` React Native provides — but vxrn's native
+* resolver omits the `browser` aliasField (and its rolldown binding doesn't even
+* support `aliasFields`). vxrn's native dev engine ignores the Vite config's
+* `resolve.alias`/`resolveId` too — BUT it DOES read `globalThis.__vxrnAddNativePlugins`
+* inside `getNativePlugins`, so a `resolveId` registered there runs on native.
+* This re-asserts the browser redirect with no node_modules patch. Web is
+* unaffected (engine.io is SSR-externalized and the web client already maps `browser`).
+*/
+function registerNativeEngineIoBrowserTransports() {
+	const g = globalThis;
+	const name = "vxrn-engineio-browser-transports";
+	g.__vxrnAddNativePlugins = g.__vxrnAddNativePlugins ?? [];
+	if (g.__vxrnAddNativePlugins.some((p) => p?.name === name)) return;
+	g.__vxrnAddNativePlugins.push({
+		name,
+		async resolveId(id, importer) {
+			if (importer && /engine\.io-client[\\/]build[\\/]/.test(importer) && id.endsWith(".node.js")) return this.resolve(`${id.slice(0, -8)}.js`, importer, { skipSelf: true });
+			return null;
+		}
+	});
+}
+/**
+* Routes workspace (`@multiplatform.one/*`) packages to their `dist/esm/index.native.js`
+* build on NATIVE, via vxrn's `globalThis.__vxrnAddNativePlugins` hook.
+*
+* Why this is needed: `preferBuiltWorkspaceEntryPlugin` (a Vite plugin, web/SSR only)
+* hard-resolves every workspace bare specifier to `<root>/dist/esm/index.mjs` — the WEB
+* build — bypassing the package.json `exports` `react-native` condition. That web
+* resolution propagates into vxrn's native graph (the native engine receives no Vite
+* userPlugins, so it cannot be made native-aware there), pinning the entire workspace
+* chain to web on native and dragging web-only deps (@tiptap, prosemirror, html5-qrcode,
+* @mixmark-io/domino, …) into Hermes. Each affected package ships a `dist/esm/index.native.js`
+* (built by tamagui-build, intra-package imports already rewritten to their `.native`
+* siblings). This resolveId matches both forms — the bare specifier and the already-resolved
+* `…/dist/esm/index.mjs` path — and redirects to the native sibling when it exists, so the
+* react-native build wins on native. Web/SSR are unaffected (this plugin runs ONLY on native).
+*/
+function registerNativeWorkspaceEntries() {
+	const g = globalThis;
+	const name = "vxrn-workspace-native-entries";
+	g.__vxrnAddNativePlugins = g.__vxrnAddNativePlugins ?? [];
+	if (g.__vxrnAddNativePlugins.some((p) => p?.name === name)) return;
+	let roots;
+	try {
+		roots = discoverPublicPackageRoots(findProjectRoot());
+	} catch {
+		roots = /* @__PURE__ */ new Map();
+	}
+	g.__vxrnAddNativePlugins.push({
+		name,
+		resolveId(id) {
+			const root = roots.get(id);
+			if (root) {
+				const nativeEntry = path.join(root, "dist/esm/index.native.js");
+				return fs.existsSync(nativeEntry) ? nativeEntry : null;
+			}
+			if (id.endsWith("/dist/esm/index.mjs")) {
+				const nativeEntry = `${id.slice(0, -4)}.native.js`;
+				if (fs.existsSync(nativeEntry)) return nativeEntry;
+			}
+			return null;
+		}
+	});
+}
+function findProjectRoot() {
+	try {
+		const { execSync } = __require("node:child_process");
+		return execSync("git rev-parse --show-toplevel", { encoding: "utf8" }).trim();
+	} catch {
+		return process.cwd();
+	}
+}
+/**
+* package.json `exports` cannot branch on whether `dist/` exists. For workspace
+* packages, prefer `dist/esm/index.{mjs,js}` when built; otherwise fall back to
+* `src/index.ts` so local dev works without a build while published tarballs
+* still resolve through `exports` to `dist`.
+*/
+function preferBuiltWorkspaceEntryPlugin() {
+	const roots = discoverPublicPackageRoots(findProjectRoot());
+	return {
+		name: "multiplatform-prefer-built-workspace-main",
+		enforce: "pre",
+		resolveId(id) {
+			const root = roots.get(id);
+			if (!root) return null;
+			const distCandidates = [path.join(root, "dist/esm/index.mjs"), path.join(root, "dist/esm/index.js")];
+			for (const file of distCandidates) if (fs.existsSync(file)) return file;
+			const srcTs = path.join(root, "src/index.ts");
+			if (fs.existsSync(srcTs)) return srcTs;
+			const srcTsx = path.join(root, "src/index.tsx");
+			if (fs.existsSync(srcTsx)) return srcTsx;
+			const pkgJsonPath = path.join(root, "package.json");
+			if (fs.existsSync(pkgJsonPath)) try {
+				const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+				const entry = pkg.exports?.["."]?.import || pkg.exports?.["."]?.default || pkg.main || pkg.module;
+				if (entry) {
+					const resolved = path.resolve(root, entry);
+					if (fs.existsSync(resolved)) return resolved;
+				}
+			} catch {}
+			return null;
+		}
+	};
+}
+
+//#endregion
+export { createViteConfig as t };

package/lib/vite.js

@@ -0,0 +1,4 @@
+import { t as createViteConfig } from "./vite-BfDEN9iw.js";
+import { n as publicPackageViteSourceAliases, t as discoverPublicPackageRoots } from "./workspacePublicPackages-BPzu1MKc.js";
+
+export { createViteConfig, discoverPublicPackageRoots, publicPackageViteSourceAliases };

package/lib/vitest.js

@@ -0,0 +1,150 @@
+import path from "node:path";
+import { tamaguiPlugin } from "@tamagui/vite-plugin";
+import react from "@vitejs/plugin-react";
+
+//#region src/vitest.ts
+/**
+* Creates a shared Vitest configuration for multiplatform.one packages.
+*
+* This eliminates the ~100 lines of duplicated vitest config across 13+ packages,
+* handling Tamagui transforms, react-native-web replacement, React deduplication,
+* and consistent coverage/environment settings.
+*
+* @example
+* ```ts
+* // packages/components/vitest.config.mjs
+* import { createVitestConfig } from "@multiplatform.one/config/vitest";
+*
+* export default createVitestConfig({
+*   setupFiles: ["./tests/setup.tsx"],
+*   tamaguiConfig: "../../features/tamagui.config.ts",
+* });
+* ```
+*/
+function createVitestConfig(options = {}) {
+	const { tamaguiConfig = "./tests/tamagui.config.ts", environment = "jsdom", setupFiles = [], testTimeout = 3e4, inlineDeps = [], externalDeps = [], aliases = {}, coverage, replaceReactNative = true, dedupeReact = true, rootNodeModules: _rootNodeModules, conditions = [
+		"source",
+		"test",
+		"browser"
+	], include, exclude, passWithNoTests } = options;
+	const rootNodeModules = _rootNodeModules || path.resolve(process.cwd(), "../../node_modules");
+	const plugins = [react({ jsxRuntime: "automatic" })];
+	if (replaceReactNative) plugins.push({
+		name: "replace-react-native",
+		transform(code, id) {
+			if (id.includes("node_modules")) return;
+			return {
+				code: code.replace(/from ['"]react-native['"]/g, "from \"react-native-web\""),
+				map: null
+			};
+		}
+	});
+	if (tamaguiConfig !== false) plugins.push(tamaguiPlugin({
+		components: ["tamagui"],
+		config: tamaguiConfig
+	}));
+	const resolveAliases = {};
+	if (replaceReactNative) {
+		resolveAliases["react-native"] = "react-native-web";
+		resolveAliases["react-native-svg"] = "@tamagui/react-native-svg";
+	}
+	if (dedupeReact) {
+		resolveAliases.react = path.resolve(rootNodeModules, "react");
+		resolveAliases["react-dom"] = path.resolve(rootNodeModules, "react-dom");
+		resolveAliases["react-dom/client"] = path.resolve(rootNodeModules, "react-dom/client");
+		resolveAliases["react-dom/server"] = path.resolve(rootNodeModules, "react-dom/server");
+		resolveAliases["react/jsx-runtime"] = path.resolve(rootNodeModules, "react/jsx-runtime");
+		resolveAliases["react/jsx-dev-runtime"] = path.resolve(rootNodeModules, "react/jsx-dev-runtime");
+		resolveAliases.scheduler = path.resolve(rootNodeModules, "scheduler");
+	}
+	const testConfig = {
+		environment,
+		globals: true,
+		setupFiles,
+		testTimeout,
+		coverage: {
+			provider: "v8",
+			reporter: [
+				"text",
+				"lcov",
+				"html"
+			],
+			reportsDirectory: "./coverage",
+			all: true,
+			clean: true,
+			exclude: [
+				"node_modules/",
+				"tests/",
+				"*.config.*",
+				"**/*.stories.*",
+				"**/*.spec.*",
+				"**/*.test.*",
+				...coverage?.exclude || []
+			]
+		},
+		server: { deps: {
+			inline: [
+				"react-native-web",
+				"one",
+				/@tamagui\//,
+				"tamagui",
+				...inlineDeps
+			],
+			...externalDeps.length > 0 ? { external: externalDeps } : {},
+			interopDefault: true
+		} }
+	};
+	if (include) testConfig.include = include;
+	if (exclude) testConfig.exclude = exclude;
+	if (passWithNoTests) testConfig.passWithNoTests = true;
+	return {
+		plugins,
+		test: testConfig,
+		resolve: {
+			extensions: [
+				".test.ts",
+				".test.tsx",
+				".web.ts",
+				".web.tsx",
+				".web.js",
+				".web.jsx",
+				".ts",
+				".tsx",
+				".js",
+				".jsx"
+			],
+			mainFields: [
+				"browser",
+				"module",
+				"main"
+			],
+			alias: {
+				...resolveAliases,
+				...aliases
+			},
+			conditions,
+			dedupe: dedupeReact ? [
+				"react",
+				"react-dom",
+				"scheduler"
+			] : []
+		},
+		define: {
+			__DEV__: true,
+			global: "globalThis",
+			process: JSON.stringify({
+				env: {
+					NODE_ENV: "test",
+					NODE_DEBUG: false
+				},
+				platform: process.platform,
+				version: process.version,
+				type: "renderer"
+			}),
+			"Buffer.isBuffer": "((obj) => obj?.constructor?.name === 'Buffer')"
+		}
+	};
+}
+
+//#endregion
+export { createVitestConfig };

package/lib/workspacePublicPackages-BPzu1MKc.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+
+//#region src/workspacePublicPackages.ts
+/**
+* Every direct child of `public/` with a `package.json` `name` is treated as a
+* publishable workspace package (same rule as Metro in `apps/storybook-expo`).
+*
+* Tamagui’s internal esbuild (bundling `tamagui.config` + `components`) reads
+* `compilerOptions.paths` from the repo `tsconfig.base.json` chain, including
+* `tamagui-workspace-paths.generated.json` (see `scripts/generate-tamagui-workspace-paths.mjs`).
+*/
+function discoverPublicPackageRoots(workspaceRoot) {
+	const byName = /* @__PURE__ */ new Map();
+	const publicDir = path.join(workspaceRoot, "public");
+	if (!fs.existsSync(publicDir)) return byName;
+	for (const ent of fs.readdirSync(publicDir, { withFileTypes: true })) {
+		if (!ent.isDirectory()) continue;
+		const pkgRoot = path.join(publicDir, ent.name);
+		const pkgJsonPath = path.join(pkgRoot, "package.json");
+		if (!fs.existsSync(pkgJsonPath)) continue;
+		try {
+			const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+			if (typeof pkg.name === "string" && pkg.name.length > 0) byName.set(pkg.name, pkgRoot);
+		} catch {}
+	}
+	return byName;
+}
+/** Main entry file for Vite/Storybook-style “compile from source” aliases. */
+function resolvePackageMainSource(pkgDir) {
+	return [
+		path.join(pkgDir, "src", "index.storybook.ts"),
+		path.join(pkgDir, "src", "index.storybook.tsx"),
+		path.join(pkgDir, "src", "index.ts"),
+		path.join(pkgDir, "src", "index.tsx"),
+		path.join(pkgDir, "index.storybook.ts"),
+		path.join(pkgDir, "index.storybook.tsx"),
+		path.join(pkgDir, "index.ts"),
+		path.join(pkgDir, "index.tsx")
+	].find((c) => fs.existsSync(c));
+}
+/**
+* Vite `resolve.alias` entries: each public package name → its TypeScript main.
+* For SPA / ad-hoc Vite configs that should not list packages by hand.
+*/
+function publicPackageViteSourceAliases(workspaceRoot) {
+	const aliases = {};
+	for (const [name, dir] of discoverPublicPackageRoots(workspaceRoot)) {
+		const main = resolvePackageMainSource(dir);
+		if (main) aliases[name] = main;
+	}
+	return aliases;
+}
+
+//#endregion
+export { publicPackageViteSourceAliases as n, resolvePackageMainSource as r, discoverPublicPackageRoots as t };

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@multiplatform.one/config",
+  "version": "6.0.0",
+  "description": "Shared build and test configuration presets for multiplatform.one",
+  "keywords": [
+    "config",
+    "multiplatform.one",
+    "playwright",
+    "storybook",
+    "tsconfig",
+    "vite",
+    "vitest"
+  ],
+  "homepage": "https://multiplatform.one",
+  "bugs": {
+    "url": "https://gitlab.com/bitspur/multiplatform.one/multiplatform.one/issues",
+    "email": "support@risserlabs.com"
+  },
+  "license": "Apache-2.0",
+  "author": "BitSpur <support@risserlabs.com> (https://risserlabs.com)",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/bitspur/multiplatform.one/multiplatform.one"
+  },
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "lib",
+    "tsconfig",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "types": "src/index.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./src/index.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.js"
+    },
+    "./storybook": {
+      "source": "./src/storybook.ts",
+      "types": "./src/storybook.ts",
+      "import": "./lib/storybook.js",
+      "require": "./lib/storybook.js"
+    },
+    "./vite": {
+      "source": "./src/vite.ts",
+      "types": "./src/vite.ts",
+      "import": "./lib/vite.js",
+      "require": "./lib/vite.js"
+    },
+    "./vitest": {
+      "source": "./src/vitest.ts",
+      "types": "./src/vitest.ts",
+      "import": "./lib/vitest.js",
+      "require": "./lib/vitest.js"
+    },
+    "./playwright": {
+      "source": "./src/playwright.ts",
+      "types": "./src/playwright.ts",
+      "import": "./lib/playwright.js",
+      "require": "./lib/playwright.js"
+    },
+    "./tsconfig/base.json": "./tsconfig/base.json",
+    "./tsconfig/build.json": "./tsconfig/build.json",
+    "./tsconfig/app.json": "./tsconfig/app.json",
+    "./react-native-config": "./src/react-native.config.cjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@tamagui/vite-plugin": "2.0.0-rc.41",
+    "@vitejs/plugin-react": "^6.0.1",
+    "dotenv": "^17.4.2",
+    "vite": "^8.0.10",
+    "vite-plugin-external": "^6.2.2",
+    "vite-plugin-i18next-loader": "^3.1.3",
+    "vitest": "^4.1.5",
+    "@multiplatform.one/utils": "6.0.0"
+  },
+  "devDependencies": {
+    "tsdown": "^0.21.10",
+    "typescript": "~5.9.3"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.20.0",
+    "one": "^1.4.10"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    },
+    "one": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "rm -rf lib 2>/dev/null && tsdown"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { createStorybookViteConfig, type CreateStorybookViteConfigOptions } from "./storybook";
+export { createViteConfig, type CreateViteConfigOptions } from "./vite";
+export { createVitestConfig, type CreateVitestConfigOptions } from "./vitest";