@jsenv/server 15.0.1 → 15.0.3

package/src/internal/hostname_parser.js

@@ -1,4 +1,4 @@
-import { isIP } from "node:net"
+import { isIP } from "node:net";
 
 export const parseHostname = (hostname) => {
   if (hostname === "0.0.0.0") {
@@ -6,7 +6,7 @@ export const parseHostname = (hostname) => {
       type: "ip",
       label: "unspecified",
       version: 4,
-    }
+    };
   }
   if (
     hostname === "::" ||
@@ -16,14 +16,14 @@ export const parseHostname = (hostname) => {
       type: "ip",
       label: "unspecified",
       version: 6,
-    }
+    };
   }
   if (hostname === "127.0.0.1") {
     return {
       type: "ip",
       label: "loopback",
       version: 4,
-    }
+    };
   }
   if (
     hostname === "::1" ||
@@ -33,16 +33,16 @@ export const parseHostname = (hostname) => {
       type: "ip",
       label: "loopback",
       version: 6,
-    }
+    };
   }
-  const ipVersion = isIP(hostname)
+  const ipVersion = isIP(hostname);
   if (ipVersion === 0) {
     return {
       type: "hostname",
-    }
+    };
   }
   return {
     type: "ip",
     version: ipVersion,
-  }
-}
+  };
+};

package/src/internal/listen.js

@@ -1,5 +1,5 @@
-import { createServer } from "node:net"
-import { Abort } from "@jsenv/abort"
+import { createServer } from "node:net";
+import { Abort } from "@jsenv/abort";
 
 const listen = async ({
   signal = new AbortController().signal,
@@ -8,28 +8,28 @@ const listen = async ({
   portHint,
   hostname,
 }) => {
-  const listeningOperation = Abort.startOperation()
+  const listeningOperation = Abort.startOperation();
 
   try {
-    listeningOperation.addAbortSignal(signal)
+    listeningOperation.addAbortSignal(signal);
 
     if (portHint) {
-      listeningOperation.throwIfAborted()
+      listeningOperation.throwIfAborted();
       port = await findFreePort(portHint, {
         signal: listeningOperation.signal,
         hostname,
-      })
+      });
     }
-    listeningOperation.throwIfAborted()
-    port = await startListening({ server, port, hostname })
-    listeningOperation.addAbortCallback(() => stopListening(server))
-    listeningOperation.throwIfAborted()
+    listeningOperation.throwIfAborted();
+    port = await startListening({ server, port, hostname });
+    listeningOperation.addAbortCallback(() => stopListening(server));
+    listeningOperation.throwIfAborted();
 
-    return port
+    return port;
   } finally {
-    await listeningOperation.end()
+    await listeningOperation.end();
   }
-}
+};
 
 export const findFreePort = async (
   initialPort = 1,
@@ -41,75 +41,75 @@ export const findFreePort = async (
     next = (port) => port + 1,
   } = {},
 ) => {
-  const findFreePortOperation = Abort.startOperation()
+  const findFreePortOperation = Abort.startOperation();
   try {
-    findFreePortOperation.addAbortSignal(signal)
-    findFreePortOperation.throwIfAborted()
+    findFreePortOperation.addAbortSignal(signal);
+    findFreePortOperation.throwIfAborted();
 
     const testUntil = async (port, host) => {
-      findFreePortOperation.throwIfAborted()
-      const free = await portIsFree(port, host)
+      findFreePortOperation.throwIfAborted();
+      const free = await portIsFree(port, host);
       if (free) {
-        return port
+        return port;
       }
 
-      const nextPort = next(port)
+      const nextPort = next(port);
       if (nextPort > max) {
         throw new Error(
           `${hostname} has no available port between ${min} and ${max}`,
-        )
+        );
       }
-      return testUntil(nextPort, hostname)
-    }
-    const freePort = await testUntil(initialPort, hostname)
-    return freePort
+      return testUntil(nextPort, hostname);
+    };
+    const freePort = await testUntil(initialPort, hostname);
+    return freePort;
   } finally {
-    await findFreePortOperation.end()
+    await findFreePortOperation.end();
   }
