@vixt/core 0.5.17 → 0.6.0

package/dist/index.mjs

@@ -0,0 +1,643 @@
+import { loadConfig } from "c12";
+import fs from "fs-extra";
+import path, { normalize, resolve } from "pathe";
+import process, { cwd, env } from "node:process";
+import { cac } from "cac";
+import { findUpSync } from "find-up";
+import { loadEnv as loadEnv$1, mergeConfig, parseAst } from "vite";
+import defu from "defu";
+import { createJiti } from "jiti";
+import { pathToFileURL } from "mlly";
+import Legacy from "@vitejs/plugin-legacy";
+import Analyzer from "vite-bundle-analyzer";
+import Ssl from "@vitejs/plugin-basic-ssl";
+import Checker from "vite-plugin-checker";
+
+//#region src/node/env.ts
+function loadCLIOptions() {
+	return cac().parse().options ?? {};
+}
+function loadMode() {
+	const { mode, m } = loadCLIOptions();
+	return mode || m || env.NODE_ENV;
+}
+/**
+* Load workspace and cwd env variables by default
+*/
+function loadEnv(mode, envDir, prefixes) {
+	mode = mode || loadMode();
+	return {
+		MODE: mode,
+		DEV: env.NODE_ENV !== "production",
+		PROD: env.NODE_ENV === "production",
+		...loadWorkspaceEnv(mode, prefixes),
+		...loadEnv$1(mode, envDir || cwd(), prefixes)
+	};
+}
+/**
+* find the workspace dir
+*/
+function findUpWorkspaceDir() {
+	const workspaceManifestLocation = findUpSync(["pnpm-workspace.yaml", "pnpm-workspace.yml"]);
+	return workspaceManifestLocation && path.dirname(workspaceManifestLocation);
+}
+/**
+* Load workspace env variables
+*/
+function loadWorkspaceEnv(mode, prefixes) {
+	const workspaceDir = findUpWorkspaceDir();
+	return workspaceDir ? loadEnv$1(mode, workspaceDir, prefixes) : {};
+}
+
+//#endregion
+//#region src/node/config.ts
+function defineVixtConfig(input) {
+	return input;
+}
+async function loadVixtConfig(opts) {
+	const result = await loadConfig({
+		name: "vixt",
+		rcFile: false,
+		...opts
+	});
+	const { config, cwd: cwd$1 } = result;
+	config.rootDir ??= cwd$1;
+	config.buildDir ??= resolve(config.rootDir, ".vixt");
+	config.buildTypesDir ??= resolve(config.buildDir, "types");
+	config.buildLayersDir ??= resolve(config.buildDir, "layers");
+	config.buildImportsDir ??= resolve(config.buildDir, "imports");
+	config.workspaceDir ??= findUpWorkspaceDir();
+	config.srcDir ??= resolve(config.rootDir, "src");
+	config.modulesDir ??= resolve(config.srcDir, "modules");
+	config.pluginsDir ??= resolve(config.srcDir, "plugins");
+	return result;
+}
+function applyLayers(layers, config) {
+	const { rootDir, buildLayersDir } = config;
+	return layers.filter((e) => e.cwd).map((layer) => {
+		const meta = layer.config?.meta ?? {};
+		const layerName = meta.name || layer.cwd.split("/").pop();
+		if (!isSamePath(layer.cwd, resolve(rootDir))) meta.alias = `#/layers/${layerName}`;
+		if (layer.cwd?.includes("node_modules")) {
+			const newCwd = resolve(buildLayersDir, layerName);
+			fs.removeSync(newCwd);
+			fs.copySync(layer.cwd, newCwd, { filter: (src) => {
+				const nodeModulesPath = resolve(layer.cwd, "node_modules");
+				const tsConfigPath = resolve(layer.cwd, "tsconfig.json");
+				return !isSamePath(src, nodeModulesPath) && !isSamePath(src, tsConfigPath);
+			} });
+			layer.cwd = newCwd;
+		}
+		layer.config ??= {};
+		layer.config.rootDir ??= layer.cwd;
+		layer.config.srcDir ??= resolve(layer.config.rootDir, "src");
+		layer.config.modulesDir ??= resolve(layer.config.srcDir, "modules");
+		layer.config.pluginsDir ??= resolve(layer.config.srcDir, "plugins");
+		return {
+			...layer,
+			meta
+		};
+	});
+}
+function isSamePath(a, b) {
+	return normalize(a) === normalize(b);
+}
+function resolveLayersDirs(layers = []) {
+	const dirs = {};
+	for (const layer of layers) {
+		const srcPath = layer.config.srcDir;
+		const contents = fs.existsSync(srcPath) ? fs.readdirSync(srcPath) : [];
+		for (const content of contents) {
+			const fileOrDirPath = resolve(srcPath, content);
+			if (fs.statSync(fileOrDirPath).isDirectory()) {
+				dirs[content] ??= [];
+				dirs[content].push(fileOrDirPath);
+			}
+		}
+	}
+	return dirs;
+}
+const VixtClientAutoImports = { "@vixt/core/client": [
+	"defineAppConfig",
+	"defineVixtPlugin",
+	"useAppConfig",
+	"useVixtApp"
+] };
+
+//#endregion
+//#region src/node/module.ts
+function defineVitePlugin(pluginFn) {
+	return pluginFn;
+}
+function defineVixtModule(definition) {
+	if (typeof definition == "function") return defineVixtModule({ setup: definition });
+	const module = definition;
+	function getOptions(inlineOptions, vixt) {
+		const configKey = module.meta?.configKey || module.meta?.name;
+		const resolvedOptions = defu(inlineOptions, configKey ? vixt.options[configKey] : {}, typeof module.defaults === "function" ? module.defaults(vixt) : module.defaults);
+		if (configKey) vixt.options[configKey] = resolvedOptions;
+		return resolvedOptions;
+	}
+	function normalizedModule(inlineOptions, vixt) {
+		const options = getOptions(inlineOptions, vixt);
+		return module.setup?.(options, vixt);
+	}
+	normalizedModule.getMeta = () => module.meta;
+	normalizedModule.getOptions = getOptions;
+	return normalizedModule;
+}
+function installModule(module, inlineOptions, vixt) {
+	return module(inlineOptions, vixt);
+}
+async function applyLayerModules(layers) {
+	const { modules: modulesDirs = [] } = resolveLayersDirs(layers);
+	const modules = [];
+	const jiti = createJiti(layers[0]?.cwd ?? process.cwd(), { moduleCache: false });
+	for (const m of modulesDirs.reverse()) if (fs.existsSync(m)) {
+		const files = fs.readdirSync(m);
+		for (const f of files) try {
+			const fileURL = pathToFileURL(path.resolve(m, f));
+			const module = await jiti.import(fileURL, { default: true });
+			modules.push(module);
+		} catch {}
+	}
+	return modules;
+}
+
+//#endregion
+//#region src/node/modules/alias.ts
+const name$8 = "vixt:alias";
+var alias_default = defineVixtModule({
+	meta: {
+		name: name$8,
+		configKey: "alias"
+	},
+	defaults(vixt) {
+		const { rootDir, buildDir, srcDir } = vixt.options;
+		const alias = {
+			"@": srcDir,
+			"~": srcDir,
+			"@@": rootDir,
+			"~~": rootDir
+		};
+		for (const layer of vixt._layers) if (layer.meta?.alias) alias[layer.meta.alias] = layer.cwd;
+		alias["#"] = buildDir;
+		return alias;
+	},
+	setup(options) {
+		return {
+			name: name$8,
+			enforce: "pre",
+			config() {
+				return { resolve: { alias: options } };
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/node/modules/app.ts
+function resolveHead(tag, attrs) {
+	const defaultInjectTo = ["script", "noscript"].includes(tag) ? "body" : void 0;
+	const { children, injectTo = defaultInjectTo, ..._attrs } = attrs;
+	return {
+		tag,
+		attrs: _attrs,
+		children,
+		injectTo
+	};
+}
+function isEmptyCode(code) {
+	if (!code) return true;
+	try {
+		return !parseAst(code, { jsx: true }).body.length;
+	} catch {
+		return true;
+	}
+}
+function resolveLoadingTemplate(options, vixt) {
+	const { loadingTemplate } = options;
+	if (loadingTemplate && fs.existsSync(loadingTemplate)) return fs.readFileSync(loadingTemplate, "utf-8");
+	for (const layer of vixt._layers) {
+		const layerLoadingTemplate = path.resolve(layer.cwd, "loading.html");
+		if (fs.existsSync(layerLoadingTemplate)) return fs.readFileSync(layerLoadingTemplate, "utf-8");
+	}
+}
+function resolveEntryCode(options, vixt) {
+	const { entryCode, entryFile } = options;
+	for (const layer of vixt._layers) {
+		const layerEntryPath = path.resolve(layer.config.srcDir, entryFile);
+		const code = fs.existsSync(layerEntryPath) && fs.readFileSync(layerEntryPath, "utf-8");
+		if (!isEmptyCode(code || "")) return code;
+	}
+	return entryCode;
+}
+const name$7 = "vixt:app";
+var app_default = defineVixtModule({
+	meta: {
+		name: name$7,
+		configKey: "app"
+	},
+	defaults: {
+		rootId: "app",
+		rootTag: "div",
+		baseURL: "/",
+		css: []
+	},
+	setup(options, vixt) {
+		const { srcDir } = vixt.options;
+		const { entryFile, rootTag, rootId, head } = options;
+		const relativeEntryPath = `/${path.basename(srcDir)}/${entryFile}`;
+		const absoluteEntryPath = path.resolve(srcDir, entryFile);
+		const order = "pre";
+		return {
+			name: name$7,
+			enforce: order,
+			load: {
+				order,
+				handler(id) {
+					if (id === relativeEntryPath) return resolveEntryCode(options, vixt);
+				}
+			},
+			transform: {
+				order,
+				handler(code, id) {
+					if (id === absoluteEntryPath && isEmptyCode(code)) return resolveEntryCode(options, vixt);
+				}
+			},
+			transformIndexHtml: {
+				order,
+				handler() {
+					const tags = Object.entries(head ?? {}).map(([tag, attrs]) => attrs.map((attr) => resolveHead(tag, attr))).flat();
+					const loadingTemplate = resolveLoadingTemplate(options, vixt);
+					return [
+						{
+							tag: rootTag,
+							attrs: { id: rootId },
+							children: loadingTemplate,
+							injectTo: "body"
+						},
+						{
+							tag: "script",
+							attrs: {
+								type: "module",
+								src: relativeEntryPath
+							},
+							injectTo: "body"
+						},
+						...tags
+					];
+				}
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/node/modules/build.ts
+const name$6 = "vixt:build";
+var build_default = defineVixtModule({
+	meta: {
+		name: name$6,
+		configKey: "build"
+	},
+	setup(options) {
+		const analyzeOptions = {
+			enabled: !!options.analyze,
+			...typeof options.analyze === "object" ? options.analyze : {}
+		};
+		const legacyOptions = {
+			enabled: !!options.legacy,
+			...typeof options.legacy === "object" ? options.legacy : {}
+		};
+		return [analyzeOptions.enabled && Analyzer(analyzeOptions), legacyOptions.enabled && Legacy(legacyOptions)];
+	}
+});
+
+//#endregion
+//#region src/node/modules/dev-server.ts
+const name$5 = "vixt:dev-server";
+var dev_server_default = defineVixtModule({
+	meta: {
+		name: name$5,
+		configKey: "devServer"
+	},
+	defaults(vixt) {
+		const watchFiles = [];
+		const configFiles = vixt._layers.map((layer) => layer.configFile).filter((e) => !e.includes("node_modules"));
+		const modulesDirs = vixt._layers.map((layer) => layer.config.modulesDir).filter((e) => !e.includes("node_modules"));
+		watchFiles.push(...configFiles, ...modulesDirs);
+		const workspaceDir = findUpWorkspaceDir();
+		if (workspaceDir) {
+			const mode = loadMode();
+			const envFiles = [
+				`${workspaceDir}/.env`,
+				`${workspaceDir}/.env.local`,
+				`${workspaceDir}/.env.${mode}`,
+				`${workspaceDir}/.env.${mode}.local`
+			];
+			watchFiles.push(...envFiles);
+		}
+		return { watch: watchFiles };
+	},
+	setup(options) {
+		const sslOptions = {
+			enabled: !!options.https,
+			...typeof options.https === "object" ? options.https : {}
+		};
+		const watchFiles = options.watch ?? [];
+		let timer;
+		function schedule(fn) {
+			clearTimeout(timer);
+			timer = setTimeout(fn, 500);
+		}
+		return [{
+			name: name$5,
+			enforce: "pre",
+			config() {
+				const { port, host, cors } = options;
+				return { server: {
+					port,
+					host,
+					cors
+				} };
+			},
+			configureServer(server) {
+				server.watcher.add(watchFiles);
+				server.watcher.on("all", (_, file) => {
+					watchFiles.some((e) => path.normalize(file).match(e)) && schedule(() => server.restart());
+				});
+			}
+		}, sslOptions.enabled && Ssl(sslOptions)];
+	}
+});
+
+//#endregion
+//#region src/node/modules/typescript.ts
+function generateTsConfig(options, vixt) {
+	const { buildDir } = vixt.options;
+	const codePath = path.resolve(buildDir, "tsconfig.json");
+	const code = JSON.stringify(options.tsConfig, null, 2);
+	fs.outputFileSync(codePath, code);
+}
+function generateVixtDts(options, vixt) {
+	const { buildDir } = vixt.options;
+	const codePath = path.resolve(buildDir, "vixt.d.ts");
+	const code = options.references?.map((reference) => {
+		if (typeof reference === "string") return `/// <reference path="${reference}" />`;
+		else if (typeof reference === "object" && reference.path && reference.content) {
+			fs.outputFileSync(path.resolve(buildDir, reference.path), reference.content);
+			return `/// <reference path="${reference.path}" />`;
+		} else return "";
+	}).concat("export {}").join("\n");
+	code && fs.outputFileSync(codePath, code);
+}
+function genarateShim(options, vixt) {
+	if (!options.shim) return;
+	const { buildTypesDir } = vixt.options;
+	const code = `
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent
+  export default component
+}
+`;
+	const codePath = path.resolve(buildTypesDir, "vue-shim.d.ts");
+	fs.outputFileSync(codePath, code);
+}
+function generateEnvDts(env$1, vixt) {
+	const { buildTypesDir } = vixt.options;
+	const codePath = path.resolve(buildTypesDir, "vite-env.d.ts");
+	const code = `interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+interface ImportMetaEnv {
+  ${Object.entries(env$1).map(([key, value]) => `/** ${key}=${value} */\n  ${key}: ${typeof value}`).join("\n  ")}
+}
+`;
+	fs.outputFileSync(codePath, code);
+}
+const name$4 = "vixt:typescript";
+var typescript_default = defineVixtModule({
+	meta: {
+		name: name$4,
+		configKey: "typescript"
+	},
+	defaults(vixt) {
+		const { rootDir, alias } = vixt.options;
+		const paths = {};
+		for (const [ak, av] of Object.entries(alias ?? {})) {
+			const stats = fs.existsSync(av) ? fs.statSync(av) : null;
+			paths[ak] = [av];
+			if (stats?.isDirectory()) paths[`${ak}/*`] = [`${av}/*`];
+		}
+		const include = ["./**/*", ...vixt._layers.map((e) => e.cwd)];
+		return {
+			tsConfig: {
+				extends: "@vue/tsconfig/tsconfig.dom.json",
+				compilerOptions: {
+					baseUrl: rootDir,
+					paths,
+					types: ["vite/client"]
+				},
+				include
+			},
+			typeCheck: {
+				enableBuild: false,
+				overlay: { initialIsOpen: false }
+			}
+		};
+	},
+	setup(options, vixt) {
+		return [{
+			name: name$4,
+			configResolved(config) {
+				generateTsConfig(options, vixt);
+				generateVixtDts(options, vixt);
+				genarateShim(options, vixt);
+				generateEnvDts(config.env, vixt);
+			}
+		}, Checker(options.typeCheck ?? {})];
+	}
+});
+
+//#endregion
+//#region src/node/modules/virtual-app-config.ts
+const name$3 = "virtual:vixt:app-config";
+const virtualModuleId$2 = name$3;
+const resolvedVirtualModuleId$2 = `\0${virtualModuleId$2}`;
+var virtual_app_config_default = defineVixtModule({
+	meta: { name: name$3 },
+	setup(_, vixt) {
+		let appConfigsImportTemplate = "";
+		let appConfigsMergeTemplate = "";
+		let i = 0;
+		for (const layer of vixt._layers) {
+			const appConfigPath = path.resolve(layer.config.srcDir, "app.config.ts");
+			if (fs.existsSync(appConfigPath)) {
+				const appConfigName = `__app_config_${i}`;
+				appConfigsImportTemplate += `import ${appConfigName} from '${appConfigPath}'\n`;
+				appConfigsMergeTemplate += `${appConfigName}, `;
+				i++;
+			}
+		}
+		const { baseURL = "/", rootId = "app" } = vixt.options.app ?? {};
+		return {
+			name: name$3,
+			resolveId(id) {
+				if (id === virtualModuleId$2) return resolvedVirtualModuleId$2;
+			},
+			load(id) {
+				if (id === resolvedVirtualModuleId$2) return `
+import { defu } from 'defu'
+${appConfigsImportTemplate}
+const appConfig = defu(${appConfigsMergeTemplate}{ baseURL: '${baseURL}', rootId: '${rootId}' })
+export default appConfig
+`;
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/node/modules/virtual-css.ts
+const name$2 = "virtual:vixt:css";
+const virtualModuleId$1 = name$2;
+const resolvedVirtualModuleId$1 = `\0${virtualModuleId$1}`;
+var virtual_css_default = defineVixtModule({
+	meta: { name: name$2 },
+	setup(_, vixt) {
+		const cssTemplate = vixt.options.app?.css?.map((css) => `import '${css}'`).join("\n") ?? "";
+		return {
+			name: name$2,
+			resolveId(id) {
+				if (id === virtualModuleId$1) return resolvedVirtualModuleId$1;
+			},
+			load(id) {
+				if (id === resolvedVirtualModuleId$1) return cssTemplate;
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/node/modules/virtual-plugins.ts
+const name$1 = "virtual:vixt:plugins";
+const virtualModuleId = name$1;
+const resolvedVirtualModuleId = `\0${virtualModuleId}`;
+var virtual_plugins_default = defineVixtModule({
+	meta: { name: name$1 },
+	setup(_, vixt) {
+		const { plugins: pluginsDirs = [] } = resolveLayersDirs(vixt._layers);
+		let pluginsImportTemplate = "";
+		let pluginsMergeTemplate = "";
+		let i = 0;
+		for (const plugin of vixt.options.plugins ?? []) {
+			const pluginName = `__plugin_${i}`;
+			pluginsImportTemplate += `import ${pluginName} from '${plugin}'\n`;
+			pluginsMergeTemplate += `${pluginName}, `;
+			i++;
+		}
+		for (const pluginsDir of pluginsDirs.reverse()) {
+			const files = fs.existsSync(pluginsDir) ? fs.readdirSync(pluginsDir) : [];
+			for (const f of files.filter((f$1) => /[jt]sx?$/.test(f$1))) {
+				const p = path.resolve(pluginsDir, f);
+				const pluginName = `__plugin_${i}`;
+				pluginsImportTemplate += `import ${pluginName} from '${p}'\n`;
+				pluginsMergeTemplate += `${pluginName}, `;
+				i++;
+			}
+		}
+		return {
+			name: name$1,
+			resolveId(id) {
+				if (id === virtualModuleId) return resolvedVirtualModuleId;
+			},
+			load(id) {
+				if (id === resolvedVirtualModuleId) return `
+${pluginsImportTemplate}
+const plugins = [${pluginsMergeTemplate}]
+export default plugins
+`;
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/node/modules/vite.ts
+const name = "vixt:vite";
+var vite_default = defineVixtModule({
+	meta: { name },
+	setup(_, vixt) {
+		let env$1;
+		return {
+			name,
+			enforce: "pre",
+			config(config) {
+				const { rootDir, app } = vixt.options;
+				env$1 = loadEnv(config.mode, config.envDir, config.envPrefix);
+				const defineEnv = Object.fromEntries(Object.entries(env$1).filter(([k]) => ![
+					"MODE",
+					"DEV",
+					"PROD"
+				].includes(k)).map(([k, v]) => [`import.meta.env.${k}`, JSON.stringify(v)]));
+				return mergeConfig(vixt.options.vite ?? {}, {
+					root: rootDir,
+					base: app?.baseURL,
+					define: defineEnv
+				});
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/node/modules/index.ts
+const virtualModuleIds = {
+	css: virtual_css_default.getMeta().name,
+	appConfig: virtual_app_config_default.getMeta().name,
+	plugins: virtual_plugins_default.getMeta().name
+};
+const builtinModules = [
+	vite_default,
+	alias_default,
+	app_default,
+	build_default,
+	dev_server_default,
+	typescript_default,
+	virtual_app_config_default,
+	virtual_css_default,
+	virtual_plugins_default
+];
+
+//#endregion
+//#region src/node/vixt.ts
+async function loadVixt(opts) {
+	const result = await loadVixtConfig(opts);
+	const cliOptions = loadCLIOptions();
+	cliOptions.force && fs.removeSync(result.config.buildDir);
+	result.config.debug = !!cliOptions.debug;
+	result.config.dev = env.NODE_ENV !== "production";
+	result.layers = applyLayers(result.layers ?? [], result.config);
+	const layerModules = await applyLayerModules(result.layers ?? []);
+	return {
+		options: result.config,
+		_layers: result.layers ?? [],
+		_modules: [
+			...builtinModules,
+			...result.config.modules ?? [],
+			...layerModules
+		]
+	};
+}
+function createVixtPlugin(loadOptions) {
+	return defineVitePlugin(async (vixtOptions) => {
+		const vixt = await loadVixt(defu({ defaults: vixtOptions }, loadOptions));
+		return vixt._modules.map((module) => installModule(module, {}, vixt));
+	});
+}
+
+//#endregion
+export { VixtClientAutoImports, applyLayerModules, applyLayers, builtinModules, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, installModule, isSamePath, loadCLIOptions, loadEnv, loadMode, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, virtualModuleIds };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vixt/core",
   "type": "module",
-  "version": "0.5.17",
+  "version": "0.6.0",
   "author": "SoulLyoko<https://github.com/SoulLyoko>",
   "license": "MIT",
   "homepage": "https://soullyoko.github.io/vixt/",
@@ -16,37 +16,32 @@
     "react"
   ],
   "exports": {
-    ".": {
-      "types": "./dist/node/index.d.ts",
-      "import": "./dist/node/index.mjs"
-    },
-    "./client": {
-      "types": "./dist/client/index.d.ts",
-      "import": "./dist/client/index.mjs"
-    }
+    ".": "./dist/node/index.mjs",
+    "./client": "./dist/client/index.js",
+    "./package.json": "./package.json"
   },
   "main": "./dist/node/index.mjs",
-  "types": "./dist/node/index.d.ts",
+  "types": "./dist/node/index.d.mts",
+  "browser": "./dist/client/index.js",
   "files": [
     "dist"
   ],
   "dependencies": {
     "@types/fs-extra": "^11.0.4",
+    "@vitejs/plugin-basic-ssl": "^2.1.0",
+    "@vitejs/plugin-legacy": "^7.2.1",
     "@vue/tsconfig": "^0.8.1",
-    "c12": "^3.3.2",
+    "c12": "^3.3.3",
     "cac": "^6.7.14",
     "defu": "^6.1.4",
     "find-up": "^8.0.0",
-    "fs-extra": "^11.3.2",
+    "fs-extra": "^11.3.3",
+    "jiti": "^2.6.1",
     "mlly": "^1.8.0",
     "pathe": "^2.0.3",
     "pkg-types": "^2.3.0",
-    "tsx": "^4.21.0",
-    "vite": "^7.2.6",
-    "vite-plugin-checker": "^0.11.0"
-  },
-  "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub"
+    "vite": "^7.3.0",
+    "vite-bundle-analyzer": "^1.3.2",
+    "vite-plugin-checker": "^0.12.0"
   }
 }