@modern-js/runtime 2.15.0 → 2.15.1-alpha.1

package/dist/cjs/router/runtime/index.js

@@ -18,74 +18,79 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var runtime_exports = {};
 __export(runtime_exports, {
-  Await: () => import_react_router_dom.Await,
-  BrowserRouter: () => import_react_router_dom.BrowserRouter,
-  Form: () => import_react_router_dom.Form,
-  HashRouter: () => import_react_router_dom.HashRouter,
+  Await: () => import_react_router_dom2.Await,
+  BrowserRouter: () => import_react_router_dom2.BrowserRouter,
+  Form: () => import_react_router_dom2.Form,
+  HashRouter: () => import_react_router_dom2.HashRouter,
   Link: () => import_PrefetchLink.Link,
-  MemoryRouter: () => import_react_router_dom.MemoryRouter,
+  MemoryRouter: () => import_react_router_dom2.MemoryRouter,
   NavLink: () => import_PrefetchLink.NavLink,
-  Navigate: () => import_react_router_dom.Navigate,
-  Outlet: () => import_react_router_dom.Outlet,
-  Route: () => import_react_router_dom.Route,
-  Router: () => import_react_router_dom.Router,
-  RouterProvider: () => import_react_router_dom.RouterProvider,
-  Routes: () => import_react_router_dom.Routes,
-  ScrollRestoration: () => import_react_router_dom.ScrollRestoration,
-  createBrowserRouter: () => import_react_router_dom.createBrowserRouter,
-  createHashRouter: () => import_react_router_dom.createHashRouter,
-  createMemoryRouter: () => import_react_router_dom.createMemoryRouter,
-  createPath: () => import_react_router_dom.createPath,
-  createRoutesFromChildren: () => import_react_router_dom.createRoutesFromChildren,
-  createRoutesFromElements: () => import_react_router_dom.createRoutesFromElements,
-  createSearchParams: () => import_react_router_dom.createSearchParams,
+  Navigate: () => import_react_router_dom2.Navigate,
+  Outlet: () => import_react_router_dom2.Outlet,
+  Route: () => import_react_router_dom2.Route,
+  Router: () => import_react_router_dom2.Router,
+  RouterProvider: () => import_react_router_dom2.RouterProvider,
+  Routes: () => import_react_router_dom2.Routes,
+  ScrollRestoration: () => import_react_router_dom2.ScrollRestoration,
+  createBrowserRouter: () => import_react_router_dom2.createBrowserRouter,
+  createHashRouter: () => import_react_router_dom2.createHashRouter,
+  createMemoryRouter: () => import_react_router_dom2.createMemoryRouter,
+  createPath: () => import_react_router_dom2.createPath,
+  createRoutesFromChildren: () => import_react_router_dom2.createRoutesFromChildren,
+  createRoutesFromElements: () => import_react_router_dom2.createRoutesFromElements,
+  createSearchParams: () => import_react_router_dom2.createSearchParams,
   default: () => runtime_default,
   defer: () => import_remix_router.defer,
-  generatePath: () => import_react_router_dom.generatePath,
-  isRouteErrorResponse: () => import_react_router_dom.isRouteErrorResponse,
+  generatePath: () => import_react_router_dom2.generatePath,
+  isRouteErrorResponse: () => import_react_router_dom2.isRouteErrorResponse,
   json: () => import_remix_router.json,
-  matchPath: () => import_react_router_dom.matchPath,
-  matchRoutes: () => import_react_router_dom.matchRoutes,
+  matchPath: () => import_react_router_dom2.matchPath,
+  matchRoutes: () => import_react_router_dom2.matchRoutes,
   modifyRoutes: () => import_plugin2.modifyRoutes,
   redirect: () => import_remix_router.redirect,
-  renderMatches: () => import_react_router_dom.renderMatches,
-  resolvePath: () => import_react_router_dom.resolvePath,
-  useActionData: () => import_react_router_dom.useActionData,
-  useAsyncError: () => import_react_router_dom.useAsyncError,
-  useAsyncValue: () => import_react_router_dom.useAsyncValue,
-  useBeforeUnload: () => import_react_router_dom.useBeforeUnload,
-  useFetcher: () => import_react_router_dom.useFetcher,
-  useFetchers: () => import_react_router_dom.useFetchers,
-  useFormAction: () => import_react_router_dom.useFormAction,
-  useHref: () => import_react_router_dom.useHref,
-  useInRouterContext: () => import_react_router_dom.useInRouterContext,
-  useLinkClickHandler: () => import_react_router_dom.useLinkClickHandler,
-  useLoaderData: () => import_react_router_dom.useLoaderData,
-  useLocation: () => import_react_router_dom.useLocation,
-  useMatch: () => import_react_router_dom.useMatch,
-  useMatches: () => import_react_router_dom.useMatches,
-  useNavigate: () => import_react_router_dom.useNavigate,
-  useNavigation: () => import_react_router_dom.useNavigation,
-  useNavigationType: () => import_react_router_dom.useNavigationType,
-  useOutlet: () => import_react_router_dom.useOutlet,
-  useOutletContext: () => import_react_router_dom.useOutletContext,
-  useParams: () => import_react_router_dom.useParams,
-  useResolvedPath: () => import_react_router_dom.useResolvedPath,
-  useRevalidator: () => import_react_router_dom.useRevalidator,
-  useRouteError: () => import_react_router_dom.useRouteError,
-  useRouteLoaderData: () => import_react_router_dom.useRouteLoaderData,
-  useRoutes: () => import_react_router_dom.useRoutes,
-  useSearchParams: () => import_react_router_dom.useSearchParams,
-  useSubmit: () => import_react_router_dom.useSubmit
+  renderMatches: () => import_react_router_dom2.renderMatches,
+  resolvePath: () => import_react_router_dom2.resolvePath,
+  useActionData: () => import_react_router_dom2.useActionData,
+  useAsyncError: () => import_react_router_dom2.useAsyncError,
+  useAsyncValue: () => import_react_router_dom2.useAsyncValue,
+  useBeforeUnload: () => import_react_router_dom2.useBeforeUnload,
+  useFetcher: () => import_react_router_dom2.useFetcher,
+  useFetchers: () => import_react_router_dom2.useFetchers,
+  useFormAction: () => import_react_router_dom2.useFormAction,
+  useHref: () => import_react_router_dom2.useHref,
+  useInRouterContext: () => import_react_router_dom2.useInRouterContext,
+  useLinkClickHandler: () => import_react_router_dom2.useLinkClickHandler,
+  useLoaderData: () => import_react_router_dom2.useLoaderData,
+  useLocation: () => import_react_router_dom2.useLocation,
+  useMatch: () => import_react_router_dom2.useMatch,
+  useMatches: () => import_react_router_dom2.useMatches,
+  useNavigate: () => import_react_router_dom2.useNavigate,
+  useNavigation: () => import_react_router_dom2.useNavigation,
+  useNavigationType: () => import_react_router_dom2.useNavigationType,
+  useOutlet: () => import_react_router_dom2.useOutlet,
+  useOutletContext: () => import_react_router_dom2.useOutletContext,
+  useParams: () => import_react_router_dom2.useParams,
+  useResolvedPath: () => import_react_router_dom2.useResolvedPath,
+  useRevalidator: () => import_react_router_dom2.useRevalidator,
+  useRouteError: () => import_react_router_dom2.useRouteError,
+  useRouteLoaderData: () => useRouteLoaderData,
+  useRoutes: () => import_react_router_dom2.useRoutes,
+  useSearchParams: () => import_react_router_dom2.useSearchParams,
+  useSubmit: () => import_react_router_dom2.useSubmit
 });
 module.exports = __toCommonJS(runtime_exports);
