@aerobuilt/core 0.1.0

package/dist/runtime/index.d.ts

@@ -0,0 +1,74 @@
+import { MountOptions, AeroRenderInput } from '../types.js';
+import 'vite';
+
+/**
+ * Aero runtime: page registration, route resolution, and HTML rendering.
+ *
+ * @remarks
+ * The `Aero` class holds globals and a map of page/layout modules. `render()` resolves a page name
+ * (e.g. from `resolvePageName`), builds template context, and invokes the compiled render function.
+ * `mount` is optionally set by the client entry (`core/src/entry-dev.ts`).
+ */
+
+declare class Aero {
+    /** Global values merged into template context (e.g. from content modules). */
+    private globals;
+    /** Map from page name (or path) to module. Keys include both canonical name and full path for lookup. */
+    private pagesMap;
+    /** Set by client entry when running in the browser; used to attach the app to a DOM root. */
+    mount?: (options?: MountOptions) => Promise<void>;
+    /**
+     * Register a global value available in all templates as `name`.
+     *
+     * @param name - Key used in templates (e.g. `site`).
+     * @param value - Any value (object, string, etc.).
+     */
+    global(name: string, value: any): void;
+    /**
+     * Register page/layout modules from a Vite glob (e.g. `import.meta.glob('@pages/**\/*.html')`).
+     * Derives a lookup key from each path via pagePathToKey; also stores by full path for resolution.
+     *
+     * @param pages - Record of resolved path → module (default export is the render function).
+     */
+    registerPages(pages: Record<string, any>): void;
+    /** Type guard: true if value looks like an `AeroRenderInput` (has at least one of props, slots, request, url, params, routePath). */
+    private isRenderInput;
+    /** Coerce various call signatures into a single `AeroRenderInput` (e.g. plain object → `{ props }`). */
+    private normalizeRenderInput;
+    /** Convert a page name to a route path (e.g. `index` → `'/'`, `about` → `'/about'`). */
+    private toRoutePath;
+    /** Build a URL from route path and optional raw URL. Uses `http://localhost` as base when only a path is given. */
+    private toURL;
+    /** Build template context: globals, props, slots, request, url, params, site, and `renderComponent` / `nextPassDataId`. */
+    private createContext;
+    /** True if entry params and request params have the same keys and stringified values. */
+    private paramsMatch;
+    /**
+     * Render a page or layout to HTML.
+     *
+     * @remarks
+     * Resolves `component` (page name string or module) via `pagesMap`, with fallbacks: directory index
+     * (`foo` → `foo/index`), `index` → `home`, dynamic routes, and trailing-slash stripping. If the module
+     * exports `getStaticPaths` and no props are provided, finds the matching static path and uses its props.
+     * For root-level renders, injects accumulated styles and scripts into the document and fixes content
+     * that ends up after `</html>` when using layouts (moves it into `</body>`).
+     *
+     * @param component - Page name (e.g. `'index'`, `'about'`) or the module object.
+     * @param input - Render input (props, request, url, params, etc.). Can be a plain object (treated as props).
+     * @returns HTML string, or `null` if the page is not found or no static path match.
+     */
+    render(component: any, input?: any): Promise<any>;
+    /**
+     * Render a child component (layout or component) with the given props and slots.
+     * Used by compiled templates via context.renderComponent.
+     *
+     * @param component - Render function or module with `default` render function.
+     * @param props - Props object for the component.
+     * @param slots - Named slot content (key → HTML string).
+     * @param input - Optional request/url/params for context; `headScripts` is not passed through.
+     * @returns HTML string from the component's render function, or empty string if not invokable.
+     */
+    renderComponent(component: any, props?: any, slots?: Record<string, string>, input?: AeroRenderInput): Promise<any>;
+}
+
+export { Aero };

package/dist/runtime/index.js

@@ -0,0 +1,7 @@
+import {
+  Aero
+} from "../chunk-3OZCI7DL.js";
+import "../chunk-7A3WBPH4.js";
+export {
+  Aero
+};

package/dist/runtime/instance.d.ts

@@ -0,0 +1,31 @@
+import { Aero } from './index.js';
+import '../types.js';
+import 'vite';
+
+/**
+ * Singleton Aero instance and HMR update subscription.
+ *
+ * @remarks
+ * Provides a single shared `Aero` instance and a listener set so the client entry can subscribe to
+ * "something changed" (e.g. template or glob updates). Uses `globalThis` so the instance survives
+ * Vite HMR re-execution. On load, runs Vite-specific `import.meta.glob` for pages, components, and
+ * layouts, registers them with the instance, then calls `notify()` so any existing subscribers
+ * (e.g. the client `mount()` HMR callback) can re-render. Only used in a Vite app context.
+ */
+
+/** Global slot for the singleton Aero instance; used so HMR re-execution reuses the same instance. */
+declare global {
+    var __AERO_INSTANCE__: Aero | undefined;
+    var __AERO_LISTENERS__: Set<() => void> | undefined;
+}
+declare const aero: Aero;
+/**
+ * Subscribe to update notifications (e.g. after globs or templates change).
+ * Used by the client entry to re-render on HMR.
+ *
+ * @param cb - Callback invoked when `notify()` runs (e.g. after this module re-executes).
+ * @returns Unsubscribe function that removes `cb` from the listener set.
+ */
+declare const onUpdate: (cb: () => void) => () => boolean;
+
+export { aero, onUpdate };

