routup 3.2.0 → 4.0.0

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { subtle } from 'uncrypto';
 import { compile, all } from 'proxy-addr';
 import { getType, get } from 'mime-explorer';
 import Negotiator from 'negotiator';
-import { Readable, Writable } from 'readable-stream';
+import { Readable, PassThrough, Writable } from 'readable-stream';
 import { HTTPError } from '@ebec/http';
 import { pathToRegexp } from 'path-to-regexp';
 
@@ -32,6 +32,7 @@ var HeaderName;
     HeaderName["CONTENT_LENGTH"] = "content-length";
     HeaderName["CONTENT_RANGE"] = "content-range";
     HeaderName["CONTENT_TYPE"] = "content-type";
+    HeaderName["CONNECTION"] = "connection";
     HeaderName["COOKIE"] = "cookie";
     HeaderName["ETag"] = "etag";
     HeaderName["HOST"] = "host";
@@ -46,6 +47,7 @@ var HeaderName;
     HeaderName["RETRY_AFTER"] = "retry-after";
     HeaderName["SET_COOKIE"] = "set-cookie";
     HeaderName["TRANSFER_ENCODING"] = "transfer-encoding";
+    HeaderName["X_ACCEL_BUFFERING"] = "x-accel-buffering";
     HeaderName["X_FORWARDED_HOST"] = "x-forwarded-host";
     HeaderName["X_FORWARDED_FOR"] = "x-forwarded-for";
     HeaderName["X_FORWARDED_PROTO"] = "x-forwarded-proto";
@@ -60,55 +62,6 @@ function isRequestCacheable(req, modifiedTime) {
     return new Date(modifiedSince) >= modifiedTime;
 }
 
