@modern-js/server-core 2.69.4 → 3.0.0-alpha.0

package/dist/esm-node/serverBase.mjs

@@ -0,0 +1,136 @@
+import { server as server_server } from "@modern-js/plugin/server";
+import { Hono } from "hono";
+import { run } from "./context.mjs";
+import { handleSetupResult } from "./plugins/compat/hooks.mjs";
+import { loadConfig } from "./utils/index.mjs";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+var _applyMiddlewares = /*#__PURE__*/ new WeakSet();
+class ServerBase {
+    async init() {
+        const { serverConfig, config: cliConfig } = this.options;
+        const mergedConfig = loadConfig({
+            cliConfig,
+            serverConfig: serverConfig || {}
+        });
+        const { serverContext } = await server_server.run({
+            plugins: this.plugins,
+            options: this.options,
+            config: mergedConfig,
+            handleSetupResult: handleSetupResult
+        });
+        serverContext.serverBase = this;
+        this.serverContext = serverContext;
+        await serverContext.hooks.onPrepare.call();
+        _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
+        return this;
+    }
+    addPlugins(plugins) {
+        this.plugins.push(...plugins);
+    }
+    get hooks() {
+        return this.serverContext.hooks;
+    }
+    get all() {
+        return this.app.all.bind(this.app);
+    }
+    get use() {
+        return this.app.use.bind(this.app);
+    }
+    get get() {
+        return this.app.get.bind(this.app);
+    }
+    get post() {
+        return this.app.post.bind(this.app);
+    }
+    get put() {
+        return this.app.put.bind(this.app);
+    }
+    get delete() {
+        return this.app.delete.bind(this.app);
+    }
+    get patch() {
+        return this.app.patch.bind(this.app);
+    }
+    get handle() {
+        return this.app.fetch.bind(this.app);
+    }
+    get request() {
+        return this.app.request.bind(this.app);
+    }
+    get notFound() {
+        return this.app.notFound.bind(this.app);
+    }
+    get onError() {
+        return this.app.onError.bind(this.app);
+    }
+    constructor(options){
+        _class_private_method_init(this, _applyMiddlewares);
+        this.plugins = [];
+        this.serverContext = null;
+        this.options = options;
+        this.app = new Hono();
+        this.app.use('*', run);
+    }
+}
+function applyMiddlewares() {
+    const { middlewares } = this.serverContext;
+    const preMiddlewares = [];
+    const defaultMiddlewares = [];
+    const postMiddlewares = [];
+    for (const middleware of middlewares)switch(middleware.order){
+        case 'pre':
+            preMiddlewares.push(middleware);
+            break;
+        case 'post':
+            postMiddlewares.push(middleware);
+            break;
+        default:
+            defaultMiddlewares.push(middleware);
+    }
+    const finalMiddlewares = [];
+    const insertMiddleware = (middleware)=>{
+        if (middleware.before) {
+            const targetIndex = finalMiddlewares.findIndex((item)=>{
+                if (middleware.before?.includes(item.name)) return true;
+                return false;
+            });
+            if (-1 !== targetIndex) finalMiddlewares.splice(targetIndex, 0, middleware);
+            else finalMiddlewares.push(middleware);
+        } else finalMiddlewares.push(middleware);
+    };
+    preMiddlewares.forEach(insertMiddleware);
+    defaultMiddlewares.forEach(insertMiddleware);
+    postMiddlewares.forEach(insertMiddleware);
+    for (const middleware of finalMiddlewares){
+        const { path = '*', method = 'all', handler } = middleware;
+        const handlers = handler2Handlers(handler);
+        if (0 === handlers.length) continue;
+        const firstHandler = handlers[0];
+        const restHandlers = handlers.slice(1);
+        const m = method;
+        const register = this.app[m];
+        register.call(this.app, path, firstHandler, ...restHandlers);
+    }
+    function handler2Handlers(handler) {
+        if (Array.isArray(handler)) return handler;
+        return [
+            handler
+        ];
+    }
+}
+function createServerBase(options) {
+    if (null == options) throw new Error('can not start server without options');
+    const server = new ServerBase(options);
+    return server;
+}
+export { ServerBase, createServerBase };

