@askrjs/askr 0.0.51 → 0.0.53

package/dist/ssr/index.d.ts

@@ -1,8 +1,225 @@
-import { DocumentRenderArgs, DocumentRenderContext, DocumentRenderer } from "../common/ssr.js";
-import { SSRDataMissingError } from "../common/ssr-errors.js";
-import { SSRRoute, resolveRequest } from "./route-render.js";
-import { SSRComponent, VNode } from "./types.js";
-import { renderToStringSync } from "./render-sync.js";
-import { renderResolvedToStringSync } from "./render-resolved.js";
-import { renderToStream, renderToString } from "./index-internal.js";
-export { type DocumentRenderArgs, type DocumentRenderContext, type DocumentRenderer, type SSRComponent, SSRDataMissingError, type SSRRoute, type VNode, renderResolvedToStringSync, renderToStream, renderToString, renderToStringSync, resolveRequest };
+import { c as RenderableChild, d as DocumentRenderContext, f as DocumentRenderer, p as SSRData, u as DocumentRenderArgs } from "../control-BQvNVfAd.js";
+import { r as JSXElement, s as Props } from "../jsx-CP0gmYwJ.js";
+import { D as QueryPrefetchContext, n as ServerQueryRegistry, u as CoreTelemetry, v as DataRuntime } from "../index-Bki2rqcr.js";
+import { L as RouteRequestResult, P as RouteRegistry, a as AccessRedirectDecision, b as RouteHandler, j as RouteRecord, m as RouteAuthOptions, p as Route, r as AccessDenyDecision, x as RouteManifest } from "../router-CeYvjj5_.js";
+import { AuthContext } from "@askrjs/auth";
+
+//#region src/common/page-render-envelope.d.ts
+declare const PAGE_RENDER_ENVELOPE_VERSION: 1;
+interface PageRenderEnvelope {
+  readonly version: typeof PAGE_RENDER_ENVELOPE_VERSION;
+  readonly resources: Readonly<Record<string, unknown>>;
+  readonly route: unknown;
+  readonly framework: Readonly<Record<string, unknown>>;
+}
+//#endregion
+//#region src/common/render-context.d.ts
+interface DeferredBoundaryRegistration {
+  id: string;
+  promise: Promise<unknown>;
+  fulfilled(value: unknown): RenderableChild;
+  rejected(error: unknown): RenderableChild;
+}
+//#endregion
+//#region src/common/ssr-errors.d.ts
+/**
+ * Common call contracts: SSR error types
+ */
+declare class SSRDataMissingError extends Error {
+  readonly code = "SSR_DATA_MISSING";
+  constructor(message?: string);
+}
+//#endregion
+//#region src/ssr/context.d.ts
+interface RenderContext {
+  url: string;
+  seed: number;
+  data?: SSRData;
+  params?: Record<string, string>;
+  routes?: readonly Route[];
+  routeAuth?: RouteAuthOptions;
+  authContext?: AuthContext;
+  signal?: AbortSignal;
+  dataRuntime?: unknown;
+  queryCache?: Map<string, unknown>;
+  resourceDataProvided: boolean;
+  mode?: 'ssr' | 'spa';
+  queryPrefetch?: QueryPrefetchContext;
+  ssrCleanupFns: Array<() => void>;
+  keyCounter: number;
+  renderData: PageRenderEnvelope | null;
+  hydrationData: PageRenderEnvelope | null;
+  deferredBoundaries: DeferredBoundaryRegistration[];
+}
+declare function createRenderContext(seed?: number, opts?: {
+  url?: string;
+  data?: SSRData;
+  params?: Record<string, string>;
+  routes?: readonly Route[];
+  routeAuth?: RouteAuthOptions;
+  signal?: AbortSignal;
+  dataRuntime?: unknown;
+  mode?: 'ssr' | 'spa';
+  queryPrefetch?: QueryPrefetchContext;
+  framework?: Readonly<Record<string, unknown>>;
+  envelope?: PageRenderEnvelope;
+}): RenderContext;
+/**
+ * Run a function with the given render context.
+ * Concurrency-safe in Node.js via AsyncLocalStorage.
+ */
+declare function withRenderContext<T>(ctx: RenderContext, fn: () => T): T;
+declare function withRenderContextAsync<T>(ctx: RenderContext, fn: () => T | PromiseLike<T>): Promise<T>;
+/**
+ * Get the current render context.
+ * Returns null if not inside a render.
+ */
+declare function getRenderContext(): RenderContext | null;
+//#endregion
+//#region src/ssr/route-render.d.ts
+type SSRRoute = {
+  path: string;
+  handler: RouteHandler;
+  namespace?: string;
+};
+type SSRRouteSource = {
+  registry: RouteRegistry;
+  routes?: readonly SSRRoute[];
+} | {
+  registry?: RouteRegistry;
+  routes: readonly SSRRoute[];
+};
+type RouteRenderOptions = SSRRouteSource & {
+  url: string;
+  seed?: number;
+  data?: SSRData;
+  document?: DocumentRenderer;
+  request?: Request;
+  dataRuntime?: DataRuntime;
+  queryPrefetch?: QueryPrefetchContext;
+  telemetry?: Pick<CoreTelemetry, 'ssrRender'>; /** @internal Precomposed page state used by hydration verification. */
+  envelope?: PageRenderEnvelope;
+};
+type RouteStreamOptions = RouteRenderOptions & {
+  onChunk(html: string): void;
+  onComplete(): void;
+};
+declare function resolveRequest(opts: {
+  url: string;
+  registry: RouteRegistry;
+  manifest?: RouteManifest;
+  routes?: Array<{
+    path: string;
+    handler: RouteHandler;
+    namespace?: string;
+  }>;
+  auth?: RouteAuthOptions;
+  authContext?: AuthContext;
+  request?: Request;
+  signal?: AbortSignal;
+} | {
+  url: string;
+  manifest: RouteManifest;
+  registry?: RouteRegistry;
+  routes?: Array<{
+    path: string;
+    handler: RouteHandler;
+    namespace?: string;
+  }>;
+  auth?: RouteAuthOptions;
+  authContext?: AuthContext;
+  request?: Request;
+  signal?: AbortSignal;
+} | {
+  url: string;
+  manifest?: RouteManifest;
+  registry?: RouteRegistry;
+  routes: Array<{
+    path: string;
+    handler: RouteHandler;
+    namespace?: string;
+  }>;
+  auth?: RouteAuthOptions;
+  authContext?: AuthContext;
+  request?: Request;
+  signal?: AbortSignal;
+}): Promise<RouteRequestResult>;
+//#endregion
+//#region src/ssr/types.d.ts
+/** VNode representation for SSR rendering */
+type VNode = {
+  type: string | SSRComponent | symbol;
+  props?: Props;
+  children?: unknown[];
+  key?: string | number | null;
+};
+/**
+ * Component function signature for SSR.
+ * Components receive props and an optional context with signal and SSR context.
+ */
+type SSRComponent = (props: Props, context?: {
+  signal?: AbortSignal;
+  ssr?: RenderContext;
+}) => VNode | JSXElement | string | number | boolean | null | undefined;
+//#endregion
+//#region src/ssr/render-sync.d.ts
+declare function renderToStringSync(component: (props?: Record<string, unknown>) => VNode | JSXElement | string | number | boolean | null | undefined, props?: Record<string, unknown>, options?: {
+  seed?: number;
+  data?: SSRData; /** @internal A composed page render envelope. */
+  envelope?: PageRenderEnvelope;
+}): string;
+//#endregion
+//#region src/ssr/render-resolved.d.ts
+declare function renderResolvedToStringSync(opts: {
+  url: string;
+  routes: ReadonlyArray<{
+    path: string;
+    handler: RouteHandler;
+    namespace?: string;
+  }>;
+  handler: RouteHandler;
+  params?: Record<string, string>;
+  options?: {
+    seed?: number;
+    data?: SSRData;
+    dataRuntime?: DataRuntime;
+    envelope?: PageRenderEnvelope;
+  };
+}): string;
+//#endregion
+//#region src/ssr/route-request-render.d.ts
+interface RenderRouteRequestOptions {
+  url: string;
+  manifest?: RouteManifest;
+  registry?: RouteRegistry;
+  auth?: RouteAuthOptions;
+  authContext?: AuthContext;
+  request?: Request;
+  signal?: AbortSignal;
+  seed?: number;
+  data?: SSRData;
+  /** Askr-owned state retained independently from route loader output. */
+  framework?: Readonly<Record<string, unknown>>;
+  dataRuntime?: DataRuntime;
+  queryPrefetch?: QueryPrefetchContext;
+  queryRegistry?: ServerQueryRegistry;
+  telemetry?: CoreTelemetry;
+}
+type RenderRouteRequestResult = {
+  kind: 'render';
+  html: string;
+  stream?: ReadableStream<Uint8Array>;
+  params: Record<string, string>;
+  record?: RouteRecord;
+} | AccessRedirectDecision | AccessDenyDecision | {
+  kind: 'no-match';
+};
+declare function renderRouteRequest(options: RenderRouteRequestOptions): Promise<RenderRouteRequestResult>;
+declare function renderRouteRequestToString(options: RenderRouteRequestOptions): Promise<RenderRouteRequestResult>;
+//#endregion
+//#region src/ssr/index-internal.d.ts
+declare function renderToString(component: (props?: Record<string, unknown>) => VNode | JSXElement | string | number | null): string;
+declare function renderToString(opts: RouteRenderOptions): string;
+declare function renderToStream(opts: RouteStreamOptions): void;
+//#endregion
+export { type DocumentRenderArgs, type DocumentRenderContext, type DocumentRenderer, type RenderRouteRequestOptions, type RenderRouteRequestResult, type SSRComponent, SSRDataMissingError, type SSRRoute, type VNode, createRenderContext, getRenderContext, renderResolvedToStringSync, renderRouteRequest, renderRouteRequestToString, renderToStream, renderToString, renderToStringSync, resolveRequest, withRenderContext, withRenderContextAsync };

