@web-widget/node 0.0.3 → 0.1.1

package/dist/node.cjs

@@ -0,0 +1,143 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => NodeAdapter
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_utils = require("@edge-runtime/node-utils");
+var import_primitives = __toESM(require("@edge-runtime/primitives"), 1);
+if (!Reflect.get(global, "DISABLE_INSTALL_MCA_SHIMS")) {
+  Object.assign(global, import_primitives.default, { console });
+}
+var FetchEvent = class {
+  constructor(request) {
+    this.request = request;
+    this.response = null;
+    this.awaiting = /* @__PURE__ */ new Set();
+  }
+  respondWith(response) {
+    this.response = response;
+  }
+  waitUntil() {
+    throw new Error("waitUntil is not implemented yet for Node.js");
+  }
+};
+var dependencies = {
+  Headers,
+  ReadableStream,
+  // @ts-ignore
+  Request: class extends Request {
+    constructor(input, init) {
+      super(input, addDuplexToInit(init));
+    }
+  },
+  Uint8Array,
+  FetchEvent
+};
+var NodeAdapter = class {
+  #handler;
+  #middleware;
+  constructor(webRouter, options = {
+    defaultOrigin: webRouter?.options?.origin ?? "https://web-widget.js.org"
+  }) {
+    this.#handler = (0, import_node_utils.buildToNodeHandler)(
+      dependencies,
+      options
+    )(webRouter.handler);
+    this.#middleware = toMiddleware(webRouter.handler, options);
+  }
+  get middleware() {
+    return this.#middleware;
+  }
+  get handler() {
+    return this.#handler;
+  }
+  static get primitives() {
+    return import_primitives.default;
+  }
+};
+function addDuplexToInit(init) {
+  if (typeof init === "undefined" || typeof init === "object") {
+    return { duplex: "half", ...init };
+  }
+  return init;
+}
+async function toServerResponse(webResponse, serverResponse) {
+  if (!webResponse) {
+    serverResponse.end();
+    return;
+  }
+  (0, import_node_utils.mergeIntoServerResponse)(
+    // @ts-ignore getAll() is not standard https://fetch.spec.whatwg.org/#headers-class
+    (0, import_node_utils.toOutgoingHeaders)(webResponse.headers),
+    serverResponse
+  );
+  serverResponse.statusCode = webResponse.status;
+  serverResponse.statusMessage = webResponse.statusText;
+  if (!webResponse.body) {
+    serverResponse.end();
+    return;
+  }
+  await writeReadableStreamToWritable(webResponse.body, serverResponse);
+}
+async function writeReadableStreamToWritable(stream, writable) {
+  let reader = stream.getReader();
+  async function read() {
+    let { done, value } = await reader.read();
+    if (done) {
+      writable.end();
+      return;
+    }
+    writable.write(value);
+    let flushable = writable;
+    if (typeof flushable.flush === "function") {
+      flushable.flush();
+    }
+    await read();
+  }
+  try {
+    await read();
+  } catch (error) {
+    writable.destroy(error);
+    throw error;
+  }
+}
+function toMiddleware(webHandler, options) {
+  const toRequest = (0, import_node_utils.buildToRequest)(dependencies);
+  const toFetchEvent = (0, import_node_utils.buildToFetchEvent)(dependencies);
+  return async function middleware(incomingMessage, serverResponse, next) {
+    const request = toRequest(incomingMessage, options);
+    const webResponse = await webHandler(request, toFetchEvent(request));
+    await toServerResponse(webResponse, serverResponse);
+    next();
+  };
+}

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { IncomingMessage, ServerResponse } from 'node:http';
 import primitives from '@edge-runtime/primitives';
+import { IncomingMessage, ServerResponse } from 'node:http';
 import { RequestOptions, WebHandler, NodeHandler } from '@edge-runtime/node-utils';
 
 interface NodeAdapterOptions extends RequestOptions {

package/dist/node.js

@@ -1,13 +1,12 @@
 // src/index.ts
-import primitives from "@edge-runtime/primitives";
 import {
+  buildToFetchEvent,
   buildToNodeHandler,
   buildToRequest,
-  buildToFetchEvent,
   mergeIntoServerResponse,
-  toToReadable,
   toOutgoingHeaders
 } from "@edge-runtime/node-utils";
+import primitives from "@edge-runtime/primitives";
 if (!Reflect.get(global, "DISABLE_INSTALL_MCA_SHIMS")) {
   Object.assign(global, primitives, { console });
 }
@@ -65,24 +64,44 @@ function addDuplexToInit(init) {
   return init;
 }
 async function toServerResponse(webResponse, serverResponse) {
-  return new Promise((resolve, reject) => {
-    if (!webResponse) {
-      serverResponse.end();
+  if (!webResponse) {
+    serverResponse.end();
+    return;
+  }
+  mergeIntoServerResponse(
+    // @ts-ignore getAll() is not standard https://fetch.spec.whatwg.org/#headers-class
+    toOutgoingHeaders(webResponse.headers),
+    serverResponse
+  );
+  serverResponse.statusCode = webResponse.status;
+  serverResponse.statusMessage = webResponse.statusText;
+  if (!webResponse.body) {
+    serverResponse.end();
+    return;
+  }
+  await writeReadableStreamToWritable(webResponse.body, serverResponse);
+}
+async function writeReadableStreamToWritable(stream, writable) {
+  let reader = stream.getReader();
+  async function read() {
+    let { done, value } = await reader.read();
+    if (done) {
+      writable.end();
       return;
     }
-    mergeIntoServerResponse(
-      // @ts-ignore getAll() is not standard https://fetch.spec.whatwg.org/#headers-class
-      toOutgoingHeaders(webResponse.headers),
-      serverResponse
-    );
-    serverResponse.statusCode = webResponse.status;
-    serverResponse.statusMessage = webResponse.statusText;
-    if (!webResponse.body) {
-      serverResponse.end();
-      return;
+    writable.write(value);
+    let flushable = writable;
+    if (typeof flushable.flush === "function") {
+      flushable.flush();
     }
-    toToReadable(webResponse.body).pipe(serverResponse).on("finish", () => resolve(void 0)).on("error", reject);
-  });
+    await read();
+  }
+  try {
+    await read();
+  } catch (error) {
+    writable.destroy(error);
+    throw error;
+  }
 }
 function toMiddleware(webHandler, options) {
   const toRequest = buildToRequest(dependencies);

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@web-widget/node",
-  "version": "0.0.3",
+  "version": "0.1.1",
   "type": "module",
   "exports": {
     ".": {
       "types": "./dist/node.d.ts",
+      "require": "./dist/node.cjs",
       "default": "./dist/node.js"
     }
   },