@ubean/auto-imports 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+import { Import, InlinePreset } from "unimport";
+import { ScanResult } from "@ubean/routing";
+//#region src/index.d.ts
+interface AutoImportOptions {
+  cwd: string;
+  srcDir: string;
+  buildDir: string;
+  composablesDirs?: string[];
+  componentsDirs?: string[];
+  dirs?: {
+    composables?: string;
+    components?: string;
+  };
+  imports?: {
+    autoImport?: boolean;
+    global?: boolean;
+  };
+  components?: {
+    autoImport?: boolean;
+    directoryAsNamespace?: boolean;
+  };
+}
+declare const VUE_PRESET: InlinePreset;
+declare const VUE_MACROS_PRESET: InlinePreset;
+/**
+ * Client-safe symbols that are available in `ubean/runtime/vue`.
+ * These are safe to auto-import in Vue components (browser-side) because
+ * `ubean/runtime/vue` does not transitively import `vite` or other build tools.
+ */
+declare const UBEAN_CLIENT_PRESET: InlinePreset;
+/**
+ * Server-only symbols that come from the main `ubean` package.
+ * These import the full ubean entry (which includes build tools like `vite`),
+ * so they must only be used in server-side files (API routes, middleware, etc.).
+ */
+declare const UBEAN_SERVER_PRESET: InlinePreset;
+/** @deprecated Use UBEAN_CLIENT_PRESET + UBEAN_SERVER_PRESET instead */
+declare const UBEAN_PRESET: InlinePreset;
+declare const HONO_OPENAPI_PRESET: InlinePreset;
+declare const BUILTIN_PRESETS: InlinePreset[];
+interface ComponentInfo {
+  name: string;
+  filePath: string;
+  importPath: string;
+  pascalName: string;
+}
+interface AutoImportResult {
+  composablesImports: Import[];
+  components: ComponentInfo[];
+  autoImportsDtsPath: string;
+  componentsDtsPath: string;
+}
+declare function generateAutoImports(_scanResult: ScanResult, options: AutoImportOptions): Promise<AutoImportResult>;
+declare function getBuiltinComposables(): Import[];
+declare function getUbeanAutoImportConfig(options?: {
+  cwd?: string;
+  srcDir?: string;
+  buildDir?: string;
+  composablesDirs?: string[];
+}): {
+  imports: InlinePreset[];
+  dirs: string[];
+  dts: string;
+  vueTemplate: boolean;
+  eslintrc: {
+    enabled: boolean;
+  };
+};
+declare function getUbeanComponentsConfig(options?: {
+  cwd?: string;
+  srcDir?: string;
+  buildDir?: string;
+  componentsDirs?: string[];
+  directoryAsNamespace?: boolean;
+}): {
+  dirs: string[];
+  extensions: string[];
+  directoryAsNamespace: boolean;
+  dts: string;
+  deep: boolean;
+};
+declare function generateImportsTransform(imports: Import[]): {
+  code: string;
+  map?: null;
+};
+//#endregion
+export { AutoImportOptions, AutoImportResult, BUILTIN_PRESETS, ComponentInfo, HONO_OPENAPI_PRESET, type Import, type InlinePreset, UBEAN_CLIENT_PRESET, UBEAN_PRESET, UBEAN_SERVER_PRESET, VUE_MACROS_PRESET, VUE_PRESET, generateAutoImports, generateImportsTransform, getBuiltinComposables, getUbeanAutoImportConfig, getUbeanComponentsConfig };

package/dist/index.js

