@modern-js/runtime 2.48.2 → 2.48.4-alpha.0

package/dist/js/modern/ssr/serverRender/renderToString/entry.js

@@ -0,0 +1,171 @@
+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 React from "react";
+import ReactDomServer from "react-dom/server";
+import serialize from "serialize-javascript";
+import ReactHelmet from "react-helmet";
+import helmetReplace from "../helmet";
+import {
+  RenderLevel
+} from "../types";
+import { time } from "../utils";
+import prefetch from "../../prefetch";
+import { toFragments } from "./template";
+import { reduce } from "./reduce";
+import * as loadableRenderer from "./loadable";
+import * as styledComponentRenderer from "./styledComponent";
+const buildTemplateData = (context, data, renderLevel) => {
+  const { request } = context;
+  return {
+    data,
+    context: {
+      request: {
+        params: request.params,
+        query: request.query,
+        pathname: request.pathname,
+        host: request.host,
+        url: request.url,
+        headers: request.headers,
+        cookieMap: request.cookieMap
+      }
+    },
+    renderLevel
+  };
+};
+class Entry {
+  constructor(options) {
+    const { ctx, config } = options;
+    const {
+      entryName,
+      template,
+      request: { host }
+    } = ctx;
+    this.fragments = toFragments(template, entryName);
+    this.entryName = entryName;
+    this.host = host;
+    this.App = options.App;
+    this.pluginConfig = config;
+    this.metrics = ctx.metrics;
+    this.logger = ctx.logger;
+    this.result = {
+      renderLevel: RenderLevel.CLIENT_RENDER,
+      html: "",
+      chunksMap: {
+        js: "",
+        css: ""
+      }
+    };
+  }
+  renderToHtml(context) {
+    return __async(this, null, function* () {
+      const ssrContext = context.ssrContext;
+      if (ssrContext.redirection.url) {
+        return "";
+      }
+      const prefetchData = yield this.prefetch(context);
+      if (ssrContext.redirection.url) {
+        return "";
+      }
+      if (this.result.renderLevel >= RenderLevel.SERVER_PREFETCH) {
+        this.result.html = this.renderToString(context);
+      }
+      if (ssrContext.redirection.url) {
+        return "";
+      }
+      let html = "";
+      const templateData = buildTemplateData(
+        ssrContext,
+        prefetchData,
+        this.result.renderLevel
+      );
+      const SSRData = this.getSSRDataScript(templateData);
+      for (const fragment of this.fragments) {
+        if (fragment.isVariable && fragment.content === "SSRDataScript") {
+          html += fragment.getValue(SSRData);
+        } else {
+          html += fragment.getValue(this.result);
+        }
+      }
+      const helmetData = ReactHelmet.renderStatic();
+      return helmetData ? helmetReplace(html, helmetData) : html;
+    });
+  }
+  prefetch(context) {
+    return __async(this, null, function* () {
+      let prefetchData;
+      const end = time();
+      try {
+        prefetchData = yield prefetch(this.App, context);
+        this.result.renderLevel = RenderLevel.SERVER_PREFETCH;
+        const prefetchCost = end();
+        this.logger.debug(`App Prefetch cost = %d ms`, prefetchCost);
+        this.metrics.emitTimer("app.prefetch.cost", prefetchCost);
+      } catch (e) {
+        this.result.renderLevel = RenderLevel.CLIENT_RENDER;
+        this.logger.error("App Prefetch Render", e);
+        this.metrics.emitCounter("app.prefetch.render.error", 1);
+      }
+      return prefetchData || {};
+    });
+  }
+  renderToString(context) {
+    let html = "";
+    const end = time();
+    const { ssrContext } = context;
+    try {
+      const App = React.createElement(this.App, {
+        context: Object.assign(context, { ssr: true })
+      });
+      const renderContext = {
+        stats: ssrContext.loadableStats,
+        host: this.host,
+        result: this.result,
+        entryName: this.entryName,
+        config: this.pluginConfig
+      };
+      html = reduce(App, renderContext, [
+        styledComponentRenderer.toHtml,
+        loadableRenderer.toHtml,
+        (jsx) => ReactDomServer.renderToString(jsx)
+      ]);
+      const cost = end();
+      this.logger.debug("App Render To HTML cost = %d ms", cost);
+      this.metrics.emitTimer("app.render.html.cost", cost);
+      this.result.renderLevel = RenderLevel.SERVER_RENDER;
+    } catch (e) {
+      this.logger.error("App Render To HTML", e);
+      this.metrics.emitCounter("app.render.html.error", 1);
+    }
+    return html;
+  }
+  getSSRDataScript(templateData) {
+    return {
+      SSRDataScript: `
+        <script>window._SSR_DATA = ${serialize(templateData, {
+        isJSON: true
+      })}<\/script>
+      `
+    };
+  }
+}
+export {
+  Entry as default
+};

