@modern-js/prod-server 2.48.6 → 2.49.0

package/dist/types/libs/render/type.d.ts

@@ -1,36 +0,0 @@
-/// <reference types="react" />
-/// <reference types="node" />
-import { Writable, Readable } from 'stream';
-import { BaseSSRServerContext } from '@modern-js/types';
-type MetaKeyMap = {
-    header?: string[];
-    query?: string[];
-};
-type MetaKeyMatch = {
-    header?: MatchMap;
-    query?: MatchMap;
-};
-type MatchMap = Record<string, Record<string, string>>;
-export type CacheConfig = {
-    interval: number;
-    staleLimit: number | boolean;
-    level: number;
-    includes?: MetaKeyMap | null;
-    excludes?: MetaKeyMap | null;
-    matches?: MetaKeyMatch | null;
-};
-export declare enum RenderLevel {
-    CLIENT_RENDER = 0,
-    SERVER_PREFETCH = 1,
-    SERVER_RENDER = 2
-}
-export type SSRServerContext = BaseSSRServerContext & {
-    cacheConfig?: CacheConfig;
-    staticGenerate?: boolean;
-};
-export type ModernSSRReactComponent = React.ComponentType<any> & {
-    init: (context: SSRServerContext) => Promise<void>;
-    prefetch: (context: SSRServerContext) => Promise<Record<string, any>>;
-};
-export type RenderFunction = (context: SSRServerContext) => Promise<string | ((writable: Writable) => Promise<Readable>) | undefined>;
-export {};

package/dist/types/libs/render/utils.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="node" />
-import { Readable } from 'stream';
-import type { ModernServerContext } from '@modern-js/types';
-export declare const injectServerData: (content: string, context: ModernServerContext) => string;
-export declare const injectServerDataStream: (content: Readable, context: ModernServerContext) => import("stream").Transform;

package/dist/types/libs/reporter.d.ts

@@ -1,2 +0,0 @@
-import { Reporter } from '@modern-js/types/server';
-export declare const defaultReporter: Reporter;

package/dist/types/libs/route/index.d.ts

@@ -1,15 +0,0 @@
-import { RouteMatcher } from './matcher';
-import { ModernRoute, ModernRouteInterface } from './route';
-export declare class RouteMatchManager {
-    matchers: RouteMatcher[];
-    private specs;
-    constructor();
-    private filter;
-    private best;
-    reset(specs: ModernRouteInterface[]): void;
-    match(pathname: string): RouteMatcher | undefined;
-    matchEntry(entryname: string): RouteMatcher | undefined;
-    getBundles(): (string | undefined)[];
-}
-export type { ModernRouteInterface, ModernRoute };
-export { RouteMatcher };

package/dist/types/libs/route/matcher.d.ts

@@ -1,15 +0,0 @@
-import { MatchFunction } from 'path-to-regexp';
-import { ModernRoute, ModernRouteInterface } from './route';
-export declare class RouteMatcher {
-    spec: ModernRouteInterface;
-    urlPath: string;
-    urlMatcher?: MatchFunction;
-    urlReg?: RegExp;
-    constructor(spec: ModernRouteInterface);
-    generate(url: string): ModernRoute;
-    parseURLParams(pathname: string): Record<string, string>;
-    matchLength(pathname: string): number | null;
-    matchUrlPath(requestUrl: string): boolean;
-    matchEntry(entryName: string): boolean;
-    private setupUrlPath;
-}

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

@@ -1,14 +0,0 @@
-import { ServerRoute as ModernRouteInterface } from '@modern-js/types';
-export type { ModernRouteInterface };
-export declare class ModernRoute implements ModernRouteInterface {
-    entryName: string;
-    urlPath: string;
-    entryPath: string;
-    bundle: string;
-    isApi: boolean;
-    isSSR: boolean;
-    isSPA: boolean;
-    params: Record<string, any>;
-    responseHeaders?: Record<string, any>;
-    constructor(routeSpec: ModernRouteInterface);
-}

package/dist/types/libs/serveFile.d.ts

@@ -1,9 +0,0 @@
-import type { ModernServerContext } from '@modern-js/types';
-import { NextFunction, ModernServerHandler } from '../type';
-type Rule = {
-    path: string | RegExp;
-    target: string;
-};
-export declare const faviconFallbackHandler: ModernServerHandler;
-export declare const createStaticFileHandler: (rules: Rule[], assetPrefix?: string) => (context: ModernServerContext, next: NextFunction) => Promise<void>;
-export {};