@@ -0,0 +1,353 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, normalize, relative } from "pathe";
+import { glob } from "tinyglobby";
+import { createUnimport, toTypeDeclarationFile } from "unimport";
+//#region src/index.ts
+const VUE_PRESET = {
+	from: "vue",
+	imports: [
+		"ref",
+		"computed",
+		"reactive",
+		"readonly",
+		"watch",
+		"watchEffect",
+		"watchPostEffect",
+		"watchSyncEffect",
+		"onMounted",
+		"onUnmounted",
+		"onBeforeMount",
+		"onBeforeUnmount",
+		"onUpdated",
+		"onBeforeUpdate",
+		"onActivated",
+		"onDeactivated",
+		"onErrorCaptured",
+		"onServerPrefetch",
+		"onRenderTracked",
+		"onRenderTriggered",
+		"provide",
+		"inject",
+		"shallowRef",
+		"shallowReactive",
+		"shallowReadonly",
+		"isRef",
+		"isReactive",
+		"isReadonly",
+		"isProxy",
+		"unref",
+		"toRef",
+		"toRefs",
+		"toRaw",
+		"markRaw",
+		"triggerRef",
+		"customRef",
+		"effectScope",
+		"getCurrentScope",
+		"onScopeDispose",
+		"defineComponent",
+		"defineAsyncComponent",
+		"defineProps",
+		"defineEmits",
+		"defineExpose",
+		"defineOptions",
+		"defineSlots",
+		"defineModel",
+		"useSlots",
+		"useAttrs",
+		"useTemplateRef",
+		"nextTick",
+		"toValue",
+		"useId",
+		"useCssModule",
+		"useCssVars",
+		"useTransitionState"
+	]
+};
+const VUE_MACROS_PRESET = {
+	from: "vue/macros",
+	imports: [
+		"$",
+		"$$",
+		"$ref",
+		"$computed",
+		"$shallowRef",
+		"$customRef",
+		"$toRef"
+	]
+};
+/**
+* Client-safe symbols that are available in `ubean/runtime/vue`.
+* These are safe to auto-import in Vue components (browser-side) because
+* `ubean/runtime/vue` does not transitively import `vite` or other build tools.
+*/
+const UBEAN_CLIENT_PRESET = {
+	from: "ubean/runtime/vue",
+	imports: [
+		"definePage",
+		"defineMiddleware",
+		"defineApp",
+		"applyAppConfig",
+		"createDefaultAppConfig",
+		"t",
+		"useI18n",
+		"useSeoMeta",
+		"usePage",
+		"useRouter",
+		"useHead",
+		"useViewTransition",
+		"useCacheViews",
+		"enablePageCache",
+		"disablePageCache",
+		"excludePageCache",
+		"includePageCache",
+		"isPageExcluded",
+		"resetRouteCache",
+		"invalidatePageCache",
+		"isPageCached",
+		"usePageTransition",
+		"setPageTransition",
+		"clearPageTransition",
+		"useReloadSignal",
+		"reloadPage",
+		"isReloading"
+	]
+};
+/**
+* Server-only symbols that come from the main `ubean` package.
+* These import the full ubean entry (which includes build tools like `vite`),
+* so they must only be used in server-side files (API routes, middleware, etc.).
+*/
+const UBEAN_SERVER_PRESET = {
+	from: "ubean",
+	imports: [
+		"defineHandlerMeta",
+		"useData",
+		"createInternalAdapter",
+		"defineScheduled",
+		"defineQueue",
+		"sendMessage",
+		"sendMessages",
+		"getQueueStats",
+		"useDatabase",
+		"defineDatabase",
+		"useKV",
+		"createKV",
+		"useStorage"
+	]
+};
+/** @deprecated Use UBEAN_CLIENT_PRESET + UBEAN_SERVER_PRESET instead */
+const UBEAN_PRESET = UBEAN_SERVER_PRESET;
+const HONO_OPENAPI_PRESET = {
+	from: "hono-openapi",
+	imports: ["validator", "describeRoute"]
+};
+const BUILTIN_PRESETS = [
+	UBEAN_CLIENT_PRESET,
+	UBEAN_SERVER_PRESET,
+	HONO_OPENAPI_PRESET
+];
+function toPosixPath(p) {
+	return p.replace(/\\/g, "/");
+}
+function toCamelCase(str) {
+	return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase());
+}
+function toPascalCase(str) {
+	const camel = toCamelCase(str);
+	return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function fileBasename(p, ext) {
+	const parts = toPosixPath(p).split("/");
+	let base = parts[parts.length - 1] || "";
+	if (ext && base.endsWith(ext)) base = base.slice(0, -ext.length);
+	else if (!ext) {
+		const dotIdx = base.lastIndexOf(".");
+		if (dotIdx > 0) base = base.slice(0, dotIdx);
+	}
+	return base;
+}
+function fileDirname(p) {
+	const parts = toPosixPath(p).split("/");
+	parts.pop();
+	return parts.join("/") || ".";
+}
+function transformImportPath(filePath, srcDir) {
+	const posixPath = toPosixPath(normalize(filePath));
+	return `~/${toPosixPath(relative(toPosixPath(normalize(srcDir)), posixPath)).replace(/\.(ts|js|mts|mjs|cts|cjs|tsx|jsx)$/, "")}`;
+}
+async function scanComponentsDir(dir, srcDir, directoryAsNamespace, ignore = [
+	"**/*.test.*",
+	"**/*.spec.*",
+	"**/_*"
+]) {
+	const components = [];
+	const files = await glob("**/*.vue", {
+		cwd: dir,
+		dot: true,
+		ignore,
+		absolute: true
+	}).catch(() => []);
+	for (const fullPath of files.sort()) {
+		const relativeToSrc = toPosixPath(relative(srcDir, fullPath));
+		const relativeToDir = toPosixPath(relative(dir, fullPath));
+		const base = fileBasename(fullPath);
+		if (base.startsWith("_")) continue;
+		let name;
+		if (directoryAsNamespace) {
+			const dirPart = fileDirname(relativeToDir) === "." ? "" : fileDirname(relativeToDir);
+			const parts = dirPart ? dirPart.split("/").filter(Boolean) : [];
+			parts.push(base);
+			name = parts.map(toPascalCase).join("");
+		} else name = toPascalCase(base);
+		components.push({
+			name,
+			filePath: fullPath,
+			importPath: `~/${relativeToSrc}`,
+			pascalName: name
+		});
+	}
+	return components;
+}
+async function generateAutoImports(_scanResult, options) {
+	const { cwd, srcDir, buildDir, composablesDirs = [], componentsDirs = [], dirs = {}, imports: importsConfig, components: componentsConfig } = options;
+	const outDir = join(cwd, buildDir);
+	await mkdir(outDir, { recursive: true });
+	const autoImportEnabled = importsConfig?.autoImport !== false;
+	const componentAutoImportEnabled = componentsConfig?.autoImport !== false;
+	const directoryAsNamespace = componentsConfig?.directoryAsNamespace ?? false;
+	const composablesDir = dirs.composables || "composables";
+	const componentsDir = dirs.components || "components";
+	let composablesImports = [];
+	let components = [];
+	const autoImportsDtsPath = join(outDir, "auto-imports.d.ts");
+	const componentsDtsPath = join(outDir, "components.d.ts");
+	if (autoImportEnabled) {
+		const allComposablesDirs = [join(srcDir, composablesDir), ...composablesDirs];
+		const existingDirs = [];
+		for (const dir of allComposablesDirs) try {
+			const { statSync } = await import("node:fs");
+			if (statSync(dir).isDirectory()) existingDirs.push(dir);
+		} catch {}
+		const unimport = createUnimport({
+			presets: BUILTIN_PRESETS,
+			dirs: existingDirs,
+			dirsScanOptions: {
+				cwd: srcDir,
+				filePatterns: ["*.{ts,js,mts,mjs,cts,cjs}"],
+				types: false
+			}
+		});
+		await unimport.init();
+		composablesImports = (await unimport.getImports()).map((imp) => {
+			if (imp.from === "vue" || imp.from === "vue/macros" || imp.from === "ubean" || imp.from.startsWith("ubean/")) return imp;
+			return {
+				...imp,
+				from: transformImportPath(imp.from, srcDir)
+			};
+		});
+		await writeFile(autoImportsDtsPath, toTypeDeclarationFile(composablesImports, { resolvePath: (imp) => {
+			if (imp.from === "vue" || imp.from === "vue/macros" || imp.from === "ubean" || imp.from.startsWith("ubean/")) return imp.from;
+			return transformImportPath(imp.from, srcDir);
+		} }), "utf-8");
+	} else await writeFile(autoImportsDtsPath, "// Auto-generated by ubean - auto-imports disabled\n/* eslint-disable */\n// @ts-nocheck\nexport {}\n", "utf-8");
+	if (componentAutoImportEnabled) {
+		const allComponentsDirs = [join(srcDir, componentsDir), ...componentsDirs];
+		for (const dir of allComponentsDirs) {
+			const scanned = await scanComponentsDir(dir, srcDir, directoryAsNamespace);
+			components.push(...scanned);
+		}
+	}
+	await writeFile(componentsDtsPath, generateComponentsDts(components), "utf-8");
+	return {
+		composablesImports,
+		components,
+		autoImportsDtsPath,
+		componentsDtsPath
+	};
+}
+function generateComponentsDts(components) {
+	const lines = [
+		"// Auto-generated by ubean - do not edit manually",
+		"/* eslint-disable */",
+		"// @ts-nocheck",
+		"",
+		"declare module 'vue' {"
+	];
+	const importLines = [];
+	const componentEntries = [];
+	for (const name of ["Link", "Head"]) {
+		importLines.push(`  const ${name}: typeof import('ubean/runtime/vue')['${name}'];`);
+		componentEntries.push(`    ${name}: typeof ${name};`);
+	}
+	for (const comp of components) {
+		importLines.push(`  import ${comp.pascalName} from ${JSON.stringify(comp.importPath)};`);
+		componentEntries.push(`    ${comp.pascalName}: typeof ${comp.pascalName};`);
+	}
+	if (importLines.length > 0) {
+		lines.push(...importLines);
+		lines.push("");
+		lines.push("  export interface GlobalComponents {");
+		lines.push(...componentEntries);
+		lines.push("  }");
+	} else lines.push("  export interface GlobalComponents {}");
+	lines.push("}");
+	lines.push("");
+	lines.push("export {}");
+	return `${lines.join("\n")}\n`;
+}
+function getBuiltinComposables() {
+	const imports = [];
+	for (const preset of BUILTIN_PRESETS) for (const name of preset.imports) if (typeof name === "string") imports.push({
+		name,
+		from: preset.from
+	});
+	else if (Array.isArray(name)) imports.push({
+		name: name[0],
+		as: name[1],
+		from: preset.from
+	});
+	return imports;
+}
+function getUbeanAutoImportConfig(options = {}) {
+	const cwd = options.cwd || process.cwd();
+	const srcDir = options.srcDir || join(cwd, "src");
+	const buildDir = options.buildDir || ".ubean";
+	const composablesDirs = [join(srcDir, "composables"), ...options.composablesDirs || []];
+	return {
+		imports: [
+			UBEAN_CLIENT_PRESET,
+			UBEAN_SERVER_PRESET,
+			HONO_OPENAPI_PRESET
+		],
+		dirs: composablesDirs,
+		dts: join(cwd, buildDir, "auto-imports.d.ts"),
+		vueTemplate: true,
+		eslintrc: { enabled: false }
+	};
+}
+function getUbeanComponentsConfig(options = {}) {
+	const cwd = options.cwd || process.cwd();
+	const srcDir = options.srcDir || join(cwd, "src");
+	const buildDir = options.buildDir || ".ubean";
+	return {
+		dirs: [join(srcDir, "components"), ...options.componentsDirs || []],
+		extensions: ["vue"],
+		directoryAsNamespace: options.directoryAsNamespace ?? false,
+		dts: join(cwd, buildDir, "components.d.ts"),
+		deep: true
+	};
+}
+function generateImportsTransform(imports) {
+	const importGroups = /* @__PURE__ */ new Map();
+	for (const imp of imports) {
+		if (!importGroups.has(imp.from)) importGroups.set(imp.from, /* @__PURE__ */ new Set());
+		const namePart = imp.as ? `${imp.name} as ${imp.as}` : imp.name;
+		importGroups.get(imp.from).add(namePart);
+	}
+	const importStatements = [];
+	for (const [from, names] of importGroups) importStatements.push(`import { ${Array.from(names).join(", ")} } from '${from}';`);
+	return { code: importStatements.join("\n") };
+}
+//#endregion
+export { BUILTIN_PRESETS, HONO_OPENAPI_PRESET, UBEAN_CLIENT_PRESET, UBEAN_PRESET, UBEAN_SERVER_PRESET, VUE_MACROS_PRESET, VUE_PRESET, generateAutoImports, generateImportsTransform, getBuiltinComposables, getUbeanAutoImportConfig, getUbeanComponentsConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/auto-imports",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Auto-import presets for ubean (VUE_PRESET, UBEAN_CLIENT_PRESET, UBEAN_SERVER_PRESET)",
   "files": [
     "dist"
@@ -26,7 +26,7 @@
     "vite-plus": "0.2.6"
   },
   "peerDependencies": {
-    "@ubean/routing": "0.1.2"
+    "@ubean/routing": "0.1.4"
   },
   "peerDependenciesMeta": {
     "@ubean/routing": {