package/dist/esm-node/types/config/index.mjs

@@ -0,0 +1,6 @@
+export * from "./bff.mjs";
+export * from "./html.mjs";
+export * from "./output.mjs";
+export * from "./server.mjs";
+export * from "./source.mjs";
+export * from "./tools.mjs";

package/dist/esm-node/types/index.mjs

@@ -0,0 +1,4 @@
+export * from "./config/index.mjs";
+export * from "./plugins/index.mjs";
+export * from "./render.mjs";
+export * from "./server.mjs";

package/dist/esm-node/types/plugins/index.mjs

@@ -0,0 +1 @@
+export * from "./plugin.mjs";

package/dist/esm-node/utils/entry.mjs

@@ -0,0 +1,3 @@
+const sortRoutes = (route1, route2)=>route2.urlPath.length - route1.urlPath.length;
+const uniqueKeyByRoute = (route)=>`${route.entryName}-${route.urlPath}`;
+export { sortRoutes, uniqueKeyByRoute };

package/dist/esm-node/utils/env.mjs

@@ -0,0 +1,14 @@
+const getRuntimeEnv = ()=>{
+    if (globalThis?.process?.release?.name === 'node') return 'node';
+    return 'other';
+};
+const checkIsProd = ()=>{
+    const env = getRuntimeEnv();
+    switch(env){
+        case 'node':
+            return 'production' === process.env.NODE_ENV;
+        default:
+            return false;
+    }
+};
+export { checkIsProd, getRuntimeEnv };

package/dist/esm-node/utils/error.mjs

@@ -0,0 +1,53 @@
+import { parseHeaders } from "./request.mjs";
+const ERROR_PAGE_TEXT = {
+    404: 'This page could not be found.',
+    500: 'Internal Server Error.'
+};
+const createErrorHtml = (status)=>{
+    const text = ERROR_PAGE_TEXT[status] || '';
+    const title = `${status}: ${text}`;
+    return `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>${title}</title>
+    <style>
+      html,body {
+        margin: 0;
+      }
+
+      .page-container {
+        color: #000;
+        background: #fff;
+        height: 100vh;
+        text-align: center;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="page-container">
+    <h1>${status}</h1>
+    <div>${text}</div>
+  </body>
+  </html>
+  `;
+};
+var error_ErrorDigest = /*#__PURE__*/ function(ErrorDigest) {
+    ErrorDigest["ENOTF"] = "Page could not be found";
+    ErrorDigest["EINTER"] = "Internal server error";
+    ErrorDigest["ERENDER"] = "SSR render fallback";
+    return ErrorDigest;
+}({});
+function onError(digest, error, monitors, req) {
+    const headerData = req && parseHeaders(req);
+    headerData && delete headerData.cookie;
+    if (monitors) monitors.error(req ? `Server Error - ${digest}, error = %s, req.url = %s, req.headers = %o` : `Server Error - ${digest}, error = %s`, error instanceof Error ? error.stack || error.message : error, req?.url, headerData);
+    else if (req) console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error}, req.url = ${req.url}, req.headers = ${JSON.stringify(headerData)}`);
+    else console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error} `);
+}
+export { error_ErrorDigest as ErrorDigest, createErrorHtml, onError };

package/dist/esm-node/utils/index.mjs

@@ -0,0 +1,9 @@
+export * from "./env.mjs";
+export * from "./transformStream.mjs";
+export * from "./middlewareCollector.mjs";
+export * from "./error.mjs";
+export * from "./warmup.mjs";
+export * from "./entry.mjs";
+export * from "./request.mjs";
+export * from "./serverConfig.mjs";
+export * from "./publicDir.mjs";

package/dist/esm-node/utils/middlewareCollector.mjs

@@ -0,0 +1,26 @@
+const mergeExtension = (users)=>{
+    const output = [];
+    return {
+        middleware: output.concat(users)
+    };
+};
+const createMiddlewareCollecter = ()=>{
+    const webMiddlewares = [];
+    const apiMiddlewares = [];
+    const addWebMiddleware = (input)=>{
+        webMiddlewares.push(input);
+    };
+    const addAPIMiddleware = (input)=>{
+        apiMiddlewares.push(input);
+    };
+    const getMiddlewares = ()=>({
+            web: webMiddlewares,
+            api: apiMiddlewares
+        });
+    return {
+        getMiddlewares,
+        addWebMiddleware,
+        addAPIMiddleware
+    };
+};
+export { createMiddlewareCollecter, mergeExtension };