package/dist/js/modern/ssr/serverRender/renderToString/index.js

@@ -0,0 +1,52 @@
+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 { run } from "@modern-js/utils/ssr";
+import { PreRender } from "../../react/prerender";
+import { time } from "../utils";
+import SSREntry from "./entry";
+const render = ({
+  App,
+  context,
+  config
+}) => {
+  const ssrContext = context.ssrContext;
+  return run(ssrContext.request.headers, () => __async(void 0, null, function* () {
+    const entry = new SSREntry({
+      ctx: ssrContext,
+      App,
+      config
+    });
+    entry.metrics.emitCounter("app.visit.count", 1);
+    const end = time();
+    const html = yield entry.renderToHtml(context);
+    const cost = end();
+    entry.logger.info("App Render Total cost = %d ms", cost);
+    entry.metrics.emitTimer("app.render.cost", cost);
+    const cacheConfig = PreRender.config();
+    if (cacheConfig) {
+      context.ssrContext.cacheConfig = cacheConfig;
+    }
+    return html;
+  }));
+};
+export {
+  render
+};

package/dist/js/modern/ssr/serverRender/renderToString/loadable.js

@@ -0,0 +1,48 @@
+import { ChunkExtractor } from "@loadable/server";
+import { isCrossOrigin } from "../../utils";
+import { getLoadableScripts } from "../utils";
+const extname = (uri) => {
+  if (typeof uri !== "string" || !uri.includes(".")) {
+    return "";
+  }
+  return `.${uri == null ? void 0 : uri.split(".").pop()}` || "";
+};
+const toHtml = (jsx, renderer, next) => {
+  const {
+    stats,
+    result: { chunksMap },
+    host,
+    config = {}
+  } = renderer;
+  if (!stats || chunksMap.js) {
+    return next(jsx);
+  }
+  const extractor = new ChunkExtractor({
+    stats,
+    entrypoints: [renderer.entryName]
+  });
+  const html = next(extractor.collectChunks(jsx));
+  const chunks = extractor.getChunkAssets(extractor.chunks);
+  chunksMap.js = (chunksMap.js || "") + getLoadableScripts(extractor);
+  for (const v of chunks) {
+    const fileType = extname(v.url).slice(1);
+    if (fileType === "js") {
+      const props = [];
+      const { crossorigin } = config;
+      if (crossorigin && isCrossOrigin(v.url, host)) {
+        props.push(
+          `crossorigin="${crossorigin === true ? "anonymous" : crossorigin}"`
+        );
+      }
+      chunksMap[fileType] += `<script src="${v.url}" ${props.join(
+        " "
+      )}><\/script>`;
+    } else if (fileType === "css") {
+      chunksMap[fileType] += `<link href="${v.url}" rel="stylesheet" />`;
+    }
+  }
+  return html;
+};
+export {
+  toHtml
+};

package/dist/js/modern/ssr/serverRender/renderToString/reduce.js

@@ -0,0 +1,8 @@
+function reduce(jsx, renderer, middleware) {
+  let index = 0;
+  const createNext = () => (App) => middleware[index++](App, renderer, createNext());
+  return createNext()(jsx);
+}
+export {
+  reduce
+};

package/dist/js/modern/ssr/serverRender/renderToString/styledComponent.js

