nuxt-gin-tools 0.2.10 → 0.2.12

package/src/commands/pack.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FILES_TO_COPY = exports.PACKAGE_JSON_CONTENT = exports.SERVER_EXECUTABLE = exports.PACK_CONFIG_PATH = exports.ORIGINAL_DIST_PATH = exports.SERVER_PATH = exports.ZIP_PATH = void 0;
+exports.builtPath = builtPath;
+exports.buildAndPack = buildAndPack;
+// 导入项目构建工具，用于执行 Nuxt 项目的构建流程
+const builder_1 = __importDefault(require("./builder"));
+// 导入 7zip 压缩工具库，用于将构建后的文件打包为 7z 格式
+const Zip = __importStar(require("7zip-min"));
+// 导入增强版的文件系统模块，提供更丰富的文件操作 API
+const FS = __importStar(require("fs-extra"));
+// 导入路径处理模块，用于规范化和解析文件路径
+const Path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+/**
+ * 生成相对于服务器构建目录的绝对路径
+ * @param relativePath - 相对路径
+ * @returns 解析后的绝对路径
+ */
+function builtPath(relativePath) {
+    return Path.resolve(exports.SERVER_PATH, relativePath);
+}
+// 定义打包后的 7z 文件输出路径
+exports.ZIP_PATH = Path.resolve(process.cwd(), ".build/production/server.7z");
+// 定义服务器构建文件的输出目录
+exports.SERVER_PATH = Path.resolve(process.cwd(), ".build/production/server");
+// 定义原始 dist 目录路径，用于清理操作
+exports.ORIGINAL_DIST_PATH = Path.resolve(process.cwd(), "dist");
+exports.PACK_CONFIG_PATH = Path.resolve(process.cwd(), "pack.config.json");
+exports.SERVER_EXECUTABLE = os.platform() === "win32" ? "server-production.exe" : "server-production"; // 根据操作系统选择可执行文件名
+// 定义打包后项目的 package.json 内容
+exports.PACKAGE_JSON_CONTENT = {
+    private: true,
+    scripts: {
+        start: "./server-production.exe", // 定义启动命令
+    },
+};
+// 定义需要复制到构建目录的文件映射关系（目标为构建目录下的相对路径）
+const DEFAULT_FILES_TO_COPY = {
+    "vue/.output": "vue/.output", // Vue 应用构建输出
+    [`.build/.server/production.exe`]: "server-production.exe", // 生产环境可执行文件
+    "server.config.json": "server.config.json", // 服务器配置文件
+};
+// 兼容旧导出：默认构建目录下的绝对目标路径
+exports.FILES_TO_COPY = Object.fromEntries(Object.entries(DEFAULT_FILES_TO_COPY).map(([src, dest]) => [src, builtPath(dest)]));
+/**
+ * 写入启动脚本和 package.json 文件到构建目录
+ */
+function writeScriptFiles(serverPath, config) {
+    // 写入 Windows 批处理启动脚本
+    FS.outputFileSync(Path.resolve(serverPath, "start.bat"), `powershell -ExecutionPolicy ByPass -File ./start.ps1`);
+    // 写入 PowerShell 启动脚本
+    FS.outputFileSync(Path.resolve(serverPath, "start.ps1"), `./server-production.exe`);
+    // 写入 Linux/macOS 启动脚本
+    FS.outputFileSync(Path.resolve(serverPath, "start.sh"), `./server-production.exe`);
+    // 写入 package.json 文件，使用 2 个空格缩进
+    const mergedPackageJson = mergePackageJson(exports.PACKAGE_JSON_CONTENT, config === null || config === void 0 ? void 0 : config.packageJson);
+    FS.outputJSONSync(Path.resolve(serverPath, "package.json"), mergedPackageJson, { spaces: 2 });
+}
+/**
+ * 将配置的源文件复制到构建目录
+ */
+function copyGeneratedFiles(serverPath, config) {
+    var _a;
+    const copyOptions = {
+        overwrite: (config === null || config === void 0 ? void 0 : config.overwrite) !== false,
+        errorOnExist: (config === null || config === void 0 ? void 0 : config.overwrite) === false,
+    };
+    // 遍历文件映射，将每个源文件复制到目标位置
+    for (const [src, dest] of Object.entries(DEFAULT_FILES_TO_COPY)) {
+        const resolvedDest = Path.resolve(serverPath, dest);
+        FS.copySync(Path.resolve(process.cwd(), src), resolvedDest, copyOptions);
+    }
+    if (config === null || config === void 0 ? void 0 : config.extraFiles) {
+        for (const [src, dest] of Object.entries(config.extraFiles)) {
+            const resolvedSrc = Path.resolve(process.cwd(), src);
+            const resolvedDest = Path.isAbsolute(dest) ? dest : Path.resolve(serverPath, dest);
+            FS.copySync(resolvedSrc, resolvedDest, copyOptions);
+        }
+    }
+    if ((_a = config === null || config === void 0 ? void 0 : config.extraFilesGlobs) === null || _a === void 0 ? void 0 : _a.length) {
+        const matchedFiles = fast_glob_1.default.sync(config.extraFilesGlobs, {
+            cwd: process.cwd(),
+            onlyFiles: true,
+            dot: true,
+            ignore: config.exclude,
+        });
+        for (const file of matchedFiles) {
+            const resolvedSrc = Path.resolve(process.cwd(), file);
+            const resolvedDest = Path.resolve(serverPath, file);
+            FS.copySync(resolvedSrc, resolvedDest, copyOptions);
+        }
+    }
+}
+function mergePackageJson(base, override) {
+    if (!override) {
+        return base;
+    }
+    const baseScripts = typeof base.scripts === "object" && base.scripts ? base.scripts : {};
+    const overrideScripts = typeof override.scripts === "object" && override.scripts ? override.scripts : {};
+    return Object.assign(Object.assign(Object.assign({}, base), override), { scripts: Object.assign(Object.assign({}, baseScripts), overrideScripts) });
+}
+function readPackConfigFromCwd() {
+    if (!FS.existsSync(exports.PACK_CONFIG_PATH)) {
+        return undefined;
+    }
+    return FS.readJSONSync(exports.PACK_CONFIG_PATH);
+}
+function resolveServerPath(config) {
+    if (!(config === null || config === void 0 ? void 0 : config.serverPath)) {
+        return exports.SERVER_PATH;
+    }
+    return Path.isAbsolute(config.serverPath)
+        ? config.serverPath
+        : Path.resolve(process.cwd(), config.serverPath);
+}
+function resolveZipPath(config) {
+    if (config === null || config === void 0 ? void 0 : config.zipPath) {
+        return Path.isAbsolute(config.zipPath)
+            ? config.zipPath
+            : Path.resolve(process.cwd(), config.zipPath);
+    }
+    if (config === null || config === void 0 ? void 0 : config.zipName) {
+        return Path.resolve(Path.dirname(exports.ZIP_PATH), config.zipName);
+    }
+    return exports.ZIP_PATH;
+}
+/**
+ * 打包文件为7z格式
+ */
+function makeZip(serverPath, zipPath) {
+    return new Promise((resolve, reject) => {
+        // 使用 7zip 将服务器构建目录打包为 7z 文件
+        Zip.pack(serverPath, zipPath, (error) => {
+            if (error) {
+                console.error("打包失败:", error);
+                reject(error);
+            }
+            console.log("打包成功:", zipPath);
+            resolve(zipPath);
+        });
+    });
+}
+/**
+ * 清理原始 dist 目录
+ */
+function cleanUp(config) {
+    if ((config === null || config === void 0 ? void 0 : config.cleanDist) === false) {
+        return;
+    }
+    // 检查原始 dist 目录是否存在，存在则删除
+    if (FS.existsSync(exports.ORIGINAL_DIST_PATH)) {
+        FS.removeSync(exports.ORIGINAL_DIST_PATH);
+    }
+}
+/**
+ * 构建并打包项目的主函数
+ * 1. 执行项目构建
+ * 2. 复制生成的文件
+ * 3. 写入启动脚本
+ * 4. 打包文件为 7z 格式
+ * 5. 清理原始 dist 目录
+ */
+function buildAndPack(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resolvedConfig = config !== null && config !== void 0 ? config : readPackConfigFromCwd();
+        const serverPath = resolveServerPath(resolvedConfig);
+        const zipPath = resolveZipPath(resolvedConfig);
+        yield (0, builder_1.default)(); // 执行项目构建
+        if (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.beforePack) {
+            yield resolvedConfig.beforePack();
+        }
+        copyGeneratedFiles(serverPath, resolvedConfig); // 复制相关文件
+        if ((resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.writeScripts) !== false) {
+            writeScriptFiles(serverPath, resolvedConfig); // 写入脚本文件
+        }
+        yield makeZip(serverPath, zipPath); // 打包文件
+        if (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.afterPack) {
+            yield resolvedConfig.afterPack(zipPath);
+        }
+        cleanUp(resolvedConfig); // 清理临时文件
+    });
+}
+exports.default = buildAndPack;

