@kimesh/auto-import 0.0.1

package/dist/index.mjs

@@ -0,0 +1,961 @@
+import { t as OxcExportScanner } from "./oxc-scanner-DrjjlY9k.mjs";
+import { a as piniaPreset, c as vuePreset, d as collectExistingDirectories, i as normalizePreset, l as vueRouterPreset, n as builtinPresets, o as resolvePresets, r as kimeshPreset, s as tanstackQueryPreset, t as RegistryBuilder, u as ConflictResolver } from "./builder-c6-47OHx.mjs";
+import { parseSync } from "oxc-parser";
+import { parse } from "@vue/compiler-sfc";
+import * as fs from "node:fs";
+import * as path from "pathe";
+import { consola } from "consola";
+import MagicString from "magic-string";
+import Components from "unplugin-vue-components/vite";
+
+//#region src/scanner/reference-detector.ts
+/**
+* @kimesh/auto-import - Unresolved Reference Detector
+*
+* Detects unresolved identifiers in source code using OXC AST analysis.
+* These are the identifiers that need auto-importing.
+*/
+/**
+* Global identifiers that should not be auto-imported
+*/
+const GLOBALS = new Set([
+	"undefined",
+	"null",
+	"true",
+	"false",
+	"NaN",
+	"Infinity",
+	"Object",
+	"Array",
+	"String",
+	"Number",
+	"Boolean",
+	"Symbol",
+	"BigInt",
+	"Function",
+	"Date",
+	"RegExp",
+	"Error",
+	"TypeError",
+	"SyntaxError",
+	"RangeError",
+	"ReferenceError",
+	"EvalError",
+	"URIError",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Promise",
+	"Proxy",
+	"Reflect",
+	"JSON",
+	"Math",
+	"console",
+	"window",
+	"document",
+	"globalThis",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval",
+	"fetch",
+	"Request",
+	"Response",
+	"Headers",
+	"URL",
+	"URLSearchParams",
+	"FormData",
+	"Blob",
+	"File",
+	"FileReader",
+	"ArrayBuffer",
+	"DataView",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array",
+	"TextEncoder",
+	"TextDecoder",
+	"alert",
+	"confirm",
+	"prompt",
+	"open",
+	"close",
+	"print",
+	"localStorage",
+	"sessionStorage",
+	"navigator",
+	"location",
+	"history",
+	"performance",
+	"crypto",
+	"indexedDB",
+	"caches",
+	"requestAnimationFrame",
+	"cancelAnimationFrame",
+	"MutationObserver",
+	"ResizeObserver",
+	"IntersectionObserver",
+	"CustomEvent",
+	"Event",
+	"EventTarget",
+	"AbortController",
+	"AbortSignal",
+	"structuredClone",
+	"atob",
+	"btoa",
+	"encodeURI",
+	"decodeURI",
+	"encodeURIComponent",
+	"decodeURIComponent",
+	"escape",
+	"unescape",
+	"isFinite",
+	"isNaN",
+	"parseFloat",
+	"parseInt",
+	"eval",
+	"process",
+	"Buffer",
+	"global",
+	"__dirname",
+	"__filename",
+	"require",
+	"module",
+	"exports",
+	"Partial",
+	"Required",
+	"Readonly",
+	"Record",
+	"Pick",
+	"Omit",
+	"Exclude",
+	"Extract",
+	"NonNullable",
+	"Parameters",
+	"ReturnType",
+	"InstanceType",
+	"ThisType",
+	"Awaited",
+	"Uppercase",
+	"Lowercase",
+	"Capitalize",
+	"Uncapitalize",
+	"defineProps",
+	"defineEmits",
+	"defineExpose",
+	"defineOptions",
+	"defineSlots",
+	"defineModel",
+	"withDefaults"
+]);
+/**
+* Reference detector using scope analysis
+*/
+var ReferenceDetector = class {
+	/**
+	* Detect unresolved references in TypeScript/JavaScript code
+	*/
+	detectInScript(code, filePath) {
+		try {
+			const result = parseSync(filePath, code, { sourceType: "module" });
+			if (result.errors.length > 0) return [];
+			return this.detectInAST(result.program);
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* Detect unresolved references in Vue SFC
+	*/
+	detectInVue(code, filePath) {
+		try {
+			const { descriptor, errors } = parse(code, { filename: filePath });
+			if (errors.length > 0) return [];
+			const refs = [];
+			if (descriptor.scriptSetup) {
+				const scriptRefs = this.detectInScript(descriptor.scriptSetup.content, filePath + ".setup.ts");
+				refs.push(...scriptRefs);
+			}
+			if (descriptor.script) {
+				const scriptRefs = this.detectInScript(descriptor.script.content, filePath + ".ts");
+				refs.push(...scriptRefs);
+			}
+			return refs;
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* Detect unresolved references in parsed AST
+	*/
+	detectInAST(program) {
+		const declarations = /* @__PURE__ */ new Set();
+		const references = [];
+		this.collectDeclarations(program, declarations);
+		this.findUnresolvedReferences(program, declarations, references);
+		return references;
+	}
+	/**
+	* Collect all declared identifiers in the scope
+	*/
+	collectDeclarations(node, declarations) {
+		if (!node || typeof node !== "object") return;
+		switch (node.type) {
+			case "VariableDeclaration":
+				for (const decl of node.declarations || []) this.collectPatternNames(decl.id, declarations);
+				break;
+			case "FunctionDeclaration":
+				if (node.id?.name) declarations.add(node.id.name);
+				for (const param of node.params || []) this.collectPatternNames(param, declarations);
+				break;
+			case "VariableDeclarator":
+				this.collectPatternNames(node.id, declarations);
+				break;
+			case "ClassDeclaration":
+				if (node.id?.name) declarations.add(node.id.name);
+				break;
+			case "ImportDeclaration":
+				for (const spec of node.specifiers || []) if (spec.local?.name) declarations.add(spec.local.name);
+				break;
+			case "TSInterfaceDeclaration":
+			case "TSTypeAliasDeclaration":
+			case "TSEnumDeclaration":
+				if (node.id?.name) declarations.add(node.id.name);
+				break;
+			case "CatchClause":
+				if (node.param) this.collectPatternNames(node.param, declarations);
+				break;
+			case "ForInStatement":
+			case "ForOfStatement":
+				if (node.left?.type === "VariableDeclaration") this.collectDeclarations(node.left, declarations);
+				break;
+		}
+		for (const key of Object.keys(node)) {
+			if (key === "type" || key === "start" || key === "end") continue;
+			const child = node[key];
+			if (Array.isArray(child)) for (const item of child) this.collectDeclarations(item, declarations);
+			else if (child && typeof child === "object") this.collectDeclarations(child, declarations);
+		}
+	}
+	/**
+	* Collect names from binding patterns
+	*/
+	collectPatternNames(pattern, names) {
+		if (!pattern) return;
+		switch (pattern.type) {
+			case "Identifier":
+				names.add(pattern.name);
+				break;
+			case "ObjectPattern":
+				for (const prop of pattern.properties || []) if (prop.type === "RestElement") this.collectPatternNames(prop.argument, names);
+				else this.collectPatternNames(prop.value || prop.key, names);
+				break;
+			case "ArrayPattern":
+				for (const element of pattern.elements || []) if (element) this.collectPatternNames(element, names);
+				break;
+			case "RestElement":
+				this.collectPatternNames(pattern.argument, names);
+				break;
+			case "AssignmentPattern":
+				this.collectPatternNames(pattern.left, names);
+				break;
+		}
+	}
+	/**
+	* Find references to undeclared identifiers
+	*/
+	findUnresolvedReferences(node, declarations, references) {
+		if (!node || typeof node !== "object") return;
+		if (node.type === "Identifier" && node.name) {
+			const name = node.name;
+			if (!declarations.has(name) && !GLOBALS.has(name) && !this.isPropertyAccess(node) && !this.isPropertyKey(node) && !this.isLabelReference(node)) {
+				const isType = this.isTypeContext(node);
+				if (!references.find((r) => r.name === name && r.start === node.start)) references.push({
+					name,
+					start: node.start,
+					end: node.end,
+					isType
+				});
+			}
+		}
+		for (const key of Object.keys(node)) {
+			if (this.shouldSkipProperty(key)) continue;
+			const child = node[key];
+			if (Array.isArray(child)) for (const item of child) this.findUnresolvedReferences(item, declarations, references);
+			else if (child && typeof child === "object") this.findUnresolvedReferences(child, declarations, references);
+		}
+	}
+	/**
+	* Check if identifier is a property access (obj.prop)
+	*/
+	isPropertyAccess(node) {
+		const parent = node._parent;
+		return parent?.type === "MemberExpression" && parent.property === node && !parent.computed;
+	}
+	/**
+	* Check if identifier is a property key ({ key: value })
+	*/
+	isPropertyKey(node) {
+		const parent = node._parent;
+		return parent?.type === "Property" && parent.key === node && !parent.computed;
+	}
+	/**
+	* Check if identifier is a label reference
+	*/
+	isLabelReference(node) {
+		const parent = node._parent;
+		return parent?.type === "LabeledStatement" || parent?.type === "BreakStatement" || parent?.type === "ContinueStatement";
+	}
+	/**
+	* Check if identifier is in type context
+	*/
+	isTypeContext(node) {
+		const parent = node._parent;
+		return parent?.type === "TSTypeReference" || parent?.type === "TSQualifiedName" || parent?.type === "TSTypeQuery" || parent?.type === "TSImportType";
+	}
+	/**
+	* Properties to skip when recursing
+	*/
+	shouldSkipProperty(key) {
+		return key === "type" || key === "start" || key === "end" || key === "_parent" || key === "loc" || key === "range";
+	}
+};
+
+//#endregion
+//#region src/script/injector.ts
+/**
+* @kimesh/auto-import - Script Import Injector
+*
+* Handles injecting import statements into script code.
+*/
+var ImportInjector = class {
+	inject(code, imports, isVue) {
+		if (imports.length === 0) return null;
+		const s = new MagicString(code);
+		const importStatements = this.generateImportStatements(imports);
+		const insertPoint = this.findImportInsertionPoint(code, isVue);
+		s.appendLeft(insertPoint, "\n" + importStatements + "\n");
+		return {
+			code: s.toString(),
+			map: s.generateMap({ hires: true }),
+			count: imports.length
+		};
+	}
+	generateImportStatements(imports) {
+		const groups = this.groupImportsBySource(imports);
+		const statements = [];
+		for (const [source, entries] of groups) {
+			const { defaultImports, namedImports, typeImports } = this.categorizeImports(entries);
+			const parts = [];
+			if (defaultImports.length > 0) parts.push(defaultImports[0]);
+			if (namedImports.length > 0) parts.push(`{ ${namedImports.join(", ")} }`);
+			if (parts.length > 0) statements.push(`import ${parts.join(", ")} from '${source}';`);
+			if (typeImports.length > 0) statements.push(`import type { ${typeImports.join(", ")} } from '${source}';`);
+		}
+		return statements.join("\n");
+	}
+	groupImportsBySource(imports) {
+		const groups = /* @__PURE__ */ new Map();
+		for (const entry of imports) {
+			const existing = groups.get(entry.from) ?? [];
+			existing.push(entry);
+			groups.set(entry.from, existing);
+		}
+		return groups;
+	}
+	categorizeImports(entries) {
+		const defaultImports = [];
+		const namedImports = [];
+		const typeImports = [];
+		for (const entry of entries) {
+			const importName = entry.as ? `${entry.name} as ${entry.as}` : entry.name;
+			if (entry.isDefault) defaultImports.push(entry.as ?? entry.name);
+			else if (entry.isType) typeImports.push(importName);
+			else namedImports.push(importName);
+		}
+		return {
+			defaultImports,
+			namedImports,
+			typeImports
+		};
+	}
+	findImportInsertionPoint(code, isVue) {
+		if (isVue) return this.findVueScriptInsertionPoint(code);
+		return this.findJsInsertionPoint(code);
+	}
+	findVueScriptInsertionPoint(code) {
+		const scriptMatch = code.match(/<script(\s+[^>]*)?>|<script\s+setup[^>]*>/i);
+		if (!scriptMatch || scriptMatch.index === void 0) return 0;
+		const insertPoint = scriptMatch.index + scriptMatch[0].length;
+		const importMatch = code.slice(insertPoint).match(/^(\s*\n?\s*import\s+.*?['"].*?['"];?\s*)+/);
+		return importMatch ? insertPoint + importMatch[0].length : insertPoint;
+	}
+	findJsInsertionPoint(code) {
+		const importRegex = /^import\s+.*?['"].*?['"];?\s*$/gm;
+		let lastImportEnd = 0;
+		let match;
+		while ((match = importRegex.exec(code)) !== null) lastImportEnd = match.index + match[0].length;
+		if (lastImportEnd > 0) return lastImportEnd;
+		const useStrictMatch = code.match(/^(['"]use strict['"];?\s*)/);
+		if (useStrictMatch) return useStrictMatch[0].length;
+		const shebangMatch = code.match(/^#!.*\n/);
+		if (shebangMatch) return shebangMatch[0].length;
+		return 0;
+	}
+	extractExistingImports(code, isVue) {
+		const imported = /* @__PURE__ */ new Set();
+		const scriptContent = isVue ? this.extractVueScriptContent(code) : code;
+		if (!scriptContent) return imported;
+		const importRegex = /import\s+(?:type\s+)?(?:(\w+)\s*,?\s*)?(?:\{([^}]*)\})?\s*from\s*['"][^'"]+['"]/g;
+		let match;
+		while ((match = importRegex.exec(scriptContent)) !== null) {
+			if (match[1]) imported.add(match[1]);
+			if (match[2]) for (const name of match[2].split(",")) {
+				const trimmed = name.trim();
+				if (!trimmed) continue;
+				const asMatch = trimmed.match(/(\w+)\s+as\s+(\w+)/);
+				imported.add(asMatch ? asMatch[2] : trimmed);
+			}
+		}
+		return imported;
+	}
+	extractVueScriptContent(code) {
+		const scriptMatch = code.match(/<script[^>]*>([\s\S]*?)<\/script>/gi);
+		if (!scriptMatch) return null;
+		return scriptMatch.map((m) => {
+			const content = m.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+			return content ? content[1] : "";
+		}).join("\n");
+	}
+};
+
+//#endregion
+//#region src/types/generator.ts
+/**
+* @kimesh/auto-import - Type Declaration Generator
+*
+* Generates .d.ts files for auto-imported modules.
+*/
+const logger$2 = consola.withTag("kimesh:auto-import:types");
+async function generateDtsFiles(registry, outputDir) {
+	fs.mkdirSync(outputDir, { recursive: true });
+	writeFile(outputDir, "auto-imports.d.ts", generateAutoImportsDts(registry));
+	const presetComponents = generatePresetComponentsDts(registry);
+	if (presetComponents) writeFile(outputDir, "kimesh-components.d.ts", presetComponents);
+	writeFile(outputDir, ".eslintrc-auto-import.json", generateEslintGlobals(registry));
+}
+function writeFile(outputDir, filename, content) {
+	const filePath = path.join(outputDir, filename);
+	fs.writeFileSync(filePath, content, "utf-8");
+	logger$2.debug(`Generated: ${filePath}`);
+}
+function generateAutoImportsDts(registry) {
+	const header = [
+		"/* eslint-disable */",
+		"/* prettier-ignore */",
+		"// @ts-nocheck",
+		"// noinspection JSUnusedGlobalSymbols",
+		"",
+		"// Auto-generated by @kimesh/auto-import",
+		"// DO NOT EDIT - changes will be overwritten",
+		"",
+		"export {}",
+		"",
+		"declare global {"
+	];
+	const groups = groupImportsBySource(registry.imports, [
+		"composable",
+		"utility",
+		"preset",
+		"store"
+	]);
+	const body = [];
+	for (const [source, entries] of groups) {
+		body.push(`  // ${source}`);
+		for (const entry of entries) body.push(formatGlobalDeclaration(entry));
+		body.push("");
+	}
+	return [
+		...header,
+		...body,
+		"}"
+	].join("\n");
+}
+function formatGlobalDeclaration(entry) {
+	const comment = entry.layer !== "app" ? ` // from ${entry.layer}` : "";
+	if (entry.isType) return `  type ${entry.name} = import('${entry.from}').${entry.name}${comment}`;
+	if (entry.isDefault) return `  const ${entry.name}: typeof import('${entry.from}').default${comment}`;
+	return `  const ${entry.name}: typeof import('${entry.from}').${entry.name}${comment}`;
+}
+function generateEslintGlobals(registry) {
+	const globals = {};
+	for (const [name, entry] of registry.imports) if (!entry.isType) globals[name] = "readonly";
+	return JSON.stringify({ globals }, null, 2);
+}
+const EXCLUDED_TYPE_NAMES = new Set([
+	"Ref",
+	"ComputedRef",
+	"UnwrapRef",
+	"ShallowRef",
+	"WritableComputedRef",
+	"ToRefs",
+	"PropType",
+	"Component",
+	"ComponentPublicInstance",
+	"VNode",
+	"RouteLocationNormalized",
+	"RouteLocationNormalizedLoaded",
+	"RouteRecordRaw",
+	"NavigationGuard",
+	"NavigationFailure",
+	"Router",
+	"RouteLocation",
+	"LocationQuery",
+	"RouteParams"
+]);
+function generatePresetComponentsDts(registry) {
+	const presetComponents = [...registry.components.entries()].filter(([name, entry]) => entry.type === "preset" && /^[A-Z][a-zA-Z0-9]*$/.test(name) && !entry.isType && !EXCLUDED_TYPE_NAMES.has(name)).sort((a, b) => a[0].localeCompare(b[0]));
+	if (presetComponents.length === 0) return null;
+	const header = [
+		"/* eslint-disable */",
+		"// @ts-nocheck",
+		"// Generated by @kimesh/auto-import",
+		"// Preset components for Vue templates",
+		"// biome-ignore lint: disable",
+		"export {}",
+		"",
+		"/* prettier-ignore */",
+		"declare module 'vue' {",
+		"  export interface GlobalComponents {"
+	];
+	const componentDeclarations = presetComponents.map(([name, entry]) => {
+		return `    ${name}: ${entry.isDefault ? `typeof import('${entry.from}').default` : `typeof import('${entry.from}')['${entry.name}']`}`;
+	});
+	return [
+		...header,
+		...componentDeclarations,
+		"  }",
+		"}"
+	].join("\n");
+}
+function groupImportsBySource(imports, types) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const [, entry] of imports) {
+		if (!types.includes(entry.type)) continue;
+		const existing = groups.get(entry.from) ?? [];
+		existing.push(entry);
+		groups.set(entry.from, existing);
+	}
+	for (const entries of groups.values()) entries.sort((a, b) => {
+		if (a.isType !== b.isType) return a.isType ? 1 : -1;
+		return a.name.localeCompare(b.name);
+	});
+	return groups;
+}
+function generateSourceDts(source, entries) {
+	const lines = [
+		"// Auto-generated by @kimesh/auto-import",
+		"",
+		`// Exports from: ${source}`,
+		""
+	];
+	const defaultExports = entries.filter((e) => e.isDefault);
+	const namedExports = entries.filter((e) => !e.isDefault && !e.isType);
+	const typeExports = entries.filter((e) => e.isType);
+	if (defaultExports.length > 0) lines.push(`export { default as ${defaultExports[0].name} } from '${source}'`);
+	if (namedExports.length > 0) {
+		const names = namedExports.map((e) => e.as ? `${e.name} as ${e.as}` : e.name);
+		lines.push(`export { ${names.join(", ")} } from '${source}'`);
+	}
+	if (typeExports.length > 0) {
+		const names = typeExports.map((e) => e.as ? `${e.name} as ${e.as}` : e.name);
+		lines.push(`export type { ${names.join(", ")} } from '${source}'`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/script/plugin.ts
+const logger$1 = consola.withTag("kimesh:auto-import:script");
+const DEFAULT_INCLUDE = [
+	/\.[jt]sx?$/,
+	/\.vue$/,
+	/\.vue\?vue/
+];
+const DEFAULT_EXCLUDE = [/node_modules/, /\.d\.ts$/];
+function debounce(fn, ms) {
+	let timeoutId = null;
+	return ((...args) => {
+		if (timeoutId) clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => fn(...args), ms);
+	});
+}
+function createScriptPlugin(options) {
+	const { sources: staticSources, getSources, layers: staticLayers = [], getLayers, include = DEFAULT_INCLUDE, exclude = DEFAULT_EXCLUDE, dts = ".kimesh", debug = false, onRegistryUpdate } = options;
+	const builder = new RegistryBuilder();
+	const detector = new ReferenceDetector();
+	const injector = new ImportInjector();
+	let registry = null;
+	let config;
+	let isBuilding = false;
+	let resolvedSources = void 0;
+	function resolveSources() {
+		if (resolvedSources !== void 0) return resolvedSources;
+		resolvedSources = getSources ? getSources() : staticSources ?? [];
+		return resolvedSources;
+	}
+	function resolveLayers() {
+		return getLayers ? getLayers() : staticLayers;
+	}
+	function getRegistry() {
+		return registry;
+	}
+	function resolveDtsDir() {
+		return path.isAbsolute(dts) ? dts : path.join(config.root, dts);
+	}
+	async function generateDtsForLayers(reg) {
+		if (dts === false) return;
+		const hostDtsDir = resolveDtsDir();
+		await generateDtsFiles(reg, hostDtsDir);
+		logger$1.debug(`Generated type declarations in ${hostDtsDir}`);
+		const resolvedLayerList = resolveLayers();
+		for (const layer of resolvedLayerList) {
+			if (layer.isApp) continue;
+			let layerRoot = layer.path;
+			try {
+				layerRoot = fs.realpathSync(layer.path);
+			} catch {}
+			const layerKimeshDir = path.join(layerRoot, ".kimesh");
+			try {
+				fs.mkdirSync(layerKimeshDir, { recursive: true });
+				await generateDtsFiles(reg, layerKimeshDir);
+				logger$1.debug(`Generated type declarations for layer: ${layer.name} at ${layerKimeshDir}`);
+			} catch (err) {
+				logger$1.warn(`Failed to generate .d.ts for layer ${layer.name}: ${err}`);
+			}
+		}
+	}
+	async function buildAndLogRegistry() {
+		const startTime = performance.now();
+		const sources = resolveSources();
+		registry = await builder.build(sources);
+		const elapsed = performance.now() - startTime;
+		logger$1.info(`Script auto-import registry built in ${elapsed.toFixed(1)}ms`);
+		logger$1.info(`  ${registry.stats.composablesCount} composables, ${registry.stats.utilitiesCount} utilities, ${registry.stats.presetsCount} preset imports`);
+		if (registry.conflicts.length > 0) logger$1.warn(`  ${registry.conflicts.length} conflicts detected`);
+		await generateDtsForLayers(registry);
+		onRegistryUpdate?.(registry);
+	}
+	return {
+		name: "kimesh:auto-import:script",
+		enforce: "pre",
+		getRegistry,
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+			isBuilding = config.command === "build";
+		},
+		async buildStart() {
+			await buildAndLogRegistry();
+		},
+		configureServer(server) {
+			if (isBuilding) return;
+			const watchDirs = getWatchDirs(resolveSources());
+			if (watchDirs.length === 0) {
+				logger$1.debug("No directories to watch for auto-import");
+				return;
+			}
+			logger$1.debug(`Watching ${watchDirs.length} directories for auto-import changes`);
+			const rebuildRegistry = async () => {
+				const startTime = performance.now();
+				builder.clearCache();
+				const sources = resolveSources();
+				registry = await builder.build(sources);
+				const elapsed = performance.now() - startTime;
+				logger$1.info(`Auto-import registry rebuilt in ${elapsed.toFixed(1)}ms`);
+				logger$1.info(`  ${registry.stats.componentsCount} components, ${registry.stats.composablesCount} composables, ${registry.stats.utilitiesCount} utilities`);
+				await generateDtsForLayers(registry);
+				onRegistryUpdate?.(registry);
+			};
+			const debouncedRebuild = debounce(rebuildRegistry, 300);
+			const isWatchedFile = (file) => {
+				const ext = path.extname(file);
+				if (![
+					".ts",
+					".js",
+					".tsx",
+					".jsx",
+					".mts",
+					".mjs",
+					".vue"
+				].includes(ext)) return false;
+				return watchDirs.some((dir) => file.startsWith(dir));
+			};
+			server.watcher.on("add", (file) => {
+				if (!isWatchedFile(file)) return;
+				logger$1.debug(`New file detected: ${path.relative(config.root, file)}`);
+				debouncedRebuild();
+			});
+			server.watcher.on("unlink", (file) => {
+				if (!isWatchedFile(file)) return;
+				logger$1.debug(`File deleted: ${path.relative(config.root, file)}`);
+				debouncedRebuild();
+			});
+			server.watcher.on("change", (file) => {
+				if (!isWatchedFile(file)) return;
+				logger$1.debug(`File changed: ${path.relative(config.root, file)}`);
+				builder.invalidate(file);
+				debouncedRebuild();
+			});
+		},
+		transform(code, id) {
+			if (!registry) return null;
+			if (!shouldTransform(id, include, exclude)) return null;
+			const startTime = performance.now();
+			const isVue = id.endsWith(".vue") || id.includes(".vue?");
+			const refs = isVue ? detector.detectInVue(code, id) : detector.detectInScript(code, id);
+			if (refs.length === 0) return null;
+			const existingImports = injector.extractExistingImports(code, isVue);
+			const imports = [];
+			const matched = /* @__PURE__ */ new Set();
+			for (const ref of refs) {
+				if (matched.has(ref.name)) continue;
+				if (existingImports.has(ref.name)) continue;
+				const entry = registry.imports.get(ref.name);
+				if (!entry) continue;
+				if (ref.isType && !entry.isType) continue;
+				if (registry.components.has(ref.name)) {
+					if (debug) logger$1.debug(`Skipping component ${ref.name} for template plugin`);
+					continue;
+				}
+				imports.push(entry);
+				matched.add(ref.name);
+			}
+			if (imports.length === 0) return null;
+			const result = injector.inject(code, imports, isVue);
+			if (!result) return null;
+			const elapsed = performance.now() - startTime;
+			if (debug) logger$1.debug(`[${elapsed.toFixed(1)}ms] ${id}: injected ${imports.length} imports`);
+			return {
+				code: result.code,
+				map: result.map
+			};
+		},
+		handleHotUpdate({ file }) {
+			const relativePath = path.relative(config.root, file);
+			const sources = resolveSources();
+			for (const source of sources) if (file.startsWith(source.layerPath)) {
+				logger$1.debug(`HMR update: ${relativePath}`);
+				break;
+			}
+		}
+	};
+}
+function getWatchDirs(sources) {
+	const dirs = [];
+	for (const source of sources) {
+		const { layerPath, config: sourceConfig } = source;
+		const dirConfigs = [
+			sourceConfig.components?.dirs ?? ["components"],
+			sourceConfig.composables?.dirs ?? ["composables"],
+			sourceConfig.utils?.dirs ?? ["utils"],
+			sourceConfig.stores?.dirs ?? ["stores"]
+		];
+		for (const configDirs of dirConfigs) dirs.push(...collectExistingDirectories(layerPath, configDirs));
+	}
+	return [...new Set(dirs)];
+}
+function matchesPattern(id, pattern) {
+	if (typeof pattern === "string") return id.includes(pattern);
+	return pattern.test(id);
+}
+function shouldTransform(id, include, exclude) {
+	if (exclude.some((pattern) => matchesPattern(id, pattern))) return false;
+	return include.some((pattern) => matchesPattern(id, pattern));
+}
+
+//#endregion
+//#region src/template/resolver.ts
+const logger = consola.withTag("kimesh:auto-import:template:resolver");
+function looksLikeComponent(name) {
+	return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function createResolvedComponent(entry, name) {
+	return {
+		name: entry.isDefault ? "default" : entry.name,
+		from: entry.from,
+		as: name
+	};
+}
+function createKimeshResolver(options) {
+	const { getRegistry, debug = false } = options;
+	return {
+		type: "component",
+		resolve: (name) => {
+			const registry = getRegistry();
+			if (!registry) {
+				if (debug) logger.debug(`Registry not ready, skipping ${name}`);
+				return;
+			}
+			if (debug) {
+				logger.debug(`Resolving component: ${name}`);
+				logger.debug(`  Components map size: ${registry.components.size}`);
+				logger.debug(`  Imports map size: ${registry.imports.size}`);
+			}
+			const componentEntry = registry.components.get(name);
+			if (componentEntry) {
+				if (debug) logger.debug(`Resolved component ${name} from ${componentEntry.from} (layer: ${componentEntry.layer})`);
+				return createResolvedComponent(componentEntry, name);
+			}
+			const importEntry = registry.imports.get(name);
+			if (!importEntry) {
+				if (debug) logger.debug(`${name} not found in imports map`);
+				return;
+			}
+			if (debug) logger.debug(`Found ${name} in imports, type: ${importEntry.type}`);
+			if (importEntry.type === "component" || importEntry.type === "preset" && looksLikeComponent(name)) {
+				if (debug) logger.debug(`Resolved component ${name} from ${importEntry.from} (layer: ${importEntry.layer})`);
+				return {
+					name: importEntry.isDefault ? "default" : name,
+					from: importEntry.from,
+					as: name
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/template/plugin.ts
+function resolveDtsPath(dts) {
+	if (dts === false) return false;
+	if (typeof dts === "string") return path.join(dts, "components.d.ts");
+	return true;
+}
+function createTemplatePlugin(options) {
+	const { getRegistry, dts, debug = false } = options;
+	const basePlugin = Components({
+		resolvers: [createKimeshResolver({
+			getRegistry,
+			debug
+		})],
+		dirs: [],
+		dts: resolveDtsPath(dts),
+		include: [/\.vue$/, /\.vue\?vue/],
+		exclude: [/[\\/]node_modules[\\/]/],
+		deep: true,
+		directoryAsNamespace: false,
+		collapseSamePrefixes: true,
+		version: 3
+	});
+	const plugin = basePlugin;
+	plugin.name = "kimesh:auto-import:template";
+	const api = basePlugin.api;
+	const originalTransform = plugin.transform;
+	if (originalTransform) plugin.transform = async function(code, id, transformOptions) {
+		if (!code.includes("/* unplugin-vue-components disabled */")) return originalTransform.call(this, code, id, transformOptions);
+		const registry = getRegistry();
+		if (!registry) return null;
+		const unresolvedMatches = [...code.matchAll(/_?resolveComponent\d*\("(.+?)"\)/g)];
+		if (unresolvedMatches.length === 0) return null;
+		const existingVars = [...code.matchAll(/__unplugin_components_(\d+)/g)];
+		let nextVarIndex = existingVars.length > 0 ? Math.max(...existingVars.map((m) => parseInt(m[1], 10))) + 1 : 0;
+		const s = new MagicString(code);
+		const imports = [];
+		const resolved = /* @__PURE__ */ new Set();
+		for (const match of unresolvedMatches) {
+			const fullMatch = match[0];
+			const componentName = match[1];
+			if (resolved.has(componentName)) continue;
+			if (componentName.startsWith("_")) continue;
+			const entry = resolveComponentEntry(registry, componentName);
+			if (!entry) continue;
+			const varName = `__unplugin_components_${nextVarIndex++}`;
+			const importName = entry.isDefault ? "default" : entry.name;
+			imports.push(`import { ${importName} as ${varName} } from "${entry.from}";`);
+			replaceAllOccurrences(s, code, fullMatch, varName);
+			resolved.add(componentName);
+			if (api && typeof api.findComponent === "function") try {
+				await api.findComponent(componentName, id);
+			} catch {}
+		}
+		if (imports.length === 0) return null;
+		s.prepend(imports.join("\n") + "\n");
+		return {
+			code: s.toString(),
+			map: s.generateMap({
+				source: id,
+				includeContent: true
+			})
+		};
+	};
+	return plugin;
+}
+function resolveComponentEntry(registry, componentName) {
+	const entry = registry.components.get(componentName);
+	if (entry) return entry;
+	const importEntry = registry.imports.get(componentName);
+	if (importEntry && importEntry.type === "preset" && /^[A-Z][a-zA-Z0-9]*$/.test(componentName)) return importEntry;
+}
+function replaceAllOccurrences(s, code, search, replacement) {
+	let searchIndex = 0;
+	while (true) {
+		const idx = code.indexOf(search, searchIndex);
+		if (idx === -1) break;
+		s.overwrite(idx, idx + search.length, replacement);
+		searchIndex = idx + search.length;
+	}
+}
+
+//#endregion
+//#region src/vite/plugin.ts
+function resolveDtsDirectory(dts) {
+	if (dts === false) return false;
+	if (typeof dts === "string") return dts;
+	return ".kimesh";
+}
+function autoImportPlugin(options) {
+	const { dts = ".kimesh", debug = false } = options;
+	let sharedRegistry = null;
+	return [createScriptPlugin({
+		...options,
+		onRegistryUpdate: (registry) => {
+			sharedRegistry = registry;
+		}
+	}), createTemplatePlugin({
+		getRegistry: () => sharedRegistry,
+		dts: resolveDtsDirectory(dts),
+		debug
+	})];
+}
+const kimeshAutoImport = autoImportPlugin;
+var plugin_default = autoImportPlugin;
+
+//#endregion
+//#region src/index.ts
+/**
+* Build import registry from sources (convenience function)
+*/
+async function buildImportRegistry(sources) {
+	const { RegistryBuilder: RegistryBuilder$1 } = await import("./builder-CnceYcPH.mjs");
+	return new RegistryBuilder$1().build(sources);
+}
+/**
+* Scan exports from a file (convenience function)
+*/
+async function scanExports(filePath) {
+	const { OxcExportScanner: OxcExportScanner$1 } = await import("./oxc-scanner-g5pD6w1O.mjs");
+	return new OxcExportScanner$1().scanFile(filePath);
+}
+
+//#endregion
+export { ConflictResolver, ImportInjector, OxcExportScanner, ReferenceDetector, RegistryBuilder, autoImportPlugin, buildImportRegistry, builtinPresets, createTemplatePlugin as createComponentsPlugin, createTemplatePlugin, createKimeshResolver, createScriptPlugin, plugin_default as default, generateDtsFiles as generateDts, generateDtsFiles, generateSourceDts, kimeshAutoImport, kimeshPreset, normalizePreset, piniaPreset, resolvePresets, scanExports, tanstackQueryPreset, vuePreset, vueRouterPreset };
+//# sourceMappingURL=index.mjs.map