@modern-js/server 2.41.0 → 2.42.0

package/dist/types/constants.d.ts

@@ -1,2 +1,2 @@
 import { DevServerOptions } from './types';
-export declare const getDefaultDevOptions: () => DevServerOptions;
+export declare const getDefaultDevOptions: () => DevServerOptions;

package/dist/types/dev-tools/dev-middleware/hmr-client/createSocketUrl.d.ts

@@ -1,12 +1,7 @@
 export declare function createSocketUrl(resourceQuery: string): string;
-export declare function formatURL({
-  port,
-  protocol,
-  hostname,
-  pathname
-}: {
-  port: string;
-  protocol: string;
-  hostname: string;
-  pathname: string;
-}): string;
+export declare function formatURL({ port, protocol, hostname, pathname, }: {
+    port: string;
+    protocol: string;
+    hostname: string;
+    pathname: string;
+}): string;

package/dist/types/dev-tools/dev-middleware/hmr-client/index.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/types/dev-tools/dev-middleware/index.d.ts

@@ -4,19 +4,16 @@ import { Server } from 'http';
 import { EventEmitter } from 'events';
 import { DevServerOptions, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '../../types';
 type Options = {
-  dev: DevServerOptions;
-  devMiddleware?: CustomDevMiddleware;
+    dev: DevServerOptions;
+    devMiddleware?: CustomDevMiddleware;
 };
 export default class DevMiddleware extends EventEmitter {
-  middleware?: DevMiddlewareAPI;
-  private devOptions;
-  private socketServer;
-  constructor({
-    dev,
-    devMiddleware
-  }: Options);
-  init(app: Server): void;
-  sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
-  private setupDevMiddleware;
+    middleware?: DevMiddlewareAPI;
+    private devOptions;
+    private socketServer;
+    constructor({ dev, devMiddleware }: Options);
+    init(app: Server): void;
+    sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
+    private setupDevMiddleware;
 }
-export {};
+export {};

package/dist/types/dev-tools/dev-middleware/socketServer.d.ts

@@ -4,20 +4,20 @@ import ws from 'ws';
 import type webpack from 'webpack';
 import type { DevServerOptions } from '../../types';
 export default class SocketServer {
-  private wsServer;
-  private readonly sockets;
-  private readonly options;
-  private app?;
-  private stats?;
-  private timer;
-  constructor(options: DevServerOptions);
-  prepare(app: Server): void;
-  updateStats(stats: webpack.Stats): void;
-  sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
-  singleWrite(socket: ws, type: string, data?: Record<string, any> | string | boolean): void;
-  close(): void;
-  private onConnect;
-  private getStats;
-  private sendStats;
-  private send;
-}
+    private wsServer;
+    private readonly sockets;
+    private readonly options;
+    private app?;
+    private stats?;
+    private timer;
+    constructor(options: DevServerOptions);
+    prepare(app: Server): void;
+    updateStats(stats: webpack.Stats): void;
+    sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
+    singleWrite(socket: ws, type: string, data?: Record<string, any> | string | boolean): void;
+    close(): void;
+    private onConnect;
+    private getStats;
+    private sendStats;
+    private send;
+}

package/dist/types/dev-tools/https/index.d.ts

@@ -1,6 +1,6 @@
 import type Buffer from 'buffer';
 import type { DevServerHttpsOptions } from '../../types';
 export declare const genHttpsOptions: (userOptions: DevServerHttpsOptions, pwd: string) => Promise<{
-  key?: Buffer | string;
-  cert?: Buffer | string;
-}>;
+    key?: Buffer | string;
+    cert?: Buffer | string;
+}>;

package/dist/types/dev-tools/mock/getMockData.d.ts