+var import_react_router_dom = require("react-router-dom");
 var import_plugin = require("./plugin");
 var import_plugin2 = require("./plugin");
 __reExport(runtime_exports, require("./withRouter"), module.exports);
 var import_PrefetchLink = require("./PrefetchLink");
-var import_react_router_dom = require("react-router-dom");
+var import_react_router_dom2 = require("react-router-dom");
 var import_remix_router = require("@modern-js/utils/universal/remix-router");
 var runtime_default = import_plugin.routerPlugin;
+const useRouteLoaderData = (routeId) => {
+  const realRouteId = encodeURI(routeId);
+  return (0, import_react_router_dom.useRouteLoaderData)(realRouteId);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Await,

package/dist/esm/router/runtime/index.js

@@ -1,8 +1,13 @@
+import { useRouteLoaderData as useRouteData } from "react-router-dom";
 import { routerPlugin } from "./plugin";
 var runtime_default = routerPlugin;
 import { modifyRoutes } from "./plugin";
 export * from "./withRouter";
 import { Link, NavLink } from "./PrefetchLink";
-import { createBrowserRouter, createHashRouter, createMemoryRouter, RouterProvider, BrowserRouter, HashRouter, MemoryRouter, Router, Await, Form, Navigate, Outlet, Route, Routes, ScrollRestoration, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, createRoutesFromChildren, createRoutesFromElements, createSearchParams, generatePath, isRouteErrorResponse, matchPath, matchRoutes, renderMatches, resolvePath, createPath } from "react-router-dom";
+var useRouteLoaderData = function(routeId) {
+    var realRouteId = encodeURI(routeId);
+    return useRouteData(realRouteId);
+};
+import { createBrowserRouter, createHashRouter, createMemoryRouter, RouterProvider, BrowserRouter, HashRouter, MemoryRouter, Router, Await, Form, Navigate, Outlet, Route, Routes, ScrollRestoration, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRoutes, useSearchParams, useSubmit, createRoutesFromChildren, createRoutesFromElements, createSearchParams, generatePath, isRouteErrorResponse, matchPath, matchRoutes, renderMatches, resolvePath, createPath } from "react-router-dom";
 import { defer, json, redirect } from "@modern-js/utils/universal/remix-router";
 export { Await, BrowserRouter, Form, HashRouter, Link, MemoryRouter, NavLink, Navigate, Outlet, Route, Router, RouterProvider, Routes, ScrollRestoration, createBrowserRouter, createHashRouter, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, createSearchParams, runtime_default as default, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, modifyRoutes, redirect, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit };

package/dist/esm-node/router/runtime/index.js

@@ -1,8 +1,13 @@
+import { useRouteLoaderData as useRouteData } from "react-router-dom";
 import { routerPlugin } from "./plugin";
 var runtime_default = routerPlugin;
 import { modifyRoutes } from "./plugin";
 export * from "./withRouter";
 import { Link, NavLink } from "./PrefetchLink";
+const useRouteLoaderData = (routeId) => {
+  const realRouteId = encodeURI(routeId);
+  return useRouteData(realRouteId);
+};
 import {
   createBrowserRouter,
   createHashRouter,
@@ -42,7 +47,6 @@ import {
   useResolvedPath,
   useRevalidator,
   useRouteError,
-  useRouteLoaderData,
   useRoutes,
   useSearchParams,
   useSubmit,

package/dist/js/modern/cli/index.js

@@ -0,0 +1,72 @@
+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());
+  });
+};
+import path from "path";
+import { PLUGIN_SCHEMAS, cleanRequireCache, isReact18 } from "@modern-js/utils";
+import PluginState from "../state/cli";
+import PluginSSR from "../ssr/cli";
+import PluginRouter from "../router/cli";
+import Document from "../document/cli";
+var cli_default = () => ({
+  name: "@modern-js/runtime",
+  post: [
+    "@modern-js/plugin-router",
+    "@modern-js/plugin-ssr",
+    "@modern-js/plugin-document",
+    "@modern-js/plugin-state",
+    "@modern-js/plugin-design-token"
+  ],
+  usePlugins: [PluginState(), PluginSSR(), PluginRouter(), Document()],
+  setup: (api) => {
+    return {
+      config() {
+        const dir = api.useAppContext().internalDirectory || "";
+        process.env.IS_REACT18 = isReact18(path.join(dir, "../../")).toString();
+        return {
+          runtime: {},
+          runtimeByEntries: {},
+          source: {
+            alias: {
+              "styled-components": require.resolve("styled-components")
+            },
+            globalVars: {
+              "process.env.IS_REACT18": process.env.IS_REACT18
+            }
+          }
+        };
+      },
+      validateSchema() {
+        return PLUGIN_SCHEMAS["@modern-js/runtime"];
+      },
+      beforeRestart() {
+        return __async(this, null, function* () {
+          cleanRequireCache([
+            require.resolve("../state/cli"),
+            require.resolve("../router/cli"),
+            require.resolve("../ssr/cli")
+          ]);
+        });
+      }
+    };
+  }
+});
+export {
+  cli_default as default
+};

