weapp-vite 7.4.0 → 7.6.0

package/dist/assets-C5_YYXNk.mjs

@@ -0,0 +1,637 @@
+import { t as resolveRealpath } from "./realpathScope-Tf9mz-fh.mjs";
+import { n as loadHostRolldownBuild } from "./engine-C66J0HLz.mjs";
+import { a as hasOwn, i as resolveWeappLibEntries, o as waitForBuildTasks } from "./lib-DjccSI1B.mjs";
+import { createRequire } from "node:module";
+import process from "node:process";
+import path from "pathe";
+import "@weapp-core/shared";
+import { fs } from "@weapp-core/shared/fs";
+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
+import os from "node:os";
+import { resolveModule } from "local-pkg";
+import { spawn } from "node:child_process";
+import { dts } from "rolldown-plugin-dts";
+//#region src/runtime/libDts/compilerOptions.ts
+function serializeCompilerOptions(tsInstance, options) {
+	const serialized = { ...options };
+	const protocol = tsInstance.server.protocol;
+	const enumOptions = {
+		jsx: [tsInstance.JsxEmit, protocol.JsxEmit],
+		module: [tsInstance.ModuleKind, protocol.ModuleKind],
+		moduleResolution: [tsInstance.ModuleResolutionKind, protocol.ModuleResolutionKind],
+		target: [tsInstance.ScriptTarget, protocol.ScriptTarget]
+	};
+	for (const [name, [numericEnum, jsonEnum]] of Object.entries(enumOptions)) {
+		const value = options[name];
+		if (typeof value === "number") {
+			const member = Object.keys(jsonEnum).find((key) => numericEnum[key] === value);
+			if (member !== void 0) serialized[name] = jsonEnum[member];
+		}
+	}
+	if (options.newLine === tsInstance.NewLineKind.CarriageReturnLineFeed) serialized.newLine = protocol.NewLineKind.Crlf.toLowerCase();
+	else if (options.newLine === tsInstance.NewLineKind.LineFeed) serialized.newLine = protocol.NewLineKind.Lf.toLowerCase();
+	for (const [name, numericEnum] of Object.entries({
+		moduleDetection: tsInstance.ModuleDetectionKind,
+		importsNotUsedAsValues: tsInstance.ImportsNotUsedAsValues
+	})) {
+		const value = options[name];
+		if (typeof value === "number" && typeof numericEnum[value] === "string") serialized[name] = numericEnum[value].toLowerCase();
+	}
+	if (options.lib) serialized.lib = options.lib.map((lib) => lib.replace(/^lib\.(.+)\.d\.ts$/i, "$1"));
+	return serialized;
+}
+//#endregion
+//#region src/runtime/libDts/rewriteWevuComponent.ts
+function getVueCompilerLib(value) {
+	if (Array.isArray(value)) {
+		const resolved = value.filter((item) => typeof item === "string");
+		return resolved.length > 0 ? resolved : void 0;
+	}
+	if (typeof value === "string") return value;
+}
+function splitTopLevelTypeArgs(value) {
+	const args = [];
+	let depth = 0;
+	let start = 0;
+	let quote = null;
+	let escape = false;
+	for (let i = 0; i < value.length; i += 1) {
+		const char = value[i];
+		if (quote) {
+			if (escape) {
+				escape = false;
+				continue;
+			}
+			if (char === "\\") {
+				escape = true;
+				continue;
+			}
+			if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "<") {
+			depth += 1;
+			continue;
+		}
+		if (char === ">") {
+			if (depth > 0) depth -= 1;
+			continue;
+		}
+		if (char === "," && depth === 0) {
+			args.push(value.slice(start, i).trim());
+			start = i + 1;
+		}
+	}
+	const tail = value.slice(start).trim();
+	if (tail) args.push(tail);
+	return args;
+}
+function findMatchingAngleBracket(value, start) {
+	let depth = 1;
+	let quote = null;
+	let escape = false;
+	for (let i = start; i < value.length; i += 1) {
+		const char = value[i];
+		if (quote) {
+			if (escape) {
+				escape = false;
+				continue;
+			}
+			if (char === "\\") {
+				escape = true;
+				continue;
+			}
+			if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "<") {
+			depth += 1;
+			continue;
+		}
+		if (char === ">") {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+function rewriteVueComponentTypeToWevu(content) {
+	const token = "import(\"vue\").DefineComponent<";
+	const tokenSingle = "import('vue').DefineComponent<";
+	if (!content.includes(token) && !content.includes(tokenSingle)) return content;
+	let result = "";
+	let index = 0;
+	while (index < content.length) {
+		const nextDouble = content.indexOf(token, index);
+		const nextSingle = content.indexOf(tokenSingle, index);
+		const next = nextDouble === -1 ? nextSingle : nextSingle === -1 ? nextDouble : Math.min(nextDouble, nextSingle);
+		if (next === -1) {
+			result += content.slice(index);
+			break;
+		}
+		const match = next === nextDouble ? token : tokenSingle;
+		result += content.slice(index, next);
+		const start = next + match.length;
+		const end = findMatchingAngleBracket(content, start);
+		if (end === -1) {
+			result += content.slice(next);
+			break;
+		}
+		const args = splitTopLevelTypeArgs(content.slice(start, end));
+		while (args.length < 5) args.push("any");
+		result += `import(\"wevu\").WevuComponentConstructor<${args.slice(0, 5).join(", ")}>`;
+		index = end + 1;
+	}
+	return result;
+}
+function getVueCompilerLibOrUndefined(value) {
+	return getVueCompilerLib(value);
+}
+function shouldRewriteWevuComponentType(value) {
+	if (Array.isArray(value)) return value.includes("wevu");
+	if (typeof value === "string") return value === "wevu";
+	return true;
+}
+//#endregion
+//#region src/runtime/libDts/shared.ts
+const DTS_INPUT_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+const NUMERIC_SUFFIX_RE = /^\d+$/;
+const EMPTY_EXPORT_RE = /^export\s*\{\s*\};?\s*$/;
+const DTS_OUTPUT_FILE_RE = /\.d\.(?:m|c)?ts$/;
+const DTS_MAP_OUTPUT_FILE_RE = /\.d\.(?:m|c)?ts\.map$/;
+const SOURCE_MAPPING_URL_RE = /# sourceMappingURL=.*$/gm;
+function isBundledDtsEntry(entryPath) {
+	const ext = path.extname(entryPath);
+	if (entryPath.endsWith(".d.ts")) return true;
+	return DTS_INPUT_EXTENSIONS.has(ext);
+}
+function getStubContent(entryPath) {
+	if (entryPath.endsWith(".vue")) return "declare const _default: any\nexport default _default\n";
+	return "export {}\n";
+}
+async function ensureStub(entry, outDir) {
+	const outputPath = path.resolve(outDir, `${entry.outputBase}.d.ts`);
+	if (await fs.pathExists(outputPath)) return;
+	await fs.ensureDir(path.dirname(outputPath));
+	await fs.writeFile(outputPath, getStubContent(entry.input));
+}
+async function findDeconflictedDtsPath(expectedPath) {
+	const dir = path.dirname(expectedPath);
+	if (!await fs.pathExists(dir)) return;
+	const baseName = path.basename(expectedPath, ".d.ts");
+	const entries = await fs.readdir(dir);
+	let bestMatch;
+	let bestIndex = Number.POSITIVE_INFINITY;
+	for (const name of entries) {
+		if (!name.startsWith(baseName) || !name.endsWith(".d.ts")) continue;
+		if (name === `${baseName}.d.ts`) continue;
+		const suffix = name.slice(baseName.length, -5);
+		if (!NUMERIC_SUFFIX_RE.test(suffix)) continue;
+		const index = Number.parseInt(suffix, 10);
+		if (Number.isNaN(index) || index >= bestIndex) continue;
+		bestIndex = index;
+		bestMatch = path.join(dir, name);
+	}
+	return bestMatch;
+}
+async function isStubDts(filePath) {
+	const content = await fs.readFile(filePath, "utf8");
+	return EMPTY_EXPORT_RE.test(content.trim());
+}
+async function normalizeRolldownDtsOutput(entries, outDir) {
+	await Promise.all(entries.map(async (entry) => {
+		const expectedPath = path.resolve(outDir, `${entry.outputBase}.d.ts`);
+		const candidate = await findDeconflictedDtsPath(expectedPath);
+		if (!candidate) return;
+		if (!(!await fs.pathExists(expectedPath) || await isStubDts(expectedPath))) return;
+		await fs.ensureDir(path.dirname(expectedPath));
+		await fs.copy(candidate, expectedPath);
+		if (candidate !== expectedPath) await fs.remove(candidate);
+	}));
+}
+function normalizePath(value) {
+	return value.split(path.sep).join("/");
+}
+function resolveRelativeBase(entryPath, libRoot, cwd) {
+	const relativeToRoot = path.relative(libRoot, entryPath);
+	if (!relativeToRoot.startsWith("..") && !path.isAbsolute(relativeToRoot)) return normalizePath(relativeToRoot);
+	return normalizePath(path.relative(cwd, entryPath));
+}
+function runVueTsc(binPath, projectPath, cwd) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, [
+			binPath,
+			"--project",
+			projectPath
+		], {
+			cwd,
+			stdio: "inherit"
+		});
+		child.on("error", reject);
+		child.on("close", (code) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`[lib] vue-tsc 生成 dts 失败，退出码 ${code ?? "null"}`));
+		});
+	});
+}
+async function resolveInternalTsconfig(cwd, tsconfig) {
+	if (tsconfig === false) return;
+	if (tsconfig) {
+		const resolved = path.isAbsolute(tsconfig) ? tsconfig : path.resolve(cwd, tsconfig);
+		if (!await fs.pathExists(resolved)) throw new Error(`[lib] internal 方案未找到 tsconfig：${resolved}`);
+		return resolved;
+	}
+	const defaultPath = path.resolve(cwd, "tsconfig.json");
+	return await fs.pathExists(defaultPath) ? defaultPath : void 0;
+}
+async function tsconfigHasProjectReferences(tsconfigPath) {
+	if (!tsconfigPath) return false;
+	try {
+		const config = await fs.readJson(tsconfigPath);
+		return Array.isArray(config?.references) && config.references.length > 0;
+	} catch {
+		return false;
+	}
+}
+function ensureModuleResolution(ts, compilerOptions) {
+	if (compilerOptions.moduleResolution) return;
+	const moduleKind = typeof compilerOptions.module === "number" ? compilerOptions.module : (compilerOptions.target ?? ts.ScriptTarget.ES5) >= ts.ScriptTarget.ES2015 ? ts.ModuleKind.ES2015 : ts.ModuleKind.CommonJS;
+	let moduleResolution;
+	switch (moduleKind) {
+		case ts.ModuleKind.CommonJS:
+			moduleResolution = ts.ModuleResolutionKind.Node10;
+			break;
+		case ts.ModuleKind.Node16:
+			moduleResolution = ts.ModuleResolutionKind.Node16;
+			break;
+		case ts.ModuleKind.NodeNext:
+			moduleResolution = ts.ModuleResolutionKind.NodeNext;
+			break;
+		default: moduleResolution = ts.version.startsWith("5") ? ts.ModuleResolutionKind.Bundler : ts.ModuleResolutionKind.Classic;
+	}
+	compilerOptions.moduleResolution = moduleResolution;
+}
+function isDtsOutputFile(filePath) {
+	return DTS_OUTPUT_FILE_RE.test(filePath) && !filePath.endsWith(".map");
+}
+function isDtsMapOutputFile(filePath) {
+	return DTS_MAP_OUTPUT_FILE_RE.test(filePath);
+}
+function replaceSourceMappingUrl(content, mapFileName) {
+	return content.replace(SOURCE_MAPPING_URL_RE, `# sourceMappingURL=${mapFileName}`);
+}
+function resolveVueSourceFile(program, filePath) {
+	const normalized = normalizePath(filePath);
+	const candidates = [
+		filePath,
+		normalized,
+		`${filePath}.ts`,
+		`${filePath}.js`,
+		`${filePath}.tsx`,
+		`${filePath}.jsx`,
+		`${normalized}.ts`,
+		`${normalized}.js`,
+		`${normalized}.tsx`,
+		`${normalized}.jsx`
+	];
+	for (const candidate of candidates) {
+		const sourceFile = program.getSourceFile(candidate);
+		if (sourceFile) return sourceFile;
+	}
+}
+//#endregion
+//#region src/runtime/libDts/volar.ts
+const require = createRequire(import.meta.url);
+function resolveAdapter() {
+	const modulePath = require.resolve("weapp-vite/volar");
+	return {
+		modulePath,
+		implementationPath: createRequire(modulePath).resolve("@weapp-vite/volar")
+	};
+}
+function resolveVueTscVolarPlugins(options, cwd) {
+	const plugins = options.plugins?.map((plugin) => {
+		const name = typeof plugin === "string" ? plugin : plugin.name;
+		const modulePath = require.resolve(name, { paths: [cwd] });
+		return typeof plugin === "string" ? modulePath : {
+			...plugin,
+			name: modulePath
+		};
+	});
+	if (options.lib !== "wevu") return plugins;
+	const { modulePath, implementationPath } = resolveAdapter();
+	const normalized = (plugins ?? []).map((plugin) => {
+		if ((typeof plugin === "string" ? plugin : plugin.name) !== implementationPath) return plugin;
+		return typeof plugin === "string" ? modulePath : {
+			...plugin,
+			name: modulePath
+		};
+	});
+	let registered = false;
+	const resolved = normalized.filter((plugin) => {
+		if ((typeof plugin === "string" ? plugin : plugin.name) !== modulePath) return true;
+		if (registered) return false;
+		registered = true;
+		return true;
+	});
+	if (!registered) resolved.push(modulePath);
+	return resolved;
+}
+function resolveInternalVolarPlugins(plugins, lib) {
+	if (lib !== "wevu") return plugins;
+	const { modulePath } = resolveAdapter();
+	const factory = require(modulePath);
+	let registered = false;
+	const resolved = plugins.filter((plugin) => {
+		if (plugin !== factory) return true;
+		if (registered) return false;
+		registered = true;
+		return true;
+	});
+	if (!registered) resolved.push(factory);
+	return resolved;
+}
+//#endregion
+//#region src/runtime/libDts/generateVueDts.ts
+const FILE_EXTENSION_RE = /\.[^.]+$/;
+async function generateVueDtsWithVueTsc(configService, libConfig, vueEntries, dtsOptions) {
+	const ts = await import("typescript");
+	const vueTscPkg = resolveModule("vue-tsc/package.json", { paths: [configService.cwd, process.cwd()] });
+	if (!vueTscPkg) throw new Error("[lib] 生成 Vue SFC 的 dts 需要安装 vue-tsc，请先安装后重试。");
+	const vueTscBin = path.resolve(path.dirname(vueTscPkg), "bin/vue-tsc.js");
+	const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "weapp-vite-lib-dts-"));
+	const tempOutDir = path.join(tempRoot, "out");
+	const tsconfigPath = path.join(tempRoot, "tsconfig.json");
+	let libRoot = libConfig.root || configService.absoluteSrcRoot;
+	if (vueEntries.some((entry) => {
+		const relative = path.relative(libRoot, entry.input);
+		return relative.startsWith("..") || path.isAbsolute(relative);
+	})) libRoot = configService.cwd;
+	const baseVueTsconfig = {
+		compilerOptions: {
+			declaration: true,
+			emitDeclarationOnly: true,
+			declarationMap: false,
+			outDir: tempOutDir,
+			declarationDir: tempOutDir,
+			rootDir: libRoot,
+			allowJs: true,
+			jsx: ts.JsxEmit.Preserve,
+			skipLibCheck: true,
+			module: ts.ModuleKind.ESNext,
+			target: ts.ScriptTarget.ESNext,
+			moduleResolution: ts.ModuleResolutionKind.Bundler
+		},
+		files: vueEntries.map((entry) => entry.input),
+		include: vueEntries.map((entry) => entry.input),
+		vueCompilerOptions: { lib: "wevu" }
+	};
+	const vueTscOptions = dtsOptions?.vueTsc;
+	const vueTsconfig = {
+		...baseVueTsconfig,
+		...vueTscOptions?.tsconfig,
+		compilerOptions: {
+			...baseVueTsconfig.compilerOptions,
+			...vueTscOptions?.compilerOptions
+		},
+		vueCompilerOptions: {
+			...baseVueTsconfig.vueCompilerOptions,
+			...vueTscOptions?.vueCompilerOptions
+		}
+	};
+	const rewriteWevuComponentType = shouldRewriteWevuComponentType(getVueCompilerLibOrUndefined(vueTsconfig.vueCompilerOptions?.lib));
+	try {
+		vueTsconfig.vueCompilerOptions.plugins = resolveVueTscVolarPlugins(vueTsconfig.vueCompilerOptions, configService.cwd);
+		await fs.ensureDir(tempOutDir);
+		await fs.writeJson(tsconfigPath, {
+			...vueTsconfig,
+			compilerOptions: serializeCompilerOptions(ts, vueTsconfig.compilerOptions)
+		}, { spaces: 2 });
+		await runVueTsc(vueTscBin, tsconfigPath, configService.cwd);
+		await waitForBuildTasks(vueEntries.map(async (entry) => {
+			const relativeBase = resolveRelativeBase(entry.input, libRoot, configService.cwd);
+			const candidate = path.join(tempOutDir, `${relativeBase.replace(FILE_EXTENSION_RE, "")}.d.ts`);
+			const candidateWithExt = path.join(tempOutDir, `${relativeBase}.d.ts`);
+			const sourcePath = await fs.pathExists(candidate) ? candidate : await fs.pathExists(candidateWithExt) ? candidateWithExt : void 0;
+			if (!sourcePath) throw new Error(`[lib] 生成 Vue SFC dts 失败，未找到输出：${relativeBase}`);
+			const outputPath = path.resolve(configService.outDir, `${entry.outputBase}.d.ts`);
+			await fs.ensureDir(path.dirname(outputPath));
+			const content = await fs.readFile(sourcePath, "utf8");
+			const normalized = rewriteWevuComponentType ? rewriteVueComponentTypeToWevu(content) : content;
+			await fs.writeFile(outputPath, normalized);
+		}));
+	} finally {
+		await fs.remove(tempRoot);
+	}
+}
+async function generateVueDtsWithInternal(configService, vueEntries, dtsOptions, onWatchFile) {
+	const languageCorePkg = resolveModule("@vue/language-core/package.json", { paths: [configService.cwd, process.cwd()] });
+	const volarTsPkg = resolveModule("@volar/typescript/package.json", { paths: [configService.cwd, process.cwd()] });
+	const tsPkg = resolveModule("typescript/package.json", { paths: [configService.cwd, process.cwd()] });
+	if (!languageCorePkg || !volarTsPkg || !tsPkg) throw new Error("[lib] internal 方案生成 Vue SFC dts 需要安装 typescript、@vue/language-core 与 @volar/typescript。");
+	const ts = await import("typescript");
+	const { CompilerOptionsResolver, createParsedCommandLine, createVueLanguagePlugin, getDefaultCompilerOptions } = await import("@vue/language-core");
+	const { proxyCreateProgram } = await import("@volar/typescript");
+	const internalOptions = dtsOptions?.internal;
+	const tsconfigPath = await resolveInternalTsconfig(configService.cwd, internalOptions?.tsconfig);
+	const configHost = {
+		useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+		readDirectory: ts.sys.readDirectory,
+		fileExists: ts.sys.fileExists,
+		readFile: ts.sys.readFile,
+		getCurrentDirectory: ts.sys.getCurrentDirectory,
+		onUnRecoverableConfigFileDiagnostic: () => {}
+	};
+	const parsedVue = tsconfigPath ? createParsedCommandLine(ts, configHost, normalizePath(tsconfigPath)) : void 0;
+	const parsedTs = tsconfigPath ? ts.getParsedCommandLineOfConfigFile(tsconfigPath, void 0, configHost) : void 0;
+	const compilerOptions = {
+		...parsedVue?.options ?? parsedTs?.options ?? {},
+		...internalOptions?.compilerOptions ?? {}
+	};
+	compilerOptions.noEmit = false;
+	compilerOptions.declaration = true;
+	compilerOptions.emitDeclarationOnly = true;
+	compilerOptions.allowNonTsExtensions = true;
+	compilerOptions.allowArbitraryExtensions = true;
+	compilerOptions.skipLibCheck = true;
+	compilerOptions.checkJs = false;
+	compilerOptions.target ??= ts.ScriptTarget.ESNext;
+	ensureModuleResolution(ts, compilerOptions);
+	const baseVueOptions = parsedVue?.vueOptions ?? getDefaultCompilerOptions();
+	const { plugins: rawPlugins, ...rawOptions } = internalOptions?.vueCompilerOptions ?? {};
+	let plugins = baseVueOptions.plugins;
+	if (rawPlugins !== void 0) {
+		const resolver = new CompilerOptionsResolver(ts, configHost.readFile);
+		resolver.addConfig({ plugins: rawPlugins }, normalizePath(configService.cwd));
+		plugins = resolver.plugins;
+	}
+	const vueCompilerOptions = {
+		...baseVueOptions,
+		lib: "wevu",
+		...rawOptions
+	};
+	vueCompilerOptions.plugins = resolveInternalVolarPlugins(plugins, vueCompilerOptions.lib);
+	const rewriteWevuComponentType = shouldRewriteWevuComponentType(vueCompilerOptions.lib);
+	const rootNames = Array.from(/* @__PURE__ */ new Set([...(parsedTs?.fileNames ?? []).map((file) => path.isAbsolute(file) ? file : path.resolve(configService.cwd, file)), ...vueEntries.map((entry) => entry.input)])).map(normalizePath);
+	const host = ts.createCompilerHost(compilerOptions);
+	const program = proxyCreateProgram(ts, ts.createProgram, (tsInstance, options) => {
+		return { languagePlugins: [createVueLanguagePlugin(tsInstance, options.options, vueCompilerOptions, (id) => id)] };
+	})({
+		host,
+		rootNames,
+		options: compilerOptions,
+		projectReferences: parsedTs?.projectReferences
+	});
+	if (onWatchFile) {
+		if (tsconfigPath) onWatchFile(tsconfigPath);
+		for (const source of program.getSourceFiles()) if (!program.isSourceFileDefaultLibrary(source)) onWatchFile(source.fileName);
+	}
+	await waitForBuildTasks(vueEntries.map(async (entry) => {
+		const sourceFile = resolveVueSourceFile(program, entry.input);
+		if (!sourceFile) throw new Error(`[lib] internal 方案生成 Vue SFC dts 失败，未找到源文件：${entry.input}`);
+		const outputs = [];
+		const emitResult = program.emit(sourceFile, (filePath, content) => {
+			outputs.push({
+				path: filePath,
+				content
+			});
+		}, void 0, true);
+		if (emitResult.emitSkipped && emitResult.diagnostics.length > 0) {
+			const hostForDiagnostics = ts.createCompilerHost(compilerOptions);
+			throw new Error(ts.formatDiagnosticsWithColorAndContext(emitResult.diagnostics, hostForDiagnostics));
+		}
+		const dtsOutput = outputs.find((output) => isDtsOutputFile(output.path));
+		if (!dtsOutput) throw new Error(`[lib] internal 方案生成 Vue SFC dts 失败，未找到输出：${entry.input}`);
+		const mapOutput = outputs.find((output) => isDtsMapOutputFile(output.path));
+		const outputPath = path.resolve(configService.outDir, `${entry.outputBase}.d.ts`);
+		await fs.ensureDir(path.dirname(outputPath));
+		let content = dtsOutput.content;
+		if (rewriteWevuComponentType) content = rewriteVueComponentTypeToWevu(content);
+		if (mapOutput) {
+			const mapPath = path.resolve(configService.outDir, `${entry.outputBase}.d.ts.map`);
+			await fs.writeFile(mapPath, mapOutput.content);
+			content = replaceSourceMappingUrl(content, path.basename(mapPath));
+		}
+		await fs.writeFile(outputPath, content);
+	}));
+}
+//#endregion
+//#region src/runtime/libDts.ts
+async function generateLibDts(configService, onWatchFile) {
+	const libConfig = configService.weappLibConfig;
+	if (!libConfig) return;
+	if (!libConfig.enabled) return;
+	const dtsOptions = libConfig.dts;
+	if (dtsOptions?.enabled === false) return;
+	const entries = await resolveWeappLibEntries(configService, libConfig);
+	if (entries.length === 0) return;
+	const vueEntries = entries.filter((entry) => entry.input.endsWith(".vue"));
+	const tsEntries = entries.filter((entry) => !entry.input.endsWith(".vue") && isBundledDtsEntry(entry.input));
+	const input = {};
+	for (const entry of tsEntries) input[entry.outputBase] = resolveRealpath(entry.input);
+	if (Object.keys(input).length > 0) {
+		const tsconfigPath = path.resolve(configService.cwd, "tsconfig.json");
+		const hasTsconfig = await fs.pathExists(tsconfigPath);
+		const userRolldownOptions = dtsOptions?.rolldown ?? {};
+		const hasUserTsconfig = hasOwn(userRolldownOptions, "tsconfig");
+		const hasUserBuild = hasOwn(userRolldownOptions, "build");
+		const userTsconfig = userRolldownOptions.tsconfig;
+		const resolvedTsconfig = hasUserTsconfig ? typeof userTsconfig === "string" || userTsconfig === false ? userTsconfig : hasTsconfig ? tsconfigPath : false : hasTsconfig ? tsconfigPath : false;
+		const canonicalTsconfig = typeof resolvedTsconfig === "string" ? resolveRealpath(path.resolve(configService.cwd, resolvedTsconfig)) : resolvedTsconfig;
+		const shouldUseBuildMode = !hasUserBuild && await tsconfigHasProjectReferences(canonicalTsconfig);
+		const compilerOptions = {
+			allowImportingTsExtensions: true,
+			allowJs: true,
+			...userRolldownOptions.compilerOptions
+		};
+		const { build } = await loadHostRolldownBuild();
+		if (typeof canonicalTsconfig === "string") onWatchFile?.(canonicalTsconfig);
+		await build({
+			input,
+			plugins: [dts({
+				...userRolldownOptions,
+				newContext: true,
+				tsconfig: canonicalTsconfig,
+				build: shouldUseBuildMode ? true : userRolldownOptions.build,
+				compilerOptions,
+				cwd: resolveRealpath(configService.cwd),
+				emitDtsOnly: true,
+				vue: false
+			}), {
+				name: "weapp-vite:lib-dts-inputs",
+				buildEnd() {
+					for (const id of this.getModuleIds()) if (path.isAbsolute(id)) onWatchFile?.(id);
+				}
+			}],
+			output: {
+				dir: configService.outDir,
+				entryFileNames: "[name].d.ts"
+			},
+			write: true
+		});
+		await normalizeRolldownDtsOutput(tsEntries, configService.outDir);
+	}
+	if (vueEntries.length > 0) {
+		if (dtsOptions?.mode === "vue-tsc") await generateVueDtsWithVueTsc(configService, libConfig, vueEntries, dtsOptions);
+		else await generateVueDtsWithInternal(configService, vueEntries, dtsOptions, onWatchFile);
+	}
+	await waitForBuildTasks(entries.map((entry) => ensureStub(entry, configService.outDir)));
+	if (vueEntries.length > 0) {
+		if (shouldRewriteWevuComponentType(dtsOptions?.mode === "vue-tsc" ? getVueCompilerLibOrUndefined(dtsOptions?.vueTsc?.vueCompilerOptions?.lib) : getVueCompilerLibOrUndefined(dtsOptions?.internal?.vueCompilerOptions?.lib))) await waitForBuildTasks(vueEntries.map(async (entry) => {
+			const outputPath = path.resolve(configService.outDir, `${entry.outputBase}.d.ts`);
+			if (!await fs.pathExists(outputPath)) return;
+			const content = await fs.readFile(outputPath, "utf8");
+			const normalized = rewriteVueComponentTypeToWevu(content);
+			if (normalized !== content) await fs.writeFile(outputPath, normalized);
+		}));
+	}
+}
+//#endregion
+//#region src/runtime/libDts/assets.ts
+/** 声明编译器仅写入会话临时目录，最终产物由宿主统一 emit/write。 */
+async function prepareLibDtsAssets(service, onWatchFile) {
+	const temporaryRoot = await mkdtemp(path.join(os.tmpdir(), "weapp-vite-lib-assets-"));
+	const assets = [];
+	async function collect(directory) {
+		for (const entry of await readdir(directory, { withFileTypes: true })) {
+			const file = path.join(directory, entry.name);
+			if (entry.isDirectory()) await collect(file);
+			else if (entry.isFile()) assets.push({
+				type: "asset",
+				fileName: path.relative(temporaryRoot, file),
+				source: await readFile(file)
+			});
+		}
+	}
+	try {
+		await generateLibDts({
+			...service,
+			outDir: temporaryRoot
+		}, onWatchFile);
+		await collect(temporaryRoot);
+		return assets;
+	} finally {
+		await rm(temporaryRoot, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+export { prepareLibDtsAssets };

package/dist/auto-import-components/resolvers.mjs

@@ -1,2 +1 @@
-import { a as TDesignResolver, i as UviewPlusResolver, n as WeuiResolver, r as VantResolver, t as WotUiResolver } from "../resolvers-icNxkpcy.mjs";
-export { TDesignResolver, UviewPlusResolver, VantResolver, WeuiResolver, WotUiResolver };
+export { a as TDesignResolver, i as UviewPlusResolver, r as VantResolver, n as WeuiResolver, t as WotUiResolver } from "../resolvers-Dod-euqX.mjs";

package/dist/auto-import-presets/wevu-router.mjs

@@ -1,2 +1 @@
-import { t as wevuRouter } from "../wevu-router-Dg1LnBlg.mjs";
-export { wevuRouter as default };
+export { t as default } from "../wevu-router-Dg1LnBlg.mjs";

package/dist/auto-import-presets/wevu.mjs

@@ -1,2 +1 @@
-import { t as wevu } from "../wevu-BQWUU7br.mjs";
-export { wevu as default };
+export { t as default } from "../wevu-BQWUU7br.mjs";

package/dist/auto-routes.mjs

@@ -1,4 +1,5 @@
-import { n as getCompilerContext, y as getRouteRuntimeGlobalKeys } from "./createContext-UOEgeYnA.mjs";
+import { V as getRouteRuntimeGlobalKeys } from "./createCompilerContextInstance-aYwi8wQt.mjs";
+import { t as getCompilerContext } from "./getInstance-Dt9IQDKr.mjs";
 //#region src/auto-routes.ts
 const ROUTE_RUNTIME_OVERRIDE_KEY = Symbol.for("weapp-vite.route-runtime");
 function createGetter(resolver) {