@modern-js/prod-server 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/js/modern/libs/render/cache/spr.js

@@ -1,10 +1,35 @@
-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; }
-/* eslint-disable @typescript-eslint/member-ordering */
-/* eslint-disable no-lone-blocks */
-import crypto from 'crypto';
-import LRUCache from 'lru-cache';
-import { mime } from '@modern-js/utils';
-import { cacheAddition, connectFactor, fname, maybeSync, namespaceHash, valueFactory, withCoalescedInvoke } from "./util";
+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 crypto from "crypto";
+import LRUCache from "lru-cache";
+import { mime } from "@modern-js/utils";
+import {
+  cacheAddition,
+  connectFactor,
+  fname,
+  maybeSync,
+  namespaceHash,
+  valueFactory,
+  withCoalescedInvoke
+} from "./util";
 import { createPageCaches } from "./page-caches";
 const MAX_CACHE_EACH_REQ = Number(process.env.ROUTE_CACHE_LIMIT) || 10;
 const MAX_SIZE_EACH_CLUSTER = Number(process.env.CLUSTER_CACHE_LIMIT) || 100;
@@ -14,16 +39,11 @@ const HEADER_LEVEL = 2;
 const QUERY_HEADER_LEVEL = 3;
 class CacheManager {
   constructor(cacheOptions) {
-    _defineProperty(this, "cache", void 0);
-    _defineProperty(this, "cacheOptions", void 0);
-    _defineProperty(this, "find", (() => {
+    this.find = (() => {
       {
-        // eslint-disable-next-line consistent-this,@typescript-eslint/no-this-alias
         const _this = this;
         return {
-          [fname(BASE_LEVEL)](context, cacheKey
-          // data: CacheContent,
-          ) {
+          [fname(BASE_LEVEL)](context, cacheKey) {
             return _this.md5(cacheKey);
           },
           [fname(QUERY_LEVEL)](context, cacheKey, data) {
@@ -50,34 +70,30 @@ class CacheManager {
           }
         };
       }
-    })());
+    })();
     this.cacheOptions = cacheOptions;
     this.cache = new LRUCache({
       max: Math.min(MAX_SIZE_EACH_CLUSTER, 600) * 1024 * 1024,
-      // 默认存 100M，最大 600M
       length(n) {
         const len = n.caches.keys().reduce((total, cur) => {
-          var _n$caches$peek;
-          return total + (((_n$caches$peek = n.caches.peek(cur)) === null || _n$caches$peek === void 0 ? void 0 : _n$caches$peek.size) || 0);
+          var _a;
+          return total + (((_a = n.caches.peek(cur)) == null ? void 0 : _a.size) || 0);
         }, 1);
         return len;
       }
     });
   }
   md5(content) {
-    const md5 = crypto.createHash('md5');
-    return md5.update(content).digest('hex');
+    const md5 = crypto.createHash("md5");
+    return md5.update(content).digest("hex");
   }
   generateRequestKey(context) {
-    const {
-      pathname,
-      entry
-    } = context;
+    const { pathname, entry } = context;
     return this.md5(`${pathname}_${entry}`);
   }
   replaceValue(value, matcher) {
     let final = value;
-    Object.keys(matcher).some(replacer => {
+    Object.keys(matcher).some((replacer) => {
       const reg = new RegExp(matcher[replacer]);
       if (reg.test(value)) {
         final = replacer;
@@ -91,19 +107,19 @@ class CacheManager {
     keys.sort();
     const getValue = valueFactory(obj);
     const factorAry = keys.reduce((ary, key) => {
-      let value = getValue(key) || '';
+      let value = getValue(key) || "";
       const matcher = matches[key];
       if (matcher) {
         value = this.replaceValue(value, matcher);
       }
       return ary.concat([key, value]);
     }, []);
-    return factorAry.join(',');
+    return factorAry.join(",");
   }
   queryFactor(context, data) {
-    var _data$includes, _data$matches;
-    const queryKeys = (_data$includes = data.includes) === null || _data$includes === void 0 ? void 0 : _data$includes.query;
-    const queryMatches = (_data$matches = data.matches) === null || _data$matches === void 0 ? void 0 : _data$matches.query;
+    var _a, _b;
+    const queryKeys = (_a = data.includes) == null ? void 0 : _a.query;
+    const queryMatches = (_b = data.matches) == null ? void 0 : _b.query;
     if (!queryKeys || queryKeys.length === 0) {
       return null;
     }
@@ -112,9 +128,9 @@ class CacheManager {
     return queryFactor;
   }
   headerFactor(context, data) {
-    var _data$includes2, _data$matches2;
-    const headerKeys = (_data$includes2 = data.includes) === null || _data$includes2 === void 0 ? void 0 : _data$includes2.header;
-    const headerMatches = (_data$matches2 = data.matches) === null || _data$matches2 === void 0 ? void 0 : _data$matches2.header;
+    var _a, _b;
+    const headerKeys = (_a = data.includes) == null ? void 0 : _a.header;
+    const headerMatches = (_b = data.matches) == null ? void 0 : _b.header;
     if (!headerKeys || headerKeys.length === 0) {
       return null;
     }
@@ -122,15 +138,15 @@ class CacheManager {
     const headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
     return headerFactor;
   }
-  async best(context, cacheKey, data) {
-    const {
-      level
-    } = data;
-    const cacheHash = this.find[fname(level)](context, cacheKey, data);
-    if (!cacheHash) {
-      return null;
-    }
-    return data.caches.get(cacheHash);
+  best(context, cacheKey, data) {
+    return __async(this, null, function* () {
+      const { level } = data;
+      const cacheHash = this.find[fname(level)](context, cacheKey, data);
+      if (!cacheHash) {
+        return null;
+      }
+      return data.caches.get(cacheHash);
+    });
   }
   createCacheContent(config, caches) {
     return {
@@ -142,91 +158,91 @@ class CacheManager {
       caches
     };
   }
-  async get(context) {
-    const cacheKey = this.generateRequestKey(context);
-    const data = this.cache.get(cacheKey);
-
-    // no cache key matched
-    if (!data) {
-      return null;
-    }
-    const dest = await this.best(context, cacheKey, data);
-    // no cache for current page with current config
-    if (!dest) {
-      return null;
-    }
-    const {
-      expireTime,
-      limitTime,
-      html,
-      cacheHash
-    } = dest;
-    const isStale = Date.now() - expireTime > 0;
-    const isGarbage = limitTime ? Date.now() - limitTime > 0 : false;
-    return {
-      content: html || '',
-      contentType: mime.contentType('html'),
-      isStale,
-      isGarbage,
-      hash: cacheHash
-    };
+  get(context) {
+    return __async(this, null, function* () {
+      const cacheKey = this.generateRequestKey(context);
+      const data = this.cache.get(cacheKey);
+      if (!data) {
+        return null;
+      }
+      const dest = yield this.best(context, cacheKey, data);
+      if (!dest) {
+        return null;
+      }
+      const { expireTime, limitTime, html, cacheHash } = dest;
+      const isStale = Date.now() - expireTime > 0;
+      const isGarbage = limitTime ? Date.now() - limitTime > 0 : false;
+      return {
+        content: html || "",
+        contentType: mime.contentType("html"),
+        isStale,
+        isGarbage,
+        hash: cacheHash
+      };
+    });
   }
-  async set(context, html, cacheConfig, sync = false) {
-    if (!cacheConfig) {
-      return false;
-    }
-
-    // each version with route is a separate cache
-    const cacheKey = this.generateRequestKey(context);
-    let data = this.cache.get(cacheKey);
-    if (!data) {
-      const caches = await createPageCaches(MAX_CACHE_EACH_REQ);
-      data = this.createCacheContent(cacheConfig, caches);
-    }
-    const cacheHash = this.find[fname(cacheConfig.level)](context, cacheKey, data);
-
-    // if cacheHash is null, maybe level not match meta key, do not cache
-    if (!cacheHash) {
-      return false;
-    }
-    const cacheSyncOrAsync = async () => {
-      const next = data;
-      const limit = cacheConfig.staleLimit;
-      const storeHTML = cacheAddition(html, cacheHash);
-      const size = storeHTML.length;
-      await next.caches.set(cacheHash, {
-        expireTime: Date.now() + cacheConfig.interval * 1000,
-        limitTime: typeof limit === 'number' ? Date.now() + limit * 1000 : null,
-        cacheHash,
-        html: storeHTML,
-        size
+  set(context, html, cacheConfig, sync = false) {
+    return __async(this, null, function* () {
+      if (!cacheConfig) {
+        return false;
+      }
+      const cacheKey = this.generateRequestKey(context);
+      let data = this.cache.get(cacheKey);
+      if (!data) {
+        const caches = yield createPageCaches(MAX_CACHE_EACH_REQ);
+        data = this.createCacheContent(cacheConfig, caches);
+      }
+      const cacheHash = this.find[fname(cacheConfig.level)](
+        context,
+        cacheKey,
+        data
+      );
+      if (!cacheHash) {
+        return false;
+      }
+      const cacheSyncOrAsync = () => __async(this, null, function* () {
+        const next = data;
+        const limit = cacheConfig.staleLimit;
+        const storeHTML = cacheAddition(html, cacheHash);
+        const size = storeHTML.length;
+        yield next.caches.set(cacheHash, {
+          expireTime: Date.now() + cacheConfig.interval * 1e3,
+          limitTime: typeof limit === "number" ? Date.now() + limit * 1e3 : null,
+          cacheHash,
+          html: storeHTML,
+          size
+        });
+        this.cache.set(cacheKey, next);
+        return true;
       });
-      this.cache.set(cacheKey, next);
-      return true;
-    };
-
-    // cache set is async, each hash is cached only once at the same time
-    const doCache = withCoalescedInvoke(cacheSyncOrAsync).bind(null, namespaceHash('stream', cacheHash), []);
-    return maybeSync(doCache)(sync);
+      const doCache = withCoalescedInvoke(cacheSyncOrAsync).bind(
+        null,
+        namespaceHash("stream", cacheHash),
+        []
+      );
+      return maybeSync(doCache)(sync);
+    });
   }
-  async del(context, cacheHash) {
-    const cacheKey = this.generateRequestKey(context);
-    const data = this.cache.get(cacheKey);
-    data === null || data === void 0 ? void 0 : data.caches.del(cacheHash);
+  del(context, cacheHash) {
+    return __async(this, null, function* () {
+      const cacheKey = this.generateRequestKey(context);
+      const data = this.cache.get(cacheKey);
+      data == null ? void 0 : data.caches.del(cacheHash);
+    });
   }
 }
 let manager;
-export function createCache() {
+function createCache() {
   if (manager) {
     return manager;
   }
-  manager = new CacheManager({
-    max: 0
-  });
+  manager = new CacheManager({ max: 0 });
   return manager;
 }
-export function destroyCache() {
+function destroyCache() {
   manager = null;
 }
-/* eslint-enable no-lone-blocks */
-/* eslint-enable @typescript-eslint/member-ordering */
+export {
+  createCache,
+  destroyCache
+};

package/dist/js/modern/libs/render/cache/type.js

@@ -1 +0,0 @@
-export {};

package/dist/js/modern/libs/render/cache/util.js

@@ -1,65 +1,87 @@
-import url from 'url';
-export function namespaceHash(namespace, hash) {
+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 url from "url";
+function namespaceHash(namespace, hash) {
   return `${namespace}/${hash}`;
 }
-export function fname(lv) {
+function fname(lv) {
   return `f${lv}`;
 }
-export function connectFactor(...args) {
-  return args.join('-');
+function connectFactor(...args) {
+  return args.join("-");
 }
-export function valueFactory(obj) {
+function valueFactory(obj) {
   if (obj instanceof url.URLSearchParams) {
-    return function (key) {
+    return function(key) {
       return obj.get(key);
     };
   } else {
-    return function (key) {
+    return function(key) {
       const value = obj[key];
       if (Array.isArray(value)) {
-        return value.join(',');
+        return value.join(",");
       }
       return value;
     };
   }
 }
-export function getTime([s, ns]) {
+function getTime([s, ns]) {
   return Math.floor(s * 1e3 + ns / 1e6);
 }
 const RE_START_IN_HEAD = /<head>/;
-export function cacheAddition(html, hash) {
-  const additionHtml = html.replace(RE_START_IN_HEAD, `<head><meta name="x-moden-spr" content="${hash}">`);
+function cacheAddition(html, hash) {
+  const additionHtml = html.replace(
+    RE_START_IN_HEAD,
+    `<head><meta name="x-moden-spr" content="${hash}">`
+  );
   return additionHtml;
 }
-const globalInvokeCache = new Map();
-export function withCoalescedInvoke(func) {
-  return async function (key, args) {
-    const entry = globalInvokeCache.get(key);
-    if (entry) {
-      return entry.then(res => ({
-        isOrigin: false,
-        value: res.value
-      }));
-    }
-    function __wrapper() {
-      return func(...args);
-    }
-    const future = __wrapper().then(res => {
-      globalInvokeCache.delete(key);
-      return {
-        isOrigin: true,
-        value: res
-      };
-    }).catch(err => {
-      globalInvokeCache.delete(key);
-      throw err;
+const globalInvokeCache = /* @__PURE__ */ new Map();
+function withCoalescedInvoke(func) {
+  return function(key, args) {
+    return __async(this, null, function* () {
+      const entry = globalInvokeCache.get(key);
+      if (entry) {
+        return entry.then((res) => ({
+          isOrigin: false,
+          value: res.value
+        }));
+      }
+      function __wrapper() {
+        return func(...args);
+      }
+      const future = __wrapper().then((res) => {
+        globalInvokeCache.delete(key);
+        return { isOrigin: true, value: res };
+      }).catch((err) => {
+        globalInvokeCache.delete(key);
+        throw err;
+      });
+      globalInvokeCache.set(key, future);
+      return future;
     });
-    globalInvokeCache.set(key, future);
-    return future;
   };
 }
-export function maybeSync(fn) {
-  return sync => {
+function maybeSync(fn) {
+  return (sync) => {
     if (sync) {
       return fn();
     } else {
@@ -67,4 +89,14 @@ export function maybeSync(fn) {
       return Promise.resolve();
     }
   };
-}
+}
+export {
+  cacheAddition,
+  connectFactor,
+  fname,
+  getTime,
+  maybeSync,
+  namespaceHash,
+  valueFactory,
+  withCoalescedInvoke
+};

package/dist/js/modern/libs/render/index.js

@@ -1,64 +1,84 @@
-import path from 'path';
-import { fs, mime } from '@modern-js/utils';
+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 path from "path";
+import { fs, mime } from "@modern-js/utils";
 import { ERROR_DIGEST } from "../../constants";
 import { handleDirectory } from "./static";
 import { readFile } from "./reader";
 import * as ssr from "./ssr";
-import { supportModern, getModernEntry } from "./modern";
-export const createRenderHandler = ({
+const createRenderHandler = ({
   distDir,
   staticGenerate
-}) => async function render({
-  ctx,
-  route,
-  runner
-}) {
-  if (ctx.resHasHandled()) {
-    return null;
-  }
-  const {
-    entryPath,
-    urlPath
-  } = route;
-  const entry = path.join(distDir, entryPath);
-  if (!route.isSPA) {
-    const result = await handleDirectory(ctx, entry, urlPath);
-    return result;
-  }
-
-  // only spa can use es6-html
-  const modernEntry = getModernEntry(entry);
-  const useModern =
-  // route.enableModernMode &&
-  supportModern(ctx) && fs.existsSync(modernEntry);
-  const templatePath = useModern ? modernEntry : entry;
-  if (!fs.existsSync(templatePath)) {
-    throw new Error(`Could not find template file: ${templatePath}`);
-  }
-  const content = await readFile(templatePath);
-  if (!content) {
-    return null;
-  }
-
-  // handles ssr first
-  if (route.isSSR) {
-    try {
-      const result = await ssr.render(ctx, {
-        distDir,
-        entryName: route.entryName,
-        urlPath: route.urlPath,
-        bundle: route.bundle,
-        template: content.toString(),
-        staticGenerate
-      }, runner);
+}) => function render(_0) {
+  return __async(this, arguments, function* ({
+    ctx,
+    route,
+    runner
+  }) {
+    if (ctx.resHasHandled()) {
+      return null;
+    }
+    const { entryPath, urlPath } = route;
+    const entry = path.join(distDir, entryPath);
+    if (!route.isSPA) {
+      const result = yield handleDirectory(ctx, entry, urlPath);
       return result;
-    } catch (err) {
-      ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);
-      ctx.res.setHeader('x-modern-ssr-fallback', '1');
     }
-  }
-  return {
-    content,
-    contentType: mime.contentType(path.extname(templatePath))
-  };
-};
+    const templatePath = entry;
+    if (!fs.existsSync(templatePath)) {
+      throw new Error(`Could not find template file: ${templatePath}`);
+    }
+    const content = yield readFile(templatePath);
+    if (!content) {
+      return null;
+    }
+    if (route.isSSR) {
+      try {
+        const result = yield ssr.render(
+          ctx,
+          {
+            distDir,
+            entryName: route.entryName,
+            urlPath: route.urlPath,
+            bundle: route.bundle,
+            template: content.toString(),
+            staticGenerate
+          },
+          runner
+        );
+        return result;
+      } catch (err) {
+        ctx.error(
+          ERROR_DIGEST.ERENDER,
+          err.stack || err.message
+        );
+        ctx.res.setHeader("x-modern-ssr-fallback", "1");
+      }
+    }
+    return {
+      content,
+      contentType: mime.contentType(path.extname(templatePath))
+    };
+  });
+};
+export {
+  createRenderHandler
+};