@edgeone/nuxt-pages/dist/run/handlers/nuxt-server.js

A professional deployment package that seamlessly deploys your Nuxt 3/4 applications to Tencent Cloud EdgeOne platform with optimized performance and intelligent caching.

      var require = await (async () => {
        var { createRequire } = await import("node:module");
        return createRequire(import.meta.url);
      })();
    
import "../../esm-chunks/chunk-6BT4RYQJ.js";

// src/run/handlers/nuxt-server.ts
var defaultEdgeOneNuxtConfig = {
  // Nuxt specific configuration
  ssr: true,
  nitro: {
    storage: {}
  },
  experimental: {
    payloadExtraction: false
  },
  // EdgeOne specific settings
  useRegionalBlobs: true,
  cacheControl: {
    maxAge: 3600,
    staleWhileRevalidate: 86400
  }
};
function createH3EventFromRequest(request) {
  const url = new URL(request.url);
  const mockReq = {
    method: request.method,
    url: url.pathname + url.search,
    headers: Object.fromEntries(request.headers.entries()),
    body: request.body
  };
  const mockRes = {
    writeHead: () => {
    },
    write: () => {
    },
    end: () => {
    },
    writableEnded: false,
    headersSent: false,
    statusCode: 200,
    statusMessage: "OK",
    _headers: {},
    setHeader: function(name, value) {
      this._headers[name.toLowerCase()] = value;
    },
    getHeader: function(name) {
      return this._headers[name.toLowerCase()];
    },
    removeHeader: function(name) {
      delete this._headers[name.toLowerCase()];
    }
  };
  const event = {
    __is_event__: true,
    node: { req: mockReq, res: mockRes },
    context: {},
    _method: void 0,
    _path: void 0,
    _headers: void 0,
    _requestBody: void 0,
    _handled: false,
    _onBeforeResponseCalled: void 0,
    _onAfterResponseCalled: void 0,
    get method() {
      if (!this._method) {
        this._method = (this.node.req.method || "GET").toUpperCase();
      }
      return this._method;
    },
    get path() {
      return this._path || this.node.req.url || "/";
    },
    get headers() {
      if (!this._headers) {
        this._headers = this._normalizeNodeHeaders(this.node.req.headers);
      }
      return this._headers;
    },
    get handled() {
      return this._handled || this.node.res.writableEnded || this.node.res.headersSent;
    },
    _normalizeNodeHeaders(nodeHeaders) {
      const headers = new Headers();
      for (const [name, value] of Object.entries(nodeHeaders)) {
        if (Array.isArray(value)) {
          for (const item of value) {
            headers.append(name, item);
          }
        } else if (value) {
          headers.set(name, value);
        }
      }
      return headers;
    },
    toString() {
      return `[${this.method}] ${this.path}`;
    },
    toJSON() {
      return this.toString();
    }
  };
  return event;
}
var EdgeOneNuxtServerHandler = class {
  nuxtHandler = null;
  config;
  nuxtImportPromise;
  constructor(config = defaultEdgeOneNuxtConfig) {
    this.config = { ...defaultEdgeOneNuxtConfig, ...config };
    this.nuxtImportPromise = import(process.cwd() + "/app/.output/server/index.mjs");
  }
  async initializeNuxtServer() {
    if (!this.nuxtHandler) {
      try {
        const nuxtApp = await this.nuxtImportPromise;
        this.nuxtHandler = nuxtApp.default;
      } catch (error) {
        console.error("Failed to initialize Nuxt server:", error);
        throw error;
      }
    }
  }
  async handleRequest(request) {
    try {
      await this.initializeNuxtServer();
      const event = createH3EventFromRequest(request);
      const response = await this.nuxtHandler(event);
      return response;
    } catch (error) {
      console.error("Nuxt handler error:", error);
      return new Response("Internal Server Error", {
        status: 500,
        headers: {
          "Content-Type": "text/plain"
        }
      });
    }
  }
};
function createEdgeOneNuxtServerHandler(config = defaultEdgeOneNuxtConfig) {
  return new EdgeOneNuxtServerHandler(config);
}
var nuxt_server_default = async (request) => {
  const handler = createEdgeOneNuxtServerHandler();
  return handler.handleRequest(request);
};
export {
  EdgeOneNuxtServerHandler,
  createEdgeOneNuxtServerHandler,
  nuxt_server_default as default,
  defaultEdgeOneNuxtConfig
};