@farm.js/core 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/api.d.mts

@@ -0,0 +1,50 @@
+export { A as APIRouteMatch, c as APIRouteParamValue, b as APIRouteParams, s as AnyEndpointMiddleware, D as DELETE, f as EndpointErrorContracts, d as EndpointErrorDefinition, e as EndpointErrorDefinitions, g as EndpointErrorHandler, E as EndpointErrorSchema, h as EndpointFail, j as EndpointFailure, x as EndpointHandler, u as EndpointInvalidationContext, t as EndpointInvalidationTarget, v as EndpointInvalidations, r as EndpointMiddleware, p as EndpointMiddlewareContext, q as EndpointMiddlewareResult, w as EndpointOptions, l as EndpointParamValue, o as EndpointParams, G as GET, H as HEAD, I as InferEndpointMiddlewareContext, O as OPTIONS, B as PATCH, P as POST, z as PUT, T as TypedEndpoint, y as createEndpoint, i as invokeAPIRouteEndpoint, k as isEndpointFailure, a as isWebResponse, m as matchAPIRoute, n as normalizeRouteResponse } from './runtime-Q3u74Nbq.mjs';
+export { APIRoute, APIRouteManager, APIRouteManagerOptions, API_ROUTE_METHODS } from './api/route-manager.mjs';
+export { r as APIClient, h as APIClientError, b as APIClientOptions, i as APIClientSystemError, c as APIClientWithoutIntegrationsOptions, g as APIResult, A as APIRouteRefMetadata, C as CacheKey, l as CacheOptions, k as CachePolicy, p as ClientOptions, a as FARM_API_ROUTE_META_SYMBOL, F as FARM_API_ROUTE_REF_SYMBOL, n as InvalidateOptions, I as InvalidateTarget, o as OptimisticOptions, O as OptimisticUpdate, R as RequestEvent, j as ResponseEvent, m as RetryOptions, q as RouteAPIClient, s as ServerAPIClient, S as ServerAPIClientOptions, d as ServerAPIClientWithoutIntegrationsOptions, f as StatusEvent, e as StatusPhase, t as createAPIClient, w as createServerAPIClient, v as getAPIRouteRefMetadata, u as isAPIRouteRef } from './client-BT1mFQas.mjs';
+export { F as FarmAPIStream, c as FarmStreamResponse, a as MultipartField, M as MultipartSchema, b as MultipartValues, T as TypedFormData, e as isFarmAPIStream, d as isJSONStreamResponse, i as isMultipartSchema, j as jsonStream, m as multipart, r as readJSONStream, t as toFormData } from './transport-BmbGTXA5.mjs';
+import { Plugin } from 'vite';
+import './cache.mjs';
+import './route-runtime-DoOHzCAD.mjs';
+import './types-BMxWr97v.mjs';
+import './runtime-Cxpq6xZN.mjs';
+import './resolver-DJqjLMg_.mjs';
+import './integration-api-CHT2OKAf.mjs';
+import './client-cache-D-EZ7XVW.mjs';
+
+/**
+ * Farm.js API Routes Vite Plugin
+ *
+ * Standalone API route support that works with any Vite setup.
+ * Discovers and handles route.ts files in the api directory.
+ * Also supports root routes.ts for custom route definitions.
+ *
+ * @example
+ * ```ts
+ * import { farmApiPlugin } from '@farm.js/core'
+ *
+ * export default defineConfig({
+ *   plugins: [farmApiPlugin({ srcDir: 'src' })],
+ * })
+ * ```
+ */
+
+interface FarmApiPluginOptions {
+    /** Source directory containing the api folder (default: 'src') */
+    srcDir?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Maximum request body size, for example `"10mb"`. */
+    bodySizeLimit?: number | string;
+}
+interface ApiRoute {
+    path: string;
+    filePath: string;
+    methods: string[];
+    endpoints: Record<string, any>;
+}
+/**
+ * Farm.js API Routes Vite Plugin
+ */
+declare function farmApiPlugin(options?: FarmApiPluginOptions): Plugin;
+
+export { type ApiRoute, type FarmApiPluginOptions, farmApiPlugin };

package/dist/api.d.ts