package/src/commands/postinstall.d.ts

@@ -0,0 +1,2 @@
+export declare function postInstall(): Promise<import("concurrently").CloseEvent[]>;
+export default postInstall;

package/src/commands/postinstall.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postInstall = postInstall;
+const concurrently_1 = __importDefault(require("concurrently"));
+const node_child_process_1 = require("node:child_process");
+function postInstall() {
+    const hasGo = (0, node_child_process_1.spawnSync)("go", ["version"], { stdio: "ignore", shell: true }).status ===
+        0;
+    const commands = [
+        {
+            command: "npx nuxt prepare",
+            name: "nuxt",
+            prefixColor: "blue",
+        },
+    ];
+    if (hasGo) {
+        commands.unshift({
+            command: "go mod download && go mod tidy",
+            name: "go",
+            prefixColor: "green",
+        });
+    }
+    else {
+        console.warn("[nuxt-gin-tools] 未检测到 Go，已跳过 Go 相关安装。请先安装 Go 后再重新运行相关命令。");
+    }
+    // 执行并发命令
+    return (0, concurrently_1.default)(commands).result;
+}
+exports.default = postInstall;

package/src/commands/update.d.ts

@@ -0,0 +1,2 @@
+export declare function update(): void;
+export default update;

package/src/commands/update.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = update;
+const concurrently_1 = __importDefault(require("concurrently"));
+function update() {
+    (0, concurrently_1.default)([
+        {
+            command: "pnpm update --latest",
+            name: "pnpm",
+            prefixColor: "magenta",
+        },
+        {
+            command: "go get -u && go mod tidy",
+            name: "go",
+            prefixColor: "green",
+        },
+    ]);
+}
+exports.default = update;

