@lomray/vite-ssr-boost 7.1.0 → 8.0.0-beta.2

package/README.md

@@ -14,7 +14,7 @@ It is built for applications that want to keep Vite and React Router visible, bu
 - React Router on both client and server
 - stream rendering with request lifecycle hooks
 - a Vite-native plugin and CLI flow
-- Switch between SPA and SSR in 1 second.
+- a Fetch-based SSR core with Node, Express, Fastify, Hono and edge adapters
 - response-aware helpers such as redirects and status codes
 - custom entrypoints for mobile, embedded and service-worker-friendly shells
 
@@ -35,10 +35,27 @@ It is built for applications that want to keep Vite and React Router visible, bu
 npm i @lomray/vite-ssr-boost
 ```
 
+Requires Node 22.12+. Your React Router and Babel versions may require a newer Node release.
+Start with the [React template](https://github.com/Lomray-Software/vite-template):
+
+```bash
+git clone https://github.com/Lomray-Software/vite-template.git
+cd vite-template
+npm ci
+npm run develop
+```
+
+For production, run `npm run build` and `npm run start:ssr`. For a static SPA, run
+`npm run build:spa` and `npm run start:spa`.
+
 ## Documentation
 
 Full documentation lives here: [lomray-software.github.io/vite-ssr-boost](https://lomray-software.github.io/vite-ssr-boost/)
 
+Existing Express applications move one import to `adapters/express/entry`; hooks are unchanged. See
+[runtime adapters](https://lomray-software.github.io/vite-ssr-boost/guide/runtime-adapters)
+for the Fetch API and the differences between the managed CLI server and a custom runtime.
+
 ## License
 
 Made with 💚

package/adapters/body.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reconstruct supported parsed bodies while preserving native Fetch body values.
+ */
+declare const serializeBody: (body: unknown, contentType?: string) => BodyInit | null;
+export default serializeBody;

package/adapters/body.js

@@ -0,0 +1,2 @@
+const e=(e,r="")=>{if(null==e)return null;if("string"==typeof e||e instanceof URLSearchParams||e instanceof Blob||e instanceof FormData||e instanceof ReadableStream||e instanceof ArrayBuffer||ArrayBuffer.isView(e))return e;const n=r.split(";")[0]?.trim().toLowerCase();if("application/x-www-form-urlencoded"===n)return(e=>{const r=new URLSearchParams;return Object.entries(e).forEach(([e,n])=>{(Array.isArray(n)?n:[n]).forEach(n=>{if(null!=n&&!["string","number","boolean","bigint"].includes(typeof n))throw new TypeError("Cannot serialize nested or non-primitive URL-encoded fields. Provide the adapter getBody option.");r.append(e,null==n?"":String(n))})}),r})(e);if(!n||"application/json"===n||n.endsWith("+json"))return JSON.stringify(e);throw new TypeError(`Cannot serialize a parsed ${n} body. Provide the adapter getBody option.`)};export{e as default};
+//# sourceMappingURL=body.js.map

package/adapters/body.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"body.js","sources":["../../src/adapters/body.ts"],"sourcesContent":[null],"names":["serializeBody","body","contentType","URLSearchParams","Blob","FormData","ReadableStream","ArrayBuffer","isView","mediaType","split","trim","toLowerCase","form","Object","entries","forEach","name","value","Array","isArray","item","includes","TypeError","append","String","serializeForm","endsWith","JSON","stringify"],"mappings":"AAGA,MAuBMA,EAAgB,CAACC,EAAeC,EAAc,MAClD,GAAY,MAARD,EACF,OAAO,KAGT,GACkB,iBAATA,GACPA,aAAgBE,iBAChBF,aAAgBG,MAChBH,aAAgBI,UAChBJ,aAAgBK,gBAChBL,aAAgBM,aAChBA,YAAYC,OAAOP,GAEnB,OAAOA,EAGT,MAAMQ,EAAYP,EAAYQ,MAAM,KAAK,IAAIC,OAAOC,cAEpD,GAAkB,sCAAdH,EACF,MA3CkB,CAACR,IACrB,MAAMY,EAAO,IAAIV,gBAgBjB,OAdAW,OAAOC,QAAQd,GAAMe,QAAQ,EAAEC,EAAMC,OACpBC,MAAMC,QAAQF,GAASA,EAAQ,CAACA,IAExCF,QAASK,IACd,GAAY,MAARA,IAAiB,CAAC,SAAU,SAAU,UAAW,UAAUC,gBAAgBD,GAC7E,MAAM,IAAIE,UACR,oGAIJV,EAAKW,OAAOP,EAAc,MAARI,EAAe,GAAKI,OAAOJ,QAI1CR,GA0BEa,CAAczB,GAGvB,IAAKQ,GAA2B,qBAAdA,GAAoCA,EAAUkB,SAAS,SACvE,OAAOC,KAAKC,UAAU5B,GAGxB,MAAM,IAAIsB,UACR,6BAA6Bd"}

package/adapters/compression.d.ts

@@ -0,0 +1,11 @@
+export type TCompressionFormat = 'deflate' | 'gzip';
+export interface ICompressionOptions {
+    format?: TCompressionFormat;
+}
+export type TCompression = boolean | ICompressionOptions;
+type TCreateCompressionStream = (format: TCompressionFormat) => ReadableWritablePair<Uint8Array, BufferSource>;
+/**
+ * Compress eligible responses using the transport-provided stream implementation.
+ */
+declare const compressResponse: (request: Request, response: Response, compression?: TCompression, createStream?: TCreateCompressionStream) => Response;
+export default compressResponse;

package/adapters/compression.js

@@ -0,0 +1,2 @@
+const t=(t,e)=>{const s=new Map;return t.split(",").forEach(t=>{const[e="",...a]=t.trim().toLowerCase().split(";"),n=a.find(t=>t.trim().startsWith("q=")),o=n?Number(n.split("=")[1]):1;s.set(e,Number.isFinite(o)?o:0)}),s.get(e)??s.get("*")??0},e=(e,s,a=!1,n=t=>new CompressionStream(t))=>{if(!a||!s.body||s.bodyUsed||"HEAD"===e.method||s.status<200||[204,205,206,304].includes(s.status)||s.headers.has("Content-Encoding")||s.headers.has("Content-Range")||s.headers.get("Cache-Control")?.toLowerCase().includes("no-transform")||"function"!=typeof CompressionStream)return s;const o=e.headers.get("Accept-Encoding")??"",r="object"==typeof a?a.format:void 0,i=new Headers(s.headers),d=(r?[r]:["gzip","deflate"]).map(e=>({candidate:e,quality:t(o,e)})).filter(({quality:t})=>t>0).sort((t,e)=>e.quality-t.quality)[0]?.candidate;return((t,e)=>{const s=t.get("Vary")?.split(",").map(t=>t.trim().toLowerCase())??[];s.includes("*")||s.includes(e.toLowerCase())||t.append("Vary",e)})(i,"Accept-Encoding"),d?(i.delete("Content-Length"),i.set("Content-Encoding",d),new Response(s.body.pipeThrough(n(d)),{headers:i,status:s.status,statusText:s.statusText})):new Response(s.body,{headers:i,status:s.status,statusText:s.statusText})};export{e as default};
+//# sourceMappingURL=compression.js.map

package/adapters/compression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compression.js","sources":["../../src/adapters/compression.ts"],"sourcesContent":[null],"names":["getQuality","header","format","values","Map","split","forEach","part","encoding","params","trim","toLowerCase","quality","find","param","startsWith","parsed","Number","set","isFinite","get","compressResponse","request","response","compression","createStream","CompressionStream","body","bodyUsed","method","status","includes","headers","has","acceptEncoding","configured","undefined","Headers","map","candidate","filter","sort","left","right","value","vary","item","append","appendVary","delete","Response","pipeThrough","statusText"],"mappings":"AAeA,MAAMA,EAAa,CAACC,EAAgBC,KAClC,MAAMC,EAAS,IAAIC,IAUnB,OARAH,EAAOI,MAAM,KAAKC,QAASC,IACzB,MAAOC,EAAW,MAAOC,GAAUF,EAAKG,OAAOC,cAAcN,MAAM,KAC7DO,EAAUH,EAAOI,KAAMC,GAAUA,EAAMJ,OAAOK,WAAW,OACzDC,EAASJ,EAAUK,OAAOL,EAAQP,MAAM,KAAK,IAAM,EAEzDF,EAAOe,IAAIV,EAAUS,OAAOE,SAASH,GAAUA,EAAS,KAGnDb,EAAOiB,IAAIlB,IAAWC,EAAOiB,IAAI,MAAQ,GAqB5CC,EAAmB,CACvBC,EACAC,EACAC,GAA4B,EAC5BC,EAA0CvB,GAAW,IAAIwB,kBAAkBxB,MAE3E,IACGsB,IACAD,EAASI,MACVJ,EAASK,UACU,SAAnBN,EAAQO,QACRN,EAASO,OAAS,KAClB,CAAC,IAAK,IAAK,IAAK,KAAKC,SAASR,EAASO,SACvCP,EAASS,QAAQC,IAAI,qBACrBV,EAASS,QAAQC,IAAI,kBACrBV,EAASS,QAAQZ,IAAI,kBAAkBT,cAAcoB,SAAS,iBACjC,mBAAtBL,kBAEP,OAAOH,EAGT,MAAMW,EAAiBZ,EAAQU,QAAQZ,IAAI,oBAAsB,GAC3De,EAAoC,iBAAhBX,EAA2BA,EAAYtB,YAASkC,EACpEJ,EAAU,IAAIK,QAAQd,EAASS,SAC/B9B,GAAUiC,EAAa,CAACA,GAAe,CAAC,OAAQ,YACnDG,IAAKC,IAAS,CAAQA,YAAW3B,QAASZ,EAAWkC,EAAgBK,MACrEC,OAAO,EAAG5B,aAAcA,EAAU,GAClC6B,KAAK,CAACC,EAAMC,IAAUA,EAAM/B,QAAU8B,EAAK9B,SAAS,IAAI2B,UAI3D,MA9CiB,EAACP,EAAkBY,KACpC,MAAMC,EACJb,EACGZ,IAAI,SACHf,MAAM,KACPiC,IAAKQ,GAASA,EAAKpC,OAAOC,gBAAkB,GAE5CkC,EAAKd,SAAS,MAASc,EAAKd,SAASa,EAAMjC,gBAC9CqB,EAAQe,OAAO,OAAQH,IAoCzBI,CAAWhB,EAAS,mBAEf9B,GAQL8B,EAAQiB,OAAO,kBACfjB,EAAQd,IAAI,mBAAoBhB,GAEzB,IAAIgD,SAAS3B,EAASI,KAAKwB,YAAY1B,EAAavB,IAAU,CACnE8B,UACAF,OAAQP,EAASO,OACjBsB,WAAY7B,EAAS6B,cAbd,IAAIF,SAAS3B,EAASI,KAAM,CACjCK,UACAF,OAAQP,EAASO,OACjBsB,WAAY7B,EAAS6B"}

package/adapters/edge.d.ts

@@ -0,0 +1,11 @@
+import type { TCompression } from './compression.js';
+import type { TSsrHandler } from '../core/types.js';
+export interface IEdgeAdapterOptions {
+    compression?: TCompression;
+}
+export type TEdgeHandler<TPlatformArgs extends unknown[] = unknown[]> = (request: Request, ...platformArgs: TPlatformArgs) => Promise<Response>;
+/**
+ * Adapt the Fetch handler to runtime fetch entrypoints and optional compression.
+ */
+declare const adapterEdge: <TPlatformArgs extends unknown[] = unknown[]>(handler: TSsrHandler, { compression }?: IEdgeAdapterOptions) => TEdgeHandler<TPlatformArgs>;
+export default adapterEdge;

package/adapters/edge.js

@@ -0,0 +1,2 @@
+import o from"./compression.js";import s from"../core/head-response.js";const r=(r,{compression:e=!1}={})=>async(...[a])=>s(a,o(a,await r(a),e));export{r as default};
+//# sourceMappingURL=edge.js.map

package/adapters/edge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.js","sources":["../../src/adapters/edge.ts"],"sourcesContent":[null],"names":["adapterEdge","handler","compression","async","request","headResponse","compressResponse"],"mappings":"wEAiBA,MAAMA,EAAc,CAClBC,GACEC,eAAc,GAA+B,CAAA,IAKxCC,UAAWC,KACTC,EAAaD,EAASE,EAAiBF,QAAeH,EAAQG,GAAUF"}

package/adapters/express/create-request.d.ts

@@ -0,0 +1,11 @@
+import type { Request as ExpressRequest } from 'express';
+interface ICreateFetchRequestOptions {
+    body?: BodyInit | null;
+    signal?: AbortSignal;
+}
+/**
+ * Preserve Express's trusted protocol and original URL when creating the router request.
+ */
+declare function createFetchRequest(req: ExpressRequest, options?: ICreateFetchRequestOptions): Request;
+export type { ICreateFetchRequestOptions };
+export default createFetchRequest;

package/adapters/express/create-request.js

@@ -0,0 +1,2 @@
+import o from"../body.js";import t from"../../node/create-request.js";function e(e,r={}){const d={...r,origin:`${e.protocol}://${e.get("host")}`,url:e.originalUrl||e.url};return Object.hasOwn(r,"body")||void 0===e.body||"GET"===e.method||"HEAD"===e.method||(d.body=o(e.body,e.get("Content-Type"))),t(e,d)}export{e as default};
+//# sourceMappingURL=create-request.js.map

