@modern-js/prod-server 2.41.0 → 2.42.0

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

@@ -3,46 +3,46 @@ import { IncomingHttpHeaders } from 'http';
 import { RenderResult } from '../../../type';
 export type { CacheConfig } from '../type';
 export type CacheContent = {
-  level: number;
-  includes: {
-    header?: string[];
-    query?: string[];
-  } | null;
-  matches?: {
-    header?: Record<string, Record<string, string>>;
-    query?: Record<string, Record<string, string>>;
-  } | null;
-  interval: number;
-  limit: number | boolean;
-  caches: PageCachesInterface;
+    level: number;
+    includes: {
+        header?: string[];
+        query?: string[];
+    } | null;
+    matches?: {
+        header?: Record<string, Record<string, string>>;
+        query?: Record<string, Record<string, string>>;
+    } | null;
+    interval: number;
+    limit: number | boolean;
+    caches: PageCachesInterface;
 };
 export interface PageCachesInterface {
-  caches: any;
-  init: () => void;
-  get: (key: string) => Promise<PageCache | null>;
-  peek: (key: string) => PageCache | null;
-  set: (key: string, cache: PageCache) => Promise<void>;
-  del: (key: string) => void;
-  keys: () => string[];
+    caches: any;
+    init: () => void;
+    get: (key: string) => Promise<PageCache | null>;
+    peek: (key: string) => PageCache | null;
+    set: (key: string, cache: PageCache) => Promise<void>;
+    del: (key: string) => void;
+    keys: () => string[];
 }
 export type PageCache = {
-  html: string;
-  expireTime: number;
-  limitTime: number | null;
-  cacheHash: string;
-  size: number;
+    html: string;
+    expireTime: number;
+    limitTime: number | null;
+    cacheHash: string;
+    size: number;
 };
 export type CacheManagerOptions = {
-  max: number;
+    max: number;
 };
 export interface CacheResult extends RenderResult {
-  isStale: boolean;
-  isGarbage: boolean;
-  hash: string;
+    isStale: boolean;
+    isGarbage: boolean;
+    hash: string;
 }
 export type CacheContext = {
-  entry: string;
-  pathname: string;
-  query: Record<string, string>;
-  headers: IncomingHttpHeaders;
-};
+    entry: string;
+    pathname: string;
+    query: Record<string, string>;
+    headers: IncomingHttpHeaders;
+};

package/dist/types/libs/render/cache/util.d.ts

@@ -9,10 +9,10 @@ export declare function valueFactory(obj: url.URLSearchParams | IncomingHttpHead
 export declare function getTime([s, ns]: [number, number]): number;
 export declare function cacheAddition(html: string, hash: string): string;
 type CoalescedInvoke<T> = {
-  isOrigin: boolean;
-  value: T;
+    isOrigin: boolean;
+    value: T;
 };
 type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
 export declare function withCoalescedInvoke<F extends (...args: any[]) => Promise<any>>(func: F): (key: string, args: Parameters<F>) => Promise<CoalescedInvoke<UnwrapPromise<ReturnType<F>>>>;
 export declare function maybeSync(fn: () => Promise<any>): (sync: boolean) => Promise<any>;
-export {};
+export {};

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

@@ -4,18 +4,18 @@ import { RenderResult, ServerHookRunner } from '../../type';
 import { ModernRoute } from '../route';
 import * as ssr from './ssr';
 export type RenderHandler = (options: {
-  ctx: ModernServerContext;
-  route: ModernRoute;
-  runner: ServerHookRunner;
+    ctx: ModernServerContext;
+    route: ModernRoute;
+    runner: ServerHookRunner;
 }) => Promise<RenderResult | null>;
 type CreateRenderHandler = (ctx: {
-  distDir: string;
-  staticGenerate: boolean;
-  conf: ServerOptions;
-  ssrRender?: typeof ssr.render;
-  forceCSR?: boolean;
-  nonce?: string;
-  metaName?: string;
+    distDir: string;
+    staticGenerate: boolean;
+    conf: ServerOptions;
+    ssrRender?: typeof ssr.render;
+    forceCSR?: boolean;
+    nonce?: string;
+    metaName?: string;
 }) => RenderHandler;
 export declare const createRenderHandler: CreateRenderHandler;
-export {};
+export {};

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

@@ -1,10 +1,10 @@
 import { BaseSSRServerContext, Logger, Metrics } from '@modern-js/types';
 export declare const createMetrics: (context: BaseSSRServerContext, metrics: Metrics) => {
-  emitTimer: (name: string, cost: number, tags?: Record<string, unknown>) => void;
-  emitCounter: (name: string, counter: number, tags?: Record<string, unknown>) => void;
+    emitTimer: (name: string, cost: number, tags?: Record<string, unknown>) => void;
+    emitCounter: (name: string, counter: number, tags?: Record<string, unknown>) => void;
 };
 export declare const createLogger: (serverContext: BaseSSRServerContext, logger: Logger) => {
-  error: (message: string, e: Error | string) => void;
-  info: (message: string, ...args: any[]) => void;
-  debug: (message: string, ...args: any[]) => void;
-};
+    error: (message: string, e: Error | string) => void;
+    info: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+};

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

