@modern-js/runtime 2.52.0 → 2.54.0

package/dist/esm/router/cli/entry.js

@@ -0,0 +1,57 @@
+import path from "path";
+import { JS_EXTENSIONS, findExists, fs, isRouterV5 } from "@modern-js/utils";
+import { FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT, NESTED_ROUTES_DIR, PAGES_DIR_NAME } from "./constants";
+var hasPages = function(dir) {
+  return fs.existsSync(path.join(dir, PAGES_DIR_NAME));
+};
+var hasNestedRoutes = function(dir) {
+  return fs.existsSync(path.join(dir, NESTED_ROUTES_DIR));
+};
+var isRouteEntry = function(dir) {
+  if (hasNestedRoutes(dir)) {
+    return path.join(dir, NESTED_ROUTES_DIR);
+  }
+  if (hasPages(dir)) {
+    return path.join(dir, PAGES_DIR_NAME);
+  }
+  return false;
+};
+var modifyEntrypoints = function(entrypoints) {
+  var config = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  return entrypoints.map(function(entrypoint) {
+    if (!entrypoint.isAutoMount) {
+      return entrypoint;
+    }
+    var isHasNestedRoutes = hasNestedRoutes(entrypoint.absoluteEntryDir);
+    var isHasPages = hasPages(entrypoint.absoluteEntryDir);
+    if (!isHasNestedRoutes && !isHasPages) {
+      return entrypoint;
+    }
+    if (entrypoint.fileSystemRoutes && !isRouterV5(config)) {
+      entrypoint.nestedRoutesEntry = entrypoint.entry;
+    } else if (!entrypoint.fileSystemRoutes) {
+      entrypoint.fileSystemRoutes = {
+        globalApp: findExists(JS_EXTENSIONS.map(function(ext) {
+          return path.resolve(entrypoint.absoluteEntryDir, "./".concat(PAGES_DIR_NAME, "/").concat(FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT).concat(ext));
+        }))
+      };
+      if (isHasPages) {
+        entrypoint.entry = path.join(entrypoint.absoluteEntryDir, PAGES_DIR_NAME);
+        entrypoint.pageRoutesEntry = entrypoint.entry;
+      }
+      if (isHasNestedRoutes) {
+        entrypoint.entry = path.join(entrypoint.absoluteEntryDir, NESTED_ROUTES_DIR);
+        entrypoint.nestedRoutesEntry = entrypoint.entry;
+      }
+    } else {
+      throw Error("Custom entries with conventional routing not support use react router v5!");
+    }
+    return entrypoint;
+  });
+};
+export {
+  hasNestedRoutes,
+  hasPages,
+  isRouteEntry,
+  modifyEntrypoints
+};

package/dist/esm/router/cli/handler.js