package/dist/ssr/index.js

@@ -1,6 +1,3 @@
-import { SSRDataMissingError } from "../common/ssr-errors.js";
-import { resolveRequest } from "./route-render.js";
-import { renderToStringSync } from "./render-sync.js";
-import { renderResolvedToStringSync } from "./render-resolved.js";
-import { renderToStream, renderToString } from "./index-internal.js";
-export { SSRDataMissingError, renderResolvedToStringSync, renderToStream, renderToString, renderToStringSync, resolveRequest };
+import { u as SSRDataMissingError } from "../render-context-Clw3rFiO.js";
+import { a as renderResolvedToStringSync, c as createRenderContext, d as withRenderContextAsync, i as renderRouteRequestToString, l as getRenderContext, n as renderToString, o as renderToStringSync, r as renderRouteRequest, s as resolveRequest, t as renderToStream, u as withRenderContext } from "../ssr-D3t80Rc0.js";
+export { SSRDataMissingError, createRenderContext, getRenderContext, renderResolvedToStringSync, renderRouteRequest, renderRouteRequestToString, renderToStream, renderToString, renderToStringSync, resolveRequest, withRenderContext, withRenderContextAsync };

package/dist/{common/ssr.js → ssr-CbQO5xd3.js}

@@ -9,6 +9,4 @@ function renderDocument(document, args, apiName) {
 }
 const SSR_RENDER_DATA_ATTR = "data-askr-render-data";
 //#endregion
-export { SSR_RENDER_DATA_ATTR, renderDocument };
-
-//# sourceMappingURL=ssr.js.map
+export { renderDocument as n, SSR_RENDER_DATA_ATTR as t };