@modern-js/runtime 2.57.1 → 2.57.2-alpha.0

package/dist/index.js

@@ -0,0 +1,635 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  RuntimeReactContext: () => RuntimeReactContext,
+  bootstrap: () => bootstrap,
+  createApp: () => createApp,
+  defineConfig: () => defineConfig,
+  defineRuntimeConfig: () => defineRuntimeConfig,
+  isBrowser: () => isBrowser,
+  useLoader: () => useLoader_default,
+  useRuntimeContext: () => useRuntimeContext
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/common.ts
+var isBrowser = () => typeof window !== "undefined" && window.name !== "nodejs";
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  RuntimeReactContext: () => RuntimeReactContext,
+  ServerRouterContext: () => ServerRouterContext,
+  bootstrap: () => bootstrap,
+  createApp: () => createApp,
+  defineConfig: () => defineConfig,
+  defineRuntimeConfig: () => defineRuntimeConfig,
+  getConfig: () => getConfig,
+  runtime: () => runtime,
+  useLoader: () => useLoader_default,
+  useRuntimeContext: () => useRuntimeContext
+});
+
+// src/core/plugin/base.ts
+var import_plugin = require("@modern-js/plugin");
+var client = (0, import_plugin.createAsyncPipeline)();
+var server = (0, import_plugin.createAsyncPipeline)();
+var hoc = (0, import_plugin.createPipeline)();
+var init = (0, import_plugin.createAsyncPipeline)();
+var pickContext = (0, import_plugin.createPipeline)();
+var runtimeHooks = {
+  hoc,
+  init,
+  client,
+  server,
+  pickContext
+};
+var createRuntime = () => (0, import_plugin.createManager)(runtimeHooks);
+var runtime = createRuntime();
+
+// src/core/plugin/runner.ts
+var globalRunner;
+function setGlobalRunner(runner) {
+  globalRunner = runner;
+}
+function getGlobalRunner() {
+  if (globalRunner) {
+    return globalRunner;
+  }
+  const runner = runtime.init();
+  setGlobalRunner(runner);
+  return runner;
+}
+
+// src/core/plugin/index.ts
+function registerPlugin(internalPlugins, runtimeConfig, customRuntime) {
+  const { plugins = [] } = runtimeConfig || {};
+  (customRuntime || runtime).usePlugin(...internalPlugins, ...plugins);
+  const runner = (customRuntime || runtime).init();
+  setGlobalRunner(runner);
+  return runner;
+}
+
+// src/core/config.ts
+var APP_CONFIG_SYMBOL = "config";
+var getConfig = (Component) => (
+  // @ts-expect-error
+  Component[APP_CONFIG_SYMBOL]
+);
+var defineConfig = (Component, config) => {
+  Component[APP_CONFIG_SYMBOL] = config;
+  return Component;
+};
+var defineRuntimeConfig = (config) => config;
+
+// src/core/compatible.tsx
+var import_react2 = __toESM(require("react"));
+var import_hoist_non_react_statics = __toESM(require("hoist-non-react-statics"));
+var import_constants2 = require("@modern-js/utils/universal/constants");
+
+// src/core/context/runtime.ts
+var import_react = require("react");
+var import_constants = require("@modern-js/utils/universal/constants");
+
+// src/core/loader/loaderManager.ts
+var import_invariant = __toESM(require("invariant"));
+var createGetId = () => {
+  const idCache = /* @__PURE__ */ new Map();
+  return (objectId) => {
+    const cachedId = idCache.get(objectId);
+    if (cachedId) {
+      return cachedId;
+    }
+    const id = JSON.stringify(objectId);
+    (0, import_invariant.default)(id, "params should be not null value");
+    idCache.set(objectId, id);
+    return id;
+  };
+};
+var createLoader = (id, initialData = {
+  loading: false,
+  reloading: false,
+  data: void 0,
+  error: void 0
+}, loaderFn, skip = false) => {
+  let promise;
+  let status = 0 /* idle */;
+  let { data, error } = initialData;
+  let hasLoaded = false;
+  const handlers = /* @__PURE__ */ new Set();
+  const load = () => __async(void 0, null, function* () {
+    if (skip) {
+      return promise;
+    }
+    if (status === 1 /* loading */) {
+      return promise;
+    }
+    status = 1 /* loading */;
+    notify();
+    promise = loaderFn().then((value) => {
+      data = value;
+      error = null;
+      status = 2 /* fulfilled */;
+    }).catch((e) => {
+      error = e;
+      data = null;
+      status = 3 /* rejected */;
+    }).finally(() => {
+      promise = null;
+      hasLoaded = true;
+      notify();
+    });
+    return promise;
+  });
+  const getResult = () => ({
+    loading: !hasLoaded && status === 1 /* loading */,
+    reloading: hasLoaded && status === 1 /* loading */,
+    data,
+    error: error instanceof Error ? `${error.message}` : error,
+    // redundant fields for ssr log
+    _error: error
+  });
+  const notify = () => {
+    [...handlers].forEach((handler) => {
+      handler(status, getResult());
+    });
+  };
+  const onChange = (handler) => {
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+    };
+  };
+  return {
+    get result() {
+      return getResult();
+    },
+    get promise() {
+      return promise;
+    },
+    onChange,
+    load
+  };
+};
+var createLoaderManager = (initialDataMap, managerOptions = {}) => {
+  const { skipStatic = false, skipNonStatic = false } = managerOptions;
+  const loadersMap = /* @__PURE__ */ new Map();
+  const getId = createGetId();
+  const add = (loaderFn, loaderOptions) => {
+    const id = getId(loaderOptions.params);
+    let loader = loadersMap.get(id);
+    const cache = loaderOptions._cache;
+    if (!loader || cache === false) {
+      const ignoreNonStatic = skipNonStatic && !loaderOptions.static;
+      const ignoreStatic = skipStatic && loaderOptions.static;
+      const skipExec = ignoreNonStatic || ignoreStatic;
+      loader = createLoader(
+        id,
+        typeof initialDataMap[id] !== "undefined" ? initialDataMap[id] : { data: loaderOptions.initialData },
+        loaderFn,
+        // Todo whether static loader is exec when CSR
+        skipExec
+      );
+      loadersMap.set(id, loader);
+    }
+    return id;
+  };
+  const get = (id) => loadersMap.get(id);
+  const hasPendingLoaders = () => {
+    for (const loader of loadersMap.values()) {
+      const { promise } = loader;
+      if (promise instanceof Promise) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const awaitPendingLoaders = () => __async(void 0, null, function* () {
+    const pendingLoaders = [];
+    for (const [id, loader] of loadersMap) {
+      const { promise } = loader;
+      if (promise instanceof Promise) {
+        pendingLoaders.push([id, loader]);
+      }
+    }
+    yield Promise.all(pendingLoaders.map((item) => item[1].promise));
+    return pendingLoaders.reduce(
+      (res, [id, loader]) => {
+        res[id] = loader.result;
+        return res;
+      },
+      {}
+    );
+  });
+  return {
+    hasPendingLoaders,
+    awaitPendingLoaders,
+    add,
+    get
+  };
+};
+
+// src/core/context/runtime.ts
+var RuntimeReactContext = (0, import_react.createContext)({});
+var ServerRouterContext = (0, import_react.createContext)({});
+
+// src/core/compatible.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var IS_REACT18 = process.env.IS_REACT18 === "true";
+function isClientArgs(id) {
+  return typeof id === "string" || typeof HTMLElement !== "undefined" && id instanceof HTMLElement;
+}
+var getInitialContext = (runner) => ({
+  loaderManager: createLoaderManager({}),
+  runner,
+  isBrowser: true,
+  routeManifest: typeof window !== "undefined" && window[import_constants2.ROUTE_MANIFEST]
+});
+var createApp = ({
+  plugins,
+  runtime: runtime3,
+  props: globalProps
+}) => {
+  const runner = registerPlugin(plugins, { plugins: [] }, runtime3);
+  return (App) => {
+    const WrapperComponent = (props) => {
+      return import_react2.default.createElement(
+        App || import_react2.default.Fragment,
+        App ? __spreadValues({}, props) : null,
+        App ? props.children : import_react2.default.Children.map(
+          props.children,
+          (child) => import_react2.default.isValidElement(child) ? import_react2.default.cloneElement(child, __spreadValues(__spreadValues({}, child.props), props)) : child
+        )
+      );
+    };
+    if (App) {
+      (0, import_hoist_non_react_statics.default)(WrapperComponent, App);
+    }
+    const HOCApp = runner.hoc(
+      { App: WrapperComponent, config: globalProps || {} },
+      {
+        onLast: ({ App: App2 }) => {
+          const WrapComponent = (_a) => {
+            var _b = _a, { context } = _b, props = __objRest(_b, ["context"]);
+            let contextValue = context;
+            if (!(contextValue == null ? void 0 : contextValue.runner)) {
+              contextValue = getInitialContext(runner);
+              runner.init(
+                { context: contextValue },
+                {
+                  onLast: ({ context: context1 }) => {
+                    var _a2;
+                    return (_a2 = App2 == null ? void 0 : App2.init) == null ? void 0 : _a2.call(App2, context1);
+                  }
+                }
+              );
+            }
+            const mergedProps = __spreadValues(__spreadValues({}, props), globalProps);
+            return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RuntimeReactContext.Provider, { value: contextValue, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(App2, __spreadValues({}, mergedProps)) });
+          };
+          return (0, import_hoist_non_react_statics.default)(WrapComponent, App2);
+        }
+      }
+    );
+    return HOCApp;
+  };
+};
+var bootstrap = (BootApp, id, root, ReactDOM) => __async(void 0, null, function* () {
+  var _a, _b, _c, _d, _e, _f;
+  const App = BootApp;
+  const runner = getGlobalRunner();
+  const context = getInitialContext(runner);
+  const runInit = (_context) => runner.init(
+    { context: _context },
+    {
+      onLast: ({ context: context1 }) => {
+        var _a2;
+        return (_a2 = App == null ? void 0 : App.init) == null ? void 0 : _a2.call(App, context1);
+      }
+    }
+  );
+  if (!id) {
+    return import_react2.default.createElement(App, {
+      context
+    });
+  }
+  const isBrowser2 = typeof window !== "undefined" && window.name !== "nodejs";
+  if (isBrowser2) {
+    if (isClientArgs(id)) {
+      const ssrData = window._SSR_DATA;
+      const loadersData = ((_a = ssrData == null ? void 0 : ssrData.data) == null ? void 0 : _a.loadersData) || {};
+      const initialLoadersState = Object.keys(loadersData).reduce(
+        (res, key) => {
+          const loaderData = loadersData[key];
+          if (loaderData.loading !== false) {
+            return res;
+          }
+          res[key] = loaderData;
+          return res;
+        },
+        {}
+      );
+      Object.assign(context, __spreadValues({
+        loaderManager: createLoaderManager(initialLoadersState, {
+          skipStatic: true
+        })
+      }, ssrData ? { ssrContext: ssrData == null ? void 0 : ssrData.context } : {}));
+      context.initialData = (_b = ssrData == null ? void 0 : ssrData.data) == null ? void 0 : _b.initialData;
+      const initialData = yield runInit(context);
+      if (initialData) {
+        context.initialData = initialData;
+      }
+      const rootElement = typeof id !== "string" ? id : document.getElementById(id || "root");
+      if (!ReactDOM) {
+        throw Error("The `bootstrap` need provide `ReactDOM` parameter");
+      }
+      const ModernRender = (App2) => {
+        if (IS_REACT18) {
+          if (root) {
+            root.render(App2);
+          } else if (ReactDOM.createRoot) {
+            ReactDOM.createRoot(rootElement).render(App2);
+          } else {
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `createRoot` method"
+            );
+          }
+        } else {
+          if (!ReactDOM.render) {
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `render` method"
+            );
+          }
+          ReactDOM.render(App2, rootElement);
+        }
+      };
+      const ModernHydrate = (App2, callback) => {
+        if (IS_REACT18) {
+          if (!ReactDOM.hydrateRoot) {
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `hydrateRoot` method"
+            );
+          }
+          ReactDOM.hydrateRoot(rootElement, App2);
+        } else {
+          if (!ReactDOM.hydrate) {
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `hydrate` method"
+            );
+          }
+          ReactDOM.hydrate(App2, rootElement, callback);
+        }
+      };
+      return runner.client(
+        {
+          App,
+          context,
+          ModernRender,
+          ModernHydrate
+        },
+        {
+          onLast: ({ App: App2 }) => {
+            ModernRender(import_react2.default.createElement(App2, { context }));
+          }
+        }
+      );
+    } else {
+      throw Error(
+        "`bootstrap` needs id in browser environment, it needs to be string or element"
+      );
+    }
+  } else {
+    Object.assign(context, {
+      ssrContext: id,
+      isBrowser: false,
+      loaderManager: createLoaderManager(
+        {},
+        {
+          skipNonStatic: id.staticGenerate,
+          // if not static generate, only non-static loader can exec on prod env
+          skipStatic: process.env.NODE_ENV === "production" && !id.staticGenerate
+        }
+      )
+    });
+    const isRedirectResponse = (result) => {
+      var _a2;
+      if (typeof Response !== "undefined" && // fix: ssg workflow doesn't inject Web Response
+      result instanceof Response && result.status >= 300 && result.status <= 399) {
+        const { status } = result;
+        const redirectUrl = result.headers.get("Location") || "/";
+        const { ssrContext } = context;
+        if (ssrContext) {
+          ssrContext.res && (ssrContext.res.statusCode = status);
+          (_a2 = ssrContext.res) == null ? void 0 : _a2.setHeader("Location", redirectUrl);
+          ssrContext.redirection = ssrContext.redirection || {};
+          ssrContext.redirection.status = status;
+          ssrContext.redirection.url = redirectUrl;
+        }
+        return true;
+      }
+      return false;
+    };
+    const initialData = yield runInit(context);
+    if (!isRedirectResponse(initialData)) {
+      context.initialData = initialData;
+      if (((_c = context.routerContext) == null ? void 0 : _c.statusCode) && ((_d = context.routerContext) == null ? void 0 : _d.statusCode) !== 200) {
+        (_f = context.ssrContext) == null ? void 0 : _f.response.status((_e = context.routerContext) == null ? void 0 : _e.statusCode);
+      }
+      return runner.server({
+        App,
+        context
+      });
+    }
+  }
+});
+var useRuntimeContext = () => {
+  const context = (0, import_react2.useContext)(RuntimeReactContext);
+  const memoizedContext = (0, import_react2.useMemo)(
+    () => context.runner.pickContext(
+      { context, pickedContext: {} },
+      {
+        onLast: ({ pickedContext }) => pickedContext
+      }
+    ),
+    [context]
+  );
+  return memoizedContext;
+};
+
+// src/core/loader/useLoader.ts
+var import_react3 = require("react");
+var import_invariant2 = __toESM(require("invariant"));
+var useLoader = (loaderFn, options = { params: void 0 }) => {
+  const context = (0, import_react3.useContext)(RuntimeReactContext);
+  const isSSRRender = Boolean(context.ssr);
+  const { loaderManager } = context;
+  const loaderRef = (0, import_react3.useRef)();
+  const unlistenLoaderChangeRef = (0, import_react3.useRef)(null);
+  if (isSSRRender && Object.prototype.hasOwnProperty.call(options, "_cache")) {
+    delete options._cache;
+  }
+  const load = (0, import_react3.useCallback)(
+    (params) => {
+      var _a, _b, _c, _d, _e, _f;
+      if (typeof params === "undefined") {
+        return (_a = loaderRef.current) == null ? void 0 : _a.load();
+      }
+      const id = loaderManager.add(
+        () => {
+          try {
+            const res2 = loaderFn(context, params);
+            if (res2 instanceof Promise) {
+              return res2;
+            }
+            return Promise.resolve(res2);
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        },
+        __spreadProps(__spreadValues({}, options), {
+          params
+        })
+      );
+      loaderRef.current = loaderManager.get(id);
+      (_b = unlistenLoaderChangeRef.current) == null ? void 0 : _b.call(unlistenLoaderChangeRef);
+      if (isSSRRender) {
+        return void 0;
+      }
+      if (options.skip) {
+        return void 0;
+      }
+      if (context._hydration && ((_e = (_d = (_c = window == null ? void 0 : window._SSR_DATA) == null ? void 0 : _c.data) == null ? void 0 : _d.loadersData[id]) == null ? void 0 : _e.error) === null) {
+        return void 0;
+      }
+      const res = loaderRef.current.load();
+      unlistenLoaderChangeRef.current = (_f = loaderRef.current) == null ? void 0 : _f.onChange(
+        (_status, _result) => {
+          var _a2, _b2;
+          setResult(_result);
+          if (_status === 2 /* fulfilled */) {
+            (_a2 = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a2.call(options, _result.data);
+          }
+          if (_status === 3 /* rejected */) {
+            (_b2 = options == null ? void 0 : options.onError) == null ? void 0 : _b2.call(options, _result.error);
+          }
+        }
+      );
+      return res;
+    },
+    [options.skip]
+  );
+  (0, import_react3.useEffect)(
+    () => () => {
+      var _a;
+      (_a = unlistenLoaderChangeRef.current) == null ? void 0 : _a.call(unlistenLoaderChangeRef);
+    },
+    []
+  );
+  (0, import_react3.useMemo)(() => {
+    var _a;
+    const p = (_a = options.params) != null ? _a : loaderFn.id;
+    (0, import_invariant2.default)(
+      typeof p !== "undefined" && p !== null,
+      "Params is required in useLoader"
+    );
+    load(p);
+  }, [options.params]);
+  const [result, setResult] = (0, import_react3.useState)(loaderRef.current.result);
+  return __spreadProps(__spreadValues({}, result), {
+    reload: load
+  });
+};
+var useLoader_default = useLoader;
+
+// src/core/index.ts
+__reExport(core_exports, require("@modern-js/plugin"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RuntimeReactContext,
+  bootstrap,
+  createApp,
+  defineConfig,
+  defineRuntimeConfig,
+  isBrowser,
+  useLoader,
+  useRuntimeContext
+});

package/dist/types/core/compatible.d.ts

@@ -11,7 +11,7 @@ export type CreateAppOptions = {
     runtime?: typeof runtime;
     props?: any;
 };
-export declare const createApp: ({ plugins, runtime, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => ({ _internal_context, ...props }: any) => JSX.Element;
+export declare const createApp: ({ plugins, runtime, props: globalProps, }: CreateAppOptions) => (App?: React.ComponentType<any>) => (props: any) => JSX.Element;
 type BootStrap<T = unknown> = (App: React.ComponentType, id: string | HTMLElement | RuntimeContext, root?: any, ReactDOM?: {
     render?: Renderer;
     hydrate?: Renderer;

package/dist/types/core/react/index.d.ts

@@ -1,2 +1,2 @@
 import React from 'react';
-export declare function createRoot(UserApp?: React.ComponentType | null): ({ _internal_context, ...props }: any) => JSX.Element;
+export declare function createRoot(UserApp?: React.ComponentType | null): React.ComponentType<any>;

package/dist/types/core/react/wrapper.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { RuntimeContext } from '../context';
+export declare function wrapRuntimeContextProvider(App: React.ReactElement, contextValue: RuntimeContext): React.FunctionComponentElement<React.ProviderProps<RuntimeContext>>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.57.1",
+  "version": "2.57.2-alpha.0",
   "engines": {
     "node": ">=14.17.6"
   },
@@ -200,9 +200,9 @@
     "styled-components": "^5.3.1",
     "@swc/helpers": "0.5.3",
     "@modern-js/plugin": "2.57.1",
+    "@modern-js/utils": "2.57.1",
     "@modern-js/types": "2.57.1",
     "@modern-js/plugin-data-loader": "2.57.1",
-    "@modern-js/utils": "2.57.1",
     "@modern-js/runtime-utils": "2.57.1"
   },
   "peerDependencies": {
@@ -210,7 +210,7 @@
     "react-dom": ">=17"
   },
   "devDependencies": {
-    "@rsbuild/core": "1.0.1-beta.3",
+    "@rsbuild/core": "1.0.1-beta.9",
     "@types/cookie": "0.5.1",
     "@remix-run/web-fetch": "^4.1.3",
     "@testing-library/react": "^13.4.0",
@@ -227,9 +227,9 @@
     "typescript": "^5",
     "webpack": "^5.93.0",
     "@modern-js/app-tools": "2.57.1",
+    "@modern-js/core": "2.57.1",
     "@scripts/build": "2.57.1",
-    "@scripts/jest-config": "2.57.1",
-    "@modern-js/core": "2.57.1"
+    "@scripts/jest-config": "2.57.1"
   },
   "sideEffects": false,
   "publishConfig": {