@@ -0,0 +1,103 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "path";
+import { cloneDeep } from "@modern-js/utils/lodash";
+import { modifyEntrypoints } from "./entry";
+import { isPageComponentFile } from "./code/utils";
+var originEntrypoints = [];
+function handleModifyEntrypoints(api, entrypoints) {
+  return _handleModifyEntrypoints.apply(this, arguments);
+}
+function _handleModifyEntrypoints() {
+  _handleModifyEntrypoints = _async_to_generator(function(api, entrypoints) {
+    var config, newEntryPoints, appContext, resolvedConfig, generateCode;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          config = api.useResolvedConfigContext();
+          newEntryPoints = modifyEntrypoints(entrypoints, config);
+          appContext = api.useAppContext();
+          resolvedConfig = api.useResolvedConfigContext();
+          appContext.entrypoints = newEntryPoints;
+          originEntrypoints = cloneDeep(newEntryPoints);
+          return [
+            4,
+            import("./code")
+          ];
+        case 1:
+          generateCode = _state.sent().generateCode;
+          return [
+            4,
+            generateCode(appContext, resolvedConfig, entrypoints, api)
+          ];
+        case 2:
+          _state.sent();
+          return [
+            2,
+            newEntryPoints
+          ];
+      }
+    });
+  });
+  return _handleModifyEntrypoints.apply(this, arguments);
+}
+function handleFileChange(api, e) {
+  return _handleFileChange.apply(this, arguments);
+}
+function _handleFileChange() {
+  _handleFileChange = _async_to_generator(function(api, e) {
+    var appContext, appDirectory, entrypoints, filename, eventType, nestedRouteEntries, pagesDir, isPageFile, absoluteFilePath, isRouteComponent, resolvedConfig, generateCode, entrypoints1;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appContext = api.useAppContext();
+          appDirectory = appContext.appDirectory, entrypoints = appContext.entrypoints;
+          filename = e.filename, eventType = e.eventType;
+          nestedRouteEntries = entrypoints.map(function(point) {
+            return point.nestedRoutesEntry;
+          }).filter(Boolean);
+          pagesDir = entrypoints.map(function(point) {
+            return point.entry;
+          }).filter(function(entry) {
+            return entry && !path.extname(entry);
+          }).concat(nestedRouteEntries);
+          isPageFile = function(name) {
+            return pagesDir.some(function(pageDir) {
+              return name.includes(pageDir);
+            });
+          };
+          absoluteFilePath = path.resolve(appDirectory, filename);
+          isRouteComponent = isPageFile(absoluteFilePath) && isPageComponentFile(absoluteFilePath);
+          if (!(isRouteComponent && (eventType === "add" || eventType === "unlink")))
+            return [
+              3,
+              3
+            ];
+          resolvedConfig = api.useResolvedConfigContext();
+          return [
+            4,
+            import("./code")
+          ];
+        case 1:
+          generateCode = _state.sent().generateCode;
+          entrypoints1 = cloneDeep(originEntrypoints);
+          return [
+            4,
+            generateCode(appContext, resolvedConfig, entrypoints1, api)
+          ];
+        case 2:
+          _state.sent();
+          _state.label = 3;
+        case 3:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return _handleFileChange.apply(this, arguments);
+}
+export {
+  handleFileChange,
+  handleModifyEntrypoints
+};

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

@@ -1,6 +1,12 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { getEntryOptions, createRuntimeExportsUtils, isRouterV5 as isV5 } from "@modern-js/utils";
+import { isRouteEntry } from "./entry";
+import { handleFileChange, handleModifyEntrypoints } from "./handler";
+import { isRouteEntry as isRouteEntry2 } from "./entry";
+import { handleFileChange as handleFileChange2, handleModifyEntrypoints as handleModifyEntrypoints2 } from "./handler";
 var PLUGIN_IDENTIFIER = "router";
 var ROUTES_IDENTIFIER = "routes";
 var routerPlugin = function() {
@@ -13,6 +19,13 @@ var routerPlugin = function() {
       var runtimeConfigMap = /* @__PURE__ */ new Map();
       var pluginsExportsUtils;
       return {
+        checkEntryPoint: function checkEntryPoint(param) {
+          var path = param.path, entry = param.entry;
+          return {
+            path,
+            entry: entry || isRouteEntry(path)
+          };
+        },
         config: function config() {
           var appContext = api.useAppContext();
           pluginsExportsUtils = createRuntimeExportsUtils(appContext.internalDirectory, "plugins");
@@ -32,6 +45,29 @@ var routerPlugin = function() {
             }
           };
         },
+        modifyEntrypoints: function modifyEntrypoints(param) {
+          var entrypoints = param.entrypoints;
+          return _async_to_generator(function() {
+            var newEntryPoints;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  return [
+                    4,
+                    handleModifyEntrypoints(api, entrypoints)
+                  ];
+                case 1:
+                  newEntryPoints = _state.sent();
+                  return [
+                    2,
+                    {
+                      entrypoints: newEntryPoints
+                    }
+                  ];
+              }
+            });
+          })();
+        },
         modifyEntryImports: function modifyEntryImports(param) {
           var entrypoint = param.entrypoint, imports = param.imports;
           var entryName = entrypoint.entryName, isMainEntry = entrypoint.isMainEntry, fileSystemRoutes = entrypoint.fileSystemRoutes;
@@ -91,6 +127,24 @@ var routerPlugin = function() {
           if (!isV5(userConfig)) {
             pluginsExportsUtils.addExport("export { default as router } from '@modern-js/runtime/router'");
           }
+        },
+        fileChange: function fileChange(e) {
+          return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  return [
+                    4,
+                    handleFileChange(api, e)
+                  ];
+                case 1:
+                  _state.sent();
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
         }
       };
     }
