@modern-js/prod-server 2.40.0 → 2.42.0

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

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

@@ -11,73 +11,61 @@ import { mergeExtension } from '../utils';
 import * as reader from '../libs/render/reader';
 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 reader: typeof reader;
-  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 initReader(): void;
-  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;
+    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 reader: typeof reader;
+    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 initReader(): void;
+    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 {};
+export {};

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

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

package/dist/types/type.d.ts

@@ -8,67 +8,67 @@ import type { ServerPlugin } from '@modern-js/server-core';
 import type { Metrics, Logger, NextFunction, ModernServerContext, InternalPlugins, Reporter } from '@modern-js/types';
 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;
-  }
+    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?: Logger;
-  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;
+    pwd: string;
+    config: ServerOptions;
+    plugins?: ServerPlugin[];
+    internalPlugins?: InternalPlugins;
+    routes?: ModernRouteInterface[];
+    staticGenerate?: boolean;
+    logger?: Logger;
+    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;
-  redirect?: boolean;
+    content: string | Buffer;
+    contentType: string;
+    contentStream?: Readable;
+    statusCode?: number;
+    redirect?: boolean;
 };
 export type ConfWithBFF = {
-  bff?: {
-    prefix: string;
-  } & ServerOptions['bff'];
+    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[];
+    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>;
+    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>;
 }
 export type ServerConstructor = (options: ModernServerOptions) => ModernServerInterface;
-export type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;
+export type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;

package/dist/types/utils.d.ts

@@ -1,24 +1,24 @@
+/// <reference path="type.d.ts" />
 /// <reference types="node" />
 /// <reference types="node/http" />
-/// <reference types=".dts-temp/x-wr1AtAisepvCMvqMiIW/src/type" />
 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[];
+    middleware: any[];
 };
 export declare const noop: () => void;
 export declare const createErrorDocument: (status: number, text: string) => string;
 export type CollectMiddlewaresResult = {
-  web: any[];
-  api: any[];
+    web: any[];
+    api: any[];
 };
 export declare const createMiddlewareCollecter: () => {
-  getMiddlewares: () => CollectMiddlewaresResult;
-  addWebMiddleware: (input: any) => void;
-  addAPIMiddleware: (input: any) => void;
+    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;
+export declare const isRedirect: (code: number) => boolean;

package/dist/types/workerServer.d.ts

@@ -1,58 +1,59 @@
-import { AfterMatchContext, AfterRenderContext, MiddlewareContext, NextFunction } from '@modern-js/types';
+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>;
+    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;
+    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;
+    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>;
+    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;
-  };
+    /**
+     * @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 {};
+export {};

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.40.0",
+  "version": "2.42.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -63,24 +63,24 @@
     }
   },
   "dependencies": {
-    "@swc/helpers": "0.5.1",
-    "cookie": "^0.4.2",
+    "@swc/helpers": "0.5.3",
+    "cookie": "0.5.0",
     "etag": "^1.8.1",
     "fresh": "^0.5.2",
-    "http-proxy-middleware": "^2.0.1",
+    "http-proxy-middleware": "^2.0.4",
     "ignore-styles": "^5.0.1",
     "lru-cache": "^6.0.0",
     "merge-deep": "^3.0.3",
     "node-html-parser": "^6.1.5",
     "path-to-regexp": "^6.2.0",
     "serve-static": "^1.14.1",
-    "@modern-js/plugin": "2.40.0",
-    "@modern-js/server-core": "2.40.0",
-    "@modern-js/utils": "2.40.0",
-    "@modern-js/runtime-utils": "2.40.0"
+    "@modern-js/plugin": "2.42.0",
+    "@modern-js/utils": "2.42.0",
+    "@modern-js/server-core": "2.42.0",
+    "@modern-js/runtime-utils": "2.42.0"
   },
   "devDependencies": {
-    "@types/cookie": "^0.4.1",
+    "@types/cookie": "0.5.1",
     "@types/etag": "^1.8.1",
     "@types/fresh": "^0.5.0",
     "@types/jest": "^29",
@@ -89,17 +89,17 @@
     "@types/node": "^14",
     "@types/serve-static": "^1.13.10",
     "@types/ws": "^8.5.5",
-    "axios": "^1.2.1",
+    "axios": "^1.6.0",
     "jest": "^29",
     "memfs": "^3.5.1",
     "node-mocks-http": "^1.11.0",
     "portfinder": "^1.0.28",
     "typescript": "^5",
     "ws": "^8.13.0",
-    "@modern-js/server-core": "2.40.0",
-    "@modern-js/types": "2.40.0",
-    "@scripts/build": "2.40.0",
-    "@scripts/jest-config": "2.40.0"
+    "@modern-js/server-core": "2.42.0",
+    "@modern-js/types": "2.42.0",
+    "@scripts/build": "2.42.0",
+    "@scripts/jest-config": "2.42.0"
   },
   "sideEffects": false,
   "publishConfig": {