@bleedingdev/modern-js-runtime 3.2.0-ultramodern.0

package/dist/cjs/cli/template.js

@@ -0,0 +1,276 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    AppProxyForRSC: ()=>AppProxyForRSC,
+    entryForCSRWithRSC: ()=>entryForCSRWithRSC,
+    index: ()=>index,
+    register: ()=>register,
+    runtimeGlobalContext: ()=>runtimeGlobalContext,
+    runtimeGlobalContextForRSCClient: ()=>runtimeGlobalContextForRSCClient,
+    runtimeGlobalContextForRSCServer: ()=>runtimeGlobalContextForRSCServer,
+    runtimeRegister: ()=>runtimeRegister
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_constants_js_namespaceObject = require("./constants.js");
+const genRenderStatement = ({ enableRsc, mountId, isNestedRouter })=>{
+    if (enableRsc) {
+        if (!isNestedRouter) return `render(<ModernRoot>
+                  <RscClientRoot rscPayload={data} />
+                </ModernRoot>, '${mountId || 'root'}');`;
+        return `render(<ModernRoot rscPayload={data} />, '${mountId || 'root'}');`;
+    }
+    return `render(<ModernRoot />, '${mountId || 'root'}');`;
+};
+const genRenderCode = ({ srcDirectory, internalSrcAlias, metaName, entry, customEntry, mountId, enableRsc, isNestedRouter })=>{
+    if (customEntry) return `import '${(0, utils_namespaceObject.formatImportPath)(entry.replace(srcDirectory, internalSrcAlias))}'`;
+    return `import { createRoot } from '@${metaName}/runtime/react';
+import { render } from '@${metaName}/runtime/browser';
+
+${enableRsc ? `import { RscClientRoot, createFromReadableStream, rscStream, callServer, setServerCallback } from '@${metaName}/runtime/rsc/client';` : ''}
+
+${enableRsc ? "setServerCallback(callServer);" : ''}
+
+${enableRsc ? `const data = createFromReadableStream(rscStream, {
+    callServer: callServer,
+  });` : ''}
+
+const ModernRoot = createRoot();
+
+${genRenderStatement({
+        enableRsc,
+        mountId,
+        isNestedRouter
+    })}`;
+};
+const entryForCSRWithRSC = ({ metaName, entryName, urlPath = '/', mountId = 'root', isNestedRouter })=>`
+  import '@${metaName}/runtime/registry/${entryName}';
+  import { render } from '@${metaName}/runtime/browser';
+  import { createRoot } from '@${metaName}/runtime/react';
+
+  import {
+    RscClientRoot,
+    createFromFetch,
+    isRedirectResponse,
+    rscStream,
+    callServer,
+    setServerCallback,
+    createFromReadableStream
+  } from '@${metaName}/runtime/rsc/client';
+
+  setServerCallback(callServer);
+
+  const handleRedirectResponse = (res) => {
+    const { headers } = res;
+    const location = headers.get('X-Modernjs-Redirect');
+    const baseUrl = headers.get('X-Modernjs-BaseUrl');
+    if (location) {
+      if (baseUrl !== '/') {
+        window.location.replace(baseUrl + location);
+      } else {
+        window.location.replace(location);
+      }
+      return;
+    }
+    return res;
+  };
+
+  ${process.env.MODERN_DISABLE_INJECT_RSC_DATA ? `
+      const data = createFromFetch(
+        fetch(location.pathname, {
+          headers: {
+            'x-rsc-tree': 'true',
+          },
+        }).then(handleRedirectResponse),
+      )
+      ` : `
+      const data = createFromReadableStream(rscStream, {
+        callServer: callServer,
+      });
+      `}
+
+  const ModernRoot = createRoot();
+
+  ${isNestedRouter ? `
+      render(
+        <ModernRoot rscPayload={data}>
+        </ModernRoot>,
+        '${mountId}',
+      );
+      ` : `
+      render(
+        <ModernRoot>
+          <RscClientRoot rscPayload={data} />
+        </ModernRoot>,
+        '${mountId}',
+      );
+      `}
+  `;
+const index = ({ srcDirectory, internalSrcAlias, metaName, entry, entryName, customEntry, mountId, enableRsc, isNestedRouter })=>`import '@${metaName}/runtime/registry/${entryName}';
+${genRenderCode({
+        srcDirectory,
+        internalSrcAlias,
+        metaName,
+        entry,
+        customEntry,
+        mountId,
+        enableRsc,
+        isNestedRouter
+    })}
+`;
+const register = ()=>`import './${external_constants_js_namespaceObject.ENTRY_POINT_RUNTIME_GLOBAL_CONTEXT_FILE_NAME}';
+import './${external_constants_js_namespaceObject.ENTRY_POINT_RUNTIME_REGISTER_FILE_NAME}';
+`;
+const getImportRuntimeConfigCode = (srcDirectory, internalSrcAlias, runtimeConfigFile)=>{
+    if (runtimeConfigFile && (0, utils_namespaceObject.findExists)(utils_namespaceObject.JS_EXTENSIONS.map((ext)=>external_path_default().resolve(srcDirectory, `${runtimeConfigFile}${ext}`)))) return `import modernRuntime from '${internalSrcAlias}/${runtimeConfigFile}';
+const runtimeConfig = typeof modernRuntime === 'function' ? modernRuntime(getCurrentEntryName()) : modernRuntime`;
+    return "let runtimeConfig;";
+};
+const getRegisterRuntimePluginCode = (entryName, configName, config)=>`plugins.push(${configName}Plugin(mergeConfig(${JSON.stringify(config)}, (runtimeConfig || {})['${configName}'])));`;
+const runtimeRegister = ({ entryName, srcDirectory, internalSrcAlias, metaName, runtimeConfigFile, runtimePlugins })=>`import { registerPlugin, mergeConfig } from '@${metaName}/runtime/plugin';
+import { getGlobalLayoutApp, getCurrentEntryName } from '@${metaName}/runtime/context';
+
+${getImportRuntimeConfigCode(srcDirectory, internalSrcAlias, runtimeConfigFile)}
+
+const plugins = [];
+
+${runtimePlugins.map(({ name, path, config })=>`import { ${name}Plugin } from '${path}';
+
+${getRegisterRuntimePluginCode(entryName, name, config)}
+`).join('\n')}
+registerPlugin(plugins, runtimeConfig);
+`;
+const runtimeGlobalContext = ({ entryName, srcDirectory, internalSrcAlias, metaName, entry, customEntry, basename })=>`import { setGlobalContext } from '@${metaName}/runtime/context'
+
+import App from '${(0, utils_namespaceObject.formatImportPath)(customEntry ? entry.replace(/entry\.[tj]sx/, 'App').replace(srcDirectory, internalSrcAlias) : entry.replace(srcDirectory, internalSrcAlias).replace(/\.[tj]sx/, ''))}';
+
+const entryName = '${entryName}';
+const basename = '${basename || '/'}';
+setGlobalContext({
+  entryName,
+  App,
+  basename,
+});`;
+const runtimeGlobalContextForRSCServer = ({ metaName })=>`
+  import { createElement, Fragment } from 'react';
+  import { setGlobalContext } from '@${metaName}/runtime/context';
+  import AppProxy from './AppProxy';
+
+  const DefaultRoot = ({ children }) =>
+    createElement(Fragment, null, children);
+
+
+  setGlobalContext({
+    App: DefaultRoot,
+    RSCRoot: AppProxy,
+  });`;
+const runtimeGlobalContextForRSCClient = ({ metaName, customEntry })=>`
+   ${customEntry ? `import {
+     RscClientRoot,
+     createFromFetch,
+     createFromReadableStream,
+     isRedirectResponse,
+     rscStream,
+     callServer,
+     setServerCallback,
+   } from '@${metaName}/runtime/rsc/client';` : ''}
+   import { createElement, Fragment } from 'react';
+   import { setGlobalContext } from '@${metaName}/runtime/context';
+
+   ${customEntry ? 'setServerCallback(callServer);' : ''}
+
+   ${customEntry ? `const handleRedirectResponse = (res) => {
+     const { headers } = res;
+     const location = headers.get('X-Modernjs-Redirect');
+     const baseUrl = headers.get('X-Modernjs-BaseUrl');
+     if (location) {
+       if (baseUrl && baseUrl !== '/') {
+         window.location.replace(baseUrl + location);
+       } else {
+         window.location.replace(location);
+       }
+       return res;
+     }
+     return res;
+   };
+
+   const data = ${process.env.MODERN_DISABLE_INJECT_RSC_DATA ? `createFromFetch(
+     fetch(location.pathname, {
+       headers: {
+         'x-rsc-tree': 'true',
+       },
+     }).then(handleRedirectResponse),
+   )` : `createFromReadableStream(rscStream, {
+     callServer: callServer,
+   })`};` : ''}
+
+   const DefaultRoot = ({ children }) =>
+     createElement(Fragment, null, children);
+
+   ${customEntry ? 'const RSCRoot = () => createElement(RscClientRoot, { rscPayload: data });' : ''}
+
+   setGlobalContext({
+     App: ${customEntry ? 'RSCRoot' : 'DefaultRoot'}
+   });`;
+const AppProxyForRSC = ({ srcDirectory, internalSrcAlias, entry, customEntry })=>`
+  import App from '${(0, utils_namespaceObject.formatImportPath)(customEntry ? entry.replace(/entry\.[tj]sx/, 'App').replace(srcDirectory, internalSrcAlias) : entry.replace(srcDirectory, internalSrcAlias).replace('.tsx', ''))}';
+  import React from 'react';
+
+  export default function Root() {
+    return React.createElement(App, null);
+  }
+  `;
+exports.AppProxyForRSC = __webpack_exports__.AppProxyForRSC;
+exports.entryForCSRWithRSC = __webpack_exports__.entryForCSRWithRSC;
+exports.index = __webpack_exports__.index;
+exports.register = __webpack_exports__.register;
+exports.runtimeGlobalContext = __webpack_exports__.runtimeGlobalContext;
+exports.runtimeGlobalContextForRSCClient = __webpack_exports__.runtimeGlobalContextForRSCClient;
+exports.runtimeGlobalContextForRSCServer = __webpack_exports__.runtimeGlobalContextForRSCServer;
+exports.runtimeRegister = __webpack_exports__.runtimeRegister;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AppProxyForRSC",
+    "entryForCSRWithRSC",
+    "index",
+    "register",
+    "runtimeGlobalContext",
+    "runtimeGlobalContextForRSCClient",
+    "runtimeGlobalContextForRSCServer",
+    "runtimeRegister"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/cli/template.server.js