package/dist/types/libs/serverTiming.d.ts

@@ -1,13 +0,0 @@
-import { ServerTiming as IServerTiming } from '@modern-js/types';
-interface Res {
-    getHeader: (name: string) => number | string | string[] | undefined;
-    setHeader: (name: string, value: string) => void;
-    set: (name: string, value: any) => this;
-}
-export declare class ServerTiming implements IServerTiming {
-    meta: string;
-    res: Res;
-    constructor(res: Res, meta: string);
-    addServeTiming(name: string, dur: number, desc?: string): this;
-}
-export {};

package/dist/types/renderHtml.d.ts

@@ -1,23 +0,0 @@
-/// <reference path="type.d.ts" />
-/// <reference types="node" />
-/// <reference types="node/http" />
-import { IncomingHttpHeaders, OutgoingHttpHeaders } from 'http';
-import { ModernServerOptions } from './type';
-export interface RenderHtmlOptions {
-    /** request url */
-    url: string;
-    /** request method */
-    method?: string;
-    /** request headers  */
-    headers?: IncomingHttpHeaders;
-    /** request body */
-    body?: string;
-    serverOptions: ModernServerOptions;
-}
-export interface ReturnResponse {
-    headers: OutgoingHttpHeaders;
-    redirected: boolean;
-    status: number;
-    url: string;
-    body: string;
-}

package/dist/types/server/index.d.ts

@@ -1,55 +0,0 @@
-/// <reference path="../type.d.ts" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node/http" />
-import { IncomingMessage, ServerResponse } from 'http';
-import type { ListenOptions } from 'net';
-import { ModernServerOptions, ServerConstructor } from '../type';
-export declare class Server {
-    options: ModernServerOptions;
-    protected serverImpl: ServerConstructor;
-    private server;
-    private app;
-    private runner;
-    private serverConfig;
-    constructor(options: ModernServerOptions);
-    /**
-     * 初始化顺序
-     * - 读取 .env.{process.env.MODERN_ENV} 文件，加载环境变量
-     * - 获取 server runtime config
-     * - 设置 context
-     * - 创建 hooksRunner
-     * - 合并插件，内置插件和 serverConfig 中配置的插件
-     * - 执行 config hook
-     * - 获取最终的配置
-     * - 设置配置到 context
-     * - 初始化 server
-     * - 执行 prepare hook
-     * - 执行 server init
-     */
-    init({ disableHttpServer }?: {
-        disableHttpServer: boolean;
-    }): Promise<this>;
-    /**
-     * Execute config hooks
-     * @param runner
-     * @param options
-     */
-    private runConfigHook;
-    private runPrepareHook;
-    private initServerConfig;
-    /**
-     *
-     * merge cliConfig and serverConfig
-     */
-    private initConfig;
-    close(): Promise<void>;
-    listen<T extends number | ListenOptions | undefined>(options: T, listener: any): void;
-    getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
-    render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | import("stream").Readable | null>;
-    private createHookRunner;
-    private injectContext;
-    private initAppContext;
-    private loadServerEnv;
-}

package/dist/types/server/modernServer.d.ts