@@ -99,5 +153,8 @@ var routerPlugin = function() {
 var cli_default = routerPlugin;
 export {
   cli_default as default,
+  handleFileChange2 as handleFileChange,
+  handleModifyEntrypoints2 as handleModifyEntrypoints,
+  isRouteEntry2 as isRouteEntry,
   routerPlugin
 };

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

@@ -56,10 +56,11 @@ var routerPlugin = function(param) {
           });
         },
         hoc: function(param2, next) {
-          var App = param2.App;
+          var App = param2.App, config = param2.config;
           if (!finalRouteConfig && !createRoutes) {
             return next({
-              App
+              App,
+              config
             });
           }
           var getRouteApp = function() {
@@ -134,11 +135,13 @@ var routerPlugin = function(param) {
           }
           if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
             return next({
-              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp)
+              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp),
+              config
             });
           }
           return next({
-            App: RouteApp
+            App: RouteApp,
+            config
           });
         },
         pickContext: function(param2, next) {

package/dist/esm/router/runtime/plugin.node.js

@@ -90,7 +90,7 @@ var routerPlugin = function(param) {
         init: function init(param2, next) {
           var context = param2.context;
           return _async_to_generator(function() {
-            var _context_ssrContext, _context_ssrContext1, request, ssrMode, nonce, baseUrl, _basename, _context_ssrContext2, reporter, serverTiming, requestContext, routes, runner, query, remixRequest, end, routerContext, cost, router;
+            var _context_ssrContext, _context_ssrContext1, request, ssrMode, nonce, _context_ssrContext_loaderFailureMode, loaderFailureMode, baseUrl, _basename, _context_ssrContext2, reporter, serverTiming, requestContext, routes, runner, query, remixRequest, end, routerContext, cost, router;
             return _ts_generator(this, function(_state) {
               switch (_state.label) {
                 case 0:
@@ -102,7 +102,7 @@ var routerPlugin = function(param) {
                       })
                     ];
                   }
-                  _context_ssrContext1 = context.ssrContext, request = _context_ssrContext1.request, ssrMode = _context_ssrContext1.mode, nonce = _context_ssrContext1.nonce;
+                  _context_ssrContext1 = context.ssrContext, request = _context_ssrContext1.request, ssrMode = _context_ssrContext1.mode, nonce = _context_ssrContext1.nonce, _context_ssrContext_loaderFailureMode = _context_ssrContext1.loaderFailureMode, loaderFailureMode = _context_ssrContext_loaderFailureMode === void 0 ? "errorBoundary" : _context_ssrContext_loaderFailureMode;
                   baseUrl = originalBaseUrl || request.baseUrl;
                   _basename = baseUrl === "/" ? urlJoin(baseUrl, basename) : baseUrl;
                   _context_ssrContext2 = context.ssrContext, reporter = _context_ssrContext2.reporter, serverTiming = _context_ssrContext2.serverTiming;
@@ -140,6 +140,10 @@ var routerPlugin = function(param) {
                       routerContext
                     ];
                   }
+                  if (routerContext.statusCode >= 500 && routerContext.statusCode < 600 && loaderFailureMode === "clientRender") {
+                    routerContext.statusCode = 200;
+                    throw routerContext.errors[0];
+                  }
                   router = createStaticRouter(routes, routerContext);
                   context.remixRouter = router;
                   context.routerContext = routerContext;
@@ -156,10 +160,11 @@ var routerPlugin = function(param) {
           })();
         },
         hoc: function(param2, next) {
-          var App = param2.App;
+          var App = param2.App, config = param2.config;
           if (!routesConfig) {
             return next({
-              App
+              App,
+              config
             });
           }
           var getRouteApp = function() {
@@ -185,11 +190,13 @@ var routerPlugin = function(param) {
           var RouteApp = getRouteApp();
           if (routesConfig === null || routesConfig === void 0 ? void 0 : routesConfig.globalApp) {
             return next({
-              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp)
+              App: hoistNonReactStatics(RouteApp, routesConfig.globalApp),
+              config
             });
           }
           return next({
-            App: RouteApp
+            App: RouteApp,
+            config
           });
         },
         pickContext: function(param2, next) {

package/dist/esm/ssr/index.node.js

@@ -45,6 +45,7 @@ var ssr = function() {
           context.ssrContext.request = formatServer(request);
           context.ssrContext.mode = config.mode;
           context.ssrContext.tracker = createSSRTracker(context.ssrContext);
+          context.ssrContext.loaderFailureMode = config.loaderFailureMode;
           if (!context.ssrContext.htmlModifiers) {
             context.ssrContext.htmlModifiers = [];
           }

package/dist/esm/state/runtime/plugin.js

@@ -61,7 +61,7 @@ var state = function(config) {
       var storeConfig = getStoreConfig(config);
       return {
         hoc: function hoc(param, next) {
-          var App = param.App;
+          var App = param.App, _$config = param.config;
           var getStateApp = function(props) {
             var context = useContext(RuntimeReactContext);
             return /* @__PURE__ */ _jsx(Provider, {
@@ -71,7 +71,8 @@ var state = function(config) {
             });
           };
           return next({
-            App: hoistNonReactStatics(getStateApp, App)
+            App: hoistNonReactStatics(getStateApp, App),
+            config: _$config
           });
         },
         init: function init(param, next) {

package/dist/esm-node/cli/constants.js

@@ -0,0 +1,4 @@
+const APP_FILE_NAME = "App";
+export {
+  APP_FILE_NAME
+};

package/dist/esm-node/cli/entry.js

@@ -0,0 +1,8 @@
+import path from "path";
+import { JS_EXTENSIONS, findExists } from "@modern-js/utils";
+import { APP_FILE_NAME } from "./constants";
+const hasApp = (dir) => findExists(JS_EXTENSIONS.map((ext) => path.resolve(dir, `${APP_FILE_NAME}${ext}`)));
+const isRuntimeEntry = (dir) => hasApp(dir);
+export {
+  isRuntimeEntry
+};

package/dist/esm-node/cli/index.js

@@ -3,6 +3,8 @@ import { statePlugin } from "../state/cli";
 import { ssrPlugin } from "../ssr/cli";
 import { routerPlugin } from "../router/cli";
 import { documentPlugin } from "../document/cli";
+import { isRuntimeEntry } from "./entry";
+import { isRuntimeEntry as isRuntimeEntry2 } from "./entry";
 const runtimePlugin = () => ({
   name: "@modern-js/runtime",
   post: [
@@ -21,6 +23,12 @@ const runtimePlugin = () => ({
   ],
   setup: (api) => {
     return {
+      checkEntryPoint({ path, entry }) {
+        return {
+          path,
+          entry: entry || isRuntimeEntry(path)
+        };
+      },
       config() {
         const appDir = api.useAppContext().appDirectory;
         process.env.IS_REACT18 = isReact18(appDir).toString();
@@ -63,5 +71,6 @@ const runtimePlugin = () => ({
 var cli_default = runtimePlugin;
 export {
   cli_default as default,
+  isRuntimeEntry2 as isRuntimeEntry,
   runtimePlugin
 };

package/dist/esm-node/core/compatible.js

@@ -2,48 +2,39 @@ import { jsx as _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/universal/constants";
-import { RuntimeReactContext } from "../runtimeContext";
-import { runtime } from "./plugin";
+import { RuntimeReactContext } from "./context/runtime";
+import { registerPlugin } from "./plugin";
 import { createLoaderManager } from "./loader/loaderManager";
+import { getGlobalRunner } from "./plugin/runner";
 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, props: globalProps }) => {
-  const appRuntime = runtime.clone();
-  appRuntime.usePlugin(...plugins);
+const createApp = ({ plugins, runtime, props: globalProps }) => {
+  const runner = registerPlugin(plugins, {
+    plugins: []
+  }, runtime);
   return (App) => {
-    const runner = appRuntime.init();
     const WrapperComponent = (props) => {
-      const element = /* @__PURE__ */ React.createElement(App || React.Fragment, App ? {
+      return /* @__PURE__ */ React.createElement(App || React.Fragment, App ? {
         ...props
       } : null, App ? props.children : React.Children.map(props.children, (child) => /* @__PURE__ */ React.isValidElement(child) ? /* @__PURE__ */ React.cloneElement(child, {
         ...child.props,
         ...props
       }) : child));
-      const context = useContext(RuntimeReactContext);
-      return runner.provide({
-        element,
-        props: {
-          ...props
-        },
-        context
-      }, {
-        onLast: ({ element: element2 }) => element2
-      });
     };
     if (App) {
       hoistNonReactStatics(WrapperComponent, App);
     }
     const HOCApp = runner.hoc({
-      App: WrapperComponent
+      App: WrapperComponent,
+      config: globalProps || {}
     }, {
       onLast: ({ App: App2 }) => {
         const WrapComponent = ({ context, ...props }) => {
@@ -73,19 +64,12 @@ const createApp = ({ plugins, props: globalProps }) => {
         return hoistNonReactStatics(WrapComponent, App2);
       }
     });
-    runnerMap.set(HOCApp, runner);
     return HOCApp;
   };
 };
 const bootstrap = async (BootApp, id, root, ReactDOM) => {
-  let App = BootApp;
-  let runner = runnerMap.get(App);
-  if (!runner) {
-    App = createApp({
-      plugins: []
-    })(App);
-    runner = runnerMap.get(App);
-  }
+  const App = BootApp;
+  const runner = getGlobalRunner();
   const context = getInitialContext(runner);
   const runInit = (_context) => runner.init({
     context: _context

package/dist/esm-node/core/{appConfig.js → config.js}

@@ -1,6 +1,5 @@
 const APP_CONFIG_SYMBOL = "config";
 const getConfig = (Component) => (
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-expect-error
   Component[APP_CONFIG_SYMBOL]
 );
@@ -8,7 +7,9 @@ const defineConfig = (Component, config) => {
   Component[APP_CONFIG_SYMBOL] = config;
   return Component;
 };
+const defineRuntimeConfig = (config) => config;
 export {
   defineConfig,
+  defineRuntimeConfig,
   getConfig
 };

package/dist/esm-node/core/context/index.js

@@ -0,0 +1,4 @@
+import { RuntimeReactContext } from "./runtime";
+export {
+  RuntimeReactContext
+};

package/dist/esm-node/core/context/runtime.js

@@ -0,0 +1,16 @@
+import { createContext } from "react";
+import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
+import { createLoaderManager } from "../loader/loaderManager";
+const RuntimeReactContext = createContext({});
+const ServerRouterContext = createContext({});
+const getInitialContext = (runner) => ({
+  loaderManager: createLoaderManager({}),
+  runner,
+  isBrowser: true,
+  routeManifest: typeof window !== "undefined" && window[ROUTE_MANIFEST]
+});
+export {
+  RuntimeReactContext,
+  ServerRouterContext,
+  getInitialContext
+};

package/dist/esm-node/core/index.js

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

package/dist/esm-node/core/loader/useLoader.js

@@ -1,6 +1,6 @@
 import { useContext, useRef, useMemo, useState, useCallback, useEffect } from "react";
 import invariant from "invariant";
-import { RuntimeReactContext } from "../../runtimeContext";
+import { RuntimeReactContext } from "../context/runtime";
 import { LoaderStatus } from "./loaderManager";
 const useLoader = (loaderFn, options = {
   params: void 0

package/dist/esm-node/core/plugin/base.js

@@ -0,0 +1,19 @@
+import { createManager, createPipeline, createAsyncPipeline } from "@modern-js/plugin";
+const client = createAsyncPipeline();
+const server = createAsyncPipeline();
+const hoc = createPipeline();
+const init = createAsyncPipeline();
+const pickContext = createPipeline();
+const runtimeHooks = {
+  hoc,
+  init,
+  client,
+  server,
+  pickContext
+};
+const createRuntime = () => createManager(runtimeHooks);
+const runtime = createRuntime();
+export {
+  createRuntime,
+  runtime
+};

package/dist/esm-node/core/plugin/index.js

@@ -0,0 +1,13 @@
+import { runtime } from "./base";
+import { setGlobalRunner } from "./runner";
+export * from "./base";
+function registerPlugin(internalPlugins, runtimeConfig, customRuntime) {
+  const { plugins = [] } = runtimeConfig || {};
+  (customRuntime || runtime).usePlugin(...internalPlugins, ...plugins);
+  const runner = (customRuntime || runtime).init();
+  setGlobalRunner(runner);
+  return runner;
+}
+export {
+  registerPlugin
+};

package/dist/esm-node/core/plugin/runner.js

@@ -0,0 +1,17 @@
+import { runtime } from "./base";
+let globalRunner;
+function setGlobalRunner(runner) {
+  globalRunner = runner;
+}
+function getGlobalRunner() {
+  if (globalRunner) {
+    return globalRunner;
+  }
+  const runner = runtime.init();
+  setGlobalRunner(runner);
+  return runner;
+}
+export {
+  getGlobalRunner,
+  setGlobalRunner
+};

package/dist/esm-node/index.js

@@ -1,13 +1,12 @@
 import { isBrowser } from "./common";
-import { createApp, createPlugin, useLoader, bootstrap, RuntimeReactContext, defineConfig, registerInit, useRuntimeContext } from "./core";
+import { createApp, useLoader, bootstrap, RuntimeReactContext, defineConfig, defineRuntimeConfig, useRuntimeContext } from "./core";
 export {
   RuntimeReactContext,
   bootstrap,
   createApp,
-  createPlugin,
   defineConfig,
+  defineRuntimeConfig,
   isBrowser,
-  registerInit,
   useLoader,
   useRuntimeContext
 };