package/adapters/express/create-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-request.js","sources":["../../../src/adapters/express/create-request.ts"],"sourcesContent":[null],"names":["createFetchRequest","req","options","requestOptions","origin","protocol","get","url","originalUrl","Object","hasOwn","undefined","body","method","serializeBody","createRequest"],"mappings":"sEAaA,SAASA,EACPC,EACAC,EAAsC,IAEtC,MAAMC,EAAwC,IACzCD,EACHE,OAAQ,GAAGH,EAAII,cAAcJ,EAAIK,IAAI,UACrCC,IAAKN,EAAIO,aAAeP,EAAIM,KAY9B,OARGE,OAAOC,OAAOR,EAAS,cACXS,IAAbV,EAAIW,MACW,QAAfX,EAAIY,QACW,SAAfZ,EAAIY,SAEJV,EAAeS,KAAOE,EAAcb,EAAIW,KAAMX,EAAIK,IAAI,kBAGjDS,EAAcd,EAAKE,EAC5B"}

package/adapters/express/entry.d.ts

@@ -0,0 +1,55 @@
+import type { Server } from 'node:net';
+import type { CompressionOptions } from 'compression';
+import type { Express, Request, Response as ExpressResponse } from 'express';
+import type { FC, PropsWithChildren } from 'react';
+import { createStaticHandler } from 'react-router';
+import type { ServeStaticOptions } from 'serve-static';
+import type { Logger } from 'vite';
+import type { IRenderOptions, TRender } from './render.js';
+import type { TRouteObject } from '../../interfaces/route-object.js';
+import type ServerApi from '../../services/server-api.js';
+import type ServerConfig from '../../services/server-config.js';
+export interface IInitServerRequestOut<T = Record<string, any>> {
+    appProps?: T;
+    hasEarlyHints?: boolean;
+    shouldSkip?: boolean;
+    shouldCancel?: boolean;
+}
+export interface IEntrypointOptions<TAppProps = Record<string, any>> extends Pick<IRenderOptions<TAppProps>, 'onRouterReady' | 'onShellReady' | 'onShellError' | 'onResponse' | 'onError' | 'getState' | 'getBody'> {
+    onServerCreated?: (app: Express, serverApi: ServerApi) => Promise<void> | void;
+    onServerStarted?: (app: Express, serverApi: ServerApi, server: Server) => Promise<void> | void;
+    onRequest?: (req: Request, res: ExpressResponse) => Promise<IInitServerRequestOut<TAppProps>> | IInitServerRequestOut<TAppProps>;
+}
+export interface IPrepareRenderOut<TAppProps = Record<string, any>> {
+    render: TRender;
+    init: IEntryServerOptions<TAppProps>['init'];
+    routes: TRouteObject[];
+    abortDelay?: number;
+    loggerProd?: Logger;
+    loggerDev?: Logger;
+    middlewares?: {
+        compression?: CompressionOptions | false;
+        /**
+         * basename should be same as vite 'base' config
+         */
+        expressStatic?: (ServeStaticOptions & {
+            basename?: string;
+        }) | false;
+    };
+}
+export interface IAppServerProps<T = Record<string, any>> {
+    server: T;
+}
+export type TApp<T> = FC<PropsWithChildren<Record<string, any> & IAppServerProps<T>>>;
+export interface IEntryServerOptions<TAppProps = Record<string, any>> extends Pick<IPrepareRenderOut, 'loggerProd' | 'loggerDev' | 'middlewares'> {
+    abortDelay?: number;
+    init?: (params: {
+        config: ServerConfig;
+    }) => IEntrypointOptions<TAppProps> | Promise<IEntrypointOptions<TAppProps>>;
+    routerOptions?: Parameters<typeof createStaticHandler>[1];
+}
+/**
+ * Render server side application
+ */
+declare function entry<TAppProps>(App: TApp<TAppProps>, routes: TRouteObject[], { init, routerOptions, ...rest }?: IEntryServerOptions<TAppProps>): IPrepareRenderOut<TAppProps>;
+export default entry;

