@modern-js/runtime 2.49.2 → 2.49.3-alpha.0

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

@@ -0,0 +1,196 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var entry_exports = {};
+__export(entry_exports, {
+  default: () => Entry
+});
+module.exports = __toCommonJS(entry_exports);
+var import_react = __toESM(require("react"));
+var import_server = __toESM(require("react-dom/server"));
+var import_serialize_javascript = __toESM(require("serialize-javascript"));
+var import_react_helmet = __toESM(require("react-helmet"));
+var import_helmet = __toESM(require("../helmet"));
+var import_types = require("../types");
+var import_utils = require("../utils");
+var import_prefetch = __toESM(require("../../prefetch"));
+var import_template = require("./template");
+var import_reduce = require("./reduce");
+var loadableRenderer = __toESM(require("./loadable"));
+var styledComponentRenderer = __toESM(require("./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 = (0, import_template.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: import_types.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 >= import_types.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 = import_react_helmet.default.renderStatic();
+      return helmetData ? (0, import_helmet.default)(html, helmetData) : html;
+    });
+  }
+  prefetch(context) {
+    return __async(this, null, function* () {
+      let prefetchData;
+      const end = (0, import_utils.time)();
+      try {
+        prefetchData = yield (0, import_prefetch.default)(this.App, context);
+        this.result.renderLevel = import_types.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 = import_types.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 = (0, import_utils.time)();
+    const { ssrContext } = context;
+    try {
+      const App = import_react.default.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 = (0, import_reduce.reduce)(App, renderContext, [
+        styledComponentRenderer.toHtml,
+        loadableRenderer.toHtml,
+        (jsx) => import_server.default.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 = import_types.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 = ${(0, import_serialize_javascript.default)(templateData, {
+        isJSON: true
+      })}<\/script>
+      `
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

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

@@ -0,0 +1,81 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var renderToString_exports = {};
+__export(renderToString_exports, {
+  render: () => render
+});
+module.exports = __toCommonJS(renderToString_exports);
+var import_ssr = require("@modern-js/utils/ssr");
+var import_prerender = require("../../react/prerender");
+var import_utils = require("../utils");
+var import_entry = __toESM(require("./entry"));
+const render = ({
+  App,
+  context,
+  config
+}) => {
+  const ssrContext = context.ssrContext;
+  return (0, import_ssr.run)(ssrContext.request.headers, () => __async(void 0, null, function* () {
+    const entry = new import_entry.default({
+      ctx: ssrContext,
+      App,
+      config
+    });
+    entry.metrics.emitCounter("app.visit.count", 1);
+    const end = (0, import_utils.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 = import_prerender.PreRender.config();
+    if (cacheConfig) {
+      context.ssrContext.cacheConfig = cacheConfig;
+    }
+    return html;
+  }));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  render
+});

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

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loadable_exports = {};
+__export(loadable_exports, {
+  toHtml: () => toHtml
+});
+module.exports = __toCommonJS(loadable_exports);
+var import_server = require("@loadable/server");
+var import_utils = require("../../utils");
+var import_utils2 = require("../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 import_server.ChunkExtractor({
+    stats,
+    entrypoints: [renderer.entryName]
+  });
+  const html = next(extractor.collectChunks(jsx));
+  const chunks = extractor.getChunkAssets(extractor.chunks);
+  chunksMap.js = (chunksMap.js || "") + (0, import_utils2.getLoadableScripts)(extractor);
+  for (const v of chunks) {
+    const fileType = extname(v.url).slice(1);
+    if (fileType === "js") {
+      const props = [];
+      const { crossorigin } = config;
+      if (crossorigin && (0, import_utils.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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toHtml
+});

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

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reduce_exports = {};
+__export(reduce_exports, {
+  reduce: () => reduce
+});
+module.exports = __toCommonJS(reduce_exports);
+function reduce(jsx, renderer, middleware) {
+  let index = 0;
+  const createNext = () => (App) => middleware[index++](App, renderer, createNext());
+  return createNext()(jsx);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reduce
+});

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

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var styledComponent_exports = {};
+__export(styledComponent_exports, {
+  toHtml: () => toHtml
+});
+module.exports = __toCommonJS(styledComponent_exports);
+var import_styled_components = require("styled-components");
+const toHtml = (jsx, renderer, next) => {
+  const sheet = new import_styled_components.ServerStyleSheet();
+  const html = next(sheet.collectStyles(jsx));
+  const css = sheet.getStyleTags();
+  renderer.result.chunksMap.css += css;
+  return html;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toHtml
+});

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

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var template_exports = {};
+__export(template_exports, {
+  Fragment: () => Fragment,
+  toFragments: () => toFragments
+});
+module.exports = __toCommonJS(template_exports);
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  toFragments
+});

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

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_exports = {};
+__export(type_exports, {
+  RenderLevel: () => RenderLevel
+});
+module.exports = __toCommonJS(type_exports);
+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 || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RenderLevel
+});

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

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  RenderLevel: () => import_type.RenderLevel
+});
+module.exports = __toCommonJS(types_exports);
+var import_type = require("./renderToString/type");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RenderLevel
+});

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

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getLoadableScripts: () => getLoadableScripts,
+  time: () => time
+});
+module.exports = __toCommonJS(utils_exports);
+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);
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLoadableScripts,
+  time
+});