abi.js/dist/node/server.cjs

[![typescript-icon]][typescript-link] [![license-icon]][license-link] [![status-icon]][status-link] [![ci-icon]][ci-link] [![twitter-icon]][twitter-link]

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/server.ts
var server_exports = {};
__export(server_exports, {
  Server: () => Server
});
module.exports = __toCommonJS(server_exports);

// src/serve.ts
var import_node_http = require("node:http");

// src/defaults.ts
var defaultPort = 3e3;
var defaultHost = "0.0.0.0";

// src/helpers.ts
function isPort(port) {
  return typeof port === "number";
}
function isHostname(host) {
  return typeof host === "string";
}
function isAddress(address) {
  return typeof address === "object" && "port" in address && "hostname" in address && isPort(address.port) && isHostname(address.hostname);
}
function isHandler(handler) {
  return typeof handler === "function";
}
function hasHandler(options) {
  return "handler" in options && isHandler(options.handler);
}
function isServeOptions(options) {
  return isAddress(options) && hasHandler(options);
}
function toServeOptions(arg1, arg2, arg3) {
  let options;
  if (typeof arg1 === "function") {
    options = { port: defaultPort, hostname: defaultHost, handler: arg1 };
  } else if (isPort(arg1) && isHandler(arg2)) {
    options = { port: arg1, hostname: defaultHost, handler: arg2 };
  } else if (isHostname(arg1) && isHandler(arg2)) {
    options = { port: defaultPort, hostname: arg1, handler: arg2 };
  } else if (isPort(arg1) && isHostname(arg2) && isHandler(arg3)) {
    options = { port: arg1, hostname: arg2, handler: arg3 };
  } else if (isAddress(arg1) && isHandler(arg2)) {
    options = {
      port: arg1.port,
      hostname: arg1.hostname,
      handler: arg2
    };
  } else if (isServeOptions(arg1)) {
    options = arg1;
  } else {
    throw new Error("Invalid arguments for serve function");
  }
  return options;
}

// src/serve.ts
function serve(arg1, arg2, arg3) {
  const { port, hostname, handler } = toServeOptions(arg1, arg2, arg3);
  const server = (0, import_node_http.createServer)((req, res) => {
    const data = [];
    req.on("error", (err) => {
      throw err;
    }).on("data", (chunk) => {
      data.push(chunk);
    }).on("end", async () => {
      const requestBody = Buffer.concat(data);
      const method = req.method?.toUpperCase() || "GET";
      const url = new URL(req.url || "/", `http://${hostname}:${port}`);
      const requestOptions = {
        method,
        headers: Object.entries(req.headers).reduce(
          (headers, [key, value]) => {
            if (Array.isArray(value)) {
              for (const v of value) {
                headers.append(key, v);
              }
            } else if (value !== void 0) {
              headers.set(key, value);
            }
            return headers;
          },
          new Headers()
        )
      };
      if (!(method === "GET" || method === "HEAD")) {
        requestOptions.body = requestBody;
      }
      const request = new Request(url.toString(), requestOptions);
      const response = await handler(request);
      let responseBody = null;
      if (response.body instanceof ReadableStream) {
        const reader = response.body.getReader();
        const streamData = [];
        while (true) {
          const { done, value } = await reader.read();
          if (done) {
            break;
          }
          streamData.push(value);
        }
        responseBody = Buffer.concat(streamData);
      } else if (response.body) {
        responseBody = Buffer.isBuffer(response.body) ? response.body : Buffer.from(response.body);
      }
      res.writeHead(
        response.status || 200,
        Object.fromEntries(response.headers.entries())
      );
      res.end(responseBody);
    });
  });
  server.listen(port, hostname);
  const address = server.address();
  return address && typeof address === "object" ? {
    port: address.port,
    hostname: address.address
  } : { port, hostname };
}

// src/server.ts
var Server = class {
  constructor(root, assets = "") {
    this.root = root;
    this.assets = assets;
    this.fetch = this.fetch.bind(this);
  }
  #handlers = /* @__PURE__ */ new Set();
  pipe(handler, ...handlers) {
    this.#handlers.add(handler);
    for (const _handler of handlers) {
      this.#handlers.add(_handler);
    }
    return this;
  }
  async fetch(request) {
    for (const handler of this.#handlers) {
      const response = await handler(request);
      if (response.ok) {
        return response;
      }
    }
    return this.error(`Cannot ${request.method} ${request.url}`);
  }
  start() {
    serve(this.fetch);
  }
  listen(arg1, arg2) {
    const args = [arg1, arg2].filter(
      (arg) => arg !== void 0 && arg !== null
    );
    serve(...args, this.fetch);
  }
  error(err) {
    console.log(`Unexpected server error: ${err}`);
    return new Response("Error 500: Server error.", {
      status: 500
    });
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  Server
});