@modern-js/prod-server 1.22.1 → 2.0.0-alpha.0

package/dist/js/node/libs/context/context.js

@@ -1,255 +1,189 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 context_exports = {};
+__export(context_exports, {
+  ModernServerContext: () => ModernServerContext
 });
-exports.ModernServerContext = void 0;
-
-var _url = require("url");
-
-var _querystring = _interopRequireDefault(require("querystring"));
-
-var _buffer = require("buffer");
-
-var _etag = _interopRequireDefault(require("etag"));
-
-var _fresh = _interopRequireDefault(require("fresh"));
-
-var _utils = require("../../utils");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-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; }
-
+module.exports = __toCommonJS(context_exports);
+var import_url = require("url");
+var import_querystring = __toESM(require("querystring"));
+var import_buffer = require("buffer");
+var import_etag = __toESM(require("etag"));
+var import_fresh = __toESM(require("fresh"));
+var import_utils = require("../../utils");
 class ModernServerContext {
-  /**
-   * http request
-   */
-
-  /**
-   * http response
-   */
-
-  /**
-   * url params
-   */
-  get logger() {
-    return this.req.logger;
-  }
-
-  get metrics() {
-    return this.req.metrics;
-  }
-
   constructor(req, res, options) {
-    _defineProperty(this, "req", void 0);
-
-    _defineProperty(this, "res", void 0);
-
-    _defineProperty(this, "params", {});
-
-    _defineProperty(this, "serverData", void 0);
-
-    _defineProperty(this, "options", {});
-
+    this.params = {};
+    this.options = {};
     this.req = req;
     this.res = res;
     this.options = options || {};
     this.serverData = {};
     this.bind();
   }
-
+  get logger() {
+    return this.req.logger;
+  }
+  get metrics() {
+    return this.req.metrics;
+  }
   bind() {
-    const {
-      req,
-      res
-    } = this;
-
-    req.get = key => this.getReqHeader(key);
-
+    const { req, res } = this;
+    req.get = (key) => this.getReqHeader(key);
     res.set = (key, value) => this.res.setHeader(key, value);
-
-    res.send = body => {
+    res.send = (body) => {
       this.send(body);
     };
-  } // compat express res.send, only support etag now
-
-
+  }
   send(body) {
     try {
-      const generateETag = !this.res.getHeader('ETag') && this.options.etag;
-
-      if (body !== undefined && generateETag) {
-        const encoding = typeof body === 'string' ? 'utf-8' : undefined;
-        const buf = !_buffer.Buffer.isBuffer(body) ? _buffer.Buffer.from(body, encoding) : body;
-        const etag = (0, _etag.default)(buf, {
-          weak: true
-        });
-
+      const generateETag = !this.res.getHeader("ETag") && this.options.etag;
+      if (body !== void 0 && generateETag) {
+        const encoding = typeof body === "string" ? "utf-8" : void 0;
+        const buf = !import_buffer.Buffer.isBuffer(body) ? import_buffer.Buffer.from(body, encoding) : body;
+        const etag = (0, import_etag.default)(buf, { weak: true });
         if (etag) {
-          this.res.setHeader('ETag', etag);
+          this.res.setHeader("ETag", etag);
         }
       }
-
       if (this.fresh) {
         this.status = 304;
       }
     } catch (e) {
       this.logger.error(e.message);
     }
-
     this.res.end(body);
   }
-
   setParams(params) {
     this.params = params;
   }
-
   setServerData(key, value) {
     this.serverData[key] = value;
   }
-
   getReqHeader(key) {
-    const {
-      req
-    } = this;
+    const { req } = this;
     const field = key.toLowerCase();
-
     switch (field) {
-      case 'referer':
-      case 'referrer':
-        return req.headers.referrer || req.headers.referer || '';
-
+      case "referer":
+      case "referrer":
+        return req.headers.referrer || req.headers.referer || "";
       default:
-        return req.headers[field] || '';
+        return req.headers[field] || "";
     }
   }
-
   get fresh() {
-    const {
-      status,
-      res,
-      method
-    } = this; // GET or HEAD for weak freshness validation only
-
-    if ('GET' !== method && 'HEAD' !== method) {
+    const { status, res, method } = this;
+    if ("GET" !== method && "HEAD" !== method) {
       return false;
     }
-
     if (status >= 200 && status < 300 || 304 === status) {
-      return (0, _fresh.default)(this.headers, {
-        etag: res.getHeader('ETag'),
-        'last-modified': res.getHeader('Last-Modified')
+      return (0, import_fresh.default)(this.headers, {
+        etag: res.getHeader("ETag"),
+        "last-modified": res.getHeader("Last-Modified")
       });
     }
-
     return false;
   }
-  /* request property */
-
-
   get headers() {
     return this.req.headers;
   }
-
   get method() {
     return this.req.method;
   }
-
   get url() {
-    return this.req.url || '';
+    return this.req.url || "";
   }
-
   set url(val) {
     this.req.url = val;
   }
-
   get host() {
-    let host = this.getReqHeader('X-Forwarded-Host');
-
+    let host = this.getReqHeader("X-Forwarded-Host");
     if (!host) {
-      host = this.getReqHeader('Host');
+      host = this.getReqHeader("Host");
     }
-
-    return host.split(/\s*,\s*/, 1)[0] || '';
+    return host.split(/\s*,\s*/, 1)[0] || "";
   }
-
   get protocol() {
     if (this.req.socket.encrypted) {
-      return 'https';
+      return "https";
     }
-
-    const proto = this.getReqHeader('X-Forwarded-Proto');
-    return proto ? proto.split(/\s*,\s*/, 1)[0] : 'http';
+    const proto = this.getReqHeader("X-Forwarded-Proto");
+    return proto ? proto.split(/\s*,\s*/, 1)[0] : "http";
   }
-
   get origin() {
     return `${this.protocol}://${this.host}`;
   }
-
   get href() {
     return this.origin + this.url;
   }
-
   get parsedURL() {
-    const url = new _url.URL(this.req.url, this.origin);
+    const url = new import_url.URL(this.req.url, this.origin);
     return url;
   }
-
   get path() {
     return this.parsedURL.pathname;
   }
-
   set path(p) {
-    const url = new _url.URL(this.req.url, this.origin); // this should never happened
-
+    const url = new import_url.URL(this.req.url, this.origin);
     if (!url || !p) {
       return;
     }
-
     if (url.pathname === p) {
       return;
     }
-
     url.pathname = p;
     this.url = url.toString();
   }
-
   get querystring() {
     if (!this.req) {
-      return '';
+      return "";
     }
-
-    return this.parsedURL.search.replace(/^\?/, '') || '';
+    return this.parsedURL.search.replace(/^\?/, "") || "";
   }
-
   get query() {
     const str = this.querystring;
-    return _querystring.default.parse(str);
+    return import_querystring.default.parse(str);
   }
-  /* response property */
-
-
   get status() {
     return this.res.statusCode;
   }
-
   set status(statusCode) {
     this.res.statusCode = statusCode;
   }
-  /**
-   * 判断链接是否已经关闭
-   */
-
-
   resHasHandled() {
     return this.res.writableEnded;
   }
-
-  error(dig, e = '') {
-    this.logger.error(`Web Server Error - ${dig}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, this.path, (0, _utils.headersWithoutCookie)(this.headers));
+  error(dig, e = "") {
+    this.logger.error(
+      `Web Server Error - ${dig}, error = %s, req.url = %s, req.headers = %o`,
+      e instanceof Error ? e.stack || e.message : e,
+      this.path,
+      (0, import_utils.headersWithoutCookie)(this.headers)
+    );
   }
-
 }
-
-exports.ModernServerContext = ModernServerContext;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModernServerContext
+});

package/dist/js/node/libs/context/index.js

@@ -1,18 +1,30 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "ModernServerContext", {
-  enumerable: true,
-  get: function () {
-    return _context.ModernServerContext;
+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 context_exports = {};
+__export(context_exports, {
+  ModernServerContext: () => import_context.ModernServerContext,
+  createContext: () => createContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_context = require("./context");
+const createContext = (req, res, options) => new import_context.ModernServerContext(req, res, options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModernServerContext,
+  createContext
 });
-exports.createContext = void 0;
-
-var _context = require("./context");
-
-const createContext = (req, res, options) => new _context.ModernServerContext(req, res, options);
-
-exports.createContext = createContext;

package/dist/js/node/libs/hook-api/index.js

@@ -0,0 +1,164 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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));
+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 hook_api_exports = {};
+__export(hook_api_exports, {
+  base: () => base,
+  createAfterMatchContext: () => createAfterMatchContext,
+  createAfterRenderContext: () => createAfterRenderContext,
+  createMiddlewareContext: () => createMiddlewareContext
+});
+module.exports = __toCommonJS(hook_api_exports);
+var import_cookie = __toESM(require("cookie"));
+var import_route = require("./route");
+var import_template = require("./template");
+class Response {
+  constructor(res) {
+    this.res = res;
+    this._cookie = import_cookie.default.parse(res.getHeader("set-cookie") || "");
+    this.cookies = {
+      get: this.getCookie.bind(this),
+      set: this.setCookie.bind(this),
+      delete: this.deleteCookie.bind(this),
+      clear: this.clearCookie.bind(this),
+      apply: this.applyCookie.bind(this)
+    };
+  }
+  get(key) {
+    return this.res.getHeader(key);
+  }
+  set(key, value) {
+    return this.res.setHeader(key, value);
+  }
+  status(code) {
+    this.res.statusCode = code;
+  }
+  getCookie(key) {
+    return this._cookie[key];
+  }
+  setCookie(key, value) {
+    this._cookie[key] = value;
+  }
+  deleteCookie(key) {
+    if (this._cookie[key]) {
+      delete this._cookie[key];
+    }
+  }
+  clearCookie() {
+    this._cookie = {};
+  }
+  applyCookie() {
+    const str = Object.entries(this._cookie).map(([key, value]) => {
+      return import_cookie.default.serialize(key, value);
+    }).join("; ");
+    if (str) {
+      this.res.setHeader("set-cookie", str);
+    } else {
+      this.res.removeHeader("set-cookie");
+    }
+  }
+  raw(body, options) {
+    const { status, headers = {} } = options || {};
+    Object.entries(headers).forEach(([key, value]) => {
+      this.res.setHeader(key, value);
+    });
+    if (status) {
+      this.res.statusCode = status;
+    }
+    this.res.end(body);
+  }
+}
+class Request {
+  constructor(ctx) {
+    this.url = ctx.url;
+    this.host = ctx.host;
+    this.pathname = ctx.path;
+    this.query = ctx.query;
+    this.headers = ctx.headers;
+    this.cookie = ctx.headers.cookie || "";
+    this._cookie = import_cookie.default.parse(this.cookie);
+    this.cookies = {
+      get: this.getCookie.bind(this)
+    };
+  }
+  getCookie(key) {
+    return this._cookie[key];
+  }
+}
+const base = (context) => {
+  const { res } = context;
+  return {
+    response: new Response(res),
+    request: new Request(context),
+    logger: context.logger,
+    metrics: context.metrics
+  };
+};
+const createAfterMatchContext = (context, entryName) => {
+  const baseContext = base(context);
+  return __spreadProps(__spreadValues({}, baseContext), {
+    router: new import_route.RouteAPI(entryName)
+  });
+};
+const createAfterRenderContext = (context, content) => {
+  const baseContext = base(context);
+  return __spreadProps(__spreadValues({}, baseContext), {
+    template: new import_template.TemplateAPI(content)
+  });
+};
+const createMiddlewareContext = (context) => {
+  const baseContext = base(context);
+  return __spreadProps(__spreadValues({}, baseContext), {
+    response: __spreadProps(__spreadValues({}, baseContext.response), {
+      locals: context.res.locals || {}
+    }),
+    source: {
+      req: context.req,
+      res: context.res
+    }
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base,
+  createAfterMatchContext,
+  createAfterRenderContext,
+  createMiddlewareContext
+});

package/dist/js/node/libs/hook-api/route.js

@@ -1,53 +1,43 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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 route_exports = {};
+__export(route_exports, {
+  RouteAPI: () => RouteAPI
 });
-exports.createRouteAPI = void 0;
-
-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; }
-
+module.exports = __toCommonJS(route_exports);
 class RouteAPI {
-  constructor(matched, router, url) {
-    _defineProperty(this, "router", void 0);
-
-    _defineProperty(this, "current", void 0);
-
-    _defineProperty(this, "url", void 0);
-
-    this.current = matched;
-    this.router = router;
-    this.url = url;
+  constructor(entryName) {
+    this.current = entryName;
+    this.status = 200;
+    this.url = "";
   }
-
-  cur() {
-    return this.current.generate(this.url);
+  redirect(url, status = 302) {
+    this.url = url;
+    this.status = status;
   }
-
-  get(entryName) {
-    const {
-      router
-    } = this;
-    const matched = router.matchEntry(entryName);
-    return matched ? matched.generate(this.url) : null;
+  rewrite(entryName) {
+    this.current = entryName;
   }
-
   use(entryName) {
-    const {
-      router
-    } = this;
-    const matched = router.matchEntry(entryName);
-
-    if (matched) {
-      this.current = matched;
-      return true;
-    } else {
-      return false;
-    }
+    this.rewrite(entryName);
   }
-
 }
-
-const createRouteAPI = (matched, router, url) => new RouteAPI(matched, router, url);
-
-exports.createRouteAPI = createRouteAPI;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RouteAPI
+});