@jsenv/server 15.0.2 → 15.0.4

package/src/interfacing_with_node/observable.js

@@ -1,10 +1,10 @@
 if ("observable" in Symbol === false) {
-  Symbol.observable = Symbol.for("observable")
+  Symbol.observable = Symbol.for("observable");
 }
 
 export const createObservable = (producer) => {
   if (typeof producer !== "function") {
-    throw new TypeError(`producer must be a function, got ${producer}`)
+    throw new TypeError(`producer must be a function, got ${producer}`);
   }
 
   const observable = {
@@ -12,160 +12,160 @@ export const createObservable = (producer) => {
     subscribe: ({
       next = () => {},
       error = (value) => {
-        throw value
+        throw value;
       },
       complete = () => {},
     }) => {
-      let cleanup = () => {}
+      let cleanup = () => {};
       const subscription = {
         closed: false,
         unsubscribe: () => {
-          subscription.closed = true
-          cleanup()
+          subscription.closed = true;
+          cleanup();
         },
-      }
+      };
 
       const producerReturnValue = producer({
         next: (value) => {
-          if (subscription.closed) return
-          next(value)
+          if (subscription.closed) return;
+          next(value);
         },
         error: (value) => {
-          if (subscription.closed) return
-          error(value)
+          if (subscription.closed) return;
+          error(value);
         },
         complete: () => {
-          if (subscription.closed) return
-          complete()
+          if (subscription.closed) return;
+          complete();
         },
-      })
+      });
       if (typeof producerReturnValue === "function") {
-        cleanup = producerReturnValue
+        cleanup = producerReturnValue;
       }
-      return subscription
+      return subscription;
     },
-  }
+  };
 
-  return observable
-}
+  return observable;
+};
 
 export const isObservable = (value) => {
   if (value === null || value === undefined) {
-    return false
+    return false;
   }
 
   if (typeof value === "object" || typeof value === "function") {
-    return Symbol.observable in value
+    return Symbol.observable in value;
   }
 
-  return false
-}
+  return false;
+};
 
 export const observableFromValue = (value) => {
   if (isObservable(value)) {
-    return value
+    return value;
   }
 
   return createObservable(({ next, complete }) => {
-    next(value)
+    next(value);
     const timer = setTimeout(() => {
-      complete()
-    })
+      complete();
+    });
     return () => {
-      clearTimeout(timer)
-    }
-  })
-}
+      clearTimeout(timer);
+    };
+  });
+};
 
 export const createCompositeProducer = ({ cleanup = () => {} } = {}) => {
-  const observables = new Set()
-  const observers = new Set()
+  const observables = new Set();
+  const observers = new Set();
 
   const addObservable = (observable) => {
     if (observables.has(observable)) {
-      return false
+      return false;
     }
 
-    observables.add(observable)
+    observables.add(observable);
     observers.forEach((observer) => {
-      observer.observe(observable)
-    })
-    return true
-  }
+      observer.observe(observable);
+    });
+    return true;
+  };
 
   const removeObservable = (observable) => {
     if (!observables.has(observable)) {
-      return false
+      return false;
     }
 
-    observables.delete(observable)
+    observables.delete(observable);
     observers.forEach((observer) => {
-      observer.unobserve(observable)
-    })
-    return true
-  }
+      observer.unobserve(observable);
+    });
+    return true;
+  };
 
   const producer = ({
     next = () => {},
     complete = () => {},
     error = () => {},
   }) => {
-    let completeCount = 0
+    let completeCount = 0;
 
     const checkComplete = () => {
       if (completeCount === observables.size) {
-        complete()
+        complete();
       }
-    }
+    };
 
