@jsenv/server 16.0.1 → 16.0.2

package/dist/html/route_inspector.html

@@ -232,7 +232,7 @@
         // AsyncIterator objects; they just return a Promise for the value of
         // the final result produced by the iterator.
         exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-          if (PromiseImpl === undefined) PromiseImpl = Promise;
+          if (PromiseImpl === void 0) PromiseImpl = Promise;
       
           var iter = new AsyncIterator(
             wrap(innerFn, outerFn, self, tryLocsList),

package/dist/js/vendors.js

@@ -1,10 +1,10 @@
-import { PassThrough, Transform, Stream } from "node:stream";
 import os from "node:os";
 import path from "node:path";
 import fsPromises from "node:fs/promises";
 import { EventEmitter } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import require$$0 from "node:domain";
+import { PassThrough, Transform, Stream } from "node:stream";
 import fs from "node:fs";
 import require$$1, { createHash } from "node:crypto";
 

package/dist/js/ws.js

@@ -12,6 +12,175 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
+var stream$1;
+var hasRequiredStream;
+
+function requireStream () {
+	if (hasRequiredStream) return stream$1;
+	hasRequiredStream = 1;
+
+	const { Duplex } = require$$0;
+
+	/**
+	 * Emits the `'close'` event on a stream.
+	 *
+	 * @param {Duplex} stream The stream.
+	 * @private
+	 */
+	function emitClose(stream) {
+	  stream.emit('close');
+	}
+
+	/**
+	 * The listener of the `'end'` event.
+	 *
+	 * @private
+	 */
+	function duplexOnEnd() {
+	  if (!this.destroyed && this._writableState.finished) {
+	    this.destroy();
+	  }
+	}
+
+	/**
+	 * The listener of the `'error'` event.
+	 *
+	 * @param {Error} err The error
+	 * @private
+	 */
+	function duplexOnError(err) {
+	  this.removeListener('error', duplexOnError);
+	  this.destroy();
+	  if (this.listenerCount('error') === 0) {
+	    // Do not suppress the throwing behavior.
+	    this.emit('error', err);
+	  }
+	}
+
+	/**
+	 * Wraps a `WebSocket` in a duplex stream.
+	 *
+	 * @param {WebSocket} ws The `WebSocket` to wrap
+	 * @param {Object} [options] The options for the `Duplex` constructor
+	 * @return {Duplex} The duplex stream
+	 * @public
+	 */
+	function createWebSocketStream(ws, options) {
+	  let terminateOnDestroy = true;
+
+	  const duplex = new Duplex({
+	    ...options,
+	    autoDestroy: false,
+	    emitClose: false,
+	    objectMode: false,
+	    writableObjectMode: false
+	  });
+
+	  ws.on('message', function message(msg, isBinary) {
+	    const data =
+	      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+
+	    if (!duplex.push(data)) ws.pause();
+	  });
+
+	  ws.once('error', function error(err) {
+	    if (duplex.destroyed) return;
+
+	    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
+	    //
+	    // - If the `'error'` event is emitted before the `'open'` event, then
+	    //   `ws.terminate()` is a noop as no socket is assigned.
+	    // - Otherwise, the error is re-emitted by the listener of the `'error'`
+	    //   event of the `Receiver` object. The listener already closes the
+	    //   connection by calling `ws.close()`. This allows a close frame to be
+	    //   sent to the other peer. If `ws.terminate()` is called right after this,
+	    //   then the close frame might not be sent.
+	    terminateOnDestroy = false;
+	    duplex.destroy(err);
+	  });
+
+	  ws.once('close', function close() {
+	    if (duplex.destroyed) return;
+
+	    duplex.push(null);
+	  });
+
+	  duplex._destroy = function (err, callback) {
+	    if (ws.readyState === ws.CLOSED) {
+	      callback(err);
+	      process.nextTick(emitClose, duplex);
+	      return;
+	    }
+
+	    let called = false;
+
+	    ws.once('error', function error(err) {
+	      called = true;
+	      callback(err);
+	    });
+
+	    ws.once('close', function close() {
+	      if (!called) callback(err);
+	      process.nextTick(emitClose, duplex);
+	    });
+
+	    if (terminateOnDestroy) ws.terminate();
+	  };
+
+	  duplex._final = function (callback) {
+	    if (ws.readyState === ws.CONNECTING) {
+	      ws.once('open', function open() {
+	        duplex._final(callback);
+	      });
+	      return;
+	    }
+
+	    // If the value of the `_socket` property is `null` it means that `ws` is a
+	    // client websocket and the handshake failed. In fact, when this happens, a
+	    // socket is never assigned to the websocket. Wait for the `'error'` event
+	    // that will be emitted by the websocket.
+	    if (ws._socket === null) return;
+
+	    if (ws._socket._writableState.finished) {
+	      callback();
+	      if (duplex._readableState.endEmitted) duplex.destroy();
+	    } else {
+	      ws._socket.once('finish', function finish() {
+	        // `duplex` is not destroyed here because the `'end'` event will be
+	        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+	        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+	        callback();
+	      });
+	      ws.close();
+	    }
+	  };
+
+	  duplex._read = function () {
+	    if (ws.isPaused) ws.resume();
+	  };
+
+	  duplex._write = function (chunk, encoding, callback) {
+	    if (ws.readyState === ws.CONNECTING) {
+	      ws.once('open', function open() {
+	        duplex._write(chunk, encoding, callback);
+	      });
+	      return;
+	    }
+
+	    ws.send(chunk, callback);
+	  };
+
+	  duplex.on('end', duplexOnEnd);
+	  duplex.on('error', duplexOnError);
+	  return duplex;
+	}
+
+	stream$1 = createWebSocketStream;
+	return stream$1;
+}
+
+requireStream();
+
 var bufferUtil = {exports: {}};
 
 var constants;
@@ -3730,6 +3899,8 @@ var hasRequiredSender;
 function requireSender () {
 	if (hasRequiredSender) return sender$1;
 	hasRequiredSender = 1;
+
+	const { Duplex } = require$$0;
 	const { randomFillSync } = require$$1;
 
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -4858,6 +5029,7 @@ function requireWebsocket () {
 	const net$1 = net;
 	const tls = require$$4;
 	const { randomBytes, createHash } = require$$1;
+	const { Duplex, Readable } = require$$0;
 	const { URL } = require$$7;
 
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -6321,6 +6493,7 @@ function requireWebsocketServer () {
 
 	const EventEmitter = require$$0$2;
 	const http$1 = http;
+	const { Duplex } = require$$0;
 	const { createHash } = require$$1;
 
 	const extension = requireExtension();

package/dist/jsenv_server.js

@@ -9,10 +9,10 @@ import { Readable, Stream, Writable } from "node:stream";
 import http from "node:http";
 import { Http2ServerResponse } from "node:http2";
 import { createReadStream, existsSync, readFileSync, readdirSync, lstatSync, statSync, readFile } from "node:fs";
-import { pathToFileURL, fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { lookup } from "node:dns";
+import { createHash } from "node:crypto";
 
 const createCallbackListNotifiedOnce = () => {
   let callbacks = [];
@@ -1499,15 +1499,8 @@ const createObservable = (producer) => {
       },
       { signal = new AbortController().signal } = {},
     ) => {
-      let cleanup = () => {};
       const subscription = {
-        active: true,
-        signal,
-        unsubscribe: () => {
-          subscription.closed = true;
-          cleanup();
-        },
-      };
+        active: true};
 
       const teardownCallbackList = [];
       const close = () => {
@@ -1523,7 +1516,7 @@ const createObservable = (producer) => {
         close();
       });
 
-      const producerReturnValue = producer({
+      producer({
         next: (value) => {
           if (!subscription.active) {
             return;
@@ -1552,9 +1545,6 @@ const createObservable = (producer) => {
           teardownCallbackList.push(teardownCallback);
         },
       });
-      if (typeof producerReturnValue === "function") {
-        cleanup = producerReturnValue;
-      }
       return undefined;
     },
   };
@@ -1728,7 +1718,7 @@ const fromNodeRequest = (
         `formData() called on a request with content-type: "${contentType}". multipart/form-data was expected.`,
       );
     }
-    const { formidable } = await import("./js/formidable.js");
+    const { formidable } = await import("./js/formidable_index.js");
     const form = formidable({});
     nodeRequest.resume(); // was paused in line #53
     const [fields, files] = await form.parse(nodeRequest);
@@ -3403,35 +3393,6 @@ const resourceToExtension = (resource) => {
   return pathnameToExtension(pathname);
 };
 
-const isFileSystemPath$1 = (value) => {
-  if (typeof value !== "string") {
-    throw new TypeError(
-      `isFileSystemPath first arg must be a string, got ${value}`,
-    );
-  }
-  if (value[0] === "/") {
-    return true;
-  }
-  return startsWithWindowsDriveLetter$1(value);
-};
-
-const startsWithWindowsDriveLetter$1 = (string) => {
-  const firstChar = string[0];
-  if (!/[a-zA-Z]/.test(firstChar)) return false;
-
-  const secondChar = string[1];
-  if (secondChar !== ":") return false;
-
-  return true;
-};
-
-const fileSystemPathToUrl$1 = (value) => {
-  if (!isFileSystemPath$1(value)) {
-    throw new Error(`value must be a filesystem path, got ${value}`);
-  }
-  return String(pathToFileURL(value));
-};
-
 const getCommonPathname = (pathname, otherPathname) => {
   if (pathname === otherPathname) {
     return pathname;
@@ -3553,9 +3514,6 @@ const urlToFileSystemPath = (url) => {
   return fileSystemPath;
 };
 
-process.platform === "win32";
-fileSystemPathToUrl$1(process.cwd());
-
 const getParentDirectoryUrl = (url) => {
   if (url.startsWith("file://")) {
     // With node.js new URL('../', 'file:///C:/').href
@@ -4155,34 +4113,6 @@ const URL_META = {
   createFilter,
 };
 
-/*
- * - stats object documentation on Node.js
- *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_class_fs_stats
- */
-
-
-process.platform === "win32";
-
-/*
- * - stats object documentation on Node.js
- *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_class_fs_stats
- */
-
-
-process.platform === "win32";
-
-process.platform === "win32";
-
-process.platform === "win32";
-
-process.platform === "win32";
-
-process.platform === "linux";
-
-process.platform === "darwin";
-process.platform === "linux";
-process.platform === "freebsd";
-
 const isEscaped = (i, string) => {
   let backslashBeforeCount = 0;
   while (i--) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "16.0.1",
+  "version": "16.0.2",
   "description": "A modern Node.js HTTP server with declarative routing, content negotiation, and WebSocket support",
   "license": "MIT",
   "author": {
@@ -33,6 +33,7 @@
     "/dist/",
     "/src/"
   ],
+  "sideEffects": false,
   "scripts": {
     "build": "node --experimental-import-meta-resolve ./scripts/build.mjs",
     "prepublishOnly": "npm run build"
@@ -40,9 +41,9 @@
   "dependencies": {
     "launch-editor": "2.10.0",
     "@jsenv/abort": "4.3.1",
-    "@jsenv/humanize": "1.3.0",
+    "@jsenv/humanize": "1.3.1",
     "@jsenv/url-meta": "8.5.4",
-    "@jsenv/utils": "2.2.0",
+    "@jsenv/utils": "2.2.1",
     "ws": "8.18.0",
     "formidable": "3.5.2"
   },

package/dist/js/{formidable.js → formidable_index.js}

@@ -1,12 +1,12 @@
 import { IncomingForm } from "./vendors.js";
 export { DummyParser, PersistentFile as File, JSONParser, MultipartParser, OctetStreamParser, OctetStreamParser as OctetstreamParser, PersistentFile, QuerystringParser as QueryStringParser, QuerystringParser, VolatileFile, DEFAULT_OPTIONS as defaultOptions, plugin$3 as json, plugin$2 as multipart, plugin as octetstream, plugin$1 as querystring } from "./vendors.js";
-import "node:stream";
 import "node:os";
 import "node:path";
 import "node:fs/promises";
 import "node:events";
 import "node:string_decoder";
 import "node:domain";
+import "node:stream";
 import "node:fs";
 import "node:crypto";