@jsenv/server 15.0.2 → 15.0.3

package/README.md

@@ -3,7 +3,7 @@
 `@jsenv/server` helps to write flexible server code with a declarative API.
 
 ```js
-import { startServer } from "@jsenv/server"
+import { startServer } from "@jsenv/server";
 
 await startServer({
   port: 8080,
@@ -16,11 +16,11 @@ await startServer({
             "content-type": "text/plain",
           },
           body: "Hello world",
-        }
+        };
       },
     },
   ],
-})
+});
 ```
 
 # Examples
@@ -35,7 +35,7 @@ _Code starting a server with 2 request handlers:_
  * - otherwise
  *   -> respond with 404
  */
-import { startServer, composeServices } from "@jsenv/server"
+import { startServer, composeServices } from "@jsenv/server";
 
 const server = await startServer({
   services: [
@@ -43,33 +43,33 @@ const server = await startServer({
       name: "index",
       handleRequest: (request) => {
         if (request.resource === "/") {
-          return { status: 200 }
+          return { status: 200 };
         }
-        return null
+        return null;
       },
     },
     {
       name: "otherwise",
       handleRequest: () => {
-        return { status: 404 }
+        return { status: 404 };
       },
     },
   ],
-})
+});
 
-const fetch = await import("node-fetch")
-const responseForOrigin = await fetch(server.origin)
-responseForOrigin.status // 200
+const fetch = await import("node-fetch");
+const responseForOrigin = await fetch(server.origin);
+responseForOrigin.status; // 200
 
-const responseForFoo = await fetch(`${server.origin}/foo`)
-responseForFoo.status // 404
+const responseForFoo = await fetch(`${server.origin}/foo`);
+responseForFoo.status; // 404
 ```
 
 _Code starting a server in https:_
 
 ```js