@@ -1,20 +1,20 @@
 /// <reference types="node" />
 import type { IFs } from 'memfs';
 export declare class LruReader {
-  private readonly cache;
-  private fs;
-  constructor();
-  init(fs?: IFs): void;
-  close(): void;
-  read(filepath: string): Promise<{
-    content: Buffer;
-    mtime: Date;
-  } | {
-    content: Buffer;
-  } | null>;
-  update(): void;
+    private readonly cache;
+    private fs;
+    constructor();
+    init(fs?: IFs): void;
+    close(): void;
+    read(filepath: string): Promise<{
+        content: Buffer;
+        mtime: Date;
+    } | {
+        content: Buffer;
+    } | null>;
+    update(): void;
 }
 export declare const readFile: (filepath: string) => Promise<Buffer | undefined>;
 export declare const updateFile: () => void;
 export declare const init: (fs?: IFs) => void;
-export declare const close: () => void;
+export declare const close: () => void;

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

@@ -1,12 +1,12 @@
 import type { ModernServerContext } from '@modern-js/types';
 import { RenderResult, ServerHookRunner } from '../../type';
 export declare const render: (ctx: ModernServerContext, renderOptions: {
-  distDir: string;
-  bundle: string;
-  urlPath: string;
-  template: string;
-  entryName: string;
-  staticGenerate: boolean;
-  enableUnsafeCtx?: boolean;
-  nonce?: string;
-}, runner: ServerHookRunner) => Promise<RenderResult>;
+    distDir: string;
+    bundle: string;
+    urlPath: string;
+    template: string;
+    entryName: string;
+    staticGenerate: boolean;
+    enableUnsafeCtx?: boolean;
+    nonce?: string;
+}, runner: ServerHookRunner) => Promise<RenderResult>;

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

@@ -1,3 +1,3 @@
 import type { ModernServerContext } from '@modern-js/types';
 import { RenderResult } from '../../type';
-export declare function handleDirectory(ctx: ModernServerContext, entryPath: string, urlPath: string): Promise<RenderResult | null>;
+export declare function handleDirectory(ctx: ModernServerContext, entryPath: string, urlPath: string): Promise<RenderResult | null>;

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

@@ -3,34 +3,34 @@
 import { Writable, Readable } from 'stream';
 import { BaseSSRServerContext } from '@modern-js/types';
 type MetaKeyMap = {
-  header?: string[];
-  query?: string[];
+    header?: string[];
+    query?: string[];
 };
 type MetaKeyMatch = {
-  header?: MatchMap;
-  query?: MatchMap;
+    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;
+    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,
+    CLIENT_RENDER = 0,
+    SERVER_PREFETCH = 1,
+    SERVER_RENDER = 2
 }
 export type SSRServerContext = BaseSSRServerContext & {
-  cacheConfig?: CacheConfig;
-  staticGenerate?: boolean;
+    cacheConfig?: CacheConfig;
+    staticGenerate?: boolean;
 };
 export type ModernSSRReactComponent = React.ComponentType<any> & {
-  init: (context: SSRServerContext) => Promise<void>;
-  prefetch: (context: SSRServerContext) => Promise<Record<string, any>>;
+    init: (context: SSRServerContext) => Promise<void>;
+    prefetch: (context: SSRServerContext) => Promise<Record<string, any>>;
 };
 export type RenderFunction = (context: SSRServerContext) => Promise<string | ((writable: Writable) => Promise<Readable>)>;
-export {};
+export {};

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

@@ -2,4 +2,4 @@
 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;
+export declare const injectServerDataStream: (content: Readable, context: ModernServerContext) => import("stream").Transform;

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

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

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

@@ -1,15 +1,15 @@
 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)[];
+    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 };
+export { RouteMatcher };

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

@@ -1,15 +1,15 @@
 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;
-}
+    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 +1,14 @@
 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);
-}
+    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 +1,9 @@
 import type { ModernServerContext } from '@modern-js/types';
 import { NextFunction, ModernServerHandler } from '../type';
 type Rule = {
-  path: string | RegExp;
-  target: string;
+    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 {};
+export {};

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

@@ -1,13 +1,13 @@
 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;
+    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;
+    meta: string;
+    res: Res;
+    constructor(res: Res, meta: string);
+    addServeTiming(name: string, dur: number, desc?: string): this;
 }
-export {};
+export {};

package/dist/types/renderHtml.d.ts

@@ -2,20 +2,20 @@
 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;
+    /** 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;
-}
+    headers: OutgoingHttpHeaders;
+    redirected: boolean;
+    status: number;
+    url: string;
+    body: string;
+}

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

@@ -5,51 +5,49 @@ 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;
-}
+    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;
+}