@elysiajs/node/dist/cjs/utils.js

Elysia adapter to run Elysia on Node.js

"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/utils.ts
var utils_exports = {};
__export(utils_exports, {
  createResponseHandler: () => createResponseHandler,
  handleFile: () => handleFile,
  mergeHeaders: () => mergeHeaders,
  mergeStatus: () => mergeStatus
});
module.exports = __toCommonJS(utils_exports);
var import_srvx = require("srvx");
var import_utils = require("elysia/utils");
var import_utils2 = require("elysia/adapter/utils");
var handleFile = (response, set) => {
  if (response instanceof Promise)
    return response.then((res) => handleFile(res, set));
  const size = response.size;
  const immutable = set && (set.status === 206 || set.status === 304 || set.status === 412 || set.status === 416);
  const defaultHeader = immutable ? {
    "transfer-encoding": "chunked"
  } : {
    "accept-ranges": "bytes",
    "content-range": size ? `bytes 0-${size - 1}/${size}` : void 0,
    "transfer-encoding": "chunked"
  };
  if (!set && !size) return new import_srvx.FastResponse(response);
  if (!set)
    return new import_srvx.FastResponse(response, {
      headers: defaultHeader
    });
  if (set.headers instanceof Headers) {
    let setHeaders = defaultHeader;
    setHeaders = {};
    for (const [key, value] of set.headers.entries())
      if (key in set.headers) setHeaders[key] = value;
    if (immutable) {
      delete set.headers["content-length"];
      delete set.headers["accept-ranges"];
    }
    return new import_srvx.FastResponse(response, {
      status: set.status,
      headers: setHeaders
    });
  }
  if ((0, import_utils.isNotEmpty)(set.headers))
    return new import_srvx.FastResponse(response, {
      status: set.status,
      headers: Object.assign(defaultHeader, set.headers)
    });
  return new import_srvx.FastResponse(response, {
    status: set.status,
    headers: defaultHeader
  });
};
function mergeHeaders(responseHeaders, setHeaders) {
  const headers = new Headers(Object.fromEntries(responseHeaders.entries()));
  if (setHeaders instanceof Headers)
    for (const key of setHeaders.keys()) {
      if (key === "set-cookie") {
        if (headers.has("set-cookie")) continue;
        for (const cookie of setHeaders.getSetCookie())
          headers.append("set-cookie", cookie);
      } else if (!responseHeaders.has(key))
        headers.set(key, setHeaders?.get(key) ?? "");
    }
  else
    for (const key in setHeaders)
      if (key === "set-cookie")
        headers.append(key, setHeaders[key]);
      else if (!responseHeaders.has(key))
        headers.set(key, setHeaders[key]);
  return headers;
}
function mergeStatus(responseStatus, setStatus) {
  if (typeof setStatus === "string") setStatus = import_utils.StatusMap[setStatus];
  if (responseStatus === 200) return setStatus;
  return responseStatus;
}
var createResponseHandler = (handler) => {
  const handleStream = (0, import_utils2.createStreamHandler)(handler);
  return (response, set, request) => {
    const newResponse = new import_srvx.FastResponse(response.body, {
      headers: mergeHeaders(response.headers, set.headers),
      status: mergeStatus(response.status, set.status)
    });
    if (!newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked")
      return handleStream(
        (0, import_utils2.streamResponse)(newResponse),
        (0, import_utils2.responseToSetHeaders)(newResponse, set),
        request,
        // @ts-ignore
        true
        // don't auto-format SSE for pre-formatted Response
      );
    return newResponse;
  };
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createResponseHandler,
  handleFile,
  mergeHeaders,
  mergeStatus
});