webhoster 0.3.2 → 0.3.4

package/middleware/ContentDecoderMiddleware.js

@@ -1,9 +1,10 @@
 import { Transform } from 'node:stream';
 import {
+  // @ts-expect-error Bad typings
   BrotliDecompress, Gunzip, Inflate,
 } from 'node:zlib';
 
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
 
 /**
  * @typedef ContentDecoderMiddlewareOptions
@@ -69,17 +70,20 @@ export default class ContentDecoderMiddleware {
     const gzipOptions = { chunkSize: this.chunkSize };
     const newDownstream = new Transform({
 
-      read: (...args) => {
+      read: (...arguments_) => {
         if (!initialized) {
           /** @type {import("zlib").Gzip} */
           switch (contentEncoding) {
             case 'deflate':
+              // @ts-expect-error Bad typings
               gzipStream = new Inflate(gzipOptions);
               break;
             case 'gzip':
+              // @ts-expect-error Bad typings
               gzipStream = new Gunzip(gzipOptions);
               break;
             case 'br':
+              // @ts-expect-error Bad typings
               gzipStream = new BrotliDecompress(gzipOptions);
               break;
             default:
@@ -89,7 +93,7 @@ export default class ContentDecoderMiddleware {
           // To newDownstream <= gzipStream < =inputStream
 
           // Forward errors
-          gzipStream.on('error', (err) => inputStream.emit('error', err));
+          gzipStream.on('error', (error) => inputStream.emit('error', error));
           gzipStream.on('data', (chunk) => newDownstream.push(chunk));
 
           inputStream.on('end', () => gzipStream.end());
@@ -104,12 +108,13 @@ export default class ContentDecoderMiddleware {
           initialized = true;
         }
 
-        Transform.prototype._read.call(this, ...args);
+        // eslint-disable-next-line no-underscore-dangle
+        Transform.prototype._read.call(this, ...arguments_);
       },
       transform: (chunk, chunkEncoding, callback) => {
-        gzipStream.write(chunk, (err) => {
-          if (err) console.error(err);
-          callback(err);
+        gzipStream.write(chunk, (error) => {
+          if (error) console.error(error);
+          callback(error);
         });
       },
       flush: (callback) => {
@@ -129,7 +134,6 @@ export default class ContentDecoderMiddleware {
       },
     });
 
-    newDownstream.tag = 'ContentDecoder';
     inputStream = request.addDownstream(newDownstream, { autoPause: true });
 
     return CONTINUE;

package/middleware/ContentEncoderMiddleware.js

@@ -15,8 +15,8 @@ const { BROTLI_OPERATION_FLUSH, Z_SYNC_FLUSH } = ZlibContants;
 /** @typedef {import('http').IncomingHttpHeaders} IncomingHttpHeaders */
 /** @typedef {import('../lib/HttpRequest.js').default} HttpRequest */
 /** @typedef {import('../lib/HttpResponse.js').default} HttpResponse */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').ResponseFinalizer} ResponseFinalizer */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
 
 /** @typedef {'br'|'gzip'|'deflate'|'identity'|'*'} COMPATIBLE_ENCODING */
 
@@ -75,8 +75,9 @@ export default class ContentEncoderMiddleware {
     let encoding = COMPATIBLE_ENCODINGS[0];
     const allowWildcards = (encodings.get('*')?.q !== 0);
     const encodingEntries = [...encodings.entries()];
-    // @ts-expect-error Cannot cast to COMPATIBLE_ENCODINGS
-    encoding = (encodingEntries.find(([value, spec]) => spec.q !== 0 && COMPATIBLE_ENCODINGS.includes(value))?.[0]);
+    encoding = /** @type {COMPATIBLE_ENCODING} */ (encodingEntries
+      .find(([value, spec]) => spec.q !== 0
+        && COMPATIBLE_ENCODINGS.includes(/** @type {COMPATIBLE_ENCODING} */ (value)))?.[0]);
     if (allowWildcards && (encoding === '*' || !encoding)) {
       // Server preference
       // Get first compatible encoding not specified
@@ -154,7 +155,7 @@ export default class ContentEncoderMiddleware {
       encoding = getContentEncoding().toLowerCase?.();
     }
 
-    const isEventStream = response.headers['content-type']?.includes('text/event-stream');
+    const isEventStream = /** @type {string|null} */ (response.headers['content-type'])?.includes('text/event-stream');
 
     let newStream;
     switch (encoding) {

package/middleware/ContentLengthMiddleware.js

@@ -1,6 +1,6 @@
 /** @typedef {import('../lib/HttpResponse.js').default} HttpResponse */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').ResponseFinalizer} ResponseFinalizer */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
 
 import { Transform } from 'node:stream';
 

package/middleware/HashMiddleware.js

@@ -4,8 +4,8 @@ import { Transform } from 'node:stream';
 /** @typedef {import('node:crypto').BinaryToTextEncoding} BinaryToTextEncoding */
 /** @typedef {import('../lib/HttpRequest.js').default} HttpRequest */
 /** @typedef {import('../lib/HttpResponse.js').default} HttpResponse */
-/** @typedef {import('../types/index.js').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types/index.js').ResponseFinalizer} ResponseFinalizer */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
 
 const DEFAULT_ALGORITHM = 'sha1';
 /** @type {BinaryToTextEncoding} */

package/middleware/HeadMethodMiddleware.js

@@ -1,6 +1,6 @@
-/** @typedef {import('../types/index.js').HttpTransaction} HttpTransaction */
-/** @typedef {import('../types/index.js').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types/index.js').ResponseFinalizer} ResponseFinalizer */
+/** @typedef {import('../data/custom-types.js').HttpTransaction} HttpTransaction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
 
 import { Transform } from 'node:stream';
 

package/middleware/MethodMiddleware.js

@@ -1,6 +1,6 @@
-/** @typedef {import('../types').HttpTransaction} HttpTransaction */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
+/** @typedef {import('../data/custom-types.js').HttpTransaction} HttpTransaction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
 
 /** @typedef {RegExp|RequestMethod} MethodEntry */
 

package/middleware/PathMiddleware.js

@@ -1,9 +1,9 @@
 import { posix } from 'node:path';
 
-/** @typedef {import('../types').HttpTransaction} HttpTransaction */
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').RequestMethod} RequestMethod */
+/** @typedef {import('../data/custom-types.js').HttpTransaction} HttpTransaction */
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').RequestMethod} RequestMethod */
 
 /** @typedef {RegExp|string} PathEntry */
 

package/middleware/ReadFormData.js

@@ -1,5 +1,5 @@
 /** @typedef {import('../lib/HttpRequest.js').default} HttpRequest */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
 
 /**
  * The application/x-www-form-urlencoded format is in many ways an aberrant monstrosity,

package/middleware/SendJsonMiddleware.js

@@ -1,7 +1,7 @@
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareResponseFunction} MiddlewareResponseFunction */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types/index.js').ResponseFinalizer} ResponseFinalizer */
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareResponseFunction} MiddlewareResponseFunction */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
 
 /**
  * @typedef {Object} SendJsonMiddlewareOptions

package/middleware/SendStringMiddleware.js

@@ -1,6 +1,6 @@
-/** @typedef {import('../types/index.js').IMiddleware} IMiddleware */
-/** @typedef {import('../types/index.js').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types/index.js').ResponseFinalizer} ResponseFinalizer */
+/** @typedef {import('../data/custom-types.js').IMiddleware} IMiddleware */
+/** @typedef {import('../data/custom-types.js').MiddlewareFunction} MiddlewareFunction */
+/** @typedef {import('../data/custom-types.js').ResponseFinalizer} ResponseFinalizer */
 
 /**
  * @typedef {Object} SendStringMiddlewareOptions

package/package.json

@@ -24,7 +24,16 @@
     "node": ">v16.13"
   },
   "exports": {
-    "./*": "./*"
+    "./data/*": "./data/*",
+    "./errata/*": "./errata/*",
+    "./examples/*": "./examples/*",
+    "./helpers/*": "./helpers/*",
+    "./lib/*": "./lib/*",
+    "./middleware/*": "./middleware/*",
+    "./polyfills/*": "./polyfills/*",
+    "./templates/*": "./templates/*",
+    "./types/*": "./types/*",
+    "./utils/*": "./utils/*"
   },
   "keywords": [
     "http",
@@ -42,6 +51,7 @@
   "scripts": {
     "debug-test": "ava --serial",
     "test": "c8 ava",
+    "prepublishOnly": "rm -Rf types && tsc --emitDeclarationOnly",
     "pretestallsync": "rimraf coverage",
     "testallsync": "scripts/test-all-sync.sh",
     "posttestallsync": "c8 report",
@@ -50,5 +60,12 @@
     "posttestall": "c8 report"
   },
   "type": "module",
-  "version": "0.3.2"
-}
+  "typesVersions": {
+    "*": {
+      "*": [
+        "types/*"
+      ]
+    }
+  },
+  "version": "0.3.4"
+}

package/templates/starter.js

@@ -13,8 +13,8 @@ import HeadMethodMiddleware from '../middleware/HeadMethodMiddleware.js';
  * @param {Object} options
  * @param {string} [options.host='0.0.0.0']
  * @param {number} [options.port=8080]
- * @param {import('../types').Middleware[]} [options.middleware]
- * @param {import('../types').MiddlewareErrorHandler[]} [options.errorHandlers]
+ * @param {import('../data/custom-types.js').Middleware[]} [options.middleware]
+ * @param {import('../data/custom-types.js').MiddlewareErrorHandler[]} [options.errorHandlers]
  * @return {Promise<import('../helpers/HttpListener.js').default>}
  */
 export async function start(options) {

package/tsconfig.json

@@ -1,12 +1,29 @@
 {
   "compilerOptions": {
+    "allowJs": true,
     "checkJs": true,
     "noImplicitAny": true,
+    "declaration": true,
+    "declarationMap": true,
+    "declarationDir": "types",
+    "outDir": "/dev/null",
     "target": "es2022",
     "module": "esnext",
     "moduleResolution": "node"
   },
+  "include": [
+    "./data/*",
+    "./errata/*",
+    "./examples/*",
+    "./helpers/*",
+    "./lib/*",
+    "./middleware/*",
+    "./polyfills/*",
+    "./templates/*",
+    "./utils/*"
+  ],
   "exclude": [
-    "**/node_modules/*"
+    "**/node_modules/*",
+    "**/test/*"
   ]
 }

package/utils/headers.js

@@ -1,7 +1,7 @@
 /**
  *
  * @param {?string} contentType
- * @return {import('../types/index.js').MediaType}
+ * @return {import('../data/custom-types.js').MediaType}
  */
 export function parseContentType(contentType) {
   let type;

package/errata/index.js

@@ -1 +0,0 @@
-export * as socketio from './socketio.js';

package/index.js

@@ -1,4 +0,0 @@
-export * as lib from './lib/index.js';
-export * as helpers from './helpers/index.js';
-export * as middleware from './middleware/index.js';
-export * as errata from './errata/index.js';

package/lib/index.js

@@ -1,3 +0,0 @@
-export { default as HttpRequest } from './HttpRequest.js';
-export { default as HttpResponse } from './HttpResponse.js';
-export { default as HttpHandler } from './HttpHandler.js';

package/middleware/ContentReaderMiddleware.js

@@ -1,249 +0,0 @@
-import { PassThrough, Transform } from 'stream';
-
-/** @typedef {import('stream').Readable} Readable */
-/** @typedef {import('../types').IMiddleware} IMiddleware */
-/** @typedef {import('../types').MiddlewareFunction} MiddlewareFunction */
-/** @typedef {import('../types').MiddlewareFunctionParams} MiddlewareFunctionParams */
-/** @typedef {import('../types').MiddlewareFunctionResult} MiddlewareFunctionResult */
-
-/**
- * @typedef {Object} ContentReaderMiddlewareOptions
- * @prop {string} [defaultMediaType]
- * Assumed mediatype if not specified
- * @prop {boolean} [parseJSON=false]
- * Automatically parses JSON if `application/json` mediatype
- * @prop {'entries'|'object'|'string'|'none'} [formURLEncodedFormat='none']
- * Automatically converts to object if `application/x-www-form-urlencoded` mediatype
- * @prop {boolean} [buildString=false]
- * Automatically builds string into one `read()` response
- * @prop {boolean|string} [cache=false]
- * Caches content in req.local.content or req.local[cacheName]
- */
-
-/** @implements {IMiddleware} */
-export default class ContentReaderMiddleware {
-  /** @param {ContentReaderMiddlewareOptions} [options] */
-  constructor(options = {}) {
-    this.defaultMediaType = options.defaultMediaType;
-    this.parseJSON = options.parseJSON === true;
-    this.formURLEncodedFormat = options.formURLEncodedFormat || 'none';
-    this.buildString = options.buildString === true;
-    this.cache = options.cache;
-  }
-
-  /**
-   * @param {string} charset
-   * @return {BufferEncoding}
-   */
-  static charsetAsBufferEncoding(charset) {
-    switch (charset) {
-      case 'iso-8859-1':
-      case 'ascii':
-      case 'binary':
-      case 'latin1':
-        return 'latin1';
-      case 'utf-16le':
-      case 'ucs-2':
-      case 'ucs2':
-      case 'utf16le':
-        return 'utf16le';
-      default:
-      case 'utf-8':
-      case 'utf8':
-        return 'utf-8';
-      case 'base64':
-      case 'hex':
-        return /** @type {BufferEncoding} */ (charset);
-    }
-  }
-
-  /**
-   * The application/x-www-form-urlencoded format is in many ways an aberrant monstrosity,
-   * the result of many years of implementation accidents and compromises leading to a set of
-   * requirements necessary for interoperability, but in no way representing good design practices.
-   * In particular, readers are cautioned to pay close attention to the twisted details
-   * involving repeated (and in some cases nested) conversions between character encodings and byte sequences.
-   * Unfortunately the format is in widespread use due to the prevalence of HTML forms. [HTML]
-   * @param {Buffer} buffer
-   * @param {string} charset
-   * @return {[string, string][]} Tuple
-   */
-  static readUrlEncoded(buffer, charset) {
-  // https://url.spec.whatwg.org/#urlencoded-parsing
-    const bufferEncoding = ContentReaderMiddleware.charsetAsBufferEncoding(charset);
-
-    const sequences = [];
-    let startIndex = 0;
-    for (let i = 0; i < buffer.length; i += 1) {
-      if (buffer[i] === 0x26) {
-        sequences.push(buffer.subarray(startIndex, i));
-        startIndex = i + 1;
-      }
-      if (i === buffer.length - 1) {
-        sequences.push(buffer.subarray(startIndex, i + 1));
-        break;
-      }
-    }
-    /** @type {[string, string][]} */
-    const output = [];
-    sequences.forEach((bytes) => {
-      if (!bytes.length) return;
-
-      // Find 0x3D and replace 0x2B in one loop for better performance
-      let indexOf0x3D = -1;
-      for (let i = 0; i < bytes.length; i += 1) {
-        switch (bytes[i]) {
-          case 0x3D:
-            if (indexOf0x3D === -1) {
-              indexOf0x3D = i;
-            }
-            break;
-          case 0x2B:
-          // Replace bytes on original stream for memory conservation
-          // eslint-disable-next-line no-param-reassign
-            bytes[i] = 0x20;
-            break;
-          default:
-        }
-      }
-      let name;
-      let value;
-      if (indexOf0x3D === -1) {
-        name = bytes;
-        value = bytes.subarray(bytes.length, 0);
-      } else {
-        name = bytes.subarray(0, indexOf0x3D);
-        value = bytes.subarray(indexOf0x3D + 1);
-      }
-      const nameString = decodeURIComponent(name.toString(bufferEncoding));
-      const valueString = decodeURIComponent(value.toString(bufferEncoding));
-      output.push([nameString, valueString]);
-    });
-    return output;
-  }
-
-  /**
-   * @param {MiddlewareFunctionParams} params
-   * @return {MiddlewareFunctionResult}
-   */
-  execute({ req }) {
-    switch (req.method) {
-      case 'HEAD':
-      case 'GET':
-        return 'continue';
-      default:
-    }
-
-    const contentType = (req.headers['content-type']);
-    /** @type {string} */
-    let mediaType;
-    /** @type {string} */
-    let charset;
-    if (contentType) {
-      contentType.split(';').forEach((directive) => {
-        const parameters = directive.split('=');
-        if (parameters.length === 1) {
-          mediaType = directive.trim().toLowerCase();
-          return;
-        }
-        if (parameters[0].trim().toLowerCase() !== 'charset') {
-          return;
-        }
-        charset = parameters[1]?.trim().toLowerCase();
-        const firstQuote = charset.indexOf('"');
-        const lastQuote = charset.lastIndexOf('"');
-        if (firstQuote !== -1 && lastQuote !== -1) {
-          charset = charset.substring(firstQuote + 1, lastQuote);
-        }
-      });
-    }
-
-    if (!mediaType) {
-      mediaType = this.defaultMediaType;
-    }
-    const isFormUrlEncoded = mediaType === 'application/x-www-form-urlencoded';
-    const isJSON = /application\/(.+\+)?json/i.test(mediaType);
-    if (!charset) {
-      if (!mediaType) {
-        return 'continue';
-      }
-      if (isFormUrlEncoded && (this.formURLEncodedFormat || 'none') === 'none') {
-        return 'continue';
-      }
-      if (!isFormUrlEncoded && !isJSON && !mediaType.startsWith('text/')) {
-        return 'continue';
-      }
-    }
-
-    const readAll = isJSON || isFormUrlEncoded;
-
-    let fullString = '';
-    /** @type {Buffer[]} */
-    const pendingChunks = [];
-    const source = req.stream;
-    const {
-      buildString, formURLEncodedFormat, cache, parseJSON,
-    } = this;
-    const newReadable = new Transform({
-      objectMode: true,
-      read(...args) {
-        if (source.isPaused()) source.resume();
-        // eslint-disable-next-line no-underscore-dangle
-        Transform.prototype._read.call(this, ...args);
-      },
-      transform(chunk, encoding, callback) {
-        if (typeof chunk === 'string') {
-          if (readAll || buildString) {
-            fullString += chunk;
-          } else {
-            this.push(chunk);
-          }
-        } else if (isFormUrlEncoded) {
-          pendingChunks.push(chunk);
-        } else {
-          this.push(chunk);
-        }
-        callback();
-      },
-      flush(callback) {
-        let result = null;
-        if (isFormUrlEncoded) {
-          const combinedBuffer = Buffer.concat(pendingChunks);
-          if (formURLEncodedFormat === 'object') {
-            result = Object.fromEntries(ContentReaderMiddleware.readUrlEncoded(combinedBuffer, charset));
-          } else if (formURLEncodedFormat === 'string') {
-            result = combinedBuffer.toString(ContentReaderMiddleware.charsetAsBufferEncoding(charset));
-          } else {
-            result = ContentReaderMiddleware.readUrlEncoded(combinedBuffer, charset);
-          }
-        } else if (isJSON && parseJSON) {
-          try {
-            result = JSON.parse(fullString);
-          } catch {
-            result = fullString;
-          }
-        } else if (fullString) {
-          result = fullString;
-        }
-        if (cache && result) {
-          const cacheName = cache === true ? 'content' : cache;
-          req.locals[cacheName] = result;
-        }
-        callback(null, result);
-      },
-    });
-    req.replaceStream(newReadable);
-    if (!isFormUrlEncoded) {
-    // Data read from source will be decoded as a string
-      const encoding = ContentReaderMiddleware.charsetAsBufferEncoding(charset);
-      const stringDecoder = new PassThrough({ encoding });
-      newReadable.setDefaultEncoding(encoding);
-      source.pipe(stringDecoder).pipe(newReadable);
-    } else {
-      source.pipe(newReadable);
-    }
-    source.pause();
-
-    return 'continue';
-  }
-}