void 0.22.0 → 0.23.0

package/dist/runtime/route-url.d.mts

@@ -0,0 +1,4 @@
+//#region src/runtime/route-url.d.ts
+/** Expand complete route tokens without changing query strings or fragments. */
+export declare function interpolateRouteParams(path: string, params?: Record<string, string>): string;
+//#endregion

package/dist/runtime/route-url.mjs

@@ -0,0 +1,2 @@
+import { t as interpolateRouteParams } from "../route-url-CG7U-cRN.mjs";
+export { interpolateRouteParams };

package/dist/runtime/routing.d.mts

@@ -0,0 +1,180 @@
+import { t as DevCssAsset } from "../types-BAp5AEBU.mjs";
+import { a as handlePageMutation, i as handlePageGet } from "../protocol-CjF_iI9X.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Context, ExecutionContext, Hono, MiddlewareHandler } from "hono";
+//#region src/runtime/routing-errors.d.ts
+type ErrorRendererOptions = {
+  dev?: boolean;
+  projectRoot: string;
+  homeDir: string;
+};
+type ErrorRenderer = {
+  createResponse: (request: Request, status: number, title: string, error?: unknown) => Response;
+  serveCustomPage: (context: Context, status: number, title: string, error?: unknown) => Promise<Response>;
+  onError: (error: Error, context: Context) => Promise<Response> | Response;
+};
+/** Error rendering is shared by generated Pages apps; production never includes exception details. */
+export declare function createErrorRenderer(options: ErrorRendererOptions): ErrorRenderer;
+//#endregion
+//#region src/runtime/routing-worker.d.ts
+type AssetBinding = {
+  fetch: (request: Request) => Promise<Response>;
+};
+type RuntimeEnvironment = Record<string, unknown> & {
+  ASSETS?: AssetBinding;
+};
+type AssetFallbackOptions = {
+  assetsDir?: string;
+  serveSpaFallback?: boolean;
+  notFound?: "none" | "404-page" | "single-page-application";
+};
+export declare function createAssetFallback(options?: AssetFallbackOptions): (request: Request, env: RuntimeEnvironment, response: Response) => Promise<Response>;
+/** Hide platform capabilities without copying bindings or changing application bindings. */
+export declare function filterInternalBindings<E extends Record<string, unknown>>(env: E, prefixes: Array<string>, exactNames?: Array<string>): E;
+type WorkerFetchOptions = {
+  app: {
+    fetch: (request: Request, env: RuntimeEnvironment, context: ExecutionContext) => Response | Promise<Response>;
+  };
+  assets: ReturnType<typeof createAssetFallback>;
+  withRawEnv: (env: RuntimeEnvironment, fn: () => Promise<Response>) => Promise<Response>;
+  withRuntimeEnv: (env: RuntimeEnvironment, fn: () => Promise<Response>) => Promise<Response>;
+  filterBindings: (env: RuntimeEnvironment) => RuntimeEnvironment;
+  validateEnv?: (env: RuntimeEnvironment) => Promise<void>;
+  /** Authored/generated version metadata binding used to prove the served native version. */
+  versionMetadataBinding?: string;
+  remoteEnv?: (env: RuntimeEnvironment) => RuntimeEnvironment;
+  internalRoute: (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext) => Promise<Response | null>;
+  collectPrerenderPaths: (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext) => Promise<Array<string>>;
+  emailReceipt?: (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext) => Promise<Response>;
+  isr?: {
+    deploymentId: string;
+    handle: (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext, render: (request: Request) => Promise<Response>) => Promise<Response | null>;
+  };
+};
+export declare function createWorkerFetch(options: WorkerFetchOptions): (request: Request, env: RuntimeEnvironment, ctx: ExecutionContext) => Promise<Response>;
+//#endregion
+//#region src/runtime/routing-assets.d.ts
+type ClientAssetTags = {
+  css: string;
+  preloads: string;
+  body: string;
+  devCss?: Array<DevCssAsset>;
+};
+type ClientManifest = Record<string, {
+  file?: string;
+  imports?: Array<string>;
+  css?: Array<string>;
+  /** Build-proven fingerprinted outputs; absent in older/third-party manifests. */
+  immutableFiles?: Array<string>;
+}>;
+type ManifestLoader = (request: Request, env: RuntimeEnvironment) => Promise<ClientManifest | null>;
+export declare function createManifestLoader(): ManifestLoader;
+type ClientAssetOptions = {
+  entryId: string;
+  entryUrl: string;
+  extraEntryId?: string;
+  extraEntryUrl?: string;
+  pageCssKeys?: Record<string, Array<string>>;
+  devRootPhases?: Record<string, Array<Array<string>>>;
+  kind: "ssr" | "pages" | "islands";
+  dev?: boolean;
+  reactRefresh?: boolean;
+  devCss?: (request: Request, env: RuntimeEnvironment, options: {
+    kind: "pages" | "islands";
+    componentId: string;
+    rootPhases: Array<Array<string>>;
+  }) => Promise<unknown>;
+};
+/** Frameworks supply only client entry IDs and active layout/page roots. */
+export declare function createClientAssetTags(options: ClientAssetOptions, loadManifest?: ManifestLoader): (request: Request, env: RuntimeEnvironment, componentId?: string) => Promise<ClientAssetTags>;
+//#endregion
+//#region src/runtime/routing-pages.d.ts
+type PageGetArguments = Parameters<typeof handlePageGet>;
+type PageModule = {
+  loader?: PageGetArguments[0];
+  head?: PageGetArguments[1];
+  action?: Parameters<typeof handlePageMutation>[0];
+  actions?: Record<string, Parameters<typeof handlePageMutation>[0]>;
+};
+type PageRouteOptions = {
+  load?: () => Promise<PageModule>;
+  head?: PageGetArguments[1];
+  componentId: string;
+  render: PageGetArguments[4];
+  assets: PageGetArguments[5];
+  headConfig: PageGetArguments[6] | null;
+  renderOptions: PageGetArguments[7];
+  namedActions?: boolean;
+};
+export declare function createPageGetHandler(options: PageRouteOptions): (c: Context) => Promise<Response>;
+export declare function createPageMutationHandler(options: PageRouteOptions): (c: Context) => Promise<Response>;
+export declare function createPagesFallback(options: {
+  routing: RoutingRuntime;
+  errors: ErrorRenderer;
+  fallbackRules?: Array<RoutingRule>;
+  assetsDir?: string;
+}): (c: Context) => Promise<Response>;
+type SsrModule = {
+  render?: (c: Context, assets: ClientAssetTags) => Response | Promise<Response>;
+  default?: (c: Context, assets: unknown) => Promise<Response>;
+};
+export declare function createSsrFallback(options: {
+  routing: RoutingRuntime;
+  nodeTarget?: boolean;
+  fallbackRules?: Array<RoutingRule>;
+  load: () => Promise<SsrModule>;
+  assets: (request: Request, env: Context["env"]) => Promise<ClientAssetTags>;
+  assetsDir?: string;
+}): (c: Context) => Promise<Response>;
+export declare function createAssetNotFound(options: {
+  routing: RoutingRuntime;
+  nodeTarget?: boolean;
+  fallbackRules?: Array<RoutingRule>;
+  assetsDir?: string;
+}): (c: Context) => Promise<Response>;
+//#endregion
+//#region src/runtime/routing.d.ts
+export type RoutingRule = {
+  source: string;
+  destination: string;
+  status: number;
+  host?: string;
+  force?: boolean;
+  origin?: string;
+};
+export type RoutingHeaderRule = {
+  pattern: string;
+  headers: Array<[string, string]>;
+};
+export type RequestContextStore = {
+  request: Request;
+  executionCtx?: Context["executionCtx"];
+};
+export type RoutingContext = Context & {
+  rewrite: (path: string) => Promise<Response>;
+  originalUrl: () => URL | null;
+  isRewritten: () => boolean;
+};
+export type RoutingRuntime = {
+  requestContext: AsyncLocalStorage<RequestContextStore>;
+  originalUrls: WeakMap<Request, URL>;
+  contextMiddleware: MiddlewareHandler;
+  requestMiddleware: MiddlewareHandler;
+  routingMiddleware: (rules: Array<RoutingRule>) => MiddlewareHandler;
+  headerMiddleware: (rules: Array<RoutingHeaderRule>) => MiddlewareHandler;
+  applyFallback: (context: Context, rules: Array<RoutingRule>) => Promise<Response | undefined>;
+  markNoMatch: (request: Request, response: Response) => Response;
+};
+/** One state owner per generated app: recursive dispatch shares rewrite and fallback guards. */
+export declare function createRoutingRuntime(app: Hono, options?: {
+  dev?: boolean;
+  nodeTarget?: boolean;
+  managedDispatch?: boolean;
+  blockedAssetExtensions?: Array<string>;
+  originalUrls?: WeakMap<Request, URL>;
+}): RoutingRuntime;
+export declare const DEFAULT_ASSET_EXTENSIONS: Array<string>;
+export declare function markNoMatch(request: Request, response: Response): Response;
+export declare function createHttpRouteHandler(load: () => Promise<Record<string, (c: Context) => unknown>>, method: string): (c: Context) => Promise<Response>;
+export declare function createModuleLoader<T>(load: () => Promise<T>, cache?: boolean): () => Promise<T>;
+//#endregion