-    const subscriptions = new Map()
+    const subscriptions = new Map();
     const observe = (observable) => {
       const subscription = observable.subscribe({
         next: (value) => {
-          next(value)
+          next(value);
         },
         error: (value) => {
-          error(value)
+          error(value);
         },
         complete: () => {
-          subscriptions.delete(observable)
-          completeCount++
-          checkComplete()
+          subscriptions.delete(observable);
+          completeCount++;
+          checkComplete();
         },
-      })
-      subscriptions.set(observable, subscription)
-    }
+      });
+      subscriptions.set(observable, subscription);
+    };
     const unobserve = (observable) => {
-      const subscription = subscriptions.get(observable)
+      const subscription = subscriptions.get(observable);
       if (!subscription) {
-        return
+        return;
       }
 
-      subscription.unsubscribe()
-      subscriptions.delete(observable)
-      checkComplete()
-    }
+      subscription.unsubscribe();
+      subscriptions.delete(observable);
+      checkComplete();
+    };
     const observer = {
       observe,
       unobserve,
-    }
-    observers.add(observer)
+    };
+    observers.add(observer);
     observables.forEach((observable) => {
-      observe(observable)
-    })
+      observe(observable);
+    });
 
     return () => {
-      observers.delete(observer)
+      observers.delete(observer);
       subscriptions.forEach((subscription) => {
-        subscription.unsubscribe()
-      })
-      subscriptions.clear()
-      cleanup()
-    }
-  }
-
-  producer.addObservable = addObservable
-  producer.removeObservable = removeObservable
-
-  return producer
-}
+        subscription.unsubscribe();
+      });
+      subscriptions.clear();
+      cleanup();
+    };
+  };
+
+  producer.addObservable = addObservable;
+  producer.removeObservable = removeObservable;
+
+  return producer;
+};

package/src/interfacing_with_node/observable_from_node_stream.js

@@ -1,6 +1,6 @@
 // https://github.com/jamestalmage/stream-to-observable/blob/master/index.js
-import { Readable } from "node:stream"
-import { createObservable } from "./observable.js"
+import { Readable } from "node:stream";
+import { createObservable } from "./observable.js";
 
 export const observableFromNodeStream = (
   nodeStream,
@@ -10,31 +10,31 @@ export const observableFromNodeStream = (
 ) => {
   const observable = createObservable(({ next, error, complete }) => {
     if (nodeStream.isPaused()) {
-      nodeStream.resume()
+      nodeStream.resume();
     } else if (nodeStream.complete) {
-      complete()
-      return null
+      complete();
+      return null;
     }
     const cleanup = () => {
-      nodeStream.removeListener("data", next)
-      nodeStream.removeListener("error", error)
-      nodeStream.removeListener("end", complete)
-      nodeStream.removeListener("close", cleanup)
-      nodeStream.destroy()
-    }
+      nodeStream.removeListener("data", next);
+      nodeStream.removeListener("error", error);
+      nodeStream.removeListener("end", complete);
+      nodeStream.removeListener("close", cleanup);
+      nodeStream.destroy();
+    };
     // should we do nodeStream.resume() in case the stream was paused ?
-    nodeStream.once("error", error)
+    nodeStream.once("error", error);
     nodeStream.on("data", (data) => {
-      next(data)
-    })
+      next(data);
+    });
     nodeStream.once("close", () => {
-      cleanup()
-    })
+      cleanup();
+    });
     nodeStream.once("end", () => {
-      complete()
-    })
-    return cleanup
-  })
+      complete();
+    });
+    return cleanup;
+  });
 
   if (nodeStream instanceof Readable) {
     // safe measure, ensure the readable stream gets
@@ -49,24 +49,24 @@ export const observableFromNodeStream = (
           // url is for http client request
           detail: `path: ${nodeStream.path}, fd: ${nodeStream.fd}, url: ${nodeStream.url}`,
         },
-      )
-      nodeStream.destroy()
-    }, readableStreamLifetime)
-    observable.timeout = timeout
+      );
+      nodeStream.destroy();
+    }, readableStreamLifetime);
+    observable.timeout = timeout;
     onceReadableStreamUsedOrClosed(nodeStream, () => {
-      clearTimeout(timeout)
-    })
+      clearTimeout(timeout);
+    });
   }
 