@@ -1,71 +0,0 @@
-/// <reference path="../type.d.ts" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node/http" />
-import { IncomingMessage, ServerResponse, Server } from 'http';
-import { Adapter, WebAdapter, APIServerStartInput, ServerOptions } from '@modern-js/server-core';
-import { type ModernServerContext, type ServerRoute } from '@modern-js/types';
-import { Logger } from '@modern-js/utils/logger';
-import type { ContextOptions } from '../libs/context';
-import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, ModernServerInterface, BuildOptions, ModernServerHandler } from '../type';
-import { RouteMatchManager, ModernRouteInterface, ModernRoute } from '../libs/route';
-import { RenderHandler } from '../libs/render';
-import { mergeExtension } from '../utils';
-type ModernServerAsyncHandler = (context: ModernServerContext, next: NextFunction) => Promise<void>;
-export declare class ModernServer implements ModernServerInterface {
-    pwd: string;
-    distDir: string;
-    protected workDir: string;
-    protected router: RouteMatchManager;
-    protected conf: ServerOptions;
-    protected handlers: ModernServerAsyncHandler[];
-    protected presetRoutes?: ModernRouteInterface[];
-    protected runner: ServerHookRunner;
-    protected readonly logger: Logger;
-    protected readonly metrics: Metrics;
-    protected readonly runMode: string;
-    protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
-    protected routeRenderHandler: RenderHandler;
-    protected readonly staticGenerate: boolean;
-    protected readonly metaName?: string;
-    private loaderHandler;
-    private frameWebHandler;
-    private frameAPIHandler;
-    private _handler;
-    constructor({ pwd, config, routes, staticGenerate, logger, metrics, runMode, proxyTarget, appContext, }: ModernServerOptions);
-    onInit(runner: ServerHookRunner, app: Server): Promise<void>;
-    getRenderHandler(): RenderHandler;
-    onRepack(_: BuildOptions): void;
-    getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void | ServerResponse;
-    render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | import("stream").Readable | null>;
-    createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server<typeof IncomingMessage, typeof ServerResponse>>;
-    protected onServerChange({ filepath }: {
-        filepath: string;
-    }): Promise<void>;
-    protected getRoutes(): ServerRoute[];
-    protected addHandler(handler: ModernServerHandler): void;
-    protected render404(context: ModernServerContext): void;
-    protected prepareLoaderHandler(specs: ServerRoute[], distDir: string): Promise<void>;
-    protected prepareFrameHandler(options?: {
-        onlyApi: boolean;
-        onlyWeb: boolean;
-    }): Promise<void>;
-    protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<WebAdapter>;
-    protected prepareAPIHandler(extension: APIServerStartInput['config']): Promise<Adapter>;
-    protected filterRoutes(routes: ModernRouteInterface[]): ServerRoute[];
-    protected setupBeforeProdMiddleware(): Promise<void>;
-    protected setupStaticMiddleware(prefix?: string): (context: ModernServerContext, next: NextFunction) => Promise<void>;
-    protected handleAPI(context: ModernServerContext): Promise<void>;
-    protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<import("../type").RenderResult | null>;
-    protected proxy(): Promise<any>;
-    protected warmupSSRBundle(): void;
-    protected createContext(req: IncomingMessage, res: ServerResponse, options?: ContextOptions): import("../libs/context").ModernServerContext;
-    private routeHandler;
-    private isSend;
-    private compose;
-    private requestHandler;
-    private redirect;
-    private onError;
-    private renderErrorPage;
-}
-export {};

package/dist/types/server/modernServerSplit.d.ts

@@ -1,2 +0,0 @@
-import { ModernServerOptions, ModernServerInterface } from '../type';
-export declare const createProdServer: (options: ModernServerOptions) => ModernServerInterface;

package/dist/types/type.d.ts