package/src/nuxt-config.d.ts

@@ -1,63 +1,19 @@
 import type { NuxtConfig } from "nuxt/config";
+import { type IncomingMessage, type ServerResponse } from "node:http";
+import type { Socket } from "node:net";
 export interface ServerConfigJson {
-    /**
-     * 前端基础 URL
-     * 用于指定前端路由的基础路径
-     */
+    /** 前端基础 URL */
     baseUrl: string;
-    /**
-     * Nuxt 端口号
-     * 用于指定 Nuxt 项目的开发服务器端口号
-     * 例如，如果 Nuxt 项目的开发服务器端口号为 3000，则 nuxtPort 为 3000
-     */
+    /** Nuxt 开发端口 */
     nuxtPort: number;
-    /**
-     * Gin 端口号
-     * 用于指定 Gin 服务器的端口号
-     * 例如，如果 Gin 服务器的端口号为 8080，则 ginPort 为 8080
-     */
+    /** Gin 服务端口 */
     ginPort: number;
 }
 export interface MyNuxtConfig {
-    /**
-     * 服务器基础路径
-     * 用于指定服务器端路由的基础路径
-     * 例如，如果服务器端路由为 /api，则 serverBasePath 为 /api
-     */
-    apiBasePath: string;
-    /**
-     * WebSocket 代理基础路径列表（可选）
-     * 例如：["/ws-go", "/socket"]
-     * 会同时注入 Nitro devProxy 与 Vite proxy，默认启用 ws。
-     */
-    wsProxyBasePaths?: string[];
-    /**
-     * 服务器配置
-     * 包含服务器端的相关配置，如端口号、基础路径等
-     */
+    /** 服务器配置 */
     serverConfig: ServerConfigJson;
 }
 /**
- * 创建默认的 Nuxt 配置
- * @param param0 包含服务器配置和 API 基础路径的参数对象
- * @returns Nuxt 配置对象
- *
- * 用法如下：
- * ```typescript
- * import { createDefaultConfig } from 'nuxt-gin-tools/src/nuxt-config';
- * import type { NuxtConfig } from 'nuxt/config';
- * import { defineNuxtConfig } from 'nuxt/config';
- * import SERVER_CONFIG from './server.config.json';
- * import { BASE_PATH } from './vue/composables/api/base';
- *
- * const config = createDefaultConfig({
- *   apiBasePath: BASE_PATH,
- *   serverConfig: SERVER_CONFIG,
- * }) as NuxtConfig;
- *
- * export default defineNuxtConfig({
- *   ...config,
- * });
- * ```
+ * 创建默认的 Nuxt 配置。
  */
 export function createDefaultConfig(config: MyNuxtConfig): NuxtConfig;

