@modern-js/runtime 2.0.0-canary.0 → 2.0.0

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

@@ -1,233 +1,253 @@
-const _excluded = ["context"];
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-import React, { useContext, useMemo } from 'react';
-import hoistNonReactStatics from 'hoist-non-react-statics';
-import { RuntimeReactContext } from "../runtime-context";
+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";
-import { jsx as _jsx } from "react/jsx-runtime";
-const IS_REACT18 = process.env.IS_REACT18 === 'true';
-const ROUTE_MANIFEST = `_MODERNJS_ROUTE_MANIFEST`;
+const IS_REACT18 = process.env.IS_REACT18 === "true";
 function isClientArgs(id) {
-  return typeof id === 'string' || typeof HTMLElement !== 'undefined' && id instanceof HTMLElement;
+  return typeof id === "string" || typeof HTMLElement !== "undefined" && id instanceof HTMLElement;
 }
-const runnerMap = new WeakMap();
-const getInitialContext = runner => ({
+const runnerMap = /* @__PURE__ */ new WeakMap();
+const getInitialContext = (runner) => ({
   loaderManager: createLoaderManager({}),
   runner,
   isBrowser: true,
-  routeManifest: typeof window !== 'undefined' && window[ROUTE_MANIFEST]
+  routeManifest: typeof window !== "undefined" && window[ROUTE_MANIFEST]
 });
-export const createApp = ({
-  plugins
-}) => {
+const createApp = ({ plugins }) => {
   const appRuntime = runtime.clone();
   appRuntime.usePlugin(...plugins);
-  return App => {
+  return (App) => {
     const runner = appRuntime.init();
-    const WrapperComponent = props => {
-      const element = /*#__PURE__*/React.createElement(App || React.Fragment, _objectSpread({}, props), props.children);
+    const WrapperComponent = (props) => {
+      const element = React.createElement(
+        App || React.Fragment,
+        __spreadValues({}, props),
+        props.children
+      );
       const context = useContext(RuntimeReactContext);
-      return runner.provide({
-        element,
-        props: _objectSpread({}, props),
-        context
-      }, {
-        onLast: ({
-          element
-        }) => element
-      });
+      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
-      }) => {
-        const WrapComponent = _ref => {
-          var _contextValue;
-          let {
-              context
-            } = _ref,
-            props = _objectWithoutProperties(_ref, _excluded);
-          let contextValue = context;
-
-          // We should construct the context, when root component is not passed into `bootstrap`.
-          if (!((_contextValue = contextValue) !== null && _contextValue !== void 0 && _contextValue.runner)) {
-            contextValue = getInitialContext(runner);
-            runner.init({
-              context: contextValue
-            }, {
-              onLast: ({
-                context: context1
-              }) => {
-                var _App$init;
-                return App === null || App === void 0 ? void 0 : (_App$init = App.init) === null || _App$init === void 0 ? void 0 : _App$init.call(App, context1);
-              }
+    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 /*#__PURE__*/_jsx(RuntimeReactContext.Provider, {
-            value: contextValue,
-            children: /*#__PURE__*/_jsx(App, _objectSpread({}, props))
-          });
-        };
-        return hoistNonReactStatics(WrapComponent, App);
+          };
+          return hoistNonReactStatics(WrapComponent, App2);
+        }
       }
-    });
+    );
     runnerMap.set(HOCApp, runner);
     return HOCApp;
   };
 };
-export const bootstrap = async (BootApp,
-/**
- * When csr, id is root id.
- * When ssr, id is serverContext
- */
-id,
-/**
- * root.render need use root to run function
- */
-root, ReactDOM
-// eslint-disable-next-line consistent-return
-) => {
+const bootstrap = (BootApp, id, root, ReactDOM) => __async(void 0, null, function* () {
+  var _a, _b;
   let App = BootApp;
   let runner = runnerMap.get(App);
-
-  // ensure Component used is created by `createApp`
   if (!runner) {
-    App = createApp({
-      plugins: []
-    })(App);
+    App = createApp({ plugins: [] })(App);
     runner = runnerMap.get(App);
   }
   const context = getInitialContext(runner);
-  const runInit = _context => runner.init({
-    context: _context
-  }, {
-    onLast: ({
-      context: context1
-    }) => {
-      var _App, _App$init2;
-      return (_App = App) === null || _App === void 0 ? void 0 : (_App$init2 = _App.init) === null || _App$init2 === void 0 ? void 0 : _App$init2.call(_App, context1);
+  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);
+      }
     }
-  });
-
-  // don't mount the App, let user in charge of it.
+  );
   if (!id) {
-    return /*#__PURE__*/React.createElement(App, {
+    return React.createElement(App, {
       context
     });
   }
-  const isBrowser = typeof window !== 'undefined' && window.name !== 'nodejs';
+  const isBrowser = typeof window !== "undefined" && window.name !== "nodejs";
   if (isBrowser) {
     if (isClientArgs(id)) {
-      var _ssrData$data, _ssrData$data2;
       const ssrData = window._SSR_DATA;
-      const loadersData = (ssrData === null || ssrData === void 0 ? void 0 : (_ssrData$data = ssrData.data) === null || _ssrData$data === void 0 ? void 0 : _ssrData$data.loadersData) || {};
-      const initialLoadersState = Object.keys(loadersData).reduce((res, key) => {
-        const loaderData = loadersData[key];
-        if (loaderData.loading !== false) {
+      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;
-        }
-        res[key] = loaderData;
-        return res;
-      }, {});
-      Object.assign(context, _objectSpread({
+        },
+        {}
+      );
+      Object.assign(context, __spreadValues({
         loaderManager: createLoaderManager(initialLoadersState, {
           skipStatic: true
         })
-      }, ssrData ? {
-        ssrContext: ssrData === null || ssrData === void 0 ? void 0 : ssrData.context
-      } : {}));
-      context.initialData = ssrData === null || ssrData === void 0 ? void 0 : (_ssrData$data2 = ssrData.data) === null || _ssrData$data2 === void 0 ? void 0 : _ssrData$data2.initialData;
-      const initialData = await runInit(context);
+      }, 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');
+      const rootElement = typeof id !== "string" ? id : document.getElementById(id || "root");
       if (!ReactDOM) {
-        throw Error('The `bootstrap` need provide `ReactDOM` parameter');
+        throw Error("The `bootstrap` need provide `ReactDOM` parameter");
       }
-      // https://reactjs.org/blog/2022/03/08/react-18-upgrade-guide.html
-      const ModernRender = App => {
+      const ModernRender = (App2) => {
         if (IS_REACT18) {
           if (root) {
-            root.render(App);
+            root.render(App2);
           } else if (ReactDOM.createRoot) {
-            ReactDOM.createRoot(rootElement).render(App);
+            ReactDOM.createRoot(rootElement).render(App2);
           } else {
-            throw Error('The `bootstrap` `ReactDOM` parameter needs to provide the `createRoot` method');
+            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');
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `render` method"
+            );
           }
-          ReactDOM.render(App, rootElement);
+          ReactDOM.render(App2, rootElement);
         }
       };
-      const ModernHydrate = (App, callback) => {
+      const ModernHydrate = (App2, callback) => {
         if (IS_REACT18) {
           if (!ReactDOM.hydrateRoot) {
-            throw Error('The `bootstrap` `ReactDOM` parameter needs to provide the `hydrateRoot` method');
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `hydrateRoot` method"
+            );
           }
-          ReactDOM.hydrateRoot(rootElement, App);
+          ReactDOM.hydrateRoot(rootElement, App2);
         } else {
           if (!ReactDOM.hydrate) {
-            throw Error('The `bootstrap` `ReactDOM` parameter needs to provide the `hydrate` method');
+            throw Error(
+              "The `bootstrap` `ReactDOM` parameter needs to provide the `hydrate` method"
+            );
           }
-          ReactDOM.hydrate(App, rootElement, callback);
+          ReactDOM.hydrate(App2, rootElement, callback);
         }
       };
-      return runner.client({
-        App,
-        context,
-        ModernRender,
-        ModernHydrate
-      }, {
-        onLast: ({
-          App
-        }) => {
-          ModernRender( /*#__PURE__*/React.createElement(App, {
-            context
-          }));
+      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');
+      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
-      })
+      loaderManager: createLoaderManager(
+        {},
+        {
+          skipNonStatic: id.staticGenerate,
+          skipStatic: process.env.NODE_ENV === "production" && !id.staticGenerate
+        }
+      )
     });
-
-    // Handle redirects from React Router with an HTTP redirect
-    const isRedirectResponse = result => {
-      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;
+    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.res.setHeader("Location", redirectUrl);
           ssrContext.redirection.status = status;
           ssrContext.redirection.url = redirectUrl;
         }
@@ -235,7 +255,7 @@ root, ReactDOM
       }
       return false;
     };
-    const initialData = await runInit(context);
+    const initialData = yield runInit(context);
     if (!isRedirectResponse(initialData)) {
       context.initialData = initialData;
       return runner.server({
@@ -244,16 +264,22 @@ root, ReactDOM
       });
     }
   }
-};
-export const useRuntimeContext = () => {
+});
+const useRuntimeContext = () => {
   const context = useContext(RuntimeReactContext);
-  const memoizedContext = useMemo(() => context.runner.pickContext({
-    context,
-    pickedContext: {}
-  }, {
-    onLast: ({
-      pickedContext
-    }) => pickedContext
-  }), [context]);
+  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

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

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

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