@@ -0,0 +1,50 @@
+export { A as APIRouteMatch, c as APIRouteParamValue, b as APIRouteParams, s as AnyEndpointMiddleware, D as DELETE, f as EndpointErrorContracts, d as EndpointErrorDefinition, e as EndpointErrorDefinitions, g as EndpointErrorHandler, E as EndpointErrorSchema, h as EndpointFail, j as EndpointFailure, x as EndpointHandler, u as EndpointInvalidationContext, t as EndpointInvalidationTarget, v as EndpointInvalidations, r as EndpointMiddleware, p as EndpointMiddlewareContext, q as EndpointMiddlewareResult, w as EndpointOptions, l as EndpointParamValue, o as EndpointParams, G as GET, H as HEAD, I as InferEndpointMiddlewareContext, O as OPTIONS, B as PATCH, P as POST, z as PUT, T as TypedEndpoint, y as createEndpoint, i as invokeAPIRouteEndpoint, k as isEndpointFailure, a as isWebResponse, m as matchAPIRoute, n as normalizeRouteResponse } from './runtime-Bpp-c28k.js';
+export { APIRoute, APIRouteManager, APIRouteManagerOptions, API_ROUTE_METHODS } from './api/route-manager.js';
+export { r as APIClient, h as APIClientError, b as APIClientOptions, i as APIClientSystemError, c as APIClientWithoutIntegrationsOptions, g as APIResult, A as APIRouteRefMetadata, C as CacheKey, l as CacheOptions, k as CachePolicy, p as ClientOptions, a as FARM_API_ROUTE_META_SYMBOL, F as FARM_API_ROUTE_REF_SYMBOL, n as InvalidateOptions, I as InvalidateTarget, o as OptimisticOptions, O as OptimisticUpdate, R as RequestEvent, j as ResponseEvent, m as RetryOptions, q as RouteAPIClient, s as ServerAPIClient, S as ServerAPIClientOptions, d as ServerAPIClientWithoutIntegrationsOptions, f as StatusEvent, e as StatusPhase, t as createAPIClient, w as createServerAPIClient, v as getAPIRouteRefMetadata, u as isAPIRouteRef } from './client-Nn0q4eO4.js';
+export { F as FarmAPIStream, c as FarmStreamResponse, a as MultipartField, M as MultipartSchema, b as MultipartValues, T as TypedFormData, e as isFarmAPIStream, d as isJSONStreamResponse, i as isMultipartSchema, j as jsonStream, m as multipart, r as readJSONStream, t as toFormData } from './transport-BmbGTXA5.js';
+import { Plugin } from 'vite';
+import './cache.js';
+import './route-runtime-DoOHzCAD.js';
+import './types-BMxWr97v.js';
+import './runtime-bv63eUiO.js';
+import './resolver-IH4RmPEl.js';
+import './integration-api-CHT2OKAf.js';
+import './client-cache-CIlyBlmx.js';
+
+/**
+ * Farm.js API Routes Vite Plugin
+ *
+ * Standalone API route support that works with any Vite setup.
+ * Discovers and handles route.ts files in the api directory.
+ * Also supports root routes.ts for custom route definitions.
+ *
+ * @example
+ * ```ts
+ * import { farmApiPlugin } from '@farm.js/core'
+ *
+ * export default defineConfig({
+ *   plugins: [farmApiPlugin({ srcDir: 'src' })],
+ * })
+ * ```
+ */
+
+interface FarmApiPluginOptions {
+    /** Source directory containing the api folder (default: 'src') */
+    srcDir?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Maximum request body size, for example `"10mb"`. */
+    bodySizeLimit?: number | string;
+}
+interface ApiRoute {
+    path: string;
+    filePath: string;
+    methods: string[];
+    endpoints: Record<string, any>;
+}
+/**
+ * Farm.js API Routes Vite Plugin
+ */
+declare function farmApiPlugin(options?: FarmApiPluginOptions): Plugin;
+
+export { type ApiRoute, type FarmApiPluginOptions, farmApiPlugin };

package/dist/api.mjs

@@ -1,6 +1,6 @@
 import {
   farmApiPlugin
-} from "./chunk-4EATUJFO.mjs";
+} from "./chunk-ICTGDDV4.mjs";
 import {
   APIClientError,
   FARM_API_ROUTE_META_SYMBOL,
@@ -12,6 +12,7 @@ import {
 } from "./chunk-W2CRQFF6.mjs";
 import "./chunk-TQAEEJB4.mjs";
 import "./chunk-E6EPN5BT.mjs";
+import "./chunk-GIELMNBG.mjs";
 import "./chunk-QGOHVJ6J.mjs";
 import {
   APIRouteManager,

package/dist/app-CTFnOJaI.d.ts

@@ -0,0 +1,308 @@
+import { F as FarmConfig, C as ParsedRoute, s as RouteModule, v as LayoutModule, I as SSGCollectionResult, x as FarmRequest, y as FarmResponse, a4 as FarmMdxResolvedConfig, a5 as ResolvedFarmDevtoolsConfig, a6 as ResolvedFarmAuthConfig, a7 as ResolvedFarmPerformanceConfig, a8 as ResolvedFarmSecurityConfig } from './client-plugins-DuuleQKk.js';
+import { F as FarmDocsResolvedConfig } from './types-DTzm4TCl.js';
+import { FarmMarkdownResolvedConfig } from './markdown.js';
+import { F as FarmWorkflowsResolvedConfig } from './workflows-CusFV6mn.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-DyPRG0wX.js';
+import { F as FarmIslandStrategy } from './island-CfGru1MO.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';
+import { R as ResolvedFarmThemeConfig } from './types-CsR8fpgF.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;
+            islandStrategy: FarmIslandStrategy | null;
+            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" | "performance" | "security" | "theme"> & {
+    docs: FarmDocsResolvedConfig;
+    md: FarmMarkdownResolvedConfig;
+    mdx: FarmMdxResolvedConfig;
+    cron: FarmCronResolvedConfig;
+    workflows: FarmWorkflowsResolvedConfig;
+    devtools: ResolvedFarmDevtoolsConfig;
+    images: ResolvedFarmImageConfig;
+    i18n: ResolvedFarmI18nConfig;
+    auth: ResolvedFarmAuthConfig;
+    performance: ResolvedFarmPerformanceConfig;
+    security: ResolvedFarmSecurityConfig;
+    theme: ResolvedFarmThemeConfig;
+};
+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 };