@jk2908/solas 0.5.4 → 0.6.0

package/dist/internal/prerender.d.ts

@@ -1,140 +1,132 @@
 import type { BuildContext } from '../types.js';
-export declare namespace Prerender {
-    namespace Artifact {
-        type Mode = 'full' | 'ppr';
-        type File = 'html' | 'prelude' | 'postponed' | 'metadata';
-        type Value = {
-            schema: string;
-            route: string;
-            createdAt: number;
-            mode: Mode;
-            html: string;
-            postponed?: unknown;
-        };
-        type Metadata = Pick<Value, 'schema' | 'route' | 'createdAt' | 'mode'>;
-        type ManifestEntry = {
-            mode: Mode;
-            files?: readonly File[];
-        };
-        type Manifest = Record<string, ManifestEntry>;
-        /**
-         * Get the root directory path where prerender artifacts are stored,
-         * based on the output directory specified in the configuration
-         */
-        function getRootPath(outDir: string): string;
-        /**
-         * Get the file system path for storing prerender artifacts for a given route
-         */
-        function getPath(outDir: string, pathname: string): string;
-        /**
-         * Get the file system path for a single prerender artifact file under a route directory
-         */
-        function getFilePath(outDir: string, pathname: string, fileName: string): string;
-        /**
-         * File name used for saved full-prerender html inside each route artifact directory
-         */
-        const FULL_PRERENDER_FILENAME = "prerendered.html";
-        /**
-         * Load the postponed state for a given route from the file system, if it exists
-         */
-        function loadPostponedState(outDir: string, pathname: string): Promise<any>;
-        /**
-         * Load the prelude HTML for a given route from the file system, if it exists
-         */
-        function loadPrelude(outDir: string, pathname: string): Promise<string | null>;
-        /**
-         * Load the prerender artifact metadata for a given route from the file system, if it exists and is valid
-         */
-        function loadMetadata(outDir: string, pathname: string): Promise<{
-            schema: string;
-            route: string;
-            createdAt: number;
-            mode: "full" | "ppr";
-        } | null>;
-        /**
-         * Check if a prerender artifact is compatible with the current application version and route,
-         * based on its metadata
-         */
-        function isCompatible(artifactMetadata: Metadata, pathname: string, mode: Mode): boolean;
-        /**
-         * Compose the prelude HTML and the resume stream into a single HTML stream, by injecting the resume stream
-         * into the prelude at the appropriate location (before </body> or </html>)
-         */
-        function composePreludeAndResume(prelude: string, resumeStream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array<ArrayBufferLike>>;
-    }
-    type Result = {
-        route: string;
-        artifact: Artifact.Value;
-    } | {
-        route: string;
-        status: number;
-    } | {
-        route: string;
-        error: unknown;
-    };
-    namespace Runtime {
-        /**
-         * Custom error class to indicate that prerendering has been postponed to request-time
-         */
-        class Postponed extends Error {
-            constructor(message?: string);
-        }
-        /**
-         * Type guard to check if an error is a Postponed error, including wrapped errors like
-         * AbortError or TimeoutError
-         */
-        function isPostponed(error: unknown): boolean;
-    }
-    namespace Build {
-        /**
-         * Get the prerender concurrency value from the environment variable, or return the default
-         * if it's not set or invalid
-         */
-        function getConcurrency(): number;
-        /**
-         * Extract the prerendering mode ('full', 'ppr', or false) from the source code of a route module, by
-         * looking for an exported `prerender` binding and validating its value
-         */
-        function getStaticFlag(filePath: string, buildContext: BuildContext): Promise<"full" | "ppr" | false | undefined>;
-        /**
-         * Get the list of static parameters for a dynamic route, by looking for an exported `params` function
-         * in the route module and calling it to get the list of parameter objects
-         */
-        function getStaticParams(filePath: string, buildContext: BuildContext): Promise<Record<string, string | number | (string | number)[]>[]>;
-        /**
-         * Generate the list of prerenderable routes for a dynamic route, by combining the static parameters obtained from
-         * the route module with the route pattern, and filtering out any routes that still contain dynamic segments
-         */
-        function getDynamicRouteList(route: string, paramNames: string[], staticParams: Record<string, string | number | (string | number)[]>[]): string[];
-        /**
-         * Function to prerender a single route by making a request to the route with special headers, and returning the
-         * result which includes either the prerender artifact or an error/status code if the prerendering failed or was
-         * postponed to request-time
-         */
-        function get(app: {
-            fetch: (req: Request) => Promise<Response>;
-        }, route: string, opts: {
-            origin?: string;
-            base?: string;
-        }): Promise<{
-            route: string;
-            status: number;
-            artifact?: undefined;
-        } | {
-            status?: undefined;
-            route: string;
-            artifact: any;
-        }>;
-        /**
-         * Run the prerendering process for a list of routes with a specified concurrency limit,
-         * by calling the 'get' function for each route and yielding the results as they become available
-         */
-        function run(app: {
-            fetch: (req: Request) => Promise<Response>;
-        }, routes: string[], opts: {
-            concurrency?: number;
-            origin?: string;
-            base?: string;
-        }): AsyncGenerator<Result, void, unknown>;
-    }
+export type Mode = 'full' | 'ppr';
+export type File = 'html' | 'prelude' | 'postponed' | 'metadata';
+export type Value = {
+    schema: string;
+    route: string;
+    createdAt: number;
+    mode: Mode;
+    html: string;
+    postponed?: unknown;
+};
+export type Metadata = Pick<Value, 'schema' | 'route' | 'createdAt' | 'mode'>;
+export type Artifact = {
+    mode: Mode;
+    files?: readonly File[];
+};
+export type ArtifactManifest = Record<string, Artifact>;
+/**
+ * Get the root directory path where prerender artifacts are stored,
+ * based on the output directory specified in the configuration
+ */
+export declare function getArtifactRootPath(outDir: string): string;
+/**
+ * Get the file system path for storing prerender artifacts for a given route
+ */
+export declare function getArtifactPath(outDir: string, pathname: string): string;
+/**
+ * Get the file system path for a single prerender artifact file under a route directory
+ */
+export declare function getArtifactFilePath(outDir: string, pathname: string, fileName: string): string;
+/**
+ * File name used for saved full-prerender html inside each route artifact directory
+ */
+export declare const FULL_PRERENDER_FILENAME = "prerendered.html";
+/**
+ * Load the postponed state for a given route from the file system, if it exists
+ */
+export declare function loadPostponedState(outDir: string, pathname: string): Promise<any>;
+/**
+ * Load the prelude HTML for a given route from the file system, if it exists
+ */
+export declare function loadPrelude(outDir: string, pathname: string): Promise<string | null>;
+/**
+ * Load the prerender artifact metadata for a given route from the file system, if it exists and is valid
+ */
+export declare function loadMetadata(outDir: string, pathname: string): Promise<{
+    schema: string;
+    route: string;
+    createdAt: number;
+    mode: "full" | "ppr";
+} | null>;
+/**
+ * Check if a prerender artifact is compatible with the current application version and route,
+ * based on its metadata
+ */
+export declare function isCompatible(artifactMetadata: Metadata, pathname: string, mode: Mode): boolean;
+/**
+ * Compose the prelude HTML and the resume stream into a single HTML stream, by injecting the resume stream
+ * into the prelude at the appropriate location (before </body> or </html>)
+ */
+export declare function composePreludeAndResume(prelude: string, resumeStream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array<ArrayBufferLike>>;
+export type Result = {
+    route: string;
+    artifact: Value;
+} | {
+    route: string;
+    status: number;
+} | {
+    route: string;
+    error: unknown;
+};
+/**
+ * Custom error class to indicate that prerendering has been postponed to request-time
+ */
+export declare class Postponed extends Error {
+    constructor(message?: string);
 }
+/**
+ * Type guard to check if an error is a Postponed error, including wrapped errors like
+ * AbortError or TimeoutError
+ */
+export declare function isPostponed(error: unknown): boolean;
+/**
+ * Get the prerender concurrency value from the environment variable, or return the default
+ * if it's not set or invalid
+ */
+export declare function getConcurrency(): number;
+/**
+ * Extract the prerendering mode ('full', 'ppr', or false) from the source code of a route module, by
+ * looking for an exported `prerender` binding and validating its value
+ */
+export declare function getStaticFlag(filePath: string, buildContext: BuildContext): Promise<"full" | "ppr" | false | undefined>;
+/**
+ * Get the list of static parameters for a dynamic route, by looking for an exported `params` function
+ * in the route module and calling it to get the list of parameter objects
+ */
+export declare function getStaticParams(filePath: string, buildContext: BuildContext): Promise<Record<string, string | number | (string | number)[]>[]>;
+/**
+ * Generate the list of prerenderable routes for a dynamic route, by combining the static parameters obtained from
+ * the route module with the route pattern, and filtering out any routes that still contain dynamic segments
+ */
+export declare function getDynamicRouteList(route: string, paramNames: string[], staticParams: Record<string, string | number | (string | number)[]>[]): string[];
+/**
+ * Function to prerender a single route by making a request to the route with special headers, and returning the
+ * result which includes either the prerender artifact or an error/status code if the prerendering failed or was
+ * postponed to request-time
+ */
+export declare function get(app: {
+    fetch: (req: Request) => Promise<Response>;
+}, route: string, opts: {
+    origin?: string;
+    base?: string;
+}): Promise<{
+    route: string;
+    status: number;
+    artifact?: undefined;
+} | {
+    status?: undefined;
+    route: string;
+    artifact: any;
+}>;
+/**
+ * Run the prerendering process for a list of routes with a specified concurrency limit,
+ * by calling the 'get' function for each route and yielding the results as they become available
+ */
+export declare function run(app: {
+    fetch: (req: Request) => Promise<Response>;
+}, routes: string[], opts: {
+    concurrency?: number;
+    origin?: string;
+    base?: string;
+}): AsyncGenerator<Result, void, unknown>;