@modern-js/prod-server 2.40.0 → 2.42.0

package/dist/types/libs/render/cache/__tests__/matched-cache.d.ts

@@ -1,124 +1,124 @@
 export declare const matchedCacheableAry: (({
-  requestOpt: {
+    requestOpt: {
+        url: string;
+        headers: {};
+        query: {
+            name: string;
+        };
+    };
+    cacheConfig: {
+        level: number;
+        includes: {
+            query: string[];
+        };
+        matches: {
+            query: {
+                name: {
+                    weixin: string;
+                };
+            };
+        };
+    };
+    content: string;
+    url?: undefined;
+    headers?: undefined;
+    query?: undefined;
+} | {
     url: string;
     headers: {};
     query: {
-      name: string;
+        name: string;
     };
-  };
-  cacheConfig: {
-    level: number;
-    includes: {
-      query: string[];
+    requestOpt?: undefined;
+    cacheConfig?: undefined;
+    content?: undefined;
+})[] | ({
+    requestOpt: {
+        url: string;
+        query: {};
+        headers: {
+            age: string;
+        };
     };
-    matches: {
-      query: {
-        name: {
-          weixin: string;
+    cacheConfig: {
+        level: number;
+        includes: {
+            header: string[];
+        };
+        matches: {
+            header: {
+                age: {
+                    one: string;
+                };
+            };
         };
-      };
     };
-  };
-  content: string;
-  url?: undefined;
-  headers?: undefined;
-  query?: undefined;
+    content: string;
+    url?: undefined;
+    query?: undefined;
+    headers?: undefined;
 } | {
-  url: string;
-  headers: {};
-  query: {
-    name: string;
-  };
-  requestOpt?: undefined;
-  cacheConfig?: undefined;
-  content?: undefined;
-})[] | ({
-  requestOpt: {
     url: string;
     query: {};
     headers: {
-      age: string;
+        age: string;
     };
-  };
-  cacheConfig: {
-    level: number;
-    includes: {
-      header: string[];
+    requestOpt?: undefined;
+    cacheConfig?: undefined;
+    content?: undefined;
+})[] | ({
+    requestOpt: {
+        url: string;
+        headers: {
+            age: string;
+        };
+        query: {
+            name: string;
+        };
     };
-    matches: {
-      header: {
-        age: {
-          one: string;
+    cacheConfig: {
+        level: number;
+        includes: {
+            query: string[];
+            header: string[];
+        };
+        matches: {
+            query: {
+                name: {
+                    weixin: string;
+                };
+            };
+            header: {
+                age: {
+                    one: string;
+                };
+            };
         };
-      };
     };
-  };
-  content: string;
-  url?: undefined;
-  query?: undefined;
-  headers?: undefined;
+    content: string;
+    url?: undefined;
+    query?: undefined;
+    headers?: undefined;
 } | {
-  url: string;
-  query: {};
-  headers: {
-    age: string;
-  };
-  requestOpt?: undefined;
-  cacheConfig?: undefined;
-  content?: undefined;
-})[] | ({
-  requestOpt: {
     url: string;
+    query: {
+        name: string;
+    };
     headers: {
-      age: string;
+        age: string;
     };
+    requestOpt?: undefined;
+    cacheConfig?: undefined;
+    content?: undefined;
+} | {
+    url: string;
     query: {
-      name: string;
+        name: string;
     };
-  };
-  cacheConfig: {
-    level: number;
-    includes: {
-      query: string[];
-      header: string[];
-    };
-    matches: {
-      query: {
-        name: {
-          weixin: string;
-        };
-      };
-      header: {
-        age: {
-          one: string;
-        };
-      };
+    headers: {
+        age?: undefined;
     };
-  };
-  content: string;
-  url?: undefined;
-  query?: undefined;
-  headers?: undefined;
-} | {
-  url: string;
-  query: {
-    name: string;
-  };
-  headers: {
-    age: string;
-  };
-  requestOpt?: undefined;
-  cacheConfig?: undefined;
-  content?: undefined;
-} | {
-  url: string;
-  query: {
-    name: string;
-  };
-  headers: {
-    age?: undefined;
-  };
-  requestOpt?: undefined;
-  cacheConfig?: undefined;
-  content?: undefined;
-})[])[];
+    requestOpt?: undefined;
+    cacheConfig?: undefined;
+    content?: undefined;
+})[])[];

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

@@ -3,4 +3,4 @@ import { Readable } from 'stream';
 import type { ModernServerContext } from '@modern-js/types';
 import { RenderFunction, SSRServerContext } from '../type';
 declare const _default: (renderFn: RenderFunction, ctx: ModernServerContext) => (context: SSRServerContext) => Promise<string | Readable>;
-export default _default;
+export default _default;

package/dist/types/libs/render/cache/page-caches/index.d.ts

@@ -1,2 +1,2 @@
 import { PageCachesInterface } from '../type';
-export declare function createPageCaches(max: number): Promise<PageCachesInterface>;
+export declare function createPageCaches(max: number): Promise<PageCachesInterface>;

package/dist/types/libs/render/cache/page-caches/lru.d.ts

@@ -1,15 +1,15 @@
 import LRU from 'lru-cache';
 import { PageCache, PageCachesInterface } from '../type';
 export declare class LRUCaches implements PageCachesInterface {
-  caches: LRU<string, PageCache>;
-  private readonly max;
-  constructor(options: {
-    max: number;
-  });
-  init(): Promise<void>;
-  keys(): string[];
-  get(key: string): Promise<PageCache | null>;
-  peek(key: string): PageCache | null;
-  set(key: string, cache: PageCache): Promise<void>;
-  del(key: string): void;
-}
+    caches: LRU<string, PageCache>;
+    private readonly max;
+    constructor(options: {
+        max: number;
+    });
+    init(): Promise<void>;
+    keys(): string[];
+    get(key: string): Promise<PageCache | null>;
+    peek(key: string): PageCache | null;
+    set(key: string, cache: PageCache): Promise<void>;
+    del(key: string): void;
+}

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

@@ -1,22 +1,22 @@
 import LRUCache from 'lru-cache';
 import { CacheContent, CacheManagerOptions, CacheResult, CacheContext, CacheConfig } from './type';
 declare class CacheManager {
-  cache: LRUCache<string, CacheContent>;
-  cacheOptions: CacheManagerOptions;
-  constructor(cacheOptions: CacheManagerOptions);
-  private md5;
-  private generateRequestKey;
-  private replaceValue;
-  private factor;
-  private queryFactor;
-  private headerFactor;
-  private readonly find;
-  private best;
-  private createCacheContent;
-  get(context: CacheContext): Promise<CacheResult | null>;
-  set(context: CacheContext, html: string, cacheConfig: CacheConfig, sync?: boolean): Promise<any>;
-  del(context: CacheContext, cacheHash: string): Promise<void>;
+    cache: LRUCache<string, CacheContent>;
+    cacheOptions: CacheManagerOptions;
+    constructor(cacheOptions: CacheManagerOptions);
+    private md5;
+    private generateRequestKey;
+    private replaceValue;
+    private factor;
+    private queryFactor;
+    private headerFactor;
+    private readonly find;
+    private best;
+    private createCacheContent;
+    get(context: CacheContext): Promise<CacheResult | null>;
+    set(context: CacheContext, html: string, cacheConfig: CacheConfig, sync?: boolean): Promise<any>;
+    del(context: CacheContext, cacheHash: string): Promise<void>;
 }
 export declare function createCache(): CacheManager;
 export declare function destroyCache(): void;
-export {};
+export {};

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);
+}