@@ -2,15 +2,15 @@
 import { IncomingMessage, ServerResponse } from 'http';
 import type { ModernServerContext, NextFunction } from '@modern-js/types';
 export type MockConfig = Record<string, {
-  data: any;
+    data: any;
 } | ((req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void>)>;
 export type MockApi = {
-  method: string;
-  path: string;
-  handler: ReturnType<typeof createFunctionDataHandler | typeof createStaticDataHandler>;
+    method: string;
+    path: string;
+    handler: ReturnType<typeof createFunctionDataHandler | typeof createStaticDataHandler>;
 };
 declare const createFunctionDataHandler: (method: string, handler: (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void) => (context: ModernServerContext, next: NextFunction) => Promise<void>;
 declare const createStaticDataHandler: (method: string, handler: Record<string, any>) => (context: ModernServerContext) => void;
 declare const _default: (mockConfig: MockConfig) => MockApi[];
 export default _default;
-export declare const getMatched: (context: ModernServerContext, mockApiList: MockApi[]) => MockApi | undefined;
+export declare const getMatched: (context: ModernServerContext, mockApiList: MockApi[]) => MockApi | undefined;

package/dist/types/dev-tools/mock/index.d.ts

@@ -1,6 +1,4 @@
 import type { ModernServerContext, NextFunction } from '@modern-js/types';
-export declare const createMockHandler: ({
-  pwd
-}: {
-  pwd: string;
-}) => ((context: ModernServerContext, next: NextFunction) => Promise<void>) | null;
+export declare const createMockHandler: ({ pwd }: {
+    pwd: string;
+}) => ((context: ModernServerContext, next: NextFunction) => Promise<void>) | null;

package/dist/types/dev-tools/register/index.d.ts

@@ -1,2 +1,2 @@
 import { ModernServerOptions } from '@modern-js/prod-server';
-export declare const enableRegister: (projectRoot: string, config: ModernServerOptions['config']) => any;
+export declare const enableRegister: (projectRoot: string, config: ModernServerOptions['config']) => any;

package/dist/types/dev-tools/watcher/dependencyTree.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="node" />
 export declare const defaultIgnores: string[];
 export interface DependencyTreeOptions {
-  root: string;
-  ignore?: string[];
+    root: string;
+    ignore?: string[];
 }
 export interface TreeNode {
-  module: NodeModule;
-  parent: Set<TreeNode>;
-  children: Set<TreeNode>;
+    module: NodeModule;
+    parent: Set<TreeNode>;
+    children: Set<TreeNode>;
 }
 /**
  * `require.cache` already is a dependency tree, however require cache's
@@ -15,15 +15,15 @@ export interface TreeNode {
  *  a new tree which revisit the cache tree to find all parent node
  */
 export declare class DependencyTree {
-  private readonly tree;
-  private readonly ignore;
-  constructor();
-  getNode(path: string): TreeNode | undefined;
-  /**
-   * update dependency tree
-   *
-   * @param cache
-   */
-  update(cache: any): void;
-  private shouldIgnore;
-}
+    private readonly tree;
+    private readonly ignore;
+    constructor();
+    getNode(path: string): TreeNode | undefined;
+    /**
+     * update dependency tree
+     *
+     * @param cache
+     */
+    update(cache: any): void;
+    private shouldIgnore;
+}

package/dist/types/dev-tools/watcher/index.d.ts

@@ -1,17 +1,17 @@
 import { FSWatcher, WatchOptions } from '@modern-js/utils';
 export type WatchEvent = 'add' | 'change' | 'unlink';
 export declare const defaultWatchOptions: {
-  ignoreInitial: boolean;
-  ignored: RegExp;
+    ignoreInitial: boolean;
+    ignored: RegExp;
 };
 export declare const getWatchedFiles: (watcher: FSWatcher) => string[];
 export declare const mergeWatchOptions: (options?: WatchOptions) => WatchOptions;
 export default class Watcher {
-  private dependencyTree;
-  private watcher;
-  listen(files: string[], options: WatchOptions, callback: (changed: string, event: WatchEvent) => void): void;
-  createDepTree(): void;
-  updateDepTree(): void;
-  cleanDepCache(filepath: string): void;
-  close(): Promise<void>;
-}
+    private dependencyTree;
+    private watcher;
+    listen(files: string[], options: WatchOptions, callback: (changed: string, event: WatchEvent) => void): void;
+    createDepTree(): void;
+    updateDepTree(): void;
+    cleanDepCache(filepath: string): void;
+    close(): Promise<void>;
+}

package/dist/types/dev-tools/watcher/statsCache.d.ts