-}
+};
 
 const portIsFree = async (port, hostname) => {
-  const server = createServer()
+  const server = createServer();
 
   try {
     await startListening({
       server,
       port,
       hostname,
-    })
+    });
   } catch (error) {
     if (error && error.code === "EADDRINUSE") {
-      return false
+      return false;
     }
     if (error && error.code === "EACCES") {
-      return false
+      return false;
     }
-    throw error
+    throw error;
   }
 
-  await stopListening(server)
-  return true
-}
+  await stopListening(server);
+  return true;
+};
 
 const startListening = ({ server, port, hostname }) => {
   return new Promise((resolve, reject) => {
-    server.on("error", reject)
+    server.on("error", reject);
     server.on("listening", () => {
       // in case port is 0 (randomly assign an available port)
       // https://nodejs.org/api/net.html#net_server_listen_port_host_backlog_callback
-      resolve(server.address().port)
-    })
-    server.listen(port, hostname)
-  })
-}
+      resolve(server.address().port);
+    });
+    server.listen(port, hostname);
+  });
+};
 
 export const stopListening = (server) => {
   return new Promise((resolve, reject) => {
-    server.on("error", reject)
-    server.on("close", resolve)
-    server.close()
-  })
-}
+    server.on("error", reject);
+    server.on("close", resolve);
+    server.close();
+  });
+};
 
 // unit test exports
-export { listen, portIsFree }
+export { listen, portIsFree };

package/src/internal/listenClientError.js

@@ -1,4 +1,4 @@
-import { listenEvent } from "./listenEvent.js"
+import { listenEvent } from "./listenEvent.js";
 
 export const listenClientError = (nodeServer, clientErrorCallback) => {
   if (nodeServer._httpServer) {
@@ -6,22 +6,22 @@ export const listenClientError = (nodeServer, clientErrorCallback) => {
       nodeServer,
       "clientError",
       clientErrorCallback,
-    )
+    );
     const removeHttpClientError = listenEvent(
       nodeServer._httpServer,
       "clientError",
       clientErrorCallback,
-    )
+    );
     const removeTlsClientError = listenEvent(
       nodeServer._tlsServer,
       "clientError",
       clientErrorCallback,
-    )
+    );
     return () => {
-      removeNetClientError()
-      removeHttpClientError()
-      removeTlsClientError()
-    }
+      removeNetClientError();
+      removeHttpClientError();
+      removeTlsClientError();
+    };
   }
-  return listenEvent(nodeServer, "clientError", clientErrorCallback)
-}
+  return listenEvent(nodeServer, "clientError", clientErrorCallback);
+};

package/src/internal/listenEvent.js

@@ -5,11 +5,11 @@ export const listenEvent = (
   { once = false } = {},
 ) => {
   if (once) {
-    objectWithEventEmitter.once(eventName, callback)
+    objectWithEventEmitter.once(eventName, callback);
   } else {
-    objectWithEventEmitter.addListener(eventName, callback)
+    objectWithEventEmitter.addListener(eventName, callback);
   }
   return () => {
-    objectWithEventEmitter.removeListener(eventName, callback)
-  }
-}
+    objectWithEventEmitter.removeListener(eventName, callback);
+  };
+};

package/src/internal/listenRequest.js

@@ -1,4 +1,4 @@
-import { listenEvent } from "./listenEvent.js"
+import { listenEvent } from "./listenEvent.js";
 
 export const listenRequest = (nodeServer, requestCallback) => {
   if (nodeServer._httpServer) {
@@ -6,16 +6,16 @@ export const listenRequest = (nodeServer, requestCallback) => {
       nodeServer._httpServer,
       "request",
       requestCallback,
-    )
+    );
     const removeTlsRequestListener = listenEvent(
       nodeServer._tlsServer,
       "request",
       requestCallback,
-    )
+    );
     return () => {
-      removeHttpRequestListener()
-      removeTlsRequestListener()
-    }
+      removeHttpRequestListener();
+      removeTlsRequestListener();
+    };
   }