@@ -0,0 +1,11 @@
+import { ServerStyleSheet } from "styled-components";
+const toHtml = (jsx, renderer, next) => {
+  const sheet = new ServerStyleSheet();
+  const html = next(sheet.collectStyles(jsx));
+  const css = sheet.getStyleTags();
+  renderer.result.chunksMap.css += css;
+  return html;
+};
+export {
+  toHtml
+};

package/dist/js/modern/ssr/serverRender/renderToString/template.js

@@ -0,0 +1,58 @@
+const VARIABLE_REG_EXP = /<!--<\?([-=+])\s*(.*?)\s*\?>-->/;
+const VARIABLE_SPLITTER = /(<!--<\?.*?\?>-->)/;
+const ENCODE_HTML_RULES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&#34;",
+  "'": "&#39;"
+};
+const MATCH_HTML = /[&<>'"]/g;
+function encodeChar(c) {
+  return ENCODE_HTML_RULES[c] || c;
+}
+function escape(str) {
+  return str.replace(MATCH_HTML, encodeChar);
+}
+const _Fragment = class {
+  constructor(template) {
+    const match = VARIABLE_REG_EXP.exec(template);
+    if (match) {
+      const [, filterFlag, content] = match;
+      this.isVariable = true;
+      this.content = content;
+      this.filters = [_Fragment.filterMap[filterFlag]];
+      this.path = content.replace(/\[['"](.*?)['"]\]/g, ".$1").split(".");
+    } else {
+      this.isVariable = false;
+      this.content = template;
+      this.filters = [];
+      this.path = [];
+    }
+  }
+  getValue(data) {
+    if (this.isVariable) {
+      const value = this.path.reduce((p, n) => p != null ? p[n] : p, data);
+      return this.filters.reduce((p, n) => n(p), value != null ? value : "");
+    }
+    return this.content;
+  }
+};
+let Fragment = _Fragment;
+Fragment.filterMap = {
+  "=": escape,
+  "-": (v) => v
+};
+const fragmentListMap = {};
+function toFragments(template, entryName) {
+  if (fragmentListMap[entryName]) {
+    return fragmentListMap[entryName];
+  }
+  const fragmentList = template.split(VARIABLE_SPLITTER).filter((v) => Boolean(v)).map((v) => new Fragment(v));
+  fragmentListMap[entryName] = fragmentList;
+  return fragmentList;
+}
+export {
+  Fragment,
+  toFragments
+};

package/dist/js/modern/ssr/serverRender/renderToString/type.js

@@ -0,0 +1,9 @@
+var RenderLevel = /* @__PURE__ */ ((RenderLevel2) => {
+  RenderLevel2[RenderLevel2["CLIENT_RENDER"] = 0] = "CLIENT_RENDER";
+  RenderLevel2[RenderLevel2["SERVER_PREFETCH"] = 1] = "SERVER_PREFETCH";
+  RenderLevel2[RenderLevel2["SERVER_RENDER"] = 2] = "SERVER_RENDER";
+  return RenderLevel2;
+})(RenderLevel || {});
+export {
+  RenderLevel
+};

package/dist/js/modern/ssr/serverRender/types.js

@@ -0,0 +1,4 @@
+import { RenderLevel } from "./renderToString/type";
+export {
+  RenderLevel
+};

package/dist/js/modern/ssr/serverRender/utils.js

@@ -0,0 +1,22 @@
+function getLoadableScripts(extractor) {
+  const check = (scripts2) => (scripts2 || "").includes("__LOADABLE_REQUIRED_CHUNKS___ext");
+  const scripts = extractor.getScriptTags();
+  if (!check(scripts)) {
+    return "";
+  }
+  return scripts.split("<\/script>").slice(0, 2).map((i) => `${i}<\/script>`).join("");
+}
+const getLatency = (hrtime) => {
+  const [s, ns] = process.hrtime(hrtime);
+  return s * 1e3 + ns / 1e6;
+};
+const time = () => {
+  const hrtime = process.hrtime();
+  return () => {
+    return getLatency(hrtime);
+  };
+};
+export {
+  getLoadableScripts,
+  time
+};

package/dist/js/modern/ssr/utils.js

@@ -0,0 +1,81 @@
+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;
+};
+const isReact18 = () => process.env.IS_REACT18 === "true";
+const formatServer = (request) => {
+  const {
+    cookie = "",
+    "user-agent": userAgent = "",
+    referer
+  } = request.headers || {};
+  return __spreadValues({
+    cookie,
+    userAgent,
+    referer
+  }, request);
+};
+const getQuery = () => window.location.search.substring(1).split("&").reduce((res, item) => {
+  const [key, value] = item.split("=");
+  if (key) {
+    res[key] = value;
+  }
+  return res;
+}, {});
+const formatClient = (request) => {
+  var _a, _b;
+  return {
+    params: request.params || {},
+    host: request.host || location.host,
+    pathname: request.pathname || location.pathname,
+    headers: request.headers || {},
+    cookieMap: request.cookieMap || {},
+    cookie: ((_a = request.headers) == null ? void 0 : _a.cookie) || document.cookie,
+    userAgent: ((_b = request.headers) == null ? void 0 : _b["user-agent"]) || navigator.userAgent,
+    referer: request.referer || document.referrer,
+    query: request.query || getQuery(),
+    url: location.href
+  };
+};
+const mockResponse = () => {
+  return {
+    setHeader() {
+      console.warn("response.setHeader() can only be used in the server side");
+    },
+    status() {
+      console.warn("response.status() can only be used in the server side");
+    },
+    get locals() {
+      console.warn("response.locals can only be used in the server side");
+      return {};
+    }
+  };
+};
+const isCrossOrigin = (url = "", base) => {
+  if (url.startsWith("/") || url.startsWith("./")) {
+    return false;
+  } else if (!url.includes(base)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+export {
+  formatClient,
+  formatServer,
+  isCrossOrigin,
+  isReact18,
+  mockResponse
+};

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

@@ -0,0 +1,83 @@
+import {
+  getEntryOptions,
+  createRuntimeExportsUtils,
+  PLUGIN_SCHEMAS
+} from "@modern-js/utils";
+const PLUGIN_IDENTIFIER = "state";
+var cli_default = () => ({
+  name: "@modern-js/plugin-state",
+  required: ["@modern-js/runtime"],
+  setup: (api) => {
+    const stateConfigMap = /* @__PURE__ */ new Map();
+    let pluginsExportsUtils;
+    return {
+      config() {
+        const appContext = api.useAppContext();
+        pluginsExportsUtils = createRuntimeExportsUtils(
+          appContext.internalDirectory,
+          "plugins"
+        );
+        return {
+          source: {
+            alias: {
+              "@modern-js/runtime/plugins": pluginsExportsUtils.getPath()
+            }
+          }
+        };
+      },
+      modifyEntryImports({ entrypoint, imports }) {
+        var _a;
+        const { entryName } = entrypoint;
+        const userConfig = api.useResolvedConfigContext();
+        const { packageName } = api.useAppContext();
+        const stateConfig = (_a = getEntryOptions(
+          entryName,
+          userConfig.runtime,
+          userConfig.runtimeByEntries,
+          packageName
+        )) == null ? void 0 : _a.state;
+        stateConfigMap.set(entryName, stateConfig);
+        if (stateConfig) {
+          imports.push({
+            value: "@modern-js/runtime/plugins",
+            specifiers: [
+              {
+                imported: PLUGIN_IDENTIFIER
+              }
+            ]
+          });
+        }
+        return {
+          entrypoint,
+          imports
+        };
+      },
+      modifyEntryRuntimePlugins({ entrypoint, plugins }) {
+        const stateOptions = stateConfigMap.get(entrypoint.entryName);
+        if (stateOptions) {
+          plugins.push({
+            name: PLUGIN_IDENTIFIER,
+            options: `${JSON.stringify(
+              stateConfigMap.get(entrypoint.entryName)
+            )}`
+          });
+        }
+        return {
+          entrypoint,
+          plugins
+        };
+      },
+      validateSchema() {
+        return PLUGIN_SCHEMAS["@modern-js/plugin-state"];
+      },
+      addRuntimeExports() {
+        pluginsExportsUtils.addExport(
+          `export { default as state } from '@modern-js/runtime/model'`
+        );
+      }
+    };
+  }
+});
+export {
+  cli_default as default
+};

package/dist/js/modern/state/index.js

@@ -0,0 +1,7 @@
+import { default as default2 } from "./runtime";
+import { default as default3 } from "./runtime";
+export * from "./runtime";
+export {
+  default3 as default,
+  default2 as state
+};

package/dist/js/modern/state/plugins.js

@@ -0,0 +1,13 @@
+import { plugin as effectsPlugin } from "@modern-js-reduck/plugin-effects";
+import autoActionsPlugin from "@modern-js-reduck/plugin-auto-actions";
+import immerPlugin from "@modern-js-reduck/plugin-immutable";
+import { default as default2 } from "@modern-js-reduck/plugin-devtools";
+const effects = () => effectsPlugin;
+const immer = () => immerPlugin;
+const autoActions = () => autoActionsPlugin;
+export {
+  autoActions,
+  default2 as devtools,
+  effects,
+  immer
+};

package/dist/js/modern/state/runtime/index.js

@@ -0,0 +1,9 @@
+export * from "@modern-js-reduck/react";
+import { model, createStore } from "@modern-js-reduck/store";
+import { default as default2 } from "./plugin";
+export * from "./plugin";
+export {
+  createStore,
+  default2 as default,
+  model
+};

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

@@ -0,0 +1,97 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { jsx } from "react/jsx-runtime";
+import { useContext } from "react";
+import {
+  createStore
+} from "@modern-js-reduck/store";
+import { Provider } from "@modern-js-reduck/react";
+import hoistNonReactStatics from "hoist-non-react-statics";
+import { immer, effects, autoActions, devtools } from "../plugins";
+import { RuntimeReactContext } from "../../core";
+import { isBrowser } from "../../common";
+const StatePluginHandleMap = {
+  immer,
+  effects,
+  autoActions,
+  devtools
+};
+const getStoreConfig = (config) => {
+  const internalPlugins = [
+    "immer",
+    "effects",
+    "autoActions",
+    "devtools"
+  ];
+  const plugins = [];
+  internalPlugins.filter((plugin) => config[plugin] !== false).forEach(
+    (plugin) => plugins.push(StatePluginHandleMap[plugin](config[plugin]))
+  );
+  const storeConfig = {};
+  for (const [key, value] of Object.entries(config)) {
+    if (!internalPlugins.includes(key)) {
+      storeConfig[key] = value;
+    }
+  }
+  storeConfig.plugins = plugins;
+  return storeConfig;
+};
+const state = (config) => ({
+  name: "@modern-js/plugin-state",
+  setup: () => {
+    const storeConfig = getStoreConfig(config);
+    return {
+      hoc({ App }, next) {
+        const getStateApp = (props) => {
+          const context = useContext(RuntimeReactContext);
+          return /* @__PURE__ */ jsx(Provider, {
+            store: context.store,
+            config: storeConfig,
+            children: /* @__PURE__ */ jsx(App, __spreadValues({}, props))
+          });
+        };
+        return next({
+          App: hoistNonReactStatics(getStateApp, App)
+        });
+      },
+      init({ context }, next) {
+        var _a, _b;
+        if (isBrowser()) {
+          storeConfig.initialState = storeConfig.initialState || ((_b = (_a = window == null ? void 0 : window._SSR_DATA) == null ? void 0 : _a.data) == null ? void 0 : _b.storeState) || {};
+        }
+        context.store = createStore(storeConfig);
+        return next({ context });
+      },
+      pickContext({ context, pickedContext }, next) {
+        return next({
+          context,
+          pickedContext: __spreadProps(__spreadValues({}, pickedContext), {
+            store: context.store
+          })
+        });
+      }
+    };
+  }
+});
+var plugin_default = state;
+export * from "../plugins";
+export {
+  plugin_default as default
+};