package/dist/js/modern/common.js

@@ -0,0 +1,4 @@
+const isBrowser = () => typeof window !== "undefined" && window.name !== "nodejs";
+export {
+  isBrowser
+};

package/dist/js/modern/core/app-config.js

@@ -0,0 +1,10 @@
+const APP_CONFIG_SYMBOL = "config";
+const getConfig = (Component) => Component[APP_CONFIG_SYMBOL];
+const defineConfig = (Component, config) => {
+  Component[APP_CONFIG_SYMBOL] = config;
+  return Component;
+};
+export {
+  defineConfig,
+  getConfig
+};

package/dist/js/modern/core/compatible.js

@@ -0,0 +1,285 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 __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 __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());
+  });
+};
+import { jsx } from "react/jsx-runtime";
+import React, { useContext, useMemo } from "react";
+import hoistNonReactStatics from "hoist-non-react-statics";
+import { ROUTE_MANIFEST } from "@modern-js/utils/constants";
+import {
+  RuntimeReactContext
+} from "../runtime-context";
+import { runtime } from "./plugin";
+import { createLoaderManager } from "./loader/loaderManager";
+const IS_REACT18 = process.env.IS_REACT18 === "true";
+function isClientArgs(id) {
+  return typeof id === "string" || typeof HTMLElement !== "undefined" && id instanceof HTMLElement;
+}
+const runnerMap = /* @__PURE__ */ new WeakMap();
+const getInitialContext = (runner) => ({
+  loaderManager: createLoaderManager({}),
+  runner,
+  isBrowser: true,
+  routeManifest: typeof window !== "undefined" && window[ROUTE_MANIFEST]
+});
+const createApp = ({ plugins }) => {
+  const appRuntime = runtime.clone();
+  appRuntime.usePlugin(...plugins);
+  return (App) => {
+    const runner = appRuntime.init();
+    const WrapperComponent = (props) => {
+      const element = React.createElement(
+        App || React.Fragment,
+        __spreadValues({}, props),
+        props.children
+      );
+      const context = useContext(RuntimeReactContext);
+      return runner.provide(
+        { element, props: __spreadValues({}, props), context },
+        {
+          onLast: ({ element: element2 }) => element2
+        }
+      );
+    };
+    if (App) {
+      hoistNonReactStatics(WrapperComponent, App);
+    }
+    const HOCApp = runner.hoc(
+      { App: WrapperComponent },
+      {
+        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);
+                  }
+                }
+              );
+            }
+            return /* @__PURE__ */ jsx(RuntimeReactContext.Provider, {
+              value: contextValue,
+              children: /* @__PURE__ */ jsx(App2, __spreadValues({}, props))
+            });
+          };
+          return hoistNonReactStatics(WrapComponent, App2);
+        }
+      }
+    );
+    runnerMap.set(HOCApp, runner);
+    return HOCApp;
+  };
+};
+const bootstrap = (BootApp, id, root, ReactDOM) => __async(void 0, null, function* () {
+  var _a, _b;
+  let App = BootApp;
+  let runner = runnerMap.get(App);
+  if (!runner) {
+    App = createApp({ plugins: [] })(App);
+    runner = runnerMap.get(App);
+  }
+  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 React.createElement(App, {
+      context
+    });
+  }
+  const isBrowser = typeof window !== "undefined" && window.name !== "nodejs";
+  if (isBrowser) {
+    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(React.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,
+          skipStatic: process.env.NODE_ENV === "production" && !id.staticGenerate
+        }
+      )
+    });
+    const isRedirectResponse = (result) => {
+      if (typeof Response !== "undefined" && 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.statusCode = status;
+          ssrContext.res.setHeader("Location", redirectUrl);
+          ssrContext.redirection.status = status;
+          ssrContext.redirection.url = redirectUrl;
+        }
+        return true;
+      }
+      return false;
+    };
+    const initialData = yield runInit(context);
+    if (!isRedirectResponse(initialData)) {
+      context.initialData = initialData;
+      return runner.server({
+        App,
+        context
+      });
+    }
+  }
+});
+const useRuntimeContext = () => {
+  const context = useContext(RuntimeReactContext);
+  const memoizedContext = useMemo(
+    () => context.runner.pickContext(
+      { context, pickedContext: {} },
+      {
+        onLast: ({ pickedContext }) => pickedContext
+      }
+    ),
+    [context]
+  );
+  return memoizedContext;
+};
+export {
+  bootstrap,
+  createApp,
+  useRuntimeContext
+};

package/dist/js/modern/core/index.js

@@ -0,0 +1,16 @@
+import { createPlugin, createRuntime, runtime, registerInit } from "./plugin";
+import { defineConfig, getConfig } from "./app-config";
+export * from "./compatible";
+import { RuntimeReactContext, ServerRouterContext } from "../runtime-context";
+export * from "./loader";
+export * from "@modern-js/plugin";
+export {
+  RuntimeReactContext,
+  ServerRouterContext,
+  createPlugin,
+  createRuntime,
+  defineConfig,
+  getConfig,
+  registerInit,
+  runtime
+};

package/dist/js/modern/core/loader/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./useLoader";
+export {
+  default2 as useLoader
+};