@aerobuilt/core 0.2.10 → 0.3.0

package/dist/utils/aliases.mjs

@@ -0,0 +1,117 @@
+import path from "node:path";
+import { getTsconfig } from "get-tsconfig";
+import { ResolverFactory } from "oxc-resolver";
+
+//#region src/utils/aliases.ts
+/** Shared oxc-resolver instance for Aero resolution (tsconfig auto, ESM, .html support). */
+const resolver = new ResolverFactory({
+	extensions: [
+		".html",
+		".ts",
+		".js",
+		".json",
+		".node"
+	],
+	conditionNames: ["node", "import"],
+	tsconfig: "auto"
+});
+/**
+* Build default path aliases for @pages, @layouts, @components from project root and dirs.
+* Used when tsconfig is missing or does not define these keys so the runtime globs resolve.
+*/
+function getDefaultAliases(root, dirs) {
+	return [
+		{
+			find: "@pages",
+			replacement: path.join(root, dirs.client, "pages")
+		},
+		{
+			find: "@layouts",
+			replacement: path.join(root, dirs.client, "layouts")
+		},
+		{
+			find: "@components",
+			replacement: path.join(root, dirs.client, "components")
+		}
+	];
+}
+/**
+* Load path aliases from tsconfig.json at or above the given root.
+*
+* @param root - Project root directory (e.g. `process.cwd()` or Vite config root).
+* @returns AliasResult with `aliases` for Vite resolve.alias and `resolve(specifier, importer)` for compiler/build.
+*/
+function loadTsconfigAliases(root) {
+	const result = getTsconfig(root);
+	if (!result) return {
+		aliases: [],
+		resolve: (specifier, importer) => {
+			return resolver.resolveFileSync(importer, specifier)?.path ?? specifier;
+		},
+		projectRoot: void 0
+	};
+	const options = result.config.compilerOptions;
+	const paths = options?.paths || {};
+	const baseUrl = options?.baseUrl || ".";
+	const configDir = path.dirname(result.path || root);
+	const baseDir = path.resolve(configDir, baseUrl);
+	const projectRoot = configDir;
+	const aliases = [];
+	for (const [key, values] of Object.entries(paths)) {
+		const first = Array.from(values)[0];
+		if (typeof first !== "string" || first.length === 0) continue;
+		const find = key.replace(/\/*$/, "").replace("/*", "");
+		const target = first.replace(/\/*$/, "").replace("/*", "");
+		const replacement = path.resolve(baseDir, target);
+		aliases.push({
+			find,
+			replacement
+		});
+	}
+	/** Resolve specifier from importer using oxc-resolver (tsconfig paths, extensions, package exports). */
+	const resolve = (specifier, importer) => {
+		return resolver.resolveFileSync(importer, specifier)?.path ?? specifier;
+	};
+	return {
+		aliases,
+		resolve,
+		projectRoot
+	};
+}
+/**
+* Merge framework default aliases (from dirs) with tsconfig-derived aliases.
+* Defaults are applied first; any alias from aliasResult with the same `find` overwrites.
+* Produces a resolve that tries merged aliases first, then falls back to the original resolver.
+*
+* Ensures @pages, @layouts, @components always exist so the runtime import.meta.glob patterns resolve.
+*
+* @param aliasResult - Result from loadTsconfigAliases (may have empty aliases when no tsconfig).
+* @param root - Project root.
+* @param dirs - Resolved client/layouts/components dirs.
+* @returns AliasResult with merged aliases and a resolve that uses them.
+*/
+function mergeWithDefaultAliases(aliasResult, root, dirs) {
+	const defaults = getDefaultAliases(root, dirs);
+	const byFind = /* @__PURE__ */ new Map();
+	for (const a of defaults) byFind.set(a.find, a.replacement);
+	for (const a of aliasResult.aliases) byFind.set(a.find, a.replacement);
+	const aliases = Array.from(byFind.entries()).map(([find, replacement]) => ({
+		find,
+		replacement
+	}));
+	const resolve = (specifier, importer) => {
+		for (const { find, replacement } of aliases) if (specifier === find || specifier.startsWith(find + "/")) {
+			const rest = specifier.slice(find.length);
+			return path.join(replacement, rest.replace(/^\//, ""));
+		}
+		return aliasResult.resolve(specifier, importer);
+	};
+	return {
+		aliases,
+		resolve,
+		projectRoot: aliasResult.projectRoot
+	};
+}
+
+//#endregion
+export { getDefaultAliases, loadTsconfigAliases, mergeWithDefaultAliases };

package/dist/utils/{redirects.d.ts → redirects.d.mts}

@@ -1,15 +1,10 @@
-import { RedirectRule } from '../types.js';
-import 'vite';
-
-/**
- * Convert Aero redirect rules to Nitro routeRules.
- * Used when generating Nitro config from Aero options (no project nitro.config.ts).
- */
+import { m as RedirectRule } from "../types-CLHGhnGA.mjs";
 
+//#region src/utils/redirects.d.ts
 /** Nitro routeRules redirect value: shorthand (307) or object with statusCode. */
 type NitroRedirectRule = string | {
-    to: string;
-    statusCode: number;
+  to: string;
+  statusCode: number;
 };
 /**
  * Map redirect rules to Nitro's routeRules shape.
@@ -18,7 +13,7 @@ type NitroRedirectRule = string | {
  * @returns Record suitable for Nitro's routeRules.
  */
 declare function redirectsToRouteRules(redirects: RedirectRule[]): Record<string, {
-    redirect: NitroRedirectRule;
+  redirect: NitroRedirectRule;
 }>;
-
-export { redirectsToRouteRules };
+//#endregion
+export { redirectsToRouteRules };

package/dist/utils/redirects.mjs

@@ -0,0 +1,21 @@
+//#region src/utils/redirects.ts
+/**
+* Map redirect rules to Nitro's routeRules shape.
+*
+* @param redirects - Array of { from, to, status? } from aero config.
+* @returns Record suitable for Nitro's routeRules.
+*/
+function redirectsToRouteRules(redirects) {
+	const out = {};
+	for (const rule of redirects) {
+		const status = rule.status ?? 302;
+		out[rule.from] = { redirect: status === 307 ? rule.to : {
+			to: rule.to,
+			statusCode: status
+		} };
+	}
+	return out;
+}
+
+//#endregion
+export { redirectsToRouteRules };

package/dist/vite/{index.d.ts → index.d.mts}

@@ -1,14 +1,7 @@
-import { AeroOptions } from '../types.js';
-import { PluginOption } from 'vite';
-
-/**
- * Aero Vite plugin: HTML transform, virtual modules, dev server middleware, and static build.
- *
- * @remarks
- * Split into focused sub-plugins: config, virtuals (resolve/load), transform, SSR middleware.
- * Static build plugin runs after closeBundle; Nitro and image optimizer are composed in the factory.
- */
+import { i as AeroOptions } from "../types-CLHGhnGA.mjs";
+import { PluginOption } from "vite";
 
+//#region src/vite/index.d.ts
 /**
  * Aero Vite plugin factory. Returns an array of plugins: config, virtuals, transform, SSR,
  * static-build, image optimizer, and optionally Nitro (serve only).
@@ -19,5 +12,5 @@ import { PluginOption } from 'vite';
  * @returns PluginOption[] to pass to Vite's plugins array.
  */
 declare function aero(options?: AeroOptions): PluginOption[];
-
-export { aero };
+//#endregion
+export { aero };