package/src/nuxt-config.js

@@ -1,85 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultConfig = createDefaultConfig;
+const node_http_1 = require("node:http");
+function normalizePathPrefix(value) {
+    const withLeadingSlash = value.startsWith("/") ? value : `/${value}`;
+    if (withLeadingSlash !== "/" && withLeadingSlash.endsWith("/")) {
+        return withLeadingSlash.slice(0, -1);
+    }
+    return withLeadingSlash;
+}
+function normalizeBaseUrl(value) {
+    return normalizePathPrefix(value || "/");
+}
+function isViteInternalRequest(requestPath) {
+    return (requestPath.startsWith("/@vite") ||
+        requestPath.startsWith("/__vite") ||
+        requestPath.startsWith("/node_modules/") ||
+        requestPath.startsWith("/@id/"));
+}
+function isBaseUrlRequest(baseUrl, requestPath) {
+    if (baseUrl === "/") {
+        return true;
+    }
+    return requestPath === baseUrl || requestPath.startsWith(`${baseUrl}/`);
+}
+function forwardToGin(ginPort, req, res) {
+    var _a;
+    const proxyReq = (0, node_http_1.request)({
+        hostname: "127.0.0.1",
+        port: ginPort,
+        path: (_a = req.url) !== null && _a !== void 0 ? _a : "/",
+        method: req.method,
+        headers: Object.assign(Object.assign({}, req.headers), { host: `127.0.0.1:${ginPort}` }),
+    }, (proxyRes) => {
+        var _a;
+        res.writeHead((_a = proxyRes.statusCode) !== null && _a !== void 0 ? _a : 502, proxyRes.headers);
+        proxyRes.pipe(res);
+    });
+    proxyReq.on("error", (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        res.statusCode = 502;
+        res.setHeader("content-type", "application/json; charset=utf-8");
+        res.end(JSON.stringify({ error: "Bad Gateway", message }));
+    });
+    req.pipe(proxyReq);
+}
+function forwardWebSocketToGin(ginPort, req, clientSocket, clientHead) {
+    var _a, _b;
+    const proxyReq = (0, node_http_1.request)({
+        hostname: "127.0.0.1",
+        port: ginPort,
+        path: (_a = req.url) !== null && _a !== void 0 ? _a : "/",
+        method: (_b = req.method) !== null && _b !== void 0 ? _b : "GET",
+        headers: Object.assign(Object.assign({}, req.headers), { host: `127.0.0.1:${ginPort}`, connection: "Upgrade" }),
+    });
+    proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+        var _a, _b;
+        const statusLine = `HTTP/1.1 ${(_a = proxyRes.statusCode) !== null && _a !== void 0 ? _a : 101} ${(_b = proxyRes.statusMessage) !== null && _b !== void 0 ? _b : "Switching Protocols"}\r\n`;
+        const headers = proxyRes.rawHeaders;
+        let headerText = "";
+        for (let i = 0; i < headers.length; i += 2) {
+            headerText += `${headers[i]}: ${headers[i + 1]}\r\n`;
+        }
+        clientSocket.write(`${statusLine}${headerText}\r\n`);
+        if (clientHead.length > 0) {
+            proxySocket.write(clientHead);
+        }
+        if (proxyHead.length > 0) {
+            clientSocket.write(proxyHead);
+        }
+        proxySocket.pipe(clientSocket).pipe(proxySocket);
+    });
+    proxyReq.on("error", () => {
+        if (!clientSocket.destroyed) {
+            clientSocket.destroy();
+        }
+    });
+    proxyReq.end();
+}
 /**
- * 创建默认的 Nuxt 配置
- * @param param0 包含服务器配置和 API 基础路径的参数对象
- * @returns Nuxt 配置对象
- *
- * 用法如下：
- * ```typescript
- * import { createDefaultConfig } from 'nuxt-gin-tools/src/nuxt-config';
- * import type { NuxtConfig } from 'nuxt/config';
- * import { defineNuxtConfig } from 'nuxt/config';
- * import SERVER_CONFIG from './server.config.json';
- * import { BASE_PATH } from './vue/composables/api/base';
- *
- * const config = createDefaultConfig({
- *   apiBasePath: BASE_PATH,
- *   serverConfig: SERVER_CONFIG,
- * }) as NuxtConfig;
- *
- * export default defineNuxtConfig({
- *   ...config,
- * });
- * ```
+ * 创建默认的 Nuxt 配置。
  */