-const envSymbol = Symbol.for('ReqEnv');
-function setRequestEnv(req, key, value) {
-    if (envSymbol in req) {
-        if (typeof key === 'object') {
-            if (value) {
-                req[envSymbol] = merge(req[envSymbol], key);
-            } else {
-                req[envSymbol] = key;
-            }
-        } else {
-            req[envSymbol][key] = value;
-        }
-        return;
-    }
-    if (typeof key === 'object') {
-        req[envSymbol] = key;
-        return;
-    }
-    req[envSymbol] = {
-        [key]: value
-    };
-}
-function useRequestEnv(req, key) {
-    if (envSymbol in req) {
-        if (typeof key === 'string') {
-            return req[envSymbol][key];
-        }
-        return req[envSymbol];
-    }
-    if (typeof key === 'string') {
-        return undefined;
-    }
-    return {};
-}
-function unsetRequestEnv(req, key) {
-    if (envSymbol in req) {
-        if (hasOwnProperty(req[envSymbol], key)) {
-            delete req[envSymbol][key];
-        }
-    }
-}
-
-function getRequestHeader(req, name) {
-    return req.headers[name];
-}
-function setRequestHeader(req, name, value) {
-    req.headers[name] = value;
-}
-
 /*
   Set-Cookie header field-values are sometimes comma joined in one string. This splits them without choking on commas
   that are within a single set-cookie field-value, such as in the Expires portion.
@@ -184,6 +137,12 @@ function setRequestHeader(req, name, value) {
 function isObject(item) {
     return !!item && typeof item === 'object' && !Array.isArray(item);
 }
+function setProperty(record, property, value) {
+    record[property] = value;
+}
+function getProperty(req, property) {
+    return req[property];
+}
 
 /**
  * Determine if object is a Stats object.
@@ -320,7 +279,7 @@ function basename(input, extension) {
     if (!lastSegment) {
         return input;
     }
-    return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+    return lastSegment;
 }
 
 function isPromise(p) {
@@ -376,12 +335,66 @@ function isWebResponse(input) {
     return typeof Response !== 'undefined' && input instanceof Response;
 }
 
-const NegotiatorSymbol = Symbol.for('ReqNegotiator');
+const symbol$4 = Symbol.for('ReqEnv');
+function setRequestEnv(req, key, value) {
+    const propertyValue = getProperty(req, symbol$4);
+    if (propertyValue) {
+        if (typeof key === 'object') {
+            if (value) {
+                setProperty(req, symbol$4, merge(propertyValue, key));
+            } else {
+                setProperty(req, symbol$4, key);
+            }
+        } else {
+            propertyValue[key] = value;
+            setProperty(req, symbol$4, propertyValue);
+        }
+        return;
+    }
+    if (typeof key === 'object') {
+        setProperty(req, symbol$4, key);
+        return;
+    }
+    setProperty(req, symbol$4, {
+        [key]: value
+    });
+}
+function useRequestEnv(req, key) {
+    const propertyValue = getProperty(req, symbol$4);
+    if (propertyValue) {
+        if (typeof key !== 'undefined') {
+            return propertyValue[key];
+        }
+        return propertyValue;
+    }
+    if (typeof key !== 'undefined') {
+        return undefined;
+    }
+    return {};
+}
+function unsetRequestEnv(req, key) {
+    const propertyValue = getProperty(req, symbol$4);
+    if (hasOwnProperty(propertyValue, key)) {
+        delete propertyValue[key];
+    }
+}
+
+function getRequestHeader(req, name) {
+    return req.headers[name];
+}
+function setRequestHeader(req, name, value) {
+    req.headers[name] = value;
+}
+
+const symbol$3 = Symbol.for('ReqNegotiator');
 function useRequestNegotiator(req) {
-    if (NegotiatorSymbol in req) {
-        return req[NegotiatorSymbol];
+    let value = getProperty(req, symbol$3);
+    if (value) {
+        return value;
     }
-    return new Negotiator(req);
+    value = new Negotiator(req);
+    setProperty(req, symbol$3, value);
+    return value;
 }
 
 function getRequestAcceptableContentTypes(req) {
@@ -509,13 +522,10 @@ function findRouterOption(key, path) {
 
 const routerSymbol = Symbol.for('ReqRouterID');
 function setRequestRouterPath(req, path) {
-    req[routerSymbol] = path;
+    setProperty(req, routerSymbol, path);
 }
 function useRequestRouterPath(req) {
-    if (routerSymbol in req) {
-        return req[routerSymbol];
-    }
-    return undefined;
+    return getProperty(req, routerSymbol);
 }
 
 function getRequestHostName(req, options) {
@@ -544,6 +554,10 @@ function getRequestHostName(req, options) {
     return index !== -1 ? hostname.substring(0, index) : hostname;
 }
 
+function isRequestHTTP2(req) {
+    return typeof getRequestHeader(req, ':path') !== 'undefined' && typeof getRequestHeader(req, ':method') !== 'undefined';
+}
+
 function getRequestIP(req, options) {
     options = options || {};
     let trustProxy;
@@ -556,32 +570,23 @@ function getRequestIP(req, options) {
     return addrs[addrs.length - 1];
 }
 
-const ReqMountPathSymbol = Symbol.for('ReqMountPath');
+const symbol$2 = Symbol.for('ReqMountPath');
 function useRequestMountPath(req) {
-    if (ReqMountPathSymbol in req) {
-        return req[ReqMountPathSymbol];
-    }
-    return '/';
+    return getProperty(req, symbol$2) || '/';
 }
 function setRequestMountPath(req, basePath) {
-    req[ReqMountPathSymbol] = basePath;
+    setProperty(req, symbol$2, basePath);
 }
 
-const ParamsSymbol = Symbol.for('ReqParams');
+const symbol$1 = Symbol.for('ReqParams');
 function useRequestParams(req) {
-    /* istanbul ignore next */ if ('params' in req) {
-        return req.params;
-    }
-    if (ParamsSymbol in req) {
-        return req[ParamsSymbol];
-    }
-    return {};
+    return getProperty(req, symbol$1) || getProperty(req, 'params') || {};
 }
 function useRequestParam(req, key) {
     return useRequestParams(req)[key];
 }
 function setRequestParams(req, data) {
-    req[ParamsSymbol] = data;
+    setProperty(req, symbol$1, data);
 }
 function setRequestParam(req, key, value) {
     const params = useRequestParams(req);
@@ -591,18 +596,16 @@ function setRequestParam(req, key, value) {
 
 const PathSymbol = Symbol.for('ReqPath');
 function useRequestPath(req) {
-    if ('path' in req) {
-        return req.path;
-    }
-    if (PathSymbol in req) {
-        return req[PathSymbol];
+    const path = getProperty(req, 'path') || getProperty(req, PathSymbol);
+    if (path) {
+        return path;
     }
     if (typeof req.url === 'undefined') {
         return '/';
     }
     const parsed = new URL(req.url, 'http://localhost/');
-    req[PathSymbol] = parsed.pathname;
-    return req[PathSymbol];
+    setProperty(req, PathSymbol, parsed.pathname);
+    return parsed.pathname;
 }
 
 function getRequestProtocol(req, options) {
@@ -749,15 +752,102 @@ function setResponseCacheHeaders(res, options) {
     res.setHeader('cache-control', cacheControls.join(', '));
 }
 
-const GoneSymbol = Symbol.for('ResGone');
+const symbol = Symbol.for('ResGone');
 function isResponseGone(res) {
     if (res.headersSent || res.writableEnded) {
         return true;
     }
-    if (GoneSymbol in res) {
-        return res[GoneSymbol];
+    return getProperty(res, symbol) ?? false;
+}
+function setResponseGone(res, value) {
+    setProperty(res, symbol, value);
+}
+
+function serializeEventStreamMessage(message) {
+    let result = '';
+    if (message.id) {
+        result += `id: ${message.id}\n`;
     }
-    return false;
+    if (message.event) {
+        result += `event: ${message.event}\n`;
+    }
+    if (typeof message.retry === 'number' && Number.isInteger(message.retry)) {
+        result += `retry: ${message.retry}\n`;
+    }
+    result += `data: ${message.data}\n\n`;
+    return result;
+}
+
+class EventStream {
+    open() {
+        this.response.req.on('close', ()=>this.end());
+        this.response.req.on('error', (err)=>{
+            this.emit('error', err);
+            this.end();
+        });
+        this.passThrough.on('data', (chunk)=>this.response.write(chunk));
+        this.passThrough.on('error', (err)=>{
+            this.emit('error', err);
+            this.end();
+        });
+        this.passThrough.on('close', ()=>this.end());
+        this.response.setHeader(HeaderName.CONTENT_TYPE, 'text/event-stream');
+        this.response.setHeader(HeaderName.CACHE_CONTROL, 'private, no-cache, no-store, no-transform, must-revalidate, max-age=0');
+        this.response.setHeader(HeaderName.X_ACCEL_BUFFERING, 'no');
+        if (!isRequestHTTP2(this.response.req)) {
+            this.response.setHeader(HeaderName.CONNECTION, 'keep-alive');
+        }
+        this.response.statusCode = 200;
+    }
+    write(message) {
+        if (typeof message === 'string') {
+            this.write({
+                data: message
+            });
+            return;
+        }
+        if (!this.passThrough.closed && this.passThrough.writable) {
+            this.passThrough.write(serializeEventStreamMessage(message));
+        }
+    }
+    end() {
+        if (this.flushed) return;
+        this.flushed = true;
+        if (!this.passThrough.closed) {
+            this.passThrough.end();
+        }
+        this.emit('close');
+        setResponseGone(this.response, true);
+        this.response.end();
+    }
+    on(event, listener) {
+        if (typeof this.eventHandlers[event] === 'undefined') {
+            this.eventHandlers[event] = [];
+        }
+        this.eventHandlers[event].push(listener);
+    }
+    emit(event, ...args) {
+        if (typeof this.eventHandlers[event] === 'undefined') {
+            return;
+        }
+        const listeners = this.eventHandlers[event].slice();
+        for(let i = 0; i < listeners.length; i++){
+            listeners[i].apply(this, args);
+        }
+    }
+    constructor(response){
+        this.response = response;
+        this.passThrough = new PassThrough({
+            encoding: 'utf-8'
+        });
+        this.flushed = false;
+        this.eventHandlers = {};
+        this.open();
+    }
+}
+
+function createEventStream(response) {
+    return new EventStream(response);
 }
 
 function appendResponseHeader(res, name, value) {
@@ -1632,12 +1722,14 @@ class PathMatcher {
         this.regexpKeys = [];
         this.path = path;
         this.regexpOptions = options || {};
-        this.regexp = pathToRegexp(path, this.regexpKeys, options);
+        const regexp = pathToRegexp(path, options);
+        this.regexp = regexp;
+        this.regexpKeys = regexp.keys;
     }
 }
 
 function isPath(input) {
-    return typeof input === 'string' || input instanceof RegExp;
+    return typeof input === 'string';
 }
 
 class Handler {
@@ -1830,15 +1922,9 @@ class Router {
             this.pathMatcher = undefined;
             return;
         }
-        if (typeof value === 'string') {
-            this.pathMatcher = new PathMatcher(withLeadingSlash(withoutTrailingSlash(`${value}`)), {
-                end: false
-            });
-        } else {
-            this.pathMatcher = new PathMatcher(value, {
-                end: false
-            });
-        }
+        this.pathMatcher = new PathMatcher(withLeadingSlash(withoutTrailingSlash(`${value}`)), {
+            end: false
+        });
     }
     // --------------------------------------------------
     async executePipelineStep(context) {
@@ -2060,11 +2146,7 @@ class Router {
         for(let i = 0; i < input.length; i++){
             const item = input[i];
             if (isPath(item)) {
-                if (typeof item === 'string') {
-                    path = withLeadingSlash(item);
-                } else {
-                    path = item;
-                }
+                path = withLeadingSlash(item);
                 continue;
             }
             if (isRouterInstance(item)) {
@@ -2137,5 +2219,5 @@ class Router {
     }
 }
 
-export { DispatchErrorEvent, DispatchEvent, Handler, HandlerSymbol, HandlerType, HeaderName, MethodName, PathMatcher, Router, RoutupError, appendResponseHeader, appendResponseHeaderDirective, coreHandler, createError, createNodeDispatcher, createRawDispatcher, createRequest, createResponse, createWebDispatcher, dispatch, dispatchNodeRequest, dispatchRawRequest, dispatchWebRequest, errorHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isDispatcherErrorEvent, isError, isHandler, isHandlerConfig, isPath, isPlugin, isRequestCacheable, isResponseGone, matchRequestContentType, send, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, sendWebBlob, sendWebResponse, setRequestEnv, setRequestHeader, setRequestMountPath, setRequestParam, setRequestParams, setRequestRouterPath, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseHeaderAttachment, setResponseHeaderContentType, transformHeaderToTuples, transformHeadersToTuples, unsetRequestEnv, useRequestEnv, useRequestMountPath, useRequestNegotiator, useRequestParam, useRequestParams, useRequestPath, useRequestRouterPath };
+export { DispatchErrorEvent, DispatchEvent, EventStream, Handler, HandlerSymbol, HandlerType, HeaderName, MethodName, PathMatcher, Router, RoutupError, appendResponseHeader, appendResponseHeaderDirective, coreHandler, createError, createEventStream, createNodeDispatcher, createRawDispatcher, createRequest, createResponse, createWebDispatcher, dispatch, dispatchNodeRequest, dispatchRawRequest, dispatchWebRequest, errorHandler, getRequestAcceptableCharset, getRequestAcceptableCharsets, getRequestAcceptableContentType, getRequestAcceptableContentTypes, getRequestAcceptableEncoding, getRequestAcceptableEncodings, getRequestAcceptableLanguage, getRequestAcceptableLanguages, getRequestHeader, getRequestHostName, getRequestIP, getRequestProtocol, isDispatcherErrorEvent, isError, isHandler, isHandlerConfig, isPath, isPlugin, isRequestCacheable, isRequestHTTP2, isResponseGone, matchRequestContentType, send, sendAccepted, sendCreated, sendFile, sendFormat, sendRedirect, sendStream, sendWebBlob, sendWebResponse, setRequestEnv, setRequestHeader, setRequestMountPath, setRequestParam, setRequestParams, setRequestRouterPath, setResponseCacheHeaders, setResponseContentTypeByFileName, setResponseGone, setResponseHeaderAttachment, setResponseHeaderContentType, transformHeaderToTuples, transformHeadersToTuples, unsetRequestEnv, useRequestEnv, useRequestMountPath, useRequestNegotiator, useRequestParam, useRequestParams, useRequestPath, useRequestRouterPath };
 //# sourceMappingURL=index.mjs.map