@@ -1,10 +1,10 @@
 export declare class StatsCache {
-  private readonly cachedHash;
-  private readonly cachedSize;
-  add(files: string[]): void;
-  refresh(filename: string): void;
-  del(filename: string): void;
-  isDiff(filename: string): boolean;
-  has(filename: string): boolean;
-  private hash;
-}
+    private readonly cachedHash;
+    private readonly cachedSize;
+    add(files: string[]): void;
+    refresh(filename: string): void;
+    del(filename: string): void;
+    isDiff(filename: string): boolean;
+    has(filename: string): boolean;
+    private hash;
+}

package/dist/types/index.d.ts

@@ -3,4 +3,4 @@ import type { ModernDevServerOptions } from './types';
 export { Server };
 export type { ModernDevServerOptions };
 declare const _default: (options: ModernDevServerOptions) => Promise<Server>;
-export default _default;
+export default _default;

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

@@ -7,34 +7,31 @@ import { RenderHandler } from '@modern-js/prod-server/src/libs/render';
 import { WatchEvent } from '../dev-tools/watcher';
 import type { ModernDevServerOptions } from '../types';
 export declare class ModernDevServer extends ModernServer {
-  private mockHandler;
-  private readonly dev;
-  private readonly useWorkerSSR;
-  private readonly appContext;
-  private readonly devMiddleware;
-  private watcher?;
-  constructor(options: ModernDevServerOptions);
-  private getDevOptions;
-  private addMiddlewareHandler;
-  private applySetupMiddlewares;
-  onInit(runner: ServerHookRunner, app: Server): Promise<void>;
-  getRenderHandler(): RenderHandler;
-  private applyDefaultMiddlewares;
-  onRepack(options?: BuildOptions): void;
-  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server<typeof IncomingMessage, typeof ServerResponse> | import("https").Server<typeof IncomingMessage, typeof ServerResponse>>;
-  protected warmupSSRBundle(): void;
-  protected initReader(): void;
-  protected onServerChange({
-    filepath,
-    event
-  }: {
-    filepath: string;
-    event: WatchEvent;
-  }): Promise<void>;
-  protected createContext(req: IncomingMessage, res: ServerResponse): import("@modern-js/prod-server/src/libs/context").ModernServerContext;
-  protected setupStaticMiddleware(_: string): (context: ModernServerContext, next: NextFunction) => Promise<void>;
-  private setupBeforeDevMiddleware;
-  private setupAfterDevMiddleware;
-  private cleanSSRCache;
-  private startWatcher;
-}
+    private mockHandler;
+    private readonly dev;
+    private readonly useWorkerSSR;
+    private readonly appContext;
+    private readonly devMiddleware;
+    private watcher?;
+    constructor(options: ModernDevServerOptions);
+    private getDevOptions;
+    private addMiddlewareHandler;
+    private applySetupMiddlewares;
+    onInit(runner: ServerHookRunner, app: Server): Promise<void>;
+    getRenderHandler(): RenderHandler;
+    private applyDefaultMiddlewares;
+    onRepack(options?: BuildOptions): void;
+    createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server<typeof IncomingMessage, typeof ServerResponse> | import("https").Server<typeof IncomingMessage, typeof ServerResponse>>;
+    protected warmupSSRBundle(): void;
+    protected initReader(): void;
+    protected onServerChange({ filepath, event, }: {
+        filepath: string;
+        event: WatchEvent;
+    }): Promise<void>;
+    protected createContext(req: IncomingMessage, res: ServerResponse): import("@modern-js/prod-server/src/libs/context").ModernServerContext;
+    protected setupStaticMiddleware(_: string): (context: ModernServerContext, next: NextFunction) => Promise<void>;
+    private setupBeforeDevMiddleware;
+    private setupAfterDevMiddleware;
+    private cleanSSRCache;
+    private startWatcher;
+}

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

@@ -1,5 +1,5 @@
 import { Server } from '@modern-js/prod-server';
 import type { ModernDevServerOptions } from '../types';
 export declare class DevServer extends Server {
-  constructor(options: ModernDevServerOptions);
-}
+    constructor(options: ModernDevServerOptions);
+}

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