-function createDefaultConfig({ serverConfig, apiBasePath, wsProxyBasePaths = [], }) {
-    /**
-     * 处理基础路径，去除协议和域名部分，只保留路径部分
-     * 例如，将 "https://example.com/api-go" 转换为 "/api-go"
-     */
-    const thisBasePath = apiBasePath.replace(/^https?:[/]{2}[^/]+/, "");
-    const normalizedProxyBasePath = thisBasePath.endsWith("/")
-        ? thisBasePath.slice(0, -1)
-        : thisBasePath;
-    const normalizeBasePath = (rawPath) => {
-        const trimmed = rawPath.replace(/^https?:[/]{2}[^/]+/, "");
-        if (!trimmed)
-            return "/";
-        if (trimmed === "/")
-            return "/";
-        return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
-    };
-    // Proxy target should point to backend origin only.
-    // The matched route prefix (e.g. /api-go/v1, /ws-go) is preserved by proxy itself.
-    // If target also appends basePath, final upstream path becomes duplicated and can
-    // break websocket upgrades with ECONNRESET.
-    const buildTarget = () => `http://127.0.0.1:${serverConfig.ginPort}`;
-    /**
-     * 目标服务器的 URL
-     * 格式为：http://localhost:ginPort/serverBasePath
-     * 其中，ginPort 是从 serverConfig 中获取的 Gin 服务器的端口号
-     * serverBasePath 是从 MyNuxtConfig 中获取的服务器基础路径
-     */
-    const target = buildTarget();
-    const proxyEntries = {
-        [normalizedProxyBasePath]: {
-            target,
-            changeOrigin: true,
-            ws: true,
-        },
-    };
-    for (const rawPath of wsProxyBasePaths) {
-        const normalizedPath = normalizeBasePath(rawPath);
-        proxyEntries[normalizedPath] = {
-            target: buildTarget(),
-            changeOrigin: true,
-            ws: true,
-        };
-    }
+function createDefaultConfig({ serverConfig, }) {
+    const baseUrl = normalizeBaseUrl(serverConfig.baseUrl);
     return {
-        buildDir: "vue/.nuxt", // 设置构建目录为 "vue/.nuxt"，表示 Nuxt 项目的构建输出将存放在该目录下
-        srcDir: "vue", // 设置源代码目录为 "vue"，表示 Nuxt 项目的源代码将存放在该目录下
-        // 设置服务器端代码的目录为 "vue/server"，表示服务器端的代码将存放在该目录下
-        // serverDir: "vue/server",
-        // 禁用服务器端渲染（SSR），即页面将在客户端进行渲染
+        buildDir: "vue/.nuxt",
+        srcDir: "vue",
         ssr: false,
-        /**
-         * 配置实验性功能
-         * 禁用 payloadExtraction 功能，该功能可能用于提取页面的有效负载数据
-         * 这里禁用它可能是为了避免某些兼容性问题或特定的项目需求
-         */
         experimental: {
             payloadExtraction: false,
         },
@@ -88,17 +95,7 @@ function createDefaultConfig({ serverConfig, apiBasePath, wsProxyBasePaths = [],
                 enabled: true,
             },
         },
-        /**
-         * 配置应用的基础 URL
-         * 从 server.config.json 文件中获取 baseUrl 作为应用的基础 URL
-         * 这个基础 URL 将用于构建应用的路由和请求地址
-         */
         app: { baseURL: serverConfig.baseUrl },
-        /**
-         * 配置开发服务器的端口号
-         * 从 server.config.json 文件中获取 nuxtPort 作为开发服务器的端口号
-         * 启动开发服务器时，将使用该端口号进行监听
-         */
         devServer: {
             port: serverConfig.nuxtPort,
             cors: {
@@ -109,23 +106,35 @@ function createDefaultConfig({ serverConfig, apiBasePath, wsProxyBasePaths = [],
                 maxAge: "1728000",
             },
         },
-        nitro: {
-            output: {
-                // 设置输出目录为 "vue/.nuxt", 表示 Nitro 的构建输出
-                dir: "vue/.output",
-            },
-            // 定义代理规则，将匹配基础路径的请求代理到目标服务器
-            devProxy: proxyEntries,
-        },
         vite: {
-            server: {
-                proxy: proxyEntries,
-            },
-            // 配置 Vite 插件
-            plugins: [],
-            // 配置 esbuild 编译器的选项
-            // 设置 jsxFactory 为 "h"，这是 Vue 3 中用于创建虚拟 DOM 的函数
-            // 设置 jsxFragment 为 "Fragment"，用于处理 JSX 中的片段
+            server: {},
+            plugins: [
+                {
+                    name: "nuxt-gin-base-url-proxy",
+                    configureServer(server) {
+                        server.middlewares.use((req, res, next) => {
+                            var _a;
+                            const requestPath = ((_a = req.url) !== null && _a !== void 0 ? _a : "/").split("?")[0] || "/";
+                            const shouldForward = !isViteInternalRequest(requestPath) && !isBaseUrlRequest(baseUrl, requestPath);
+                            if (shouldForward) {
+                                forwardToGin(serverConfig.ginPort, req, res);
+                                return;
+                            }
+                            next();
+                        });
+                        if (server.httpServer) {
+                            server.httpServer.on("upgrade", (req, socket, head) => {
+                                var _a;
+                                const requestPath = ((_a = req.url) !== null && _a !== void 0 ? _a : "/").split("?")[0] || "/";
+                                const shouldForward = !isViteInternalRequest(requestPath) && !isBaseUrlRequest(baseUrl, requestPath);
+                                if (shouldForward) {
+                                    forwardWebSocketToGin(serverConfig.ginPort, req, socket, head);
+                                }
+                            });
+                        }
+                    },
+                },
+            ],
             esbuild: { jsxFactory: "h", jsxFragment: "Fragment" },
         },
     };