@@ -1,78 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node/http" />
-import { IncomingMessage, Server, ServerResponse } from 'http';
-import { Readable } from 'stream';
-import { serverManager, ServerOptions } from '@modern-js/server-core';
-import type { ServerPlugin } from '@modern-js/server-core';
-import type { Metrics, Logger, NextFunction, ModernServerContext, InternalPlugins, Reporter } from '@modern-js/types';
-import { Logger as LocalLogger } from '@modern-js/utils/logger';
-import type { ModernRouteInterface } from './libs/route';
-declare module 'http' {
-    interface IncomingMessage {
-        logger: Logger;
-        metrics: Metrics;
-        reporter?: Reporter;
-        body?: any;
-    }
-    interface OutgoingMessage {
-        set: (key: string, value: any) => this;
-        modernFlushedHeaders?: boolean;
-    }
-}
-export type ModernServerOptions = {
-    pwd: string;
-    config: ServerOptions;
-    plugins?: ServerPlugin[];
-    internalPlugins?: InternalPlugins;
-    routes?: ModernRouteInterface[];
-    staticGenerate?: boolean;
-    logger?: LocalLogger;
-    metrics?: Metrics;
-    apiOnly?: boolean;
-    ssrOnly?: boolean;
-    webOnly?: boolean;
-    runMode?: string;
-    appContext?: {
-        appDirectory?: string;
-        sharedDirectory: string;
-        apiDirectory: string;
-        lambdaDirectory: string;
-        metaName: string;
-    };
-    serverConfigFile?: string;
-    proxyTarget?: any;
-};
-export type RenderResult = {
-    content: string | Buffer;
-    contentType: string;
-    contentStream?: Readable;
-    statusCode?: number;
-    headers?: Record<string, string>;
-    redirect?: boolean;
-};
-export type ConfWithBFF = {
-    bff?: {
-        prefix: string;
-    } & ServerOptions['bff'];
-};
-export type Then<T> = T extends PromiseLike<infer U> ? U : T;
-export type ServerHookRunner = Then<ReturnType<typeof serverManager.init>>;
-export type BuildOptions = {
-    routes?: ModernRouteInterface[];
-};
-export type { Metrics, Logger, NextFunction };
-export type HookNames = 'afterMatch' | 'afterRender';
-export interface ModernServerInterface {
-    pwd: string;
-    distDir: string;
-    onInit: (runner: ServerHookRunner, app: Server) => Promise<void>;
-    onRepack: (options: BuildOptions) => void;
-    getRequestHandler: () => (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
-    createHTTPServer: (handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void) => Promise<Server>;
-    render: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | Readable | null>;
-    close?: () => Promise<void>;
-}
-export type ServerConstructor = (options: ModernServerOptions) => ModernServerInterface;
-export type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;

package/dist/types/utils.d.ts

@@ -1,24 +0,0 @@
-/// <reference path="type.d.ts" />
-/// <reference types="node" />
-/// <reference types="node/http" />
-import { IncomingMessage } from 'http';
-import type { OutputNormalizedConfig, HtmlNormalizedConfig } from '@modern-js/server-core';
-export declare const debug: any;
-export declare const mergeExtension: (users: any[]) => {
-    middleware: any[];
-};
-export declare const noop: () => void;
-export declare const createErrorDocument: (status: number, text: string) => string;
-export type CollectMiddlewaresResult = {
-    web: any[];
-    api: any[];
-};
-export declare const createMiddlewareCollecter: () => {
-    getMiddlewares: () => CollectMiddlewaresResult;
-    addWebMiddleware: (input: any) => void;
-    addAPIMiddleware: (input: any) => void;
-};
-export declare const getStaticReg: (output?: OutputNormalizedConfig, html?: HtmlNormalizedConfig, prefix?: string) => RegExp;
-export declare const prepareFavicons: (favicon: string | undefined, faviconByEntries?: Record<string, string | undefined>) => string[];
-export declare const headersWithoutCookie: (headers: IncomingMessage['headers']) => import("http").IncomingHttpHeaders;
-export declare const isRedirect: (code: number) => boolean;

package/dist/types/workerServer.d.ts

@@ -1,59 +0,0 @@
-import type { AfterMatchContext, AfterRenderContext, MiddlewareContext, NextFunction } from '@modern-js/types';
-import { ModernRouteInterface } from './libs/route';
-export type Context = Record<string, any>;
-export interface HandlerOptions {
-    request: Request;
-    loadableStats: Record<string, any>;
-    routeManifest: Record<string, any>;
-}
-export declare class ReturnResponse {
-    body: string;
-    status: number;
-    headers: Headers;
-    constructor(body: string, status: number, headers?: Record<string, any>);
-    /**
-     * Iterate a Object
-     * 1. adds the value if the key does not already exist.
-     * 2. append the value if the key does already exist.
-     *
-     * more detail follow: https://developer.mozilla.org/en-US/docs/Web/API/Headers/append
-     * @param headers
-     * @returns
-     */
-    appendHeaders(headers: Record<string, any>): this;
-    /**
-     * Iterate a Object
-     * 1. adds the value if the key does not already exist.
-     * 2. modify the value if the key does already exist.
-     *
-     * more detail follow: https://developer.mozilla.org/en-US/docs/Web/API/Headers/set
-     * @param headers
-     * @returns
-     */
-    setHeaders(headers: Record<string, any>): this;
-}
-type Middleware = (context: MiddlewareContext<'worker'>, next: NextFunction) => Promise<void> | void;
-type ServerHooks = {
-    middleware?: Middleware | Middleware[];
-    afterRender?: (ctx: AfterRenderContext, next: unknown) => Promise<void> | void;
-    afterMatch?: (ctx: AfterMatchContext, next: unknown) => Promise<void> | void;
-};
-type Page = {
-    entryName: string;
-    template: string;
-    serverHooks?: ServerHooks;
-    serverRender?: (ctx: Record<string, any>) => Promise<string>;
-};
-export type Manifest = {
-    /**
-     * @param key - path
-     */
-    pages: Record<string, Page>;
-    routes: ModernRouteInterface[];
-    options?: {
-        forceCSR?: boolean;
-        metaName?: string;
-    };
-};
-export declare const createHandler: (manifest: Manifest) => (options: HandlerOptions) => Promise<ReturnResponse>;
-export {};