tauri-client/notice-client/vite.config.ts

import { defineConfig } from "vite";
import vue from "@vitejs/plugin-vue";
import AutoImport from "unplugin-auto-import/vite";
import Components from "unplugin-vue-components/vite";
import { ElementPlusResolver } from "unplugin-vue-components/resolvers";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";

// @ts-expect-error process is a nodejs global
const host = process.env.TAURI_DEV_HOST;
const APP_NAME = "com.ziyun.noticeclient";
const CONFIG_FILE_NAME = "config.json";
const API_QUEUE_PATH = "/api/queue";
const DEFAULT_API_PORT = 8845;

function getHomeDirectory(): string {
  return process.env.HOME || process.env.USERPROFILE || os.homedir() || ".";
}

function getConfigFilePath(): string {
  if (process.platform === "linux") {
    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
    const baseDirectory =
      xdgConfigHome && path.isAbsolute(xdgConfigHome)
        ? xdgConfigHome
        : path.join(getHomeDirectory(), ".config");

    return path.join(baseDirectory, APP_NAME, CONFIG_FILE_NAME);
  }

  if (process.env.APPDATA) {
    return path.join(process.env.APPDATA, APP_NAME, CONFIG_FILE_NAME);
  }

  return path.join(getHomeDirectory(), `.${APP_NAME}`, CONFIG_FILE_NAME);
}

function buildProxyTarget(serverIp: string): string {
  const raw = serverIp.trim();
  if (!raw) {
    return "";
  }

  if (raw.startsWith("http://") || raw.startsWith("https://")) {
    return raw.replace(/\/$/, "");
  }

  const hostPort = raw.replace(/^\/+/, "");
  const hasPort = /:\d+$/.test(hostPort) || /^\[.+\]:\d+$/.test(hostPort);
  if (hasPort) {
    return `http://${hostPort}`;
  }

  return `http://${hostPort}:${DEFAULT_API_PORT}`;
}

function resolveProxyTarget(): string {
  const configFilePath = getConfigFilePath();
  if (!fs.existsSync(configFilePath)) {
    return "";
  }

  try {
    const content = fs.readFileSync(configFilePath, "utf8");
    const parsed = JSON.parse(content) as Record<string, unknown>;
    const serverIp = typeof parsed.server_ip === "string" ? parsed.server_ip : "";
    return buildProxyTarget(serverIp);
  } catch {
    return "";
  }
}

const proxyTarget = resolveProxyTarget();

export default defineConfig(async () => ({
  plugins: [
    vue(),
    AutoImport({
      imports: ["vue", "vue-router"],
      dts: false,
      resolvers: [ElementPlusResolver()],
    }),
    Components({
      dts: false,
      resolvers: [ElementPlusResolver()],
    }),
  ],
  clearScreen: false,
  server: {
    port: 1422,
    strictPort: true,
    host: host || false,
    proxy: proxyTarget
      ? {
          [API_QUEUE_PATH]: {
            target: proxyTarget,
            changeOrigin: true,
          },
        }
      : undefined,
    hmr: host
      ? {
          protocol: "ws",
          host,
          port: 1423,
        }
      : undefined,
    watch: {
      ignored: ["**/src-tauri/**"],
    },
  },
}));