package/dist/esm-node/utils/publicDir.mjs

@@ -0,0 +1,33 @@
+import path from "path";
+function normalizePublicDir(publicDir) {
+    if (!publicDir) return [];
+    return Array.isArray(publicDir) ? publicDir : [
+        publicDir
+    ];
+}
+function normalizePublicDirPath(dir) {
+    return dir.replace(/^\.\//, '').replace(/\/$/, '');
+}
+function getPublicDirRoutePrefixes(publicDir) {
+    const dirs = normalizePublicDir(publicDir);
+    return dirs.map((dir)=>{
+        const normalized = normalizePublicDirPath(dir);
+        return `/${normalized}`;
+    });
+}
+function getPublicDirPatterns(publicDir) {
+    const dirs = normalizePublicDir(publicDir);
+    return dirs.map((dir)=>{
+        const normalized = normalizePublicDirPath(dir);
+        return `${normalized}/`;
+    });
+}
+function resolvePublicDirPaths(publicDir, appDirectory) {
+    const dirs = normalizePublicDir(publicDir);
+    if (!appDirectory) return dirs;
+    return dirs.map((dir)=>path.resolve(appDirectory, dir));
+}
+function getPublicDirConfig(serverConfig) {
+    return serverConfig?.publicDir;
+}
+export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths };

package/dist/esm-node/utils/request.mjs

@@ -0,0 +1,40 @@
+function parseQuery(req) {
+    const query = {};
+    const { url } = req;
+    const q = url.split('?')[1];
+    if (q) {
+        const search = new URLSearchParams(q);
+        search.forEach((v, k)=>{
+            query[k] = v;
+        });
+    }
+    return query;
+}
+function parseHeaders(request) {
+    const headersData = {};
+    request.headers.forEach((value, key)=>{
+        headersData[key] = value;
+    });
+    return headersData;
+}
+function getPathname(request) {
+    const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+    return match ? match[1] : '/';
+}
+function getHost(request) {
+    const { headers } = request;
+    let host = headers.get('X-Forwarded-Host');
+    if (!host) host = headers.get('Host');
+    host = host?.split(/\s*,\s*/, 1)[0] || 'undefined';
+    return host;
+}
+function parseCookie(req) {
+    const _cookie = req.headers.get('Cookie');
+    const cookie = {};
+    _cookie?.trim().split(';').forEach((item)=>{
+        const [k, v] = item.trim().split('=');
+        if (k) cookie[k] = v;
+    });
+    return cookie;
+}
+export { getHost, getPathname, parseCookie, parseHeaders, parseQuery };

package/dist/esm-node/utils/serverConfig.mjs

@@ -0,0 +1,9 @@
+import { merge } from "ts-deepmerge";
+const loadConfig = ({ cliConfig, serverConfig })=>{
+    const config = merge({
+        ...cliConfig,
+        plugins: []
+    }, serverConfig);
+    return config;
+};
+export { loadConfig };

package/dist/esm-node/utils/storage.mjs

