@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/app-xltejvLY.d.ts

@@ -0,0 +1,302 @@
+import { F as FarmConfig, x as ParsedRoute, p as RouteModule, r as LayoutModule, z as SSGCollectionResult, t as FarmRequest, u as FarmResponse, _ as FarmMdxResolvedConfig, $ as ResolvedFarmDevtoolsConfig, a0 as ResolvedFarmAuthConfig } from './client-plugins-DU9oMspX.js';
+import { F as FarmDocsResolvedConfig } from './types-C9N-nk5R.js';
+import { FarmMarkdownResolvedConfig } from './markdown.js';
+import { FarmWorkflowsResolvedConfig } from './workflows.js';
+import { FarmCronResolvedConfig } from './cron.js';
+import { R as ResolvedFarmImageConfig } from './image-config-Duob7wER.js';
+import { ProgrammaticRedirectRoute, ProgrammaticRouteSearchClientOptions } from './routes.js';
+import { ViteDevServer } from 'vite';
+import { M as MetadataImageKind } from './metadata-Cm9ujH4I.js';
+import { R as ResolvedFarmRouteRuntimeConfig } from './route-runtime-DoOHzCAD.js';
+import { R as ResolvedFarmI18nConfig } from './types-BMxWr97v.js';
+import { F as FarmI18nRuntime } from './runtime-bv63eUiO.js';
+
+declare const STATIC_METADATA_IMAGE_EXTENSIONS: readonly ["png", "jpg", "jpeg", "gif", "webp"];
+type StaticMetadataImageExtension = (typeof STATIC_METADATA_IMAGE_EXTENSIONS)[number];
+interface StaticMetadataImageInfo {
+    extension: StaticMetadataImageExtension;
+    contentType: string;
+    width: number;
+    height: number;
+    alt?: string;
+    hash: string;
+    byteLength: number;
+}
+
+interface RouteEntry {
+    route: ParsedRoute;
+    modulePath: string;
+    markdownSourcePath?: string;
+    pattern: string;
+    source?: "file" | "programmatic";
+    sourceRoot: string;
+}
+interface RouteSlotEntry extends RouteEntry {
+    name: string;
+    ownerPattern: string;
+    interception: boolean;
+    fallback: boolean;
+    containerId: string;
+}
+interface MatchedRouteSlot {
+    name: string;
+    ownerPattern: string;
+    containerId: string;
+    interception: boolean;
+    fallback: boolean;
+    route: RouteSlotEntry;
+    params: Record<string, string>;
+}
+interface MetadataImageEntry extends RouteEntry {
+    kind: MetadataImageKind;
+    fileName: "opengraph-image" | "twitter-image";
+    sourceType: "module" | "static";
+    staticInfo?: StaticMetadataImageInfo;
+}
+/**
+ * Manages route discovery and matching for the Farm.js application
+ */
+declare class RouteManager {
+    private config;
+    private routes;
+    private layouts;
+    private routeSlots;
+    private loadings;
+    private errors;
+    private metadataImages;
+    private redirects;
+    private programmaticPages;
+    private programmaticLayouts;
+    private viteServer?;
+    constructor(config: Required<FarmConfig>, viteServer?: ViteDevServer);
+    /**
+     * Discover all routes in the app directory
+     */
+    discoverRoutes(): Promise<void>;
+    /**
+     * Find matching route for a given URL path
+     */
+    matchRoute(pathname: string, options?: {
+        interceptFrom?: string;
+    }): {
+        route: RouteEntry | null;
+        params: Record<string, string>;
+        layouts: RouteEntry[];
+        slots: MatchedRouteSlot[];
+    };
+    /**
+     * Get all registered routes
+     */
+    getRoutes(): Map<string, RouteEntry>;
+    /**
+     * Get all registered layouts
+     */
+    getLayouts(): Map<string, RouteEntry>;
+    getRouteSlots(): Map<string, RouteSlotEntry>;
+    /** Resolve route rules, inherited layouts, and the page export in precedence order. */
+    resolveRouteRuntimeConfig(pattern: string): Promise<ResolvedFarmRouteRuntimeConfig>;
+    /**
+     * Get all route-level loading boundaries.
+     */
+    getLoadings(): Map<string, RouteEntry>;
+    /**
+     * Get all route-level error boundaries.
+     */
+    getErrors(): Map<string, RouteEntry>;
+    getMetadataImages(): Map<string, MetadataImageEntry>;
+    getRedirects(): ProgrammaticRedirectRoute[];
+    matchRedirect(pathname: string): {
+        redirect: ProgrammaticRedirectRoute;
+        destination: string;
+        statusCode: number;
+        params: Record<string, string>;
+    } | null;
+    /**
+     * Return the nearest matching loading boundary for a pathname.
+     */
+    getMatchingLoading(pathname: string): RouteEntry | null;
+    /**
+     * Return the nearest matching error boundary for a pathname.
+     */
+    getMatchingError(pathname: string): RouteEntry | null;
+    matchMetadataImage(pathname: string): {
+        image: MetadataImageEntry;
+        params: Record<string, string>;
+        pagePath: string;
+    } | null;
+    getMatchingMetadataImage(pathname: string, kind: MetadataImageKind): {
+        image: MetadataImageEntry;
+        params: Record<string, string>;
+    } | null;
+    resolveMetadataImagePath(image: MetadataImageEntry, params?: Record<string, string>): string;
+    /**
+     * Generate a client-side route manifest for SPA navigation
+     * This eliminates the need for server requests during navigation
+     */
+    generateClientManifest(projectRoot: string): {
+        routes: Array<{
+            pattern: string;
+            modulePath: string;
+            shouldHydrate: boolean;
+            isClientComponent: boolean;
+            search?: ProgrammaticRouteSearchClientOptions;
+            segments: Array<{
+                segment: string;
+                isDynamic: boolean;
+                isCatchAll?: boolean;
+                isOptional?: boolean;
+            }>;
+        }>;
+        layouts: Array<{
+            pattern: string;
+            modulePath: string;
+        }>;
+        slots: Array<{
+            name: string;
+            ownerPattern: string;
+            pattern: string;
+            modulePath: string;
+            containerId: string;
+            interception: boolean;
+            fallback: boolean;
+            shouldHydrate: boolean;
+            isClientComponent: boolean;
+            segments: RouteEntry["route"]["segments"];
+        }>;
+    };
+    /**
+     * Load a route module dynamically
+     */
+    loadRouteModule(modulePath: string): Promise<RouteModule>;
+    /**
+     * Load a layout module dynamically
+     */
+    loadLayoutModule(modulePath: string): Promise<LayoutModule>;
+    /**
+     * Create a route pattern from parsed route
+     */
+    private createRoutePattern;
+    private discoverFileRoutes;
+    private discoverProgrammaticRoutes;
+    private loadProgrammaticRoutesModule;
+    /**
+     * Find all layouts that should wrap a given path
+     */
+    private findMatchingLayouts;
+    private findMatchingRouteSlots;
+    private matchesRoutePrefix;
+    private findNearestBoundary;
+    /**
+     * Log discovered routes for debugging
+     */
+    private logRoutes;
+    /**
+     * Collect SSG pages for static generation
+     *
+     * Returns all pages marked with `export const ssg = true` along with
+     * their pre-computed paths (for dynamic routes using getStaticPaths)
+     */
+    collectSSGPages(): Promise<SSGCollectionResult>;
+    private toRoutePathname;
+    private localizeRedirectDestination;
+    private getI18nConfig;
+    /**
+     * Check if a route is SSG
+     */
+    isRouteSSG(modulePath: string): Promise<boolean>;
+    /**
+     * Check if a route has ISR (Incremental Static Regeneration)
+     */
+    hasRouteISR(modulePath: string): Promise<boolean>;
+    /**
+     * Get revalidation interval for a route
+     */
+    getRouteRevalidateInterval(modulePath: string): Promise<number | undefined>;
+}
+
+declare class ServerRenderer {
+    private config;
+    private routeManager;
+    private ssgManifest;
+    private dataCache;
+    private i18nRuntime?;
+    constructor(config: Required<FarmConfig>, routeManager: RouteManager, i18nRuntime?: FarmI18nRuntime);
+    runWithRequestContext<T>(request: Request, fn: () => T | Promise<T>): Promise<T>;
+    resolveRouteContext(input: {
+        request: Request;
+        rawRequest?: FarmRequest;
+        params: Record<string, string>;
+        search: Record<string, string | string[] | undefined>;
+        path: string;
+    }): Promise<unknown>;
+    /**
+     * Load SSG manifest from build output
+     */
+    private loadSSGManifest;
+    /**
+     * Check if a path should be served from SSG cache
+     */
+    private shouldServeSSG;
+    private getSSGCacheKey;
+    private getPPRCacheKey;
+    private getCachedSSGPage;
+    private cacheSSGPage;
+    private getCachedPPRShell;
+    private cachePPRShell;
+    private getPPRShellBypassReason;
+    private getPPRHeaders;
+    private serveCachedPPRShell;
+    /**
+     * Regenerate an SSG page in the background (ISR)
+     */
+    private regenerateSSGPage;
+    /**
+     * Serve a pre-rendered SSG page
+     */
+    private serveSSGPage;
+    renderPage(req: FarmRequest, res: FarmResponse): Promise<void>;
+    private renderPageInContext;
+    private wrapWithIntegrationProviders;
+    private resolveRouteMetadata;
+    private resolveMetadataImageReference;
+    private renderMetadataImage;
+    private writeMetadataImageResponse;
+    private writeStaticMetadataImageResponse;
+    private renderRouteErrorBoundary;
+    private renderWithSSR;
+    private render404;
+    private render500;
+    private createFullHTML;
+    private applyDeploymentHeaders;
+    private getDeploymentId;
+}
+
+type NormalizedFarmConfig = Omit<Required<FarmConfig>, "devtools" | "images" | "i18n"> & {
+    docs: FarmDocsResolvedConfig;
+    md: FarmMarkdownResolvedConfig;
+    mdx: FarmMdxResolvedConfig;
+    cron: FarmCronResolvedConfig;
+    workflows: FarmWorkflowsResolvedConfig;
+    devtools: ResolvedFarmDevtoolsConfig;
+    images: ResolvedFarmImageConfig;
+    i18n: ResolvedFarmI18nConfig;
+    auth: ResolvedFarmAuthConfig;
+};
+declare class FarmApp {
+    private config;
+    private routeManager;
+    private serverRenderer;
+    private i18nRuntime;
+    private viteServer?;
+    constructor(config?: FarmConfig, viteServer?: ViteDevServer);
+    initialize(): Promise<void>;
+    getRouteManager(): RouteManager;
+    getServerRenderer(): ServerRenderer;
+    getI18nRuntime(): FarmI18nRuntime;
+    getConfig(): NormalizedFarmConfig;
+    private normalizeConfig;
+    private verifyAppStructure;
+}
+declare function createFarmApp(config?: FarmConfig, viteServer?: ViteDevServer): FarmApp;
+
+export { FarmApp as F, RouteManager as R, ServerRenderer as S, createFarmApp as c };