@@ -0,0 +1,163 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    entryForCSRWithRSC: ()=>entryForCSRWithRSC,
+    serverIndex: ()=>serverIndex
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const SERVER_ENTRY = `
+import {
+  #render,
+  createRequestHandler,
+} from '@#metaName/runtime/ssr/server';
+
+const handleRequest = async (request, ServerRoot, options) => {
+
+  const body = await #render(request, <ServerRoot />, options);
+
+  return new Response(body, {
+    headers: {
+      'content-type': 'text/html; charset=utf-8'
+    },
+  })
+};
+
+export const requestHandler = createRequestHandler(handleRequest);
+`;
+const SERVER_ENTRY_RSC = `
+import {
+  renderStreaming,
+  createRequestHandler,
+} from '@#metaName/runtime/ssr/server';
+import { RSCServerSlot } from '@#metaName/runtime/rsc/client';
+import { renderRsc } from '@#metaName/runtime/rsc/server';
+export { handleAction } from '@#metaName/runtime/rsc/server';
+
+const handleRequest = async (request, ServerRoot, options) => {
+
+  const body = await renderStreaming(request,
+    <ServerRoot>
+      <RSCServerSlot />
+    </ServerRoot>,
+    {
+      ...options,
+      rscRoot: options.rscRoot,
+    },
+  );
+
+  return new Response(body, {
+    headers: {
+      'content-type': 'text/html; charset=utf-8'
+    },
+  })
+};
+
+export const requestHandler = createRequestHandler(handleRequest, {
+  enableRsc: true
+});
+
+const handleRSCRequest = async (request, ServerRoot, options) => {
+  const { serverPayload } = options;
+  const stream = renderRsc({
+    element: options.rscRoot
+  });
+
+  return new Response(stream);
+}
+
+
+export const rscPayloadHandler = createRequestHandler(handleRSCRequest, {
+  enableRsc: true
+});
+`;
+const serverIndex = (options)=>{
+    const { metaName = 'modern-js', entryName } = options;
+    return `
+    import '@${metaName}/runtime/registry/${entryName}';
+    ${genHandlerCode(options)}
+  `;
+};
+const entryForCSRWithRSC = ({ metaName, entryName })=>`
+  import '@${metaName}/runtime/registry/${entryName}';
+  import {
+    createRequestHandler,
+  } from '@${metaName}/runtime/ssr/server';
+  import { renderCSRWithRSC, renderRsc } from '@${metaName}/runtime/rsc/server';
+  export { handleAction } from '@${metaName}/runtime/rsc/server';
+
+  const handleCSRRender = async (request, ServerRoot, options) => {
+    return renderCSRWithRSC({
+      html: options.html,
+      rscRoot: options.rscRoot,
+    });
+  }
+
+  export const renderRscStreamHandler = createRequestHandler(handleCSRRender, {
+    enableRsc: true
+  });
+
+  const handleRequest = async (request, ServerRoot, options) => {
+    const stream = renderRsc({
+            element: options.rscRoot,
+    });
+
+    return new Response(stream);
+  }
+
+  export const rscPayloadHandler = createRequestHandler(handleRequest, {
+    enableRsc: true
+  });
+`;
+function genHandlerCode({ mode, metaName, customServerEntry, srcDirectory, internalSrcAlias, enableRsc }) {
+    if (customServerEntry) {
+        const realEntryPath = (0, utils_namespaceObject.formatImportPath)(customServerEntry.replace(srcDirectory, internalSrcAlias));
+        return `
+      export * from '${realEntryPath}';
+      export { default as requestHandler } from '${realEntryPath}'`;
+    }
+    {
+        const entrySource = enableRsc ? SERVER_ENTRY_RSC : SERVER_ENTRY;
+        const serverEntry = transformServerEntry(entrySource, {
+            metaName: metaName || 'modern-js',
+            mode
+        });
+        return serverEntry;
+    }
+}
+function transformServerEntry(source, options) {
+    const { metaName = 'modern-js', mode } = options;
+    const output = source.replace(/#metaName/g, metaName).replace(/#render/g, 'string' === mode ? 'renderString' : 'renderStreaming');
+    return output;
+}
+exports.entryForCSRWithRSC = __webpack_exports__.entryForCSRWithRSC;
+exports.serverIndex = __webpack_exports__.serverIndex;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "entryForCSRWithRSC",
+    "serverIndex"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/common.js

@@ -0,0 +1,44 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ESCAPED_SHELL_STREAM_END_MARK: ()=>ESCAPED_SHELL_STREAM_END_MARK,
+    JSX_SHELL_STREAM_END_MARK: ()=>JSX_SHELL_STREAM_END_MARK,
+    isBrowser: ()=>isBrowser
+});
+const isBrowser = ()=>"u" > typeof window && 'nodejs' !== window.name;
+const JSX_SHELL_STREAM_END_MARK = '<!--<?- SHELL_STREAM_END ?>-->';
+const ESCAPED_SHELL_STREAM_END_MARK = '&lt;!--&lt;?- SHELL_STREAM_END ?&gt;--&gt;';
+exports.ESCAPED_SHELL_STREAM_END_MARK = __webpack_exports__.ESCAPED_SHELL_STREAM_END_MARK;
+exports.JSX_SHELL_STREAM_END_MARK = __webpack_exports__.JSX_SHELL_STREAM_END_MARK;
+exports.isBrowser = __webpack_exports__.isBrowser;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ESCAPED_SHELL_STREAM_END_MARK",
+    "JSX_SHELL_STREAM_END_MARK",
+    "isBrowser"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/core/browser/hydrate.js