@@ -1,9 +1,9 @@
 import { ServerHookRunner } from '@modern-js/prod-server';
 import { ModernServerContext } from '@modern-js/types/server';
 export declare function workerSSRRender(ctx: ModernServerContext, renderOptions: {
-  urlPath: string;
-  [props: string]: any;
+    urlPath: string;
+    [props: string]: any;
 }, _runner: ServerHookRunner): Promise<{
-  content: any;
-  contentType: string;
-}>;
+    content: any;
+    contentType: string;
+}>;

package/dist/types/types.d.ts

@@ -5,23 +5,23 @@ import type { ModernServerOptions } from '@modern-js/prod-server';
 export type { DevServerOptions, DevServerHttpsOptions };
 type Middleware = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void>;
 export type DevMiddlewareAPI = Middleware & {
-  close: (callback: (err: Error | null | undefined) => void) => any;
+    close: (callback: (err: Error | null | undefined) => void) => any;
 };
 export type MiddlewareCallbacks = {
-  onInvalid: () => void;
-  onDone: (stats: any) => void;
+    onInvalid: () => void;
+    onDone: (stats: any) => void;
 };
 export type DevMiddlewareOptions = {
-  /** To ensure HMR works, the devMiddleware need inject the hmr client path into page when HMR enable. */
-  hmrClientPath?: string;
-  /** The options need by compiler middleware (like webpackMiddleware) */
-  headers?: Record<string, string | string[]>;
-  writeToDisk?: boolean | ((filename: string) => boolean);
-  stats?: boolean;
-  /** should trigger when compiler hook called */
-  callbacks: MiddlewareCallbacks;
-  /** whether use Server Side Render */
-  serverSideRender?: boolean;
+    /** To ensure HMR works, the devMiddleware need inject the hmr client path into page when HMR enable. */
+    hmrClientPath?: string;
+    /** The options need by compiler middleware (like webpackMiddleware) */
+    headers?: Record<string, string | string[]>;
+    writeToDisk?: boolean | ((filename: string) => boolean);
+    stats?: boolean;
+    /** should trigger when compiler hook called */
+    callbacks: MiddlewareCallbacks;
+    /** whether use Server Side Render */
+    serverSideRender?: boolean;
 };
 /**
  * The modern/server do nothing about compiler, the devMiddleware need do such things to ensure dev works well:
@@ -31,8 +31,8 @@ export type DevMiddlewareOptions = {
  */
 export type DevMiddleware = (options: DevMiddlewareOptions) => DevMiddlewareAPI;
 export type ExtraOptions = {
-  dev: boolean | Partial<DevServerOptions>;
-  devMiddleware?: DevMiddleware;
-  useWorkerSSR?: boolean;
+    dev: boolean | Partial<DevServerOptions>;
+    devMiddleware?: DevMiddleware;
+    useWorkerSSR?: boolean;
 };
-export type ModernDevServerOptions = ModernServerOptions & ExtraOptions;
+export type ModernDevServerOptions = ModernServerOptions & ExtraOptions;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.41.0",
+  "version": "2.42.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -47,11 +47,11 @@
     "path-to-regexp": "^6.2.0",
     "ws": "^8.13.0",
     "axios": "^1.6.0",
-    "@modern-js/prod-server": "2.41.0",
-    "@modern-js/server-utils": "2.41.0",
-    "@modern-js/types": "2.41.0",
-    "@modern-js/utils": "2.41.0",
-    "@modern-js/runtime-utils": "2.41.0"
+    "@modern-js/server-utils": "2.42.0",
+    "@modern-js/types": "2.42.0",
+    "@modern-js/prod-server": "2.42.0",
+    "@modern-js/utils": "2.42.0",
+    "@modern-js/runtime-utils": "2.42.0"
   },
   "devDependencies": {
     "@types/connect-history-api-fallback": "^1.3.5",
@@ -66,9 +66,9 @@
     "typescript": "^5",
     "webpack": "^5.88.1",
     "websocket": "^1",
-    "@modern-js/server-core": "2.41.0",
-    "@scripts/build": "2.41.0",
-    "@scripts/jest-config": "2.41.0"
+    "@modern-js/server-core": "2.42.0",
+    "@scripts/build": "2.42.0",
+    "@scripts/jest-config": "2.42.0"
   },
   "peerDependencies": {
     "devcert": "^1.0.0",