package/dist/runtime/instance.js

@@ -0,0 +1,10 @@
+import {
+  aero,
+  onUpdate
+} from "../chunk-5GK7XRII.js";
+import "../chunk-3OZCI7DL.js";
+import "../chunk-7A3WBPH4.js";
+export {
+  aero,
+  onUpdate
+};

package/dist/types.d.ts

@@ -0,0 +1,202 @@
+import * as vite from 'vite';
+
+/**
+ * Shared type definitions for the Aero framework (compiler, runtime, Vite plugin).
+ *
+ * @remarks
+ * Grouped roughly by: config/dirs, compile/parse, resolver/aliases, routing, render context.
+ */
+interface AeroDirs {
+    /** Site source directory; pages live at `client/pages` (default: `'client'`). */
+    client?: string;
+    /** Nitro server directory (default: `'server'`). */
+    server?: string;
+    /** Build output directory (default: `'dist'`). */
+    dist?: string;
+}
+/** One redirect rule: from path to URL, optional status (default 302). */
+interface RedirectRule {
+    from: string;
+    to: string;
+    status?: number;
+}
+interface AeroOptions {
+    /** Enable Nitro server integration (default: `false`). */
+    nitro?: boolean;
+    /** API route prefix (default: `'/api'`). */
+    apiPrefix?: string;
+    /** Directory overrides. */
+    dirs?: AeroDirs;
+    /**
+     * Canonical site URL (e.g. `'https://example.com'`). Exposed as `import.meta.env.SITE` and
+     * as `Aero.site` in templates. Used for sitemap, RSS, and canonical links.
+     */
+    site?: string;
+    /**
+     * Redirect rules applied in dev (Vite) and when using the Nitro server (preview:api / production).
+     * For static-only deploys use host redirect config (_redirects, vercel.json, etc.).
+     */
+    redirects?: RedirectRule[];
+    /**
+     * Optional request-time middleware (redirects, rewrites, custom responses).
+     * Runs in dev before rendering; for production redirects use Nitro server middleware or `redirects` config.
+     */
+    middleware?: AeroMiddleware[];
+    /**
+     * Optional plugins to add to the static render server (e.g. content plugin when using aero:content).
+     * Merged after the core Aero plugins so pages that import aero:content resolve during static build.
+     */
+    staticServerPlugins?: vite.Plugin[];
+}
+/** Request context passed to middleware (url, request, route path, resolved page name, site). */
+interface AeroRequestContext {
+    url: URL;
+    request: Request;
+    routePath: string;
+    pageName: string;
+    site?: string;
+}
+/** Result of middleware: redirect, rewrite render input, or send a custom response. */
+type AeroMiddlewareResult = {
+    redirect: {
+        url: string;
+        status?: number;
+    };
+} | {
+    rewrite: Partial<AeroRenderInput> & {
+        pageName?: string;
+    };
+} | {
+    response: Response;
+} | void;
+/** Middleware handler: receives request context; returns redirect/rewrite/response or nothing to continue. */
+type AeroMiddleware = (ctx: AeroRequestContext) => AeroMiddlewareResult | Promise<AeroMiddlewareResult>;
+/** Options for the client-side `mount()` entry (see `core/src/entry-dev.ts`). */
+interface MountOptions {
+    /** Root element: CSS selector or `HTMLElement`. Defaults to `#app`. */
+    target?: string | HTMLElement;
+    /** Called with the root element after mount and after each HMR re-render. */
+    onRender?: (root: HTMLElement) => void;
+}
+/**
+ * Single script entry: attrs (optional), content (body or virtual URL), optional pass:data expression.
+ * Used by parser, codegen, Vite plugin, and static build for client/inline/blocking script arrays.
+ */
+interface ScriptEntry {
+    attrs?: string;
+    content: string;
+    passDataExpr?: string;
+    /** If true, client script is injected in <head> instead of before </body>. */
+    injectInHead?: boolean;
+}
+/**
+ * Input to the codegen compiler for a single template.
+ *
+ * @remarks
+ * Script arrays come from the parser; `root` and `resolvePath` from the build.
+ */
+interface CompileOptions {
+    root: string;
+    /** Client script entries (plain `<script>`): after transform, `content` may be virtual URL. */
+    clientScripts?: ScriptEntry[];
+    /** Inline scripts (`is:inline`) to be emitted in the page. */
+    inlineScripts?: ScriptEntry[];
+    /** Blocking scripts (`is:blocking`) to be emitted in the page. */
+    blockingScripts?: ScriptEntry[];
+    /** Resolve import specifiers (e.g. `@components/foo`) to absolute paths. */
+    resolvePath?: (specifier: string) => string;
+}
+/** Options for the path resolver (e.g. resolving `@components/foo` to a file path). */
+interface ResolverOptions {
+    root: string;
+    resolvePath?: (specifier: string) => string;
+}
+/**
+ * Result of parsing one HTML template.
+ *
+ * @remarks
+ * Produced by `parser.ts`. Extracted script blocks and the remaining template string for codegen.
+ */
+interface ParseResult {
+    /** Single `<script is:build>` block, or `null` if none. */
+    buildScript: {
+        content: string;
+    } | null;
+    clientScripts: ScriptEntry[];
+    inlineScripts: ScriptEntry[];
+    blockingScripts: ScriptEntry[];
+    /** HTML after script blocks are stripped; used as input to codegen. */
+    template: string;
+}
+/** One path alias from tsconfig (e.g. find: `@components`, replacement: `.../src/components`). */
+interface UserAlias {
+    find: string;
+    replacement: string;
+}
+/** Result of loading project path aliases (`utils/aliases.ts`). */
+interface AliasResult {
+    aliases: UserAlias[];
+    resolvePath?: (specifier: string) => string;
+}
+/** Head and body HTML fragments (e.g. from `runtime/client` `extractDocumentParts`). */
+interface PageFragments {
+    head: string;
+    body: string;
+}
+/** Dynamic route segment key → value (e.g. `{ id: '42' }` for `/posts/42`). */
+interface AeroRouteParams {
+    [key: string]: string;
+}
+/** One static path for pre-rendering (e.g. from static path discovery). */
+interface StaticPathEntry {
+    params: AeroRouteParams;
+    props?: Record<string, any>;
+}
+/**
+ * Input passed into a page or layout render (request, url, params, etc.).
+ *
+ * @remarks
+ * Used by the runtime when calling the compiled render function and when rendering child components.
+ */
+interface AeroRenderInput {
+    props?: Record<string, any>;
+    /** Named slot content (key → HTML string) for layout/page render. */
+    slots?: Record<string, string>;
+    request?: Request;
+    url?: URL | string;
+    params?: AeroRouteParams;
+    /** Resolved route path pattern (e.g. `'/posts/[id]'`) for the current request. */
+    routePath?: string;
+    /** Accumulated style URLs/labels for this request. */
+    styles?: Set<string>;
+    /** Accumulated script URLs/labels for this request. */
+    scripts?: Set<string>;
+    /** Scripts to inject in <head>. */
+    headScripts?: Set<string>;
+    /** Canonical site URL from config (e.g. `'https://example.com'`). Exposed as Aero.site in templates. */
+    site?: string;
+}
+/**
+ * Context object available inside compiled templates (`is:build`) and when rendering components.
+ *
+ * @remarks
+ * Includes `props`, `slots`, `renderComponent`, `request`, `url`, `params`, and optional style/script sets.
+ * The index signature allows extra keys (e.g. from content or page data).
+ */
+interface AeroTemplateContext {
+    [key: string]: any;
+    props: Record<string, any>;
+    slots: Record<string, string>;
+    /** Used by codegen to emit calls that render a child component and return its HTML. */
+    renderComponent: (component: any, props?: Record<string, any>, slots?: Record<string, string>, context?: AeroRenderInput) => Promise<string>;
+    request: Request;
+    url: URL;
+    params: AeroRouteParams;
+    /** Canonical site URL from config (e.g. `'https://example.com'`). */
+    site?: string;
+    styles?: Set<string>;
+    scripts?: Set<string>;
+    headScripts?: Set<string>;
+}
+
+export type { AeroDirs, AeroMiddleware, AeroMiddlewareResult, AeroOptions, AeroRenderInput, AeroRequestContext, AeroRouteParams, AeroTemplateContext, AliasResult, CompileOptions, MountOptions, PageFragments, ParseResult, RedirectRule, ResolverOptions, ScriptEntry, StaticPathEntry, UserAlias };