-  return listenEvent(nodeServer, "request", requestCallback)
-}
+  return listenEvent(nodeServer, "request", requestCallback);
+};

package/src/internal/listenServerConnectionError.js

@@ -1,11 +1,11 @@
-import { listenEvent } from "./listenEvent.js"
+import { listenEvent } from "./listenEvent.js";
 
 export const listenServerConnectionError = (
   nodeServer,
   connectionErrorCallback,
   { ignoreErrorAfterConnectionIsDestroyed = true } = {},
 ) => {
-  const cleanupSet = new Set()
+  const cleanupSet = new Set();
 
   const removeConnectionListener = listenEvent(
     nodeServer,
@@ -16,34 +16,34 @@ export const listenServerConnectionError = (
         "error",
         (error) => {
           if (ignoreErrorAfterConnectionIsDestroyed && socket.destroyed) {
-            return
+            return;
           }
-          connectionErrorCallback(error, socket)
+          connectionErrorCallback(error, socket);
         },
-      )
+      );
       const removeOnceSocketCloseListener = listenEvent(
         socket,
         "close",
         () => {
-          removeSocketErrorListener()
-          cleanupSet.delete(cleanup)
+          removeSocketErrorListener();
+          cleanupSet.delete(cleanup);
         },
         {
           once: true,
         },
-      )
+      );
       const cleanup = () => {
-        removeSocketErrorListener()
-        removeOnceSocketCloseListener()
-      }
-      cleanupSet.add(cleanup)
+        removeSocketErrorListener();
+        removeOnceSocketCloseListener();
+      };
+      cleanupSet.add(cleanup);
     },
-  )
+  );
   return () => {
-    removeConnectionListener()
+    removeConnectionListener();
     cleanupSet.forEach((cleanup) => {
-      cleanup()
-    })
-    cleanupSet.clear()
-  }
-}
+      cleanup();
+    });
+    cleanupSet.clear();
+  };
+};

package/src/internal/multiple-header.js