-import { readFileSync } from "node:fs"
-import { startServer } from "@jsenv/server"
+import { readFileSync } from "node:fs";
+import { startServer } from "@jsenv/server";
 
 await startServer({
   https: {
@@ -80,7 +80,7 @@ await startServer({
   services: [
     {
       handleRequest: (request) => {
-        const clientUsesHttp = request.origin.startsWith("http:")
+        const clientUsesHttp = request.origin.startsWith("http:");
 
         return {
           status: 200,
@@ -88,29 +88,29 @@ await startServer({
             "content-type": "text/plain",
           },
           body: clientUsesHttp ? `Welcome http user` : `Welcome https user`,
-        }
+        };
       },
     },
   ],
-})
+});
 ```
 
 _Code starting a server for static files:_
 
 ```js
-import { startServer, fetchFileSystem } from "@jsenv/server"
+import { startServer, fetchFileSystem } from "@jsenv/server";
 
 await startServer({
   services: [
     {
       handleRequest: async (request) => {
-        const fileUrl = new URL(request.resource.slice(1), import.meta.url)
-        const response = await fetchFileSystem(fileUrl, request)
-        return response
+        const fileUrl = new URL(request.resource.slice(1), import.meta.url);
+        const response = await fetchFileSystem(fileUrl, request);
+        return response;
       },
     },
   ],
-})
+});
 ```
 
 # Documentation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "15.0.2",
+  "version": "15.0.3",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -10,7 +10,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/jsenv-core",
+    "url": "https://github.com/jsenv/core",
     "directory": "packages/server"
   },
   "engines": {
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@jsenv/abort": "4.2.4",
-    "@jsenv/log": "3.3.4",
+    "@jsenv/log": "3.3.5",
     "@jsenv/url-meta": "8.1.0",
     "@jsenv/utils": "2.0.1",
     "ws": "8.13.0"

package/src/content_negotiation/pick_accepted_content.js

@@ -3,24 +3,24 @@ export const pickAcceptedContent = ({
   accepteds,
   getAcceptanceScore,
 }) => {
-  let highestScore = -1
-  let availableWithHighestScore = null
-  let availableIndex = 0
+  let highestScore = -1;
+  let availableWithHighestScore = null;
+  let availableIndex = 0;
   while (availableIndex < availables.length) {
-    const available = availables[availableIndex]
-    availableIndex++
+    const available = availables[availableIndex];
+    availableIndex++;
 
-    let acceptedIndex = 0
+    let acceptedIndex = 0;
     while (acceptedIndex < accepteds.length) {
-      const accepted = accepteds[acceptedIndex]
-      acceptedIndex++
+      const accepted = accepteds[acceptedIndex];
+      acceptedIndex++;
 
-      const score = getAcceptanceScore(accepted, available)
+      const score = getAcceptanceScore(accepted, available);
       if (score > highestScore) {
-        availableWithHighestScore = available
-        highestScore = score
+        availableWithHighestScore = available;
+        highestScore = score;
       }
     }
   }
-  return availableWithHighestScore
-}
+  return availableWithHighestScore;
+};

package/src/content_negotiation/pick_content_encoding.js

@@ -1,58 +1,58 @@
-import { parseMultipleHeader } from "../internal/multiple-header.js"
-import { pickAcceptedContent } from "./pick_accepted_content.js"
+import { parseMultipleHeader } from "../internal/multiple-header.js";
+import { pickAcceptedContent } from "./pick_accepted_content.js";
 
 export const pickContentEncoding = (request, availableEncodings) => {
-  const { headers = {} } = request
-  const requestAcceptEncodingHeader = headers["accept-encoding"]
+  const { headers = {} } = request;
+  const requestAcceptEncodingHeader = headers["accept-encoding"];
   if (!requestAcceptEncodingHeader) {
-    return null
+    return null;
   }
 
   const encodingsAccepted = parseAcceptEncodingHeader(
     requestAcceptEncodingHeader,
-  )
+  );
   return pickAcceptedContent({
     accepteds: encodingsAccepted,
     availables: availableEncodings,
     getAcceptanceScore: getEncodingAcceptanceScore,
-  })
-}
+  });
+};
 
 const parseAcceptEncodingHeader = (acceptEncodingHeaderString) => {
   const acceptEncodingHeader = parseMultipleHeader(acceptEncodingHeaderString, {
     validateProperty: ({ name }) => {
       // read only q, anything else is ignored
-      return name === "q"
+      return name === "q";
     },
-  })
+  });
 
-  const encodingsAccepted = []
+  const encodingsAccepted = [];
   Object.keys(acceptEncodingHeader).forEach((key) => {
-    const { q = 1 } = acceptEncodingHeader[key]
-    const value = key
+    const { q = 1 } = acceptEncodingHeader[key];
+    const value = key;
     encodingsAccepted.push({
       value,
       quality: q,
-    })
-  })
+    });
+  });
   encodingsAccepted.sort((a, b) => {
-    return b.quality - a.quality
-  })
-  return encodingsAccepted
-}
+    return b.quality - a.quality;
+  });
+  return encodingsAccepted;
+};
 
 const getEncodingAcceptanceScore = ({ value, quality }, availableEncoding) => {
   if (value === "*") {
-    return quality
+    return quality;
   }
 
   // normalize br to brotli
-  if (value === "br") value = "brotli"
-  if (availableEncoding === "br") availableEncoding = "brotli"
+  if (value === "br") value = "brotli";
+  if (availableEncoding === "br") availableEncoding = "brotli";
 
   if (value === availableEncoding) {
-    return quality
+    return quality;
   }
 
-  return -1
-}
+  return -1;
+};

package/src/content_negotiation/pick_content_language.js

@@ -1,77 +1,78 @@
-import { parseMultipleHeader } from "../internal/multiple-header.js"
-import { pickAcceptedContent } from "./pick_accepted_content.js"
+import { parseMultipleHeader } from "../internal/multiple-header.js";
+import { pickAcceptedContent } from "./pick_accepted_content.js";
 
 export const pickContentLanguage = (request, availableLanguages) => {
-  const { headers = {} } = request
-  const requestAcceptLanguageHeader = headers["accept-language"]
+  const { headers = {} } = request;
+  const requestAcceptLanguageHeader = headers["accept-language"];
   if (!requestAcceptLanguageHeader) {
-    return null
+    return null;
   }
 
   const languagesAccepted = parseAcceptLanguageHeader(
     requestAcceptLanguageHeader,
-  )
+  );
   return pickAcceptedContent({
     accepteds: languagesAccepted,
     availables: availableLanguages,
     getAcceptanceScore: getLanguageAcceptanceScore,
-  })
-}
+  });
+};
 
 const parseAcceptLanguageHeader = (acceptLanguageHeaderString) => {
   const acceptLanguageHeader = parseMultipleHeader(acceptLanguageHeaderString, {
     validateProperty: ({ name }) => {
       // read only q, anything else is ignored
-      return name === "q"
+      return name === "q";
     },
-  })
+  });
 
-  const languagesAccepted = []
+  const languagesAccepted = [];
   Object.keys(acceptLanguageHeader).forEach((key) => {
-    const { q = 1 } = acceptLanguageHeader[key]
-    const value = key
+    const { q = 1 } = acceptLanguageHeader[key];
+    const value = key;
     languagesAccepted.push({
       value,
       quality: q,
-    })
-  })
+    });
+  });
   languagesAccepted.sort((a, b) => {
-    return b.quality - a.quality
-  })
-  return languagesAccepted
-}
+    return b.quality - a.quality;
+  });
+  return languagesAccepted;
+};
 
 const getLanguageAcceptanceScore = ({ value, quality }, availableLanguage) => {
-  const [acceptedPrimary, acceptedVariant] = decomposeLanguage(value)
+  const [acceptedPrimary, acceptedVariant] = decomposeLanguage(value);
   const [availablePrimary, availableVariant] =
-    decomposeLanguage(availableLanguage)
+    decomposeLanguage(availableLanguage);
 
   const primaryAccepted =
     acceptedPrimary === "*" ||
-    acceptedPrimary.toLowerCase() === availablePrimary.toLowerCase()
+    acceptedPrimary.toLowerCase() === availablePrimary.toLowerCase();
   const variantAccepted =
-    acceptedVariant === "*" || compareVariant(acceptedVariant, availableVariant)
+    acceptedVariant === "*" ||
+    compareVariant(acceptedVariant, availableVariant);
 
   if (primaryAccepted && variantAccepted) {
-    return quality + 1
+    return quality + 1;
   }
   if (primaryAccepted) {
-    return quality
+    return quality;
   }
-  return -1
-}
+  return -1;
+};
 
 const decomposeLanguage = (fullType) => {
-  const [primary, variant] = fullType.split("-")
-  return [primary, variant]
-}
+  const [primary, variant] = fullType.split("-");
+  return [primary, variant];
+};
 
 const compareVariant = (left, right) => {
   if (left === right) {
-    return true
+    return true;
   }
   if (left && right && left.toLowerCase() === right.toLowerCase()) {
-    return true
+    return true;
   }
-  return false
-}
+  return false;
+};

package/src/content_negotiation/pick_content_type.js

@@ -1,63 +1,63 @@
-import { parseMultipleHeader } from "../internal/multiple-header.js"
-import { pickAcceptedContent } from "./pick_accepted_content.js"
+import { parseMultipleHeader } from "../internal/multiple-header.js";
+import { pickAcceptedContent } from "./pick_accepted_content.js";
 
 export const pickContentType = (request, availableContentTypes) => {
-  const { headers = {} } = request
-  const requestAcceptHeader = headers.accept
+  const { headers = {} } = request;
+  const requestAcceptHeader = headers.accept;
   if (!requestAcceptHeader) {
-    return null
+    return null;
   }
 
-  const contentTypesAccepted = parseAcceptHeader(requestAcceptHeader)
+  const contentTypesAccepted = parseAcceptHeader(requestAcceptHeader);
   return pickAcceptedContent({
     accepteds: contentTypesAccepted,
     availables: availableContentTypes,
     getAcceptanceScore: getContentTypeAcceptanceScore,
-  })
-}
+  });
+};
 
 const parseAcceptHeader = (acceptHeader) => {
   const acceptHeaderObject = parseMultipleHeader(acceptHeader, {
     validateProperty: ({ name }) => {
       // read only q, anything else is ignored
-      return name === "q"
+      return name === "q";
     },
-  })
+  });
 
-  const accepts = []
+  const accepts = [];
   Object.keys(acceptHeaderObject).forEach((key) => {
-    const { q = 1 } = acceptHeaderObject[key]
-    const value = key
+    const { q = 1 } = acceptHeaderObject[key];
+    const value = key;
     accepts.push({
       value,
       quality: q,
-    })
-  })
+    });
+  });
   accepts.sort((a, b) => {
-    return b.quality - a.quality
-  })
-  return accepts
-}
+    return b.quality - a.quality;
+  });
+  return accepts;
+};
 
 const getContentTypeAcceptanceScore = (
   { value, quality },
   availableContentType,
 ) => {
-  const [acceptedType, acceptedSubtype] = decomposeContentType(value)
+  const [acceptedType, acceptedSubtype] = decomposeContentType(value);
   const [availableType, availableSubtype] =
-    decomposeContentType(availableContentType)
+    decomposeContentType(availableContentType);
 
-  const typeAccepted = acceptedType === "*" || acceptedType === availableType
+  const typeAccepted = acceptedType === "*" || acceptedType === availableType;
   const subtypeAccepted =
-    acceptedSubtype === "*" || acceptedSubtype === availableSubtype
+    acceptedSubtype === "*" || acceptedSubtype === availableSubtype;
 
   if (typeAccepted && subtypeAccepted) {
-    return quality
+    return quality;
   }
-  return -1
-}
+  return -1;
+};
 
 const decomposeContentType = (fullType) => {
-  const [type, subtype] = fullType.split("/")
-  return [type, subtype]
-}
+  const [type, subtype] = fullType.split("/");
+  return [type, subtype];
+};