package/dist/utils/redirects.d.ts

@@ -0,0 +1,24 @@
+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).
+ */
+
+/** Nitro routeRules redirect value: shorthand (307) or object with statusCode. */
+type NitroRedirectRule = string | {
+    to: string;
+    statusCode: number;
+};
+/**
+ * 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.
+ */
+declare function redirectsToRouteRules(redirects: RedirectRule[]): Record<string, {
+    redirect: NitroRedirectRule;
+}>;
+
+export { redirectsToRouteRules };

package/dist/utils/redirects.js

@@ -0,0 +1,6 @@
+import {
+  redirectsToRouteRules
+} from "../chunk-F7MXQXLM.js";
+export {
+  redirectsToRouteRules
+};

package/dist/vite/index.d.ts

@@ -0,0 +1,23 @@
+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.
+ */
+
+/**
+ * Aero Vite plugin factory. Returns an array of plugins: config, virtuals, transform, SSR,
+ * static-build, image optimizer, and optionally Nitro (serve only).
+ * HMR for templates and content is handled by Vite's dependency graph when the app uses a single
+ * client entry that imports @aerobuilt/core and calls aero.mount().
+ *
+ * @param options - AeroOptions (nitro, apiPrefix, dirs). Nitro can be disabled at runtime via AERO_NITRO=false.
+ * @returns PluginOption[] to pass to Vite's plugins array.
+ */
+declare function aero(options?: AeroOptions): PluginOption[];
+
+export { aero };