-  return observable
-}
+  return observable;
+};
 
 const onceReadableStreamUsedOrClosed = (readableStream, callback) => {
   const dataOrCloseCallback = () => {
-    readableStream.removeListener("data", dataOrCloseCallback)
-    readableStream.removeListener("close", dataOrCloseCallback)
-    callback()
-  }
-  readableStream.on("data", dataOrCloseCallback)
-  readableStream.once("close", dataOrCloseCallback)
-}
+    readableStream.removeListener("data", dataOrCloseCallback);
+    readableStream.removeListener("close", dataOrCloseCallback);
+    callback();
+  };
+  readableStream.on("data", dataOrCloseCallback);
+  readableStream.once("close", dataOrCloseCallback);
+};

package/src/interfacing_with_node/request_factory.js

@@ -1,28 +1,28 @@
-import { observableFromNodeStream } from "./observable_from_node_stream.js"
-import { headersFromObject } from "../internal/headersFromObject.js"
+import { observableFromNodeStream } from "./observable_from_node_stream.js";
+import { headersFromObject } from "../internal/headersFromObject.js";
 
 export const fromNodeRequest = (
   nodeRequest,
   { serverOrigin, signal, requestBodyLifetime },
 ) => {
-  const headers = headersFromObject(nodeRequest.headers)
+  const headers = headersFromObject(nodeRequest.headers);
   const body = observableFromNodeStream(nodeRequest, {
     readableStreamLifetime: requestBodyLifetime,
-  })
+  });
 
-  let requestOrigin
+  let requestOrigin;
   if (nodeRequest.upgrade) {
-    requestOrigin = serverOrigin
+    requestOrigin = serverOrigin;
   } else if (nodeRequest.authority) {
     requestOrigin = nodeRequest.connection.encrypted
       ? `https://${nodeRequest.authority}`
-      : `http://${nodeRequest.authority}`
+      : `http://${nodeRequest.authority}`;
   } else if (nodeRequest.headers.host) {
     requestOrigin = nodeRequest.connection.encrypted
       ? `https://${nodeRequest.headers.host}`
-      : `http://${nodeRequest.headers.host}`
+      : `http://${nodeRequest.headers.host}`;
   } else {
-    requestOrigin = serverOrigin
+    requestOrigin = serverOrigin;
   }
 
   return Object.freeze({
@@ -36,8 +36,8 @@ export const fromNodeRequest = (
     method: nodeRequest.method,
     headers,
     body,
-  })
-}
+  });
+};
 
 export const applyRedirectionToRequest = (
   request,
@@ -57,26 +57,26 @@ export const applyRedirectionToRequest = (
         })
       : {}),
     ...rest,
-  }
-}
+  };
+};
 
 const getPropertiesFromResource = ({ resource, baseUrl }) => {
-  const urlObject = new URL(resource, baseUrl)
-  let pathname = urlObject.pathname
+  const urlObject = new URL(resource, baseUrl);
+  let pathname = urlObject.pathname;
 
   return {
     url: String(urlObject),
     pathname,
     resource,
-  }
-}
+  };
+};
 
 const getPropertiesFromPathname = ({ pathname, baseUrl }) => {
   return getPropertiesFromResource({
     resource: `${pathname}${new URL(baseUrl).search}`,
     baseUrl,
-  })
-}
+  });
+};
 
 export const createPushRequest = (request, { signal, pathname, method }) => {
   const pushRequest = Object.freeze({
@@ -93,12 +93,12 @@ export const createPushRequest = (request, { signal, pathname, method }) => {
     method: method || request.method,
     headers: getHeadersInheritedByPushRequest(request),
     body: undefined,
-  })
-  return pushRequest
-}
+  });
+  return pushRequest;
+};
 
 const getHeadersInheritedByPushRequest = (request) => {
-  const headersInherited = { ...request.headers }
+  const headersInherited = { ...request.headers };
   // mtime sent by the client in request headers concerns the main request
   // Time remains valid for request to other resources so we keep it
   // in child requests
@@ -106,7 +106,7 @@ const getHeadersInheritedByPushRequest = (request) => {
 
   // eTag sent by the client in request headers concerns the main request
   // A request made to an other resource must not inherit the eTag
-  delete headersInherited["if-none-match"]
+  delete headersInherited["if-none-match"];
 
-  return headersInherited
-}
+  return headersInherited;
+};