@@ -0,0 +1,91 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    hydrateRoot: ()=>hydrateRoot,
+    isReact18: ()=>isReact18
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const component_namespaceObject = require("@loadable/component");
+const external_constants_js_namespaceObject = require("../constants.js");
+const wrapper_js_namespaceObject = require("../react/wrapper.js");
+const external_withCallback_js_namespaceObject = require("./withCallback.js");
+const isReact18 = ()=>'true' === process.env.IS_REACT18;
+function hydrateRoot(App, context, ModernRender, ModernHydrate) {
+    const hydrateContext = {
+        ...context,
+        get routes () {
+            return context.routes;
+        },
+        _hydration: true
+    };
+    const callback = ()=>{
+        delete hydrateContext._hydration;
+    };
+    const renderLevel = window?._SSR_DATA?.renderLevel || external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER;
+    const renderMode = window?._SSR_DATA?.mode || 'string';
+    if (isReact18() && 'stream' === renderMode) return streamSSRHydrate();
+    function streamSSRHydrate() {
+        if (renderLevel !== external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER) return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
+        {
+            const SSRApp = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_withCallback_js_namespaceObject.WithCallback, {
+                    callback: callback,
+                    children: App
+                });
+            return ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SSRApp, {}), hydrateContext));
+        }
+    }
+    return stringSSRHydrate();
+    function stringSSRHydrate() {
+        if (renderLevel === external_constants_js_namespaceObject.RenderLevel.CLIENT_RENDER) return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
+        if (renderLevel === external_constants_js_namespaceObject.RenderLevel.SERVER_RENDER) return new Promise((resolve)=>{
+            if (isReact18()) (0, component_namespaceObject.loadableReady)(()=>{
+                const SSRApp = ()=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_withCallback_js_namespaceObject.WithCallback, {
+                        callback: callback,
+                        children: App
+                    });
+                ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(SSRApp, {}), hydrateContext)).then((root)=>{
+                    resolve(root);
+                });
+            });
+            else (0, component_namespaceObject.loadableReady)(()=>{
+                ModernHydrate((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, hydrateContext), callback).then((root)=>{
+                    resolve(root);
+                });
+            });
+        });
+        console.warn(`unknow render level: ${renderLevel}, execute render()`);
+        return ModernRender((0, wrapper_js_namespaceObject.wrapRuntimeContextProvider)(App, context));
+    }
+}
+exports.hydrateRoot = __webpack_exports__.hydrateRoot;
+exports.isReact18 = __webpack_exports__.isReact18;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "hydrateRoot",
+    "isReact18"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});