package/adapters/express/entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.js","sources":["../../../src/adapters/express/entry.tsx"],"sourcesContent":[null],"names":["entry","App","routes","init","routerOptions","rest","handler","createStaticHandler","render","bind"],"mappings":"8EA4EA,SAASA,EACPC,EACAC,GACAC,KAAEA,EAAIC,cAAEA,KAAkBC,GAAyC,IAEnE,MAAMC,EAAUC,EAAoBL,EAAyBE,GAE7D,MAAO,CACLI,OAAQA,EAAOC,KAAK,KAAM,CAAEH,UAASL,QACrCE,OACAD,YACGG,EAEP"}

package/{services → adapters/express}/prepare-server.d.ts

@@ -1,26 +1,23 @@
-import { Request } from 'express';
-import { TRouteObject } from "../interfaces/route-object.js";
-import { IEntrypointOptions, IPrepareRenderOut } from "../node/entry.js";
-import { TRender } from "../node/render.js";
-import ServerApi from "./server-api.js";
-import ServerConfig from "./server-config.js";
-interface IPrepareServerEntrypointLoadOut<TAppProps = Record<string, any>> {
+import type { Request } from 'express';
+import type { IEntrypointOptions, IPrepareRenderOut } from './entry.js';
+import type { TRender } from './render.js';
+import type { TRouteObject } from '../../interfaces/route-object.js';
+import ServerApi from '../../services/server-api.js';
+import type ServerConfig from '../../services/server-config.js';
+interface IPrepareServerEntrypointLoadOut<TAppProps = Record<string, any>> extends Omit<IEntrypointOptions<TAppProps>, 'onServerCreated' | 'onServerStarted'> {
     render: TRender;
     routes: TRouteObject[];
     abortDelay?: number;
-    onRequest?: IEntrypointOptions<TAppProps>['onRequest'];
-    onRouterReady?: IEntrypointOptions<TAppProps>['onRouterReady'];
-    onShellReady?: IEntrypointOptions<TAppProps>['onShellReady'];
-    onShellError?: IEntrypointOptions<TAppProps>['onShellError'];
-    onResponse?: IEntrypointOptions<TAppProps>['onResponse'];
-    onError?: IEntrypointOptions<TAppProps>['onError'];
-    getState?: IEntrypointOptions<TAppProps>['getState'];
 }
 /**
  *  Load server entrypoint and template
  *  DEV MODE: refresh entrypoint and template
  */
 declare class PrepareServer {
+    /**
+     * Hook which calls after express server started
+     */
+    onServerStarted?: NonNullable<IEntrypointOptions['onServerStarted']>;
     /**
      * Server configuration
      */
@@ -36,11 +33,7 @@ declare class PrepareServer {
     /**
      * Hook which calls after express server created
      */
-    protected onServerCreated?: IEntrypointOptions['onServerCreated'];
-    /**
-     * Hook which calls after express server started
-     */
-    onServerStarted?: IEntrypointOptions['onServerStarted'];
+    protected onServerCreated?: NonNullable<IEntrypointOptions['onServerCreated']>;
     /**
      * Html shell
      */
@@ -48,48 +41,30 @@ declare class PrepareServer {
     /**
      * Middlewares configs
      */
-    protected middlewaresConfigs?: IPrepareRenderOut['middlewares'];
+    protected middlewaresConfigs?: NonNullable<IPrepareRenderOut['middlewares']>;
     /**
-     * @constructor
-     */
-    /**
-     * @constructor
+     * Retain runtime configuration and reuse the existing server API.
      */
     protected constructor(config: ServerConfig, serverApi?: ServerApi);
-    /**
-     * Init service
-     */
     /**
      * Init service
      */
     static init(config: ServerConfig, serverApi?: ServerApi): PrepareServer;
-    /**
-     * Resolve and return entrypoint params
-     */
     /**
      * Resolve and return entrypoint params
      */
     loadEntrypoint(shouldInit?: boolean): Promise<IPrepareServerEntrypointLoadOut>;
-    /**
-     * Load and return html shell
-     */
     /**
      * Load and return html shell
      */
     loadHtml(req: Request): Promise<[string, string]>;
-    /**
-     * Run server created hook
-     */
     /**
      * Run server created hook
      */
     onAppCreated(): Promise<PrepareServer>;
-    /**
-     * Return SSR express middlewares configs
-     */
     /**
      * Return SSR express middlewares configs
      */
     getMiddlewaresConfig(): NonNullable<PrepareServer['middlewaresConfigs']>;
 }
-export { PrepareServer as default };
+export default PrepareServer;

package/adapters/express/prepare-server.js

@@ -0,0 +1,2 @@
+import e from"node:fs";import t from"node:path";import r from"node:process";import{pathToFileURL as i}from"node:url";import o from"chalk";import s from"../../services/server-api.js";class n{onServerStarted;config;serverApi;entrypoint;onServerCreated;html;middlewaresConfigs;constructor(e,t){this.config=e,this.serverApi=t??new s}static init(e,t){return new n(e,t)}async loadEntrypoint(e=!0){if(this.entrypoint&&this.config.isProd)return this.entrypoint;const{root:s,isProd:n,serverFile:a}=this.config.getParams(),l=t.resolve(`${s}/${a}`);let d;try{d=n?(await(import(i(l).toString()))).default:(await this.config.getVite().ssrLoadModule(l,{fixStacktrace:!0})).default}catch(e){if(e instanceof Error&&e.message.includes("Cannot find module")&&e.message.includes("/build/"))return this.config.getLogger().error(o.red(`Before starting the server, you need to create a build: ${o.yellow("ssr-boost build")} or provide path to build dir: ${o.yellow("ssr-boost start --build-dir build")}`)),r.exit(1);throw e}!e&&d.init&&delete d.init;const{render:c,init:g,routes:h,abortDelay:f,loggerProd:p,loggerDev:m,middlewares:u}=d;this.middlewaresConfigs=u,p&&n?this.config.setLogger(p):m&&!n&&this.config.setLogger(m);const{onServerCreated:y,onServerStarted:v,...w}=await(g?.({config:this.config}))??{};return this.entrypoint={render:c,routes:h,abortDelay:f,...w},this.onServerCreated=y,this.onServerStarted=v,this.entrypoint}async loadHtml(r){const{isProd:i,root:o,indexFile:s,clientFile:n}=this.config.getParams();this.html&&i||(this.html=e.readFileSync(t.resolve(`${o}/${s}`),"utf-8"));let a=this.html;if(!i){const e=t.posix.normalize(`${this.config.getVite()?.config.base}/${n}`);a=(await this.config.getVite().transformIndexHtml(r.originalUrl,this.html,s)).replace(new RegExp(String.raw`<script[^>]*?\bsrc=["']/?${e}([^"']*)["'][^>]*?\sasync\b`,"g"),e=>e.replace(/\sasync\b/,""))}return a.split("\x3c!--ssr-outlet--\x3e")}async onAppCreated(){return await this.loadEntrypoint(),await(this.onServerCreated?.(this.config.getApp(),this.serverApi)),this}getMiddlewaresConfig(){const{compression:e,expressStatic:t}=this.middlewaresConfigs??{};return{compression:!1!==e&&{...e},expressStatic:!1!==t&&{...t,basename:t?.basename??"/"}}}}export{n as default};
+//# sourceMappingURL=prepare-server.js.map

package/adapters/express/prepare-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-server.js","sources":["../../../src/adapters/express/prepare-server.ts"],"sourcesContent":[null],"names":["PrepareServer","onServerStarted","config","serverApi","entrypoint","onServerCreated","html","middlewaresConfigs","constructor","this","ServerApi","init","loadEntrypoint","shouldInit","isProd","root","serverFile","getParams","entrypointPath","path","resolve","resolvedEntrypoint","pathToFileURL","toString","default","getVite","ssrLoadModule","fixStacktrace","e","Error","message","includes","getLogger","error","chalk","red","yellow","process","exit","render","routes","abortDelay","loggerProd","loggerDev","middlewares","setLogger","renderParams","loadHtml","req","indexFile","clientFile","fs","readFileSync","modifiedHtml","clientFileEntry","posix","normalize","base","transformIndexHtml","originalUrl","replace","RegExp","String","raw","match","split","onAppCreated","getApp","getMiddlewaresConfig","compression","expressStatic","basename"],"mappings":"sLAyBA,MAAMA,EAIGC,gBAKYC,OAKAC,UAKTC,WAKAC,gBAKAC,KAKAC,mBAKV,WAAAC,CAAsBN,EAAsBC,GAC1CM,KAAKP,OAASA,EACdO,KAAKN,UAAYA,GAAa,IAAIO,CACpC,CAKO,WAAOC,CAAKT,EAAsBC,GACvC,OAAO,IAAIH,EAAcE,EAAQC,EACnC,CAKO,oBAAMS,CAAeC,GAAa,GAIvC,GAAIJ,KAAKL,YAAcK,KAAKP,OAAOY,OACjC,OAAOL,KAAKL,WAGd,MAAMW,KAAEA,EAAID,OAAEA,EAAME,WAAEA,GAAeP,KAAKP,OAAOe,YAC3CC,EAAiBC,EAAKC,QAAQ,GAAGL,KAAQC,KAE/C,IAAIK,EAEJ,IAQIA,EAPGP,gBAQaQ,EAAcJ,GAAgBK,cAC5CC,eAPMf,KAAKP,OAAOuB,UAAWC,cAAcR,EAAgB,CACzDS,eAAe,KAEjBH,OAMN,CAAE,MAAOI,GACP,GACEA,aAAaC,OACbD,EAAEE,QAAQC,SAAS,uBACnBH,EAAEE,QAAQC,SAAS,WAcnB,OAZAtB,KAAKP,OACF8B,YACAC,MACCC,EAAMC,IACJ,2DAA2DD,EAAME,OAC/D,oDACiCF,EAAME,OACvC,yCAKDC,EAAQC,KAAK,GAGtB,MAAMV,CACR,EAEKf,GAAcQ,EAAmBV,aAC7BU,EAAmBV,KAG5B,MAAM4B,OAAEA,EAAM5B,KAAEA,EAAI6B,OAAEA,EAAMC,WAAEA,EAAUC,WAAEA,EAAUC,UAAEA,EAASC,YAAEA,GAC/DvB,EAEFZ,KAAKF,mBAAqBqC,EAEtBF,GAAc5B,EAChBL,KAAKP,OAAO2C,UAAUH,GACbC,IAAc7B,GACvBL,KAAKP,OAAO2C,UAAUF,GAGxB,MAAMtC,gBAAEA,EAAeJ,gBAAEA,KAAoB6C,SACpCnC,IAAO,CACZT,OAAQO,KAAKP,WACR,CAAA,EAWT,OATAO,KAAKL,WAAa,CAChBmC,SACAC,SACAC,gBACGK,GAELrC,KAAKJ,gBAAkBA,EACvBI,KAAKR,gBAAkBA,EAEhBQ,KAAKL,UACd,CAKO,cAAM2C,CAASC,GACpB,MAAMlC,OAAEA,EAAMC,KAAEA,EAAIkC,UAAEA,EAASC,WAAEA,GAAezC,KAAKP,OAAOe,YAEvDR,KAAKH,MAASQ,IACjBL,KAAKH,KAAO6C,EAAGC,aAAajC,EAAKC,QAAQ,GAAGL,KAAQkC,KAAc,UAGpE,IAAII,EAAe5C,KAAKH,KAExB,IAAKQ,EAAQ,CACX,MAAMwC,EAAkBnC,EAAKoC,MAAMC,UACjC,GAAG/C,KAAKP,OAAOuB,WAAWvB,OAAOuD,QAAQP,KAM3CG,SACQ5C,KAAKP,OAAOuB,UAAWiC,mBAAmBV,EAAIW,YAAalD,KAAKH,KAAM2C,IAC5EW,QACA,IAAIC,OACFC,OAAOC,GAAG,4BAA4BT,+BACtC,KAEDU,GAAUA,EAAMJ,QAAQ,YAAa,IAE1C,CAEA,OAAOP,EAAaY,MAAM,0BAC5B,CAKO,kBAAMC,GAIX,aAHMzD,KAAKG,uBACLH,KAAKJ,kBAAkBI,KAAKP,OAAOiE,SAAoB1D,KAAKN,YAE3DM,IACT,CAKO,oBAAA2D,GACL,MAAMC,YAAEA,EAAWC,cAAEA,GAAkB7D,KAAKF,oBAAsB,CAAA,EAElE,MAAO,CACL8D,aACkB,IAAhBA,GACI,IACKA,GAGXC,eACoB,IAAlBA,GACI,IACKA,EACHC,SAAUD,GAAeC,UAAY,KAIjD"}

package/adapters/express/render.d.ts

@@ -0,0 +1,63 @@
+import type { Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import type { StaticHandlerContext, StaticHandler } from 'react-router';
+import type { TApp } from './entry.js';
+import StreamError from '../../constants/stream-error.js';
+import type { IServerContext } from '../../context/server.js';
+import type { IObtainStreamErrorOut } from '../../helpers/obtain-stream-error.js';
+import type ServerConfig from '../../services/server-config.js';
+export interface IRequestContext<TAppProps = Record<any, any>> {
+    req: ExpressRequest;
+    res: ExpressResponse;
+    appProps: NonNullable<TAppProps>;
+    html: {
+        header: string;
+        footer: string;
+    };
+    routerContext?: StaticHandlerContext;
+    serverContext?: IServerContext;
+    isStream?: boolean;
+    hasEarlyHints?: boolean;
+    didError?: StreamError;
+}
+export type TRender<TAppProps = Record<any, any>> = (config: ServerConfig, context: IRequestContext<TAppProps>, options: IRenderOptions) => Promise<void>;
+export interface IRenderParams<TAppProps = Record<string, any>> {
+    App: TApp<TAppProps>;
+    handler: StaticHandler;
+}
+export interface IRenderOptions<TAppProps = Record<string, any>> {
+    abortDelay?: number;
+    getBody?: (request: ExpressRequest) => BodyInit | null | undefined;
+    onRouterReady?: (params: {
+        context: IRequestContext<TAppProps>;
+    }) => Promise<IRouterReadyOut> | IRouterReadyOut;
+    onShellReady?: (params: {
+        context: IRequestContext<TAppProps>;
+    }) => IShellReadyOut;
+    onShellError?: (params: {
+        context: IRequestContext<TAppProps>;
+        error: Error;
+    }) => string | undefined | void;
+    onError?: (params: {
+        context: IRequestContext<TAppProps>;
+        error: IObtainStreamErrorOut;
+    }) => void;
+    onResponse?: (params: {
+        context: IRequestContext<TAppProps>;
+        html: string;
+    }) => string | undefined | void;
+    getState?: (params: {
+        context: IRequestContext<TAppProps>;
+    }) => Record<string, Record<string, any>> | undefined | void;
+}
+export interface IRouterReadyOut {
+    isStream?: boolean;
+}
+export interface IShellReadyOut {
+    header?: string;
+    footer?: string;
+}
+/**
+ * Render application
+ */
+declare function render({ App, handler }: IRenderParams, config: ServerConfig, context: IRequestContext, { onRouterReady, onShellReady, onResponse, onShellError, onError, getBody, getState, abortDelay, }: IRenderOptions): Promise<void>;
+export default render;

package/adapters/express/render.js

@@ -0,0 +1,2 @@
+import e from"chalk";import r from"react";import t from"./create-request.js";import o from"../../constants/stream-error.js";import s from"../../core/early-hints.js";import{getHeaderEntries as n,getSetCookieHeaders as a}from"../../core/headers.js";import i from"../../core/render.js";import d from"../../node/render-to-stream.js";import c from"../../node/request-signal.js";import m from"../../node/write-early-hints.js";import p,{writeFetchHeaders as l}from"../../node/write-fetch-response.js";import h from"../../services/ssr-manifest.js";const f=(e,r,o)=>{const s={signal:r};return o&&"GET"!==e.method&&"HEAD"!==e.method&&(s.body=o(e)??null),t(e,s)};async function u({App:t,handler:u},x,y,{onRouterReady:g,onShellReady:S,onResponse:E,onShellError:w,onError:C,getBody:j,getState:v,abortDelay:R=15e3}){const{appProps:b,html:A,req:H,res:q}=y,k=x.getLogger(),D=c(H,q);try{const c={appProps:b,html:A,request:f(H,D.signal,j),response:{headers:new Headers}},L=e=>(y.didError=e.didError,y.html=e.html,y.isStream=e.isStream,y.routerContext=e.routerContext,y.serverContext=e.serverContext,y),P=await i({createApp:(e,o)=>r.createElement(t,{server:{...o.appProps,req:H}},e),handler:u,renderToStream:d},c,{abortDelay:R,getState:v?({context:e})=>v({context:L(e)}):void 0,onError:({context:r,error:t})=>{const{code:s,message:n}=t;if(C?.({context:L(r),error:t}),k.info(e.red(`Stream error. Code: ${s}`)),[o.RenderAborted,o.RenderTimeout,o.RenderCancel].includes(s))return void k.info(e.dim(n));const{original:a}=t;k.error(a)},onResponse:E?({context:e,html:r})=>E({context:L(e),html:r}):void 0,onRouterReady:g?({context:e})=>g({context:L(e)}):void 0,onShellError:w?({context:e,error:r})=>w({context:L(e),error:r}):void 0,onShellReady:({context:e})=>{const r=L(e);((e,r)=>{if(r.headersSent||r.writableEnded)return;r.status(e.response.status??200),n(e.response.headers).forEach(([e,t])=>r.setHeader(e,t));const t=a(e.response.headers);t.length&&r.setHeader("Set-Cookie",t)})(e,q);const t=S?.({context:r});return((e,r)=>{const t=new Headers(e.response.headers);t.delete("Set-Cookie");for(const[e,o]of Object.entries(r.getHeaders()))if("set-cookie"!==e.toLowerCase()&&void 0!==o)if(Array.isArray(o))for(const r of o)t.append(e,r);else t.set(e,"number"==typeof o?String(o):o);e.response.headers=t,e.response.status=r.statusCode})(e,q),t??{}},prepare:async({context:e,executionContext:r})=>{const t=L(e),o=h.get(x);await o.prepareDevAssets(e.routerContext?.matches);const n=o.injectAssets(t);t.hasEarlyHints&&await s(r,n)},routerRequestContext:y},{onEarlyHints:e=>m(q,e)});L(c),await(async(e,r)=>{const t=r.headers.get("Location");if(t&&r.status>=300&&r.status<400&&!e.headersSent&&!e.writableEnded&&!e.destroyed)return l(e,r),await(r.body?.cancel()),void e.redirect(r.status,t);await p(e,r)})(q,P)}finally{D.dispose()}}export{u as default};
+//# sourceMappingURL=render.js.map

package/adapters/express/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sources":["../../../src/adapters/express/render.tsx"],"sourcesContent":[null],"names":["createRenderRequest","req","signal","getBody","options","method","body","createFetchRequest","async","render","App","handler","config","context","onRouterReady","onShellReady","onResponse","onShellError","onError","getState","abortDelay","appProps","html","shellHtml","res","Logger","getLogger","requestSignal","createRequestSignal","coreContext","request","response","headers","Headers","syncContext","updated","didError","isStream","routerContext","serverContext","coreRender","createApp","children","React","createElement","server","renderToStream","undefined","error","code","message","info","chalk","red","StreamError","RenderAborted","RenderTimeout","RenderCancel","includes","dim","original","legacyContext","headersSent","writableEnded","status","getHeaderEntries","forEach","name","value","setHeader","cookies","getSetCookieHeaders","length","prepareResponse","shell","delete","Object","entries","getHeaders","toLowerCase","Array","isArray","item","append","set","String","statusCode","syncResponse","prepare","executionContext","manifest","SsrManifest","get","prepareDevAssets","matches","hints","injectAssets","hasEarlyHints","emitEarlyHints","routerRequestContext","onEarlyHints","writeEarlyHints","location","destroyed","writeFetchHeaders","cancel","redirect","writeFetchResponse","writeResponse","dispose"],"mappings":"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"}

package/adapters/express/server.d.ts

@@ -0,0 +1,15 @@
+import type { Server } from 'node:net';
+import type { Express } from 'express';
+import type ServerConfig from '../../services/server-config.js';
+export interface ICreateServerOut {
+    run: (options?: {
+        version?: string;
+        isPrintInfo?: boolean;
+    }) => Server;
+    app: Express;
+}
+/**
+ * Create SSR server
+ */
+declare function createServer(config: ServerConfig): Promise<ICreateServerOut>;
+export default createServer;

package/adapters/express/server.js

@@ -0,0 +1,2 @@
+import e from"node:http";import r from"node:https";import t from"node:path";import s from"compression";import o from"express";import i from"./prepare-server.js";import a from"../../helpers/print-server-info.js";import n from"../../services/server-api.js";async function p(p){const d=o().disable("x-powered-by");p.isProd&&d.set("env","production");const c=new n;p.setApp(d);const m=i.init(p,c);if(!p.isProd){const e=await(await(import("vite"))).createServer({server:{middlewareMode:!0,watch:{usePolling:!0,interval:100}},appType:"custom",mode:p.mode});d.use(e.middlewares),p.setVite(e)}const{isSPA:l}=p.getParams();if(l||await m.onAppCreated(),p.isProd){const{root:e,publicDir:r}=p.getParams(),{compression:i,expressStatic:a}=m.getMiddlewaresConfig();if(i&&d.use(s(i)),l||d.use((e,r,t)=>{"/index.html"!==e.url||c.hasAccessIndexHtml()||(e.url="/index-not-found.html"),t()}),a){const{basename:s,...i}=a;d.use(s,o.static(t.resolve(`${e}/${r}`),{...i,index:!!l&&void 0}))}}return l?d.use(/(.*)/,(e,r,t)=>{(async()=>{try{const t=(await m.loadHtml(e)).join("");r.send(t)}catch(e){p.getLogger().error(`Failed to handle request: ${e?.message}`,{error:e}),t(e)}})()}):d.use(/(.*)/,(e,r,t)=>{(async()=>{try{const[{render:s,onRequest:o,...i},a]=await Promise.all([m.loadEntrypoint(),m.loadHtml(e)]),{appProps:n,hasEarlyHints:d,shouldSkip:c,shouldCancel:l}=await(o?.(e,r))??{},[u,f]=a;if(l)return;if(c)return t();const h={req:e,res:r,hasEarlyHints:d,appProps:n??{},html:{header:u,footer:f}};await s(p,h,i)}catch(e){p.getLogger().error(`Failed to handle request: ${e?.message}`,{error:e}),t(e)}})()}),{run:({version:t,isPrintInfo:s=!0}={})=>{const{port:o,host:i}=p.getParams(),n=Boolean(p.getVite()?.config?.server?.https);p.isHost&&!p.isProd&&(p.getVite().config.server.host=i);const l=(n?r.createServer(p.getVite().config.server.https,d):e.createServer(d)).listen(o,i,()=>{m.onServerStarted?.(d,c,l),s&&a(p,{version:t,server:l})});return l},app:d}}export{p as default};
+//# sourceMappingURL=server.js.map

package/adapters/express/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sources":["../../../src/adapters/express/server.ts"],"sourcesContent":[null],"names":["async","createServer","config","app","express","disable","isProd","set","serverApi","ServerApi","setApp","prepareServer","PrepareServer","init","vite","server","middlewareMode","watch","usePolling","interval","appType","mode","use","middlewares","setVite","isSPA","getParams","onAppCreated","root","publicDir","compression","compressionConfig","expressStatic","getMiddlewaresConfig","req","_","next","url","hasAccessIndexHtml","basename","expressStaticOpts","static","path","resolve","index","undefined","res","html","loadHtml","join","send","e","getLogger","error","message","render","onRequest","renderParams","clientHtml","Promise","all","loadEntrypoint","appProps","hasEarlyHints","shouldSkip","shouldCancel","header","footer","context","run","version","isPrintInfo","port","host","isHTTPS","Boolean","getVite","https","isHost","http","listen","onServerStarted","printServerInfo"],"mappings":"+PAqBAA,eAAeC,EAAaC,GAC1B,MAAMC,EAAMC,IAAUC,QAAQ,gBAE1BH,EAAOI,QACTH,EAAII,IAAI,MAAO,cAGjB,MAAMC,EAAY,IAAIC,EAEtBP,EAAOQ,OAAOP,GAEd,MAAMQ,EAAgBC,EAAcC,KAAKX,EAAQM,GAEjD,IAAKN,EAAOI,OAAQ,CAMlB,MAAMQ,qBACS,UACbb,aAAa,CACbc,OAAQ,CACNC,gBAAgB,EAChBC,MAAO,CAKLC,YAAY,EACZC,SAAU,MAGdC,QAAS,SACTC,KAAMnB,EAAOmB,OAMflB,EAAImB,IAAIR,EAAKS,aAEbrB,EAAOsB,QAAQV,EACjB,CAEA,MAAMW,MAAEA,GAAUvB,EAAOwB,YAMzB,GAJKD,SACGd,EAAcgB,eAGlBzB,EAAOI,OAAQ,CACjB,MAAMsB,KAAEA,EAAIC,UAAEA,GAAc3B,EAAOwB,aAC3BI,YAAaC,EAAiBC,cAAEA,GAAkBrB,EAAcsB,uBAmBxE,GAjBIF,GACF5B,EAAImB,IAAIQ,EAAYC,IAGjBN,GAIHtB,EAAImB,IAAI,CAACY,EAAKC,EAAGC,KACC,gBAAZF,EAAIG,KAA0B7B,EAAU8B,uBAC1CJ,EAAIG,IAAM,yBAGZD,MAIAJ,EAAe,CACjB,MAAMO,SAAEA,KAAaC,GAAsBR,EAE3C7B,EAAImB,IACFiB,EACAnC,EAAQqC,OAAOC,EAAKC,QAAQ,GAAGf,KAAQC,KAAc,IAChDW,EACHI,QAAOnB,QAAQoB,IAGrB,CACF,CA8DA,OAzDKpB,EAyCHtB,EAAImB,IAAI,OAAQ,CAACY,EAAKY,EAAKV,KACpB,WACH,IACE,MAAMW,SAAcpC,EAAcqC,SAASd,IAAMe,KAAK,IAEtDH,EAAII,KAAKH,EACX,CAAE,MAAOI,GACPjD,EACGkD,YACAC,MAAM,6BAA8BF,GAAaG,UAAW,CAAED,MAAOF,IACxEf,EAAKe,EACP,CACD,EAXI,KAzCPhD,EAAImB,IAAI,OAAQ,CAACY,EAAKY,EAAKV,KACpB,WACH,IACE,OAAOmB,OAAEA,EAAMC,UAAEA,KAAcC,GAAgBC,SAAoBC,QAAQC,IAAI,CAC7EjD,EAAckD,iBACdlD,EAAcqC,SAASd,MAEnB4B,SAAEA,EAAQC,cAAEA,EAAaC,WAAEA,EAAUC,aAAEA,SACpCT,IAAYtB,EAAKY,KAAS,CAAA,GAC5BoB,EAAQC,GAAUT,EAEzB,GAAIO,EACF,OAGF,GAAID,EACF,OAAO5B,IAGT,MAAMgC,EAA2B,CAC/BlC,MACAY,MACAiB,gBACAD,SAAUA,GAAY,CAAA,EACtBf,KAAM,CAAEmB,SAAQC,iBAGZZ,EAAOrD,EAAQkE,EAASX,EAChC,CAAE,MAAON,GACPjD,EACGkD,YACAC,MAAM,6BAA8BF,GAAaG,UAAW,CAAED,MAAOF,IACxEf,EAAKe,EACP,CACD,EAjCI,KAuDF,CAILkB,IAAK,EAAGC,UAASC,eAAc,GAAS,CAAA,KACtC,MAAMC,KAAEA,EAAIC,KAAEA,GAASvE,EAAOwB,YACxBgD,EAAUC,QAAQzE,EAAO0E,WAAW1E,QAAQa,QAAQ8D,OAKtD3E,EAAO4E,SAAW5E,EAAOI,SAC3BJ,EAAO0E,UAAW1E,OAAOa,OAAO0D,KAAOA,GAGzC,MAAM1D,GACJ2D,EACIG,EAAM5E,aAAaC,EAAO0E,UAAW1E,OAAOa,OAAO8D,MAAQ1E,GAC3D4E,EAAK9E,aAAaE,IACtB6E,OAAOR,EAAMC,EAAM,KACd9D,EAAcsE,kBAAkB9E,EAAKK,EAAWO,GAEhDwD,GAIAW,EAAgBhF,EAAQ,CAAEoE,UAASvD,aAG1C,OAAOA,GAETZ,MAEJ"}

package/adapters/express.d.ts

@@ -0,0 +1,11 @@
+import type { Request, RequestHandler } from 'express';
+import type { INodeAdapterOptions } from './node.js';
+import type { TSsrHandler } from '../core/types.js';
+export interface IExpressAdapterOptions extends INodeAdapterOptions {
+    getBody?: (request: Request) => BodyInit | null | undefined;
+}
+/**
+ * Bridge Express middleware to Fetch while retaining parsed body support.
+ */
+declare const adapterExpress: (handler: TSsrHandler, options?: IExpressAdapterOptions) => RequestHandler;
+export default adapterExpress;

package/adapters/express.js

@@ -0,0 +1,2 @@
+import o from"./body.js";import s from"./express/create-request.js";import{handleRequest as e}from"./node.js";import t from"../node/request-signal.js";const r=(r,n={})=>(d,i,a)=>{const p=t(d,i),c=o=>{p.signal.aborted||a(o)};try{const t={signal:p.signal};n.getBody?t.body=n.getBody(d)??null:void 0!==d.body&&(t.body=o(d.body,d.get("Content-Type"))),e(r,s(d,t),i,{compression:n.compression}).catch(c).finally(p.dispose)}catch(o){p.dispose(),c(o)}};export{r as default};
+//# sourceMappingURL=express.js.map

package/adapters/express.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.js","sources":["../../src/adapters/express.ts"],"sourcesContent":[null],"names":["adapterExpress","handler","options","req","res","next","requestSignal","createRequestSignal","onError","error","signal","aborted","requestOptions","getBody","body","undefined","serializeBody","get","handleRequest","createFetchRequest","compression","catch","finally","dispose"],"mappings":"uJAeA,MAAMA,EAAiB,CACrBC,EACAC,EAAkC,KAK3B,CAACC,EAAcC,EAAsBC,KAC1C,MAAMC,EAAgBC,EAAoBJ,EAAKC,GAKzCI,EAAWC,IACVH,EAAcI,OAAOC,SACxBN,EAAKI,IAIT,IACE,MAAMG,EAAkE,CACtEF,OAAQJ,EAAcI,QAGpBR,EAAQW,QACVD,EAAeE,KAAOZ,EAAQW,QAAQV,IAAQ,UACxBY,IAAbZ,EAAIW,OACbF,EAAeE,KAAOE,EAAcb,EAAIW,KAAMX,EAAIc,IAAI,kBAGnDC,EAAcjB,EAASkB,EAAmBhB,EAAKS,GAAiBR,EAAK,CACxEgB,YAAalB,EAAQkB,cAEpBC,MAAMb,GACNc,QAAQhB,EAAciB,QAC3B,CAAE,MAAOd,GACPH,EAAciB,UACdf,EAAQC,EACV"}

package/adapters/fastify.d.ts

@@ -0,0 +1,23 @@
+import type { TCompression } from './compression.js';
+import type { TSsrHandler } from '../core/types.js';
+import type { TIncomingMessage, TServerResponse } from '../node/http.js';
+interface IFastifyRequest {
+    body?: unknown;
+    raw: TIncomingMessage;
+}
+interface IFastifyReply {
+    getHeaders?: () => Record<string, string | number | string[] | undefined>;
+    hijack: () => void;
+    raw: TServerResponse;
+}
+type TFastifyHandler = (request: IFastifyRequest, reply: IFastifyReply) => Promise<void>;
+export interface IFastifyAdapterOptions {
+    compression?: TCompression;
+    getBody?: (request: IFastifyRequest) => BodyInit | null | undefined;
+}
+/**
+ * Bridge Fastify requests and hook metadata to the raw streaming transport.
+ */
+declare const adapterFastify: (handler: TSsrHandler, options?: IFastifyAdapterOptions) => TFastifyHandler;
+export type { IFastifyReply, IFastifyRequest, TFastifyHandler };
+export default adapterFastify;

package/adapters/fastify.js

@@ -0,0 +1,2 @@
+import o from"./body.js";import e from"../node/compress-response.js";import r from"../node/create-request.js";import t from"../node/request-signal.js";import s from"../node/write-early-hints.js";import a from"../node/write-fetch-response.js";const i=(i,n={})=>async(d,c)=>{const{body:m,raw:p}=d,y=t(p,c.raw);try{const t={signal:y.signal};n.getBody?t.body=n.getBody(d)??null:void 0!==m&&(t.body=o(m,String(p.headers["content-type"]??"")));const f=r(p,t),l=e(f,await i(f,{onEarlyHints:o=>s(c.raw,o)}),n.compression);Object.entries(c.getHeaders?.()??{}).forEach(([o,e])=>{void 0!==e&&c.raw.setHeader(o,e)}),c.hijack(),await a(c.raw,l)}catch(o){if(!y.signal.aborted)throw o;c.hijack()}finally{y.dispose()}};export{i as default};
+//# sourceMappingURL=fastify.js.map

package/adapters/fastify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify.js","sources":["../../src/adapters/fastify.ts"],"sourcesContent":[null],"names":["adapterFastify","handler","options","async","request","reply","body","raw","req","requestSignal","createRequestSignal","requestOptions","signal","getBody","undefined","serializeBody","String","headers","fetchRequest","createRequest","response","compressResponse","onEarlyHints","writeEarlyHints","compression","Object","entries","getHeaders","forEach","name","value","setHeader","hijack","writeFetchResponse","error","aborted","dispose"],"mappings":"kPA+BA,MAAMA,EAAiB,CACrBC,EACAC,EAAkC,KAK3BC,MAAOC,EAASC,KACrB,MAAMC,KAAEA,EAAMC,IAAKC,GAAQJ,EACrBK,EAAgBC,EAAoBF,EAAKH,EAAME,KAErD,IACE,MAAMI,EAAkE,CACtEC,OAAQH,EAAcG,QAGpBV,EAAQW,QACVF,EAAeL,KAAOJ,EAAQW,QAAQT,IAAY,UAChCU,IAATR,IACTK,EAAeL,KAAOS,EAAcT,EAAMU,OAAOR,EAAIS,QAAQ,iBAAmB,MAGlF,MAAMC,EAAeC,EAAcX,EAAKG,GAClCS,EAAWC,EACfH,QACMjB,EAAQiB,EAAc,CAC1BI,aAAeL,GAAYM,EAAgBlB,EAAME,IAAKU,KAExDf,EAAQsB,aAMVC,OAAOC,QAAQrB,EAAMsB,gBAAkB,CAAA,GAAIC,QAAQ,EAAEC,EAAMC,WAC3ChB,IAAVgB,GACFzB,EAAME,IAAIwB,UAAUF,EAAMC,KAG9BzB,EAAM2B,eACAC,EAAmB5B,EAAME,IAAKa,EACtC,CAAE,MAAOc,GACP,IAAKzB,EAAcG,OAAOuB,QACxB,MAAMD,EAMR7B,EAAM2B,QACR,SACEvB,EAAc2B,SAChB"}

package/adapters/hono.d.ts

@@ -0,0 +1,13 @@
+import type { TSsrHandler } from '../core/types.js';
+interface IHonoContext {
+    req: {
+        raw: Request;
+    };
+}
+type THonoHandler = (context: IHonoContext) => Promise<Response>;
+/**
+ * Pass Hono's raw request to the Fetch handler.
+ */
+declare const adapterHono: (handler: TSsrHandler) => THonoHandler;
+export type { IHonoContext, THonoHandler };
+export default adapterHono;

package/adapters/hono.js

@@ -0,0 +1,2 @@
+const a=a=>({req:e})=>a(e.raw);export{a as default};
+//# sourceMappingURL=hono.js.map

package/adapters/hono.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono.js","sources":["../../src/adapters/hono.ts"],"sourcesContent":[null],"names":["adapterHono","handler","req","raw"],"mappings":"AAaA,MAAMA,EAAeC,GACZ,EAAGC,SAAUD,EAAQC,EAAIC"}

package/adapters/node.d.ts

@@ -0,0 +1,19 @@
+import type { TCompression } from './compression.js';
+import type { TSsrHandler } from '../core/types.js';
+import type { TIncomingMessage, TServerResponse } from '../node/http.js';
+type TNext = (error?: unknown) => void;
+type TNodeHandler = (req: TIncomingMessage, res: TServerResponse, next?: TNext) => Promise<void>;
+export interface INodeAdapterOptions {
+    compression?: TCompression;
+}
+/**
+ * Render and write a Fetch response using the Node transport.
+ */
+declare const handleRequest: (handler: TSsrHandler, request: Request, res: TServerResponse, { compression }?: INodeAdapterOptions) => Promise<void>;
+/**
+ * Connect Node requests to the Fetch handler and dispose disconnect listeners.
+ */
+declare const adapterNode: (handler: TSsrHandler, options?: INodeAdapterOptions) => TNodeHandler;
+export type { TNodeHandler };
+export { handleRequest };
+export default adapterNode;

package/adapters/node.js

@@ -0,0 +1,2 @@
+import e from"../node/compress-response.js";import r from"../node/create-request.js";import s from"../node/request-signal.js";import o from"../node/write-early-hints.js";import t from"../node/write-fetch-response.js";const n=async(r,s,n,{compression:a=!1}={})=>{const i=e(s,await r(s,{onEarlyHints:e=>o(n,e)}),a);await t(n,i)},a=(e,o={})=>async(t,a,i)=>{const d=s(t,a);try{await n(e,r(t,{signal:d.signal}),a,o)}catch(e){if(d.signal.aborted)return;i?i(e):a.headersSent?a.destroy(e):(a.statusCode=500,a.end("Internal Server Error"))}finally{d.dispose()}};export{a as default,n as handleRequest};
+//# sourceMappingURL=node.js.map

package/adapters/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sources":["../../src/adapters/node.ts"],"sourcesContent":[null],"names":["handleRequest","async","handler","request","res","compression","response","compressResponse","onEarlyHints","headers","writeEarlyHints","writeFetchResponse","adapterNode","options","req","next","requestSignal","createRequestSignal","createRequest","signal","error","aborted","headersSent","destroy","statusCode","end","dispose"],"mappings":"yNAmBA,MAAMA,EAAgBC,MACpBC,EACAC,EACAC,GACEC,eAAc,GAA+B,MAE/C,MAAMC,EAAWC,EACfJ,QACMD,EAAQC,EAAS,CACrBK,aAAeC,GAAYC,EAAgBN,EAAKK,KAElDJ,SAGIM,EAAmBP,EAAKE,IAM1BM,EAAc,CAACV,EAAsBW,EAA+B,KAIjEZ,MAAOa,EAAKV,EAAKW,KACtB,MAAMC,EAAgBC,EAAoBH,EAAKV,GAE/C,UACQJ,EACJE,EACAgB,EAAcJ,EAAK,CAAEK,OAAQH,EAAcG,SAC3Cf,EACAS,EAEJ,CAAE,MAAOO,GACP,GAAIJ,EAAcG,OAAOE,QACvB,OAGEN,EACFA,EAAKK,GACIhB,EAAIkB,YACblB,EAAImB,QAAQH,IAEZhB,EAAIoB,WAAa,IACjBpB,EAAIqB,IAAI,yBAEZ,SACET,EAAcU,SAChB"}

package/browser/entry.d.ts

@@ -1,17 +1,17 @@
-/// <reference types="react-dom" />
-import { FC, PropsWithChildren } from 'react';
+import type { FC, PropsWithChildren } from 'react';
 import ReactDOM from 'react-dom/client';
-import { DataRouter, createBrowserRouter } from 'react-router';
-import { TRouteObject } from "../interfaces/route-object.js";
-interface IAppClientProps<T = undefined> {
+import type { DataRouter } from 'react-router';
+import { createBrowserRouter } from 'react-router';
+import type { TRouteObject } from '../interfaces/route-object.js';
+export interface IAppClientProps<T = undefined> {
     client: T;
 }
-interface IInitPropsParams {
+export interface IInitPropsParams {
     isSSRMode: boolean;
     router: DataRouter;
 }
-type TApp<T> = FC<PropsWithChildren<IAppClientProps<T>>>;
-interface IEntryClientOptions<T> {
+export type TApp<T> = FC<PropsWithChildren<IAppClientProps<T>>>;
+export interface IEntryClientOptions<T> {
     init?: (params: IInitPropsParams) => Promise<T>;
     routerOptions?: Parameters<typeof createBrowserRouter>[1];
     createRouter?: typeof createBrowserRouter;
@@ -21,4 +21,4 @@ interface IEntryClientOptions<T> {
  * Render client side application
  */
 declare function entry<TAppProps>(App: TApp<TAppProps>, routes: TRouteObject[], { init, routerOptions, createRouter, rootId, }?: IEntryClientOptions<TAppProps>): Promise<ReactDOM.Root | void>;
-export { entry as default, IAppClientProps, IInitPropsParams, TApp, IEntryClientOptions };
+export default entry;

package/browser/entry.js

@@ -1,2 +1,2 @@
-import t from"react";import e from"react-dom/client";import{matchRoutes as o,createBrowserRouter as r,RouterProvider as a}from"react-router";import{IS_SSR_MODE as n}from"../constants/common.js";async function c(c,i,{init:l,routerOptions:m,createRouter:s=r,rootId:u="root"}={}){const d=o(i,window.location,m?.basename)?.filter((t=>t.route.lazy));d&&d?.length>0&&await Promise.all(d.map((async t=>{const{lazy:e}=t.route;if("function"==typeof e){const o=await e();o&&Object.assign(t.route,{...o,lazy:void 0})}})));const f=s(i,m),p=document.getElementById(u),y=await(l?.({isSSRMode:n,router:f})),w=()=>t.createElement(c,{client:y},t.createElement(a,{router:f}));return n&&"1"!==p.dataset.forceSpa?e.hydrateRoot(p,t.createElement(w,null)):e.createRoot(p).render(t.createElement(w,null))}export{c as default};
+import t from"react";import e from"react-dom/client";import{matchRoutes as o,createBrowserRouter as r,RouterProvider as a}from"react-router";import{IS_SSR_MODE as n}from"../constants/common.js";async function c(c,i,{init:l,routerOptions:m,createRouter:s=r,rootId:u="root"}={}){const d=o(i,window.location,m?.basename)?.filter(t=>t.route.lazy);d&&d?.length>0&&await Promise.all(d.map(async t=>{const{lazy:e}=t.route;if("function"==typeof e){const o=await e();o&&Object.assign(t.route,{...o,lazy:void 0})}}));const f=s(i,m),p=document.getElementById(u),y=await(l?.({isSSRMode:n,router:f})),w=()=>t.createElement(c,{client:y},t.createElement(a,{router:f}));return n&&"1"!==p.dataset.forceSpa?e.hydrateRoot(p,t.createElement(w,null)):e.createRoot(p).render(t.createElement(w,null))}export{c as default};
 //# sourceMappingURL=entry.js.map

package/browser/entry.js.map

@@ -1 +1 @@
-{"version":3,"file":"entry.js","sources":["../../src/browser/entry.tsx"],"sourcesContent":["import type { FC, PropsWithChildren } from 'react';\nimport React from 'react';\nimport ReactDOM from 'react-dom/client';\nimport type { DataRouter, RouteObject } from 'react-router';\nimport { createBrowserRouter, matchRoutes, RouterProvider } from 'react-router';\nimport { IS_SSR_MODE } from '@constants/common';\nimport type { TRouteObject } from '@interfaces/route-object';\n\nexport interface IAppClientProps<T = undefined> {\n  client: T;\n}\n\nexport interface IInitPropsParams {\n  isSSRMode: boolean;\n  router: DataRouter;\n}\n\nexport type TApp<T> = FC<PropsWithChildren<IAppClientProps<T>>>;\n\nexport interface IEntryClientOptions<T> {\n  init?: (params: IInitPropsParams) => Promise<T>;\n  routerOptions?: Parameters<typeof createBrowserRouter>[1];\n  createRouter?: typeof createBrowserRouter;\n  rootId?: string;\n}\n\n/**\n * Render client side application\n */\nasync function entry<TAppProps>(\n  App: TApp<TAppProps>,\n  routes: TRouteObject[],\n  {\n    init,\n    routerOptions,\n    createRouter = createBrowserRouter,\n    rootId = 'root',\n  }: IEntryClientOptions<TAppProps> = {},\n): Promise<ReactDOM.Root | void> {\n  const lazyMatches = matchRoutes(\n    routes as RouteObject[],\n    window.location,\n    routerOptions?.basename,\n  )?.filter((m) => m.route.lazy);\n\n  // Load the lazy matches and update the routes before creating router,\n  // so we can hydrate the SSR-rendered content synchronously\n  if (lazyMatches && lazyMatches?.length > 0) {\n    await Promise.all(\n      lazyMatches.map(async (m) => {\n        const { lazy } = m.route;\n\n        if (typeof lazy === 'function') {\n          const lazyResult = await lazy();\n\n          if (lazyResult) {\n            Object.assign(m.route, {\n              ...lazyResult,\n              lazy: undefined,\n            });\n          }\n        }\n      }),\n    );\n  }\n\n  const router = createRouter(routes as RouteObject[], routerOptions);\n  const root = document.getElementById(rootId) as HTMLElement;\n  const appProps = (await init?.({ isSSRMode: IS_SSR_MODE, router })) as TAppProps;\n\n  const AppComponent: FC = () => (\n    <App client={appProps}>\n      <RouterProvider router={router} />\n    </App>\n  );\n\n  if (!IS_SSR_MODE || root.dataset['forceSpa'] === '1') {\n    return ReactDOM.createRoot(root).render(<AppComponent />);\n  }\n\n  return ReactDOM.hydrateRoot(root, <AppComponent />);\n}\n\nexport default entry;\n"],"names":["async","entry","App","routes","init","routerOptions","createRouter","createBrowserRouter","rootId","lazyMatches","matchRoutes","window","location","basename","filter","m","route","lazy","length","Promise","all","map","lazyResult","Object","assign","undefined","router","root","document","getElementById","appProps","isSSRMode","IS_SSR_MODE","AppComponent","React","createElement","client","RouterProvider","dataset","ReactDOM","hydrateRoot","createRoot","render"],"mappings":"kMA6BAA,eAAeC,EACbC,EACAC,GACAC,KACEA,EAAIC,cACJA,EAAaC,aACbA,EAAeC,EAAmBC,OAClCA,EAAS,QACyB,CAAA,GAEpC,MAAMC,EAAcC,EAClBP,EACAQ,OAAOC,SACPP,GAAeQ,WACdC,QAAQC,GAAMA,EAAEC,MAAMC,OAIrBR,GAAeA,GAAaS,OAAS,SACjCC,QAAQC,IACZX,EAAYY,KAAIrB,MAAOe,IACrB,MAAME,KAAEA,GAASF,EAAEC,MAEnB,GAAoB,mBAATC,EAAqB,CAC9B,MAAMK,QAAmBL,IAErBK,GACFC,OAAOC,OAAOT,EAAEC,MAAO,IAClBM,EACHL,UAAMQ,GAGZ,MAKN,MAAMC,EAASpB,EAAaH,EAAyBE,GAC/CsB,EAAOC,SAASC,eAAerB,GAC/BsB,QAAkB1B,IAAO,CAAE2B,UAAWC,EAAaN,YAEnDO,EAAmB,IACvBC,EAAAC,cAACjC,EAAG,CAACkC,OAAQN,GACXI,EAAAC,cAACE,GAAeX,OAAQA,KAI5B,OAAKM,GAA4C,MAA7BL,EAAKW,QAAkB,SAIpCC,EAASC,YAAYb,EAAMO,EAAAC,cAACF,EAAY,OAHtCM,EAASE,WAAWd,GAAMe,OAAOR,EAAAC,cAACF,EAAY,MAIzD"}
+{"version":3,"file":"entry.js","sources":["../../src/browser/entry.tsx"],"sourcesContent":[null],"names":["async","entry","App","routes","init","routerOptions","createRouter","createBrowserRouter","rootId","lazyMatches","matchRoutes","window","location","basename","filter","m","route","lazy","length","Promise","all","map","lazyResult","Object","assign","undefined","router","root","document","getElementById","appProps","isSSRMode","IS_SSR_MODE","AppComponent","React","createElement","client","RouterProvider","dataset","ReactDOM","hydrateRoot","createRoot","render"],"mappings":"kMA6BAA,eAAeC,EACbC,EACAC,GACAC,KACEA,EAAIC,cACJA,EAAaC,aACbA,EAAeC,EAAmBC,OAClCA,EAAS,QACyB,CAAA,GAEpC,MAAMC,EAAcC,EAClBP,EACAQ,OAAOC,SACPP,GAAeQ,WACdC,OAAQC,GAAMA,EAAEC,MAAMC,MAIrBR,GAAeA,GAAaS,OAAS,SACjCC,QAAQC,IACZX,EAAYY,IAAIrB,MAAOe,IACrB,MAAME,KAAEA,GAASF,EAAEC,MAEnB,GAAoB,mBAATC,EAAqB,CAC9B,MAAMK,QAAmBL,IAErBK,GACFC,OAAOC,OAAOT,EAAEC,MAAO,IAClBM,EACHL,UAAMQ,GAGZ,KAKN,MAAMC,EAASpB,EAAaH,EAAyBE,GAC/CsB,EAAOC,SAASC,eAAerB,GAC/BsB,QAAkB1B,IAAO,CAAE2B,UAAWC,EAAaN,YAEnDO,EAAmB,IACvBC,EAAAC,cAACjC,EAAG,CAACkC,OAAQN,GACXI,EAAAC,cAACE,GAAeX,OAAQA,KAI5B,OAAKM,GAA4C,MAA7BL,EAAKW,QAAkB,SAIpCC,EAASC,YAAYb,EAAMO,EAAAC,cAACF,EAAY,OAHtCM,EAASE,WAAWd,GAAMe,OAAOR,EAAAC,cAACF,EAAY,MAIzD"}

package/cli/build.d.ts

@@ -1,6 +1,6 @@
-import { IBuildParams } from "../services/build.js";
+import type { IBuildParams } from '../services/build.js';
 /**
  * Build application
  */
 declare function build(params: IBuildParams): Promise<void>;
-export { build as default };
+export default build;