@@ -15,54 +15,54 @@ export const parseMultipleHeader = (
   multipleHeaderString,
   { validateName = () => true, validateProperty = () => true } = {},
 ) => {
-  const values = multipleHeaderString.split(",")
-  const multipleHeader = {}
+  const values = multipleHeaderString.split(",");
+  const multipleHeader = {};
   values.forEach((value) => {
-    const valueTrimmed = value.trim()
-    const valueParts = valueTrimmed.split(";")
-    const name = valueParts[0]
-    const nameValidation = validateName(name)
+    const valueTrimmed = value.trim();
+    const valueParts = valueTrimmed.split(";");
+    const name = valueParts[0];
+    const nameValidation = validateName(name);
     if (!nameValidation) {
-      return
+      return;
     }
 
     const properties = parseHeaderProperties(valueParts.slice(1), {
       validateProperty,
-    })
-    multipleHeader[name] = properties
-  })
-  return multipleHeader
-}
+    });
+    multipleHeader[name] = properties;
+  });
+  return multipleHeader;
+};
 
 const parseHeaderProperties = (headerProperties, { validateProperty }) => {
   const properties = headerProperties.reduce((previous, valuePart) => {
-    const [propertyName, propertyValueString] = valuePart.split("=")
-    const propertyValue = parseHeaderPropertyValue(propertyValueString)
-    const property = { name: propertyName, value: propertyValue }
-    const propertyValidation = validateProperty(property)
+    const [propertyName, propertyValueString] = valuePart.split("=");
+    const propertyValue = parseHeaderPropertyValue(propertyValueString);
+    const property = { name: propertyName, value: propertyValue };
+    const propertyValidation = validateProperty(property);
     if (!propertyValidation) {
-      return previous
+      return previous;
     }
     return {
       ...previous,
       [property.name]: property.value,
-    }
-  }, {})
-  return properties
-}
+    };
+  }, {});
+  return properties;
+};
 
 const parseHeaderPropertyValue = (headerPropertyValueString) => {
-  const firstChar = headerPropertyValueString[0]
+  const firstChar = headerPropertyValueString[0];
   const lastChar =
-    headerPropertyValueString[headerPropertyValueString.length - 1]
+    headerPropertyValueString[headerPropertyValueString.length - 1];
   if (firstChar === '"' && lastChar === '"') {
-    return headerPropertyValueString.slice(1, -1)
+    return headerPropertyValueString.slice(1, -1);
   }
   if (isNaN(headerPropertyValueString)) {
-    return headerPropertyValueString
+    return headerPropertyValueString;
   }
-  return parseFloat(headerPropertyValueString)
-}
+  return parseFloat(headerPropertyValueString);
+};
 
 export const stringifyMultipleHeader = (
   multipleHeader,
@@ -70,34 +70,34 @@ export const stringifyMultipleHeader = (
 ) => {
   return Object.keys(multipleHeader)
     .filter((name) => {
-      const headerProperties = multipleHeader[name]
+      const headerProperties = multipleHeader[name];
       if (!headerProperties) {
-        return false
+        return false;
       }
       if (typeof headerProperties !== "object") {
-        return false
+        return false;
       }
-      const nameValidation = validateName(name)
+      const nameValidation = validateName(name);
       if (!nameValidation) {
-        return false
+        return false;
       }
-      return true
+      return true;
     })
     .map((name) => {
-      const headerProperties = multipleHeader[name]
+      const headerProperties = multipleHeader[name];
       const headerPropertiesString = stringifyHeaderProperties(
         headerProperties,
         {
           validateProperty,
         },
-      )
+      );
       if (headerPropertiesString.length) {
-        return `${name};${headerPropertiesString}`
+        return `${name};${headerPropertiesString}`;
       }
-      return name
+      return name;
     })
-    .join(", ")
-}
+    .join(", ");
+};
 
 const stringifyHeaderProperties = (headerProperties, { validateProperty }) => {
   const headerPropertiesString = Object.keys(headerProperties)
@@ -105,24 +105,24 @@ const stringifyHeaderProperties = (headerProperties, { validateProperty }) => {
       const property = {
         name,
         value: headerProperties[name],
-      }
-      return property
+      };
+      return property;
     })
     .filter((property) => {
-      const propertyValidation = validateProperty(property)
+      const propertyValidation = validateProperty(property);
       if (!propertyValidation) {
-        return false
+        return false;
       }
-      return true
+      return true;
     })
     .map(stringifyHeaderProperty)
-    .join(";")
-  return headerPropertiesString
-}
+    .join(";");
+  return headerPropertiesString;
+};
 
 const stringifyHeaderProperty = ({ name, value }) => {
   if (typeof value === "string") {
-    return `${name}="${value}"`
+    return `${name}="${value}"`;
   }
-  return `${name}=${value}`
-}
+  return `${name}=${value}`;
+};

package/src/internal/normalizeHeaderName.js

@@ -1,8 +1,8 @@
 export const normalizeHeaderName = (headerName) => {
-  headerName = String(headerName)
+  headerName = String(headerName);
   if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(headerName)) {
-    throw new TypeError("Invalid character in header field name")
+    throw new TypeError("Invalid character in header field name");
   }
 
-  return headerName.toLowerCase()
-}
+  return headerName.toLowerCase();
+};

package/src/internal/normalizeHeaderValue.js

@@ -1,3 +1,3 @@
 export const normalizeHeaderValue = (headerValue) => {
-  return String(headerValue)
-}
+  return String(headerValue);
+};