one/dist/cjs/vite/resolveResponse.native.js

One is a new React Framework that makes Vite serve both native and web.

"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: !0
    });
  },
  __copyProps = (to, from, except, desc) => {
    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
}), mod);
var resolveResponse_exports = {};
__export(resolveResponse_exports, {
  resolveAPIEndpoint: () => resolveAPIEndpoint,
  resolveResponse: () => resolveResponse
});
module.exports = __toCommonJS(resolveResponse_exports);
var import_isResponse = require("../utils/isResponse.native.js"),
  import_one_server_only = require("./one-server-only.native.js");
function _instanceof(left, right) {
  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
}
function _type_of(obj) {
  "@swc/helpers - typeof";

  return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
function resolveResponse(getResponse) {
  return new Promise(function (res, rej) {
    (0, import_one_server_only.runWithAsyncLocalContext)(async function (id) {
      try {
        var response = await getResponse(),
          modifiedResponse = await getResponseWithAddedHeaders(response, id);
        res(modifiedResponse);
      } catch (err) {
        (0, import_isResponse.isResponse)(err) ? res(err) : rej(err);
      }
    });
  });
}
function resolveAPIEndpoint(runEndpoint, request, params) {
  return resolveResponse(async function () {
    var imported = await runEndpoint(),
      requestType = request.method || "GET",
      handler = imported[requestType] || imported.default;
    if (!handler) {
      console.warn(`No handler found for request ${requestType}`);
      return;
    }
    return await handler(request, {
      params
    });
  });
}
async function getResponseWithAddedHeaders(response, id) {
  var asyncHeaders = import_one_server_only.asyncHeadersCache.get(id);
  if (asyncHeaders) try {
    _instanceof(response, Response) ? (0, import_one_server_only.mergeHeaders)(response.headers, asyncHeaders) : response && (typeof response > "u" ? "undefined" : _type_of(response)) === "object" ? response = Response.json(response, {
      headers: asyncHeaders
    }) : response = new Response(response, {
      headers: asyncHeaders
    });
  } catch (err) {
    if (`${err}`.includes("immutable")) {
      var body = response.body ? await streamToString(response.body) : "";
      response = new Response(body, {
        headers: response.headers,
        status: response.status,
        statusText: response.statusText
      }), (0, import_one_server_only.mergeHeaders)(response.headers, asyncHeaders);
    } else console.error(` [one] error adding headers: ${err}`);
  }
  return response;
}
async function streamToString(stream) {
  var reader = stream.getReader(),
    decoder = new TextDecoder(),
    result = "";
  try {
    for (;;) {
      var {
        done,
        value
      } = await reader.read();
      if (done) break;
      result += decoder.decode(value, {
        stream: !0
      });
    }
  } catch (error) {
    console.error("Error reading the stream:", error);
  } finally {
    reader.releaseLock();
  }
  return result;
}
//# sourceMappingURL=resolveResponse.native.js.map