routup 3.2.0 → 4.0.0

package/dist/adapters/node/module.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { RequestListener } from 'node:http';
 import type { Request } from '../../request';
 import type { Response } from '../../response';

package/dist/constants.d.ts

@@ -20,6 +20,7 @@ export declare enum HeaderName {
     CONTENT_LENGTH = "content-length",
     CONTENT_RANGE = "content-range",
     CONTENT_TYPE = "content-type",
+    CONNECTION = "connection",
     COOKIE = "cookie",
     ETag = "etag",
     HOST = "host",
@@ -34,6 +35,7 @@ export declare enum HeaderName {
     RETRY_AFTER = "retry-after",
     SET_COOKIE = "set-cookie",
     TRANSFER_ENCODING = "transfer-encoding",
+    X_ACCEL_BUFFERING = "x-accel-buffering",
     X_FORWARDED_HOST = "x-forwarded-host",
     X_FORWARDED_FOR = "x-forwarded-for",
     X_FORWARDED_PROTO = "x-forwarded-proto"

package/dist/handler/module.d.ts

@@ -12,7 +12,7 @@ export declare class Handler implements Dispatcher {
     protected _method: MethodName | undefined;
     constructor(handler: HandlerConfig);
     get type(): "error" | "core";
-    get path(): Path | undefined;
+    get path(): string | undefined;
     get method(): MethodName | undefined;
     dispatch(event: DispatchEvent): Promise<void>;
     matchPath(path: string): boolean;

package/dist/index.cjs

@@ -34,6 +34,7 @@ exports.HeaderName = void 0;
     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";
@@ -48,6 +49,7 @@ exports.HeaderName = void 0;
     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";
@@ -62,55 +64,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] = smob.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 (smob.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.
@@ -186,6 +139,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.
@@ -322,7 +281,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) {
@@ -378,12 +337,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, smob.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 (smob.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) {
@@ -511,13 +524,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) {
@@ -546,6 +556,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;
@@ -558,32 +572,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);
@@ -593,18 +598,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) {
@@ -751,15 +754,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(exports.HeaderName.CONTENT_TYPE, 'text/event-stream');
+        this.response.setHeader(exports.HeaderName.CACHE_CONTROL, 'private, no-cache, no-store, no-transform, must-revalidate, max-age=0');
+        this.response.setHeader(exports.HeaderName.X_ACCEL_BUFFERING, 'no');
+        if (!isRequestHTTP2(this.response.req)) {
+            this.response.setHeader(exports.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 readableStream.PassThrough({
+            encoding: 'utf-8'
+        });
+        this.flushed = false;
+        this.eventHandlers = {};
+        this.open();
+    }
+}
+
+function createEventStream(response) {
+    return new EventStream(response);
 }
 
 function appendResponseHeader(res, name, value) {
@@ -1634,12 +1724,14 @@ class PathMatcher {
         this.regexpKeys = [];
         this.path = path;
         this.regexpOptions = options || {};
-        this.regexp = pathToRegexp.pathToRegexp(path, this.regexpKeys, options);
+        const regexp = pathToRegexp.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 {
@@ -1832,15 +1924,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) {
@@ -2062,11 +2148,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)) {
@@ -2141,6 +2223,7 @@ class Router {
 
 exports.DispatchErrorEvent = DispatchErrorEvent;
 exports.DispatchEvent = DispatchEvent;
+exports.EventStream = EventStream;
 exports.Handler = Handler;
 exports.HandlerSymbol = HandlerSymbol;
 exports.PathMatcher = PathMatcher;
@@ -2150,6 +2233,7 @@ exports.appendResponseHeader = appendResponseHeader;
 exports.appendResponseHeaderDirective = appendResponseHeaderDirective;
 exports.coreHandler = coreHandler;
 exports.createError = createError;
+exports.createEventStream = createEventStream;
 exports.createNodeDispatcher = createNodeDispatcher;
 exports.createRawDispatcher = createRawDispatcher;
 exports.createRequest = createRequest;
@@ -2179,6 +2263,7 @@ exports.isHandlerConfig = isHandlerConfig;
 exports.isPath = isPath;
 exports.isPlugin = isPlugin;
 exports.isRequestCacheable = isRequestCacheable;
+exports.isRequestHTTP2 = isRequestHTTP2;
 exports.isResponseGone = isResponseGone;
 exports.matchRequestContentType = matchRequestContentType;
 exports.send = send;
@@ -2198,6 +2283,7 @@ exports.setRequestParams = setRequestParams;
 exports.setRequestRouterPath = setRequestRouterPath;
 exports.setResponseCacheHeaders = setResponseCacheHeaders;
 exports.setResponseContentTypeByFileName = setResponseContentTypeByFileName;
+exports.setResponseGone = setResponseGone;
 exports.setResponseHeaderAttachment = setResponseHeaderAttachment;
 exports.setResponseHeaderContentType = setResponseHeaderContentType;
 exports.transformHeaderToTuples = transformHeaderToTuples;