@@ -0,0 +1,30 @@
+import { AsyncLocalStorage } from "async_hooks";
+const createStorage = ()=>{
+    let storage;
+    if (void 0 !== AsyncLocalStorage) storage = new AsyncLocalStorage();
+    const run = (context, cb)=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        return new Promise((resolve, reject)=>{
+            storage.run(context, ()=>{
+                try {
+                    return resolve(cb());
+                } catch (error) {
+                    return reject(error);
+                }
+            });
+        });
+    };
+    const useHonoContext = ()=>{
+        if (!storage) throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
+        `);
+        const context = storage.getStore();
+        if (!context) throw new Error("Can't call useContext out of server scope");
+        return context;
+    };
+    return {
+        run,
+        useHonoContext
+    };
+};
+export { createStorage };

package/dist/esm-node/utils/transformStream.mjs

@@ -0,0 +1,28 @@
+function createTransformStream(fn) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    return new TransformStream({
+        async transform (chunk, controller) {
+            const content = decoder.decode(chunk);
+            const newContent = fn ? await fn(content) : content;
+            controller.enqueue(encoder.encode(newContent));
+        }
+    });
+}
+function transformResponse(response, transformCb) {
+    let readable = null;
+    if (response.body) {
+        const stream = createTransformStream(async (before)=>{
+            if (Array.isArray(transformCb)) return transformCb.reduce(async (before, cb)=>cb(await before), Promise.resolve(before));
+            return transformCb(before);
+        });
+        response.body.pipeThrough(stream);
+        readable = stream.readable;
+    }
+    return new Response(readable, {
+        status: response.status,
+        headers: response.headers,
+        statusText: response.statusText
+    });
+}
+export { createTransformStream, transformResponse };

package/dist/esm-node/utils/warmup.mjs

@@ -0,0 +1,6 @@
+function warmup(bundles) {
+    bundles.forEach((bundle)=>{
+        bundle && import(bundle).catch((_)=>{});
+    });
+}
+export { warmup };

package/dist/types/adapters/node/helper/loadConfig.d.ts

@@ -1,3 +1,3 @@
 import type { CliConfig, ServerConfig, UserConfig } from '../../../types';
-export declare function loadServerRuntimeConfig(pwd: string, oldServerFile?: string, newServerConfigPath?: string, metaName?: string): Promise<ServerConfig | undefined>;
+export declare function loadServerRuntimeConfig(serverConfigPath: string): Promise<ServerConfig | undefined>;
 export declare function loadServerCliConfig(pwd: string, defaultConfig?: UserConfig): CliConfig;

package/dist/types/adapters/node/plugins/nodeServer.d.ts

@@ -1,6 +1,6 @@
 import type { Server as NodeServer } from 'node:http';
 import type { Http2SecureServer } from 'node:http2';
-import type { ServerPluginLegacy } from '../../../types';
+import type { ServerPlugin } from '../../../types';
 export declare const injectNodeSeverPlugin: ({ nodeServer, }: {
     nodeServer: NodeServer | Http2SecureServer;
-}) => ServerPluginLegacy;
+}) => ServerPlugin;

package/dist/types/adapters/node/plugins/resource.d.ts

@@ -1,5 +1,5 @@
 import type { Logger, ServerRoute } from '@modern-js/types';
-import type { Middleware, ServerEnv, ServerManifest, ServerPluginLegacy } from '../../../types';
+import type { Middleware, ServerEnv, ServerManifest, ServerPlugin } from '../../../types';
 export declare function getHtmlTemplates(pwd: string, routes: ServerRoute[]): Promise<Record<string, string>>;
 export declare function injectTemplates(pwd: string, routes?: ServerRoute[], htmlTemplatePromise?: ReturnType<typeof getHtmlTemplates>): Middleware<ServerEnv>;
 export declare function getServerManifest(pwd: string, routes: ServerRoute[], logger: Logger): Promise<ServerManifest>;
@@ -7,5 +7,5 @@ export declare function injectServerManifest(pwd: string, routes?: ServerRoute[]
 export declare function getRscServerManifest(pwd: string): Promise<any>;
 export declare function getClientManifest(pwd: string): Promise<any>;
 export declare function getRscSSRManifest(pwd: string): Promise<any>;
-export declare const injectRscManifestPlugin: () => ServerPluginLegacy;
-export declare const injectResourcePlugin: () => ServerPluginLegacy;
+export declare const injectRscManifestPlugin: () => ServerPlugin;
+export declare const injectResourcePlugin: () => ServerPlugin;

package/dist/types/adapters/node/plugins/static.d.ts

@@ -1,6 +1,6 @@
 import type { ServerRoute } from '@modern-js/types';
-import type { HtmlNormalizedConfig, Middleware, OutputNormalizedConfig, ServerPluginLegacy } from '../../../types';
-export declare const serverStaticPlugin: () => ServerPluginLegacy;
+import type { HtmlNormalizedConfig, Middleware, OutputNormalizedConfig, ServerNormalizedConfig, ServerPlugin } from '../../../types';
+export declare const serverStaticPlugin: () => ServerPlugin;
 export type PublicMiddlwareOptions = {
     pwd: string;
     routes: ServerRoute[];
@@ -10,6 +10,7 @@ export interface ServerStaticOptions {
     pwd: string;
     output: OutputNormalizedConfig;
     html: HtmlNormalizedConfig;
+    server: ServerNormalizedConfig;
     routes?: ServerRoute[];
 }
 /**

package/dist/types/hono.d.ts

@@ -0,0 +1,3 @@
+export type { Context, Next, MiddlewareHandler, MiddlewareHandler as Middleware, HonoRequest, } from 'hono';
+export { setCookie, getCookie, deleteCookie, } from 'hono/cookie';
+export { languageDetector } from 'hono/language';

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 export { createErrorHtml, onError, ErrorDigest } from './utils';
+export { normalizePublicDir, normalizePublicDirPath, getPublicDirRoutePrefixes, getPublicDirPatterns, resolvePublicDirPaths, getPublicDirConfig, } from './utils/publicDir';
 export { AGGRED_DIR } from './constants';
 export type { ServerBase, ServerBaseOptions } from './serverBase';
 export { createServerBase } from './serverBase';
@@ -9,6 +10,5 @@ export { getLoaderCtx } from './helper';
 export * from './plugins';
 export * from './types/plugins';
 export * from './types/render';
-export * from '@modern-js/plugin';
 export * from './types/config';
 export * from './types/requestHandler';

package/dist/types/plugins/compat/hooks.d.ts

@@ -1,4 +1,4 @@
-import type { InternalServerContext } from '@modern-js/plugin-v2';
+import type { InternalServerContext } from '@modern-js/plugin';
 import type { ServerPluginExtends } from '../../types';
 /**
  * old plugin useHookRunners function result

package/dist/types/plugins/default.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from '@modern-js/types';
-import type { ServerPlugin, ServerPluginLegacy } from '../types';
+import type { ServerPlugin } from '../types';
 import { type InjectRenderHandlerOptions } from './render';
 export type CreateDefaultPluginsOptions = InjectRenderHandlerOptions & {
     logger?: Logger | false;
 };
-export declare function createDefaultPlugins(options?: CreateDefaultPluginsOptions): (ServerPlugin | ServerPluginLegacy)[];
+export declare function createDefaultPlugins(options?: CreateDefaultPluginsOptions): ServerPlugin[];

package/dist/types/plugins/favicon.d.ts

@@ -1,2 +1,2 @@
-import type { ServerPluginLegacy } from '../types';
-export declare const faviconPlugin: () => ServerPluginLegacy;
+import type { ServerPlugin } from '../types';
+export declare const faviconPlugin: () => ServerPlugin;

package/dist/types/plugins/log.d.ts

@@ -1,2 +1,2 @@
-import type { ServerPluginLegacy } from '../types';
-export declare const logPlugin: () => ServerPluginLegacy;
+import type { ServerPlugin } from '../types';
+export declare const logPlugin: () => ServerPlugin;

package/dist/types/plugins/middlewares.d.ts

@@ -1,2 +1,2 @@
-import type { MiddlewareObj, ServerPluginLegacy } from '../types';
-export declare const injectConfigMiddlewarePlugin: (configMiddlewares?: MiddlewareObj[], configRenderMiddlewares?: MiddlewareObj[]) => ServerPluginLegacy;
+import type { MiddlewareObj, ServerPlugin } from '../types';
+export declare const injectConfigMiddlewarePlugin: (configMiddlewares?: MiddlewareObj[], configRenderMiddlewares?: MiddlewareObj[]) => ServerPlugin;

package/dist/types/plugins/monitors.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '@modern-js/types';
-import type { Context, Next, ServerEnv, ServerPluginLegacy } from '../types';
-export declare const initMonitorsPlugin: () => ServerPluginLegacy;
-export declare const injectloggerPlugin: (inputLogger: Logger) => ServerPluginLegacy;
-export declare const injectServerTiming: () => ServerPluginLegacy;
+import type { Context, Next, ServerEnv, ServerPlugin } from '../types';
+export declare const initMonitorsPlugin: () => ServerPlugin;
+export declare const injectloggerPlugin: (inputLogger: Logger) => ServerPlugin;
+export declare const injectServerTiming: () => ServerPlugin;
 export declare function requestLatencyMiddleware(): (c: Context<ServerEnv>, next: Next) => Promise<void>;

package/dist/types/plugins/processedBy.d.ts

@@ -1,2 +1,2 @@
-import type { ServerPluginLegacy } from '../types';
-export declare const processedByPlugin: () => ServerPluginLegacy;
+import type { ServerPlugin } from '../types';
+export declare const processedByPlugin: () => ServerPlugin;

package/dist/types/plugins/render/dataHandler.d.ts

@@ -1,5 +1,5 @@
 import type { ServerRoute } from '@modern-js/types';
 import type { SSRRenderOptions } from './ssrRender';
-export declare const dataHandler: (request: Request, { routeInfo, serverRoutes, reporter, monitors, onError, onTiming, serverManifest, loaderContext, }: SSRRenderOptions & {
+export declare const dataHandler: (request: Request, { routeInfo, serverRoutes, monitors, onError, onTiming, serverManifest, loaderContext, }: SSRRenderOptions & {
     serverRoutes: ServerRoute[];
 }) => Promise<Response | void>;

package/dist/types/plugins/render/index.d.ts

@@ -1,3 +1,3 @@
-import type { ServerPluginLegacy } from '../../types';
+import type { ServerPlugin } from '../../types';
 export * from './inject';
-export declare const renderPlugin: () => ServerPluginLegacy;
+export declare const renderPlugin: () => ServerPlugin;

package/dist/types/plugins/render/inject.d.ts

@@ -1,7 +1,7 @@
-import type { CacheConfig, GetRenderHandlerOptions, Render, ServerPluginLegacy } from '../../types';
+import type { CacheConfig, GetRenderHandlerOptions, Render, ServerPlugin } from '../../types';
 export interface InjectRenderHandlerOptions {
     staticGenerate?: boolean;
     cacheConfig?: CacheConfig;
 }
-export declare const injectRenderHandlerPlugin: ({ staticGenerate, cacheConfig, }: InjectRenderHandlerOptions) => ServerPluginLegacy;
+export declare const injectRenderHandlerPlugin: ({ staticGenerate, cacheConfig, }: InjectRenderHandlerOptions) => ServerPlugin;
 export declare function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback, }: GetRenderHandlerOptions): Promise<Render>;

package/dist/types/plugins/render/ssrRender.d.ts

@@ -1,4 +1,4 @@
-import type { Logger, Metrics, Reporter, ServerRoute } from '@modern-js/types';
+import type { Reporter, ServerRoute } from '@modern-js/types';
 import type { Monitors, ClientManifest as RscClientManifest, SSRManifest as RscSSRManifest, ServerManifest as RscServerManifest } from '@modern-js/types/server';
 import type { NodeRequest } from '@modern-js/types/server';
 import type { CacheConfig, ServerManifest, UserConfig } from '../../types';
@@ -15,9 +15,6 @@ export interface SSRRenderOptions {
     rscSSRManifest?: RscSSRManifest;
     loaderContext: Map<string, unknown>;
     params: Params;
-    logger: Logger;
-    metrics?: Metrics;
-    reporter?: Reporter;
     /** Produce by custom server hook */
     locals?: Record<string, any>;
     cacheConfig?: CacheConfig;
@@ -25,5 +22,6 @@ export interface SSRRenderOptions {
     monitors: Monitors;
     onError: OnError;
     onTiming: OnTiming;
+    reporter?: Reporter;
 }
-export declare function ssrRender(request: Request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, monitors, cacheConfig, logger, metrics, onError, onTiming, }: SSRRenderOptions): Promise<Response>;
+export declare function ssrRender(request: Request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, monitors, cacheConfig, onError, onTiming, reporter, }: SSRRenderOptions): Promise<Response>;

package/dist/types/plugins/route.d.ts

@@ -1,2 +1,2 @@
-import type { ServerPluginLegacy } from '../types';
-export declare const injectRoutePlugin: () => ServerPluginLegacy;
+import type { ServerPlugin } from '../types';
+export declare const injectRoutePlugin: () => ServerPlugin;