@liujitcn/kratos-uni-app-core 0.0.1

package/README.md

@@ -0,0 +1,46 @@
+# @liujitcn/kratos-uni-app-core
+
+`@liujitcn/kratos-uni-app-core` 是应用底座包，提供模块协议、启动流程、动态导航、认证与请求、共享状态、基础页面和构建期页面装配能力。业务模块只能通过本包公开 exports 使用这些能力。
+
+## 目录结构
+
+```text
+packages/core
+├── src
+│   ├── api                    # base、system 基础接口 service
+│   ├── components             # 启动状态和自绘 tabBar
+│   ├── rpc                    # Buf 生成的 TypeScript 接口类型
+│   ├── static                 # 底座图片和 tab 图标
+│   ├── stores                 # Pinia 设置与用户状态
+│   ├── styles                 # 全局基础样式
+│   ├── types                  # uni-app 与第三方类型补充
+│   ├── utils                  # HTTP、认证、文件和导航工具
+│   ├── views                  # 首页、登录、状态页和 WebView
+│   ├── bootstrap.ts           # 应用初始化
+│   ├── module.ts              # 模块定义与注册表
+│   ├── navigation.ts          # base-menu 导航解析与缓存
+│   ├── pages.ts               # core 页面声明
+│   └── vite.ts                # 自动页面装配插件
+├── test                       # 导航匹配和 Vite 装配测试
+├── tsconfig.json
+└── package.json
+```
+
+`src/rpc` 是生成产物，只能通过 workspace 根目录的 `pnpm generate:rpc` 更新；该命令委托 backend 的 `make ts-app` 和 `backend/api/buf.app.typescript.gen.yaml` 生成。
+
+## 功能
+
+- 定义 `KratosAppModule`、`viewKey`、静态页面覆盖和模块图标协议。
+- 从 `/v1/app/base/menu` 加载 `999` 下的扁平菜单，按 `parent_id` 构建树，以二级页面生成 tabBar，并原子更新动态路由和层级导航。
+- 按匿名态、登录态缓存导航，并在远端不可用时回退到最近缓存或默认菜单。
+- 统一认证、token、HTTP、上传、配置、Pinia 和基础页面能力。
+- 构建时扫描模块 `src/views/**/*.vue`，逐文件合并模块 static，生成宿主页并在退出时按事务精确恢复。
+
+## 公开入口
+
+- `@liujitcn/kratos-uni-app-core`：运行时、导航、store 和组件。
+- `@liujitcn/kratos-uni-app-core/module`：模块协议和 core 模块。
+- `@liujitcn/kratos-uni-app-core/vite`：Vite 配置与页面装配插件。
+- `@liujitcn/kratos-uni-app-core/api/*`、`components/*.vue`、`utils/*`、`views/*`：白名单子路径。
+
+构建与验证命令见 [workspace 文档](../../README.md)。

package/dist/module.mjs

@@ -0,0 +1,84 @@
+// src/pages.ts
+var corePages = {
+  "pages/index/index": {
+    style: {
+      navigationStyle: "custom",
+      navigationBarTextStyle: "white",
+      navigationBarTitleText: "\u9996\u9875"
+    }
+  },
+  "pages/login/login": { style: { navigationBarTitleText: "\u767B\u5F55" } },
+  "pages/login/protocal": { style: { navigationBarTitleText: "\u534F\u8BAE\u8BE6\u60C5" } },
+  "pages/webview/webview": {
+    style: {
+      navigationBarTitleText: "",
+      "app-plus": { titleNView: false }
+    }
+  },
+  "pages/status/index": {
+    style: {
+      navigationStyle: "custom",
+      navigationBarTitleText: ""
+    }
+  }
+};
+
+// src/module.ts
+function defineKratosAppModule(module) {
+  return module;
+}
+var registeredModules = [];
+function registerKratosAppModules(modules) {
+  registeredModules = [...modules];
+}
+function getRegisteredKratosAppModules() {
+  return [...registeredModules];
+}
+function resolveStaticView(viewKey) {
+  for (let index = registeredModules.length - 1; index >= 0; index -= 1) {
+    const route = registeredModules[index].views[viewKey];
+    if (route)
+      return route;
+  }
+}
+function resolveModuleIcon(icon) {
+  if (!icon || /^https:\/\//.test(icon))
+    return icon;
+  for (let index = registeredModules.length - 1; index >= 0; index -= 1) {
+    const source = registeredModules[index].icons?.[icon];
+    if (source) {
+      const base = import.meta.env.BASE_URL || "/";
+      return `${base.replace(/\/?$/, "/")}${source.replace(/^\/+/, "")}`;
+    }
+  }
+}
+var coreModule = defineKratosAppModule({
+  name: "@liujitcn/kratos-uni-app-core",
+  pages: corePages,
+  views: {
+    HOME: "pages/index/index",
+    LOGIN: "pages/login/login",
+    PROTOCOL: "pages/login/protocal",
+    WEBVIEW: "pages/webview/webview",
+    BOOTSTRAP_LOADING: "pages/status/index",
+    FORBIDDEN: "pages/status/index",
+    NOT_FOUND: "pages/status/index",
+    OFFLINE: "pages/status/index",
+    CONFIG_ERROR: "pages/status/index",
+    PAGE_UNAVAILABLE: "pages/status/index"
+  },
+  icons: {
+    HOME_DEFAULT: "static/tabs/home_default.png",
+    HOME_SELECTED: "static/tabs/home_selected.png",
+    USER_DEFAULT: "static/tabs/user_default.png",
+    USER_SELECTED: "static/tabs/user_selected.png"
+  }
+});
+export {
+  coreModule,
+  defineKratosAppModule,
+  getRegisteredKratosAppModules,
+  registerKratosAppModules,
+  resolveModuleIcon,
+  resolveStaticView
+};

package/dist/vite.mjs

@@ -0,0 +1,405 @@
+// src/vite.ts
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmdirSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import uniPlugin from "@dcloudio/vite-plugin-uni";
+import { defineConfig, loadEnv } from "vite";
+var sourceVersionCounter = 0;
+function createKratosUniPlugin() {
+  const createPlugin = typeof uniPlugin === "function" ? uniPlugin : uniPlugin.default;
+  return createPlugin();
+}
+function kratosApp(options) {
+  const sourceVersion = `${process.pid}-${Date.now()}-${++sourceVersionCounter}`;
+  const state = {
+    generatedFiles: [],
+    generatedStaticFiles: [],
+    cleaned: false,
+    persistent: false,
+    moduleRoots: /* @__PURE__ */ new Map()
+  };
+  const cleanup = () => {
+    if (state.cleaned)
+      return;
+    state.cleaned = true;
+    process.removeListener("exit", cleanup);
+    process.removeListener("SIGINT", handleSigint);
+    process.removeListener("SIGTERM", handleSigterm);
+    for (const file of [...state.generatedFiles].reverse()) {
+      if (existsSync(file))
+        unlinkSync(file);
+      removeEmptyParents(dirname(file), state.inputDir ?? "");
+    }
+    if (state.inputDir) {
+      removeGeneratedStaticFiles(state.generatedStaticFiles, resolve(state.inputDir, "static"));
+    }
+    if (state.pagesFile && state.originalPages !== void 0) {
+      writeFileSync(state.pagesFile, state.originalPages);
+    }
+    if (state.transactionFile && existsSync(state.transactionFile)) {
+      unlinkSync(state.transactionFile);
+    }
+  };
+  const handleSigint = () => {
+    cleanup();
+    process.exit(130);
+  };
+  const handleSigterm = () => {
+    cleanup();
+    process.exit(143);
+  };
+  return {
+    name: "kratos-uni-app-pages",
+    enforce: "pre",
+    configResolved(config) {
+      state.persistent = config.command === "serve" || Boolean(config.build.watch);
+    },
+    resolveId(source, importer) {
+      const [sourcePath, query = ""] = source.split("?", 2);
+      let target;
+      if (sourcePath === "@liujitcn/kratos-uni-app-core" || sourcePath.startsWith("@liujitcn/kratos-uni-app-core/")) {
+        const coreRoot = state.moduleRoots.get("@liujitcn/kratos-uni-app-core");
+        if (coreRoot) {
+          target = resolveWorkspacePackageSource(
+            coreRoot,
+            sourcePath.slice("@liujitcn/kratos-uni-app-core".length).replace(/^\/+/, "")
+          );
+        }
+      } else if (sourcePath === "@liujitcn/kratos-uni-app-system" || sourcePath.startsWith("@liujitcn/kratos-uni-app-system/")) {
+        const systemRoot = state.moduleRoots.get("@liujitcn/kratos-uni-app-system");
+        if (systemRoot) {
+          target = resolveWorkspacePackageSource(
+            systemRoot,
+            sourcePath.slice("@liujitcn/kratos-uni-app-system".length).replace(/^\/+/, "")
+          );
+        }
+      } else if (sourcePath.startsWith("@kratos-uni-app-system-source/")) {
+        const systemRoot = state.moduleRoots.get("@liujitcn/kratos-uni-app-system");
+        if (systemRoot) {
+          target = resolve(
+            systemRoot,
+            "src",
+            sourcePath.slice("@kratos-uni-app-system-source/".length)
+          );
+        }
+      } else if (sourcePath.startsWith("@kratos-uni-app-core-source/")) {
+        const coreRoot = state.moduleRoots.get("@liujitcn/kratos-uni-app-core");
+        if (coreRoot) {
+          target = resolve(coreRoot, "src", sourcePath.slice("@kratos-uni-app-core-source/".length));
+        }
+      } else if (sourcePath.startsWith(".") && importer) {
+        const importerPath = importer.split("?", 1)[0];
+        const moduleRoot = [...state.moduleRoots.values()].find(
+          (root) => isWithinRoot(resolve(root, "src"), importerPath)
+        );
+        if (moduleRoot)
+          target = resolve(dirname(importerPath), sourcePath);
+      }
+      if (!target)
+        return;
+      const resolved = resolveSourceFile(target);
+      const importQuery = query || dependencyVersionQuery(importer, sourceVersion);
+      return `${resolved}${importQuery ? `?${importQuery}` : ""}`;
+    },
+    transform(code, id) {
+      const sourceFile = id.split("?", 1)[0];
+      const isModuleSource = [...state.moduleRoots.values()].some(
+        (root) => isWithinRoot(resolve(root, "src"), sourceFile)
+      );
+      const isLinkedModuleSource = sourceFile.includes("/@liujitcn/kratos-uni-app-core/") || sourceFile.includes("/@liujitcn/kratos-uni-app-system/");
+      if (!isModuleSource && !isLinkedModuleSource)
+        return;
+      const transformed = code.replace(/@system\//g, "@kratos-uni-app-system-source/").replace(/@\//g, "@kratos-uni-app-core-source/");
+      if (transformed === code)
+        return;
+      return { code: transformed, map: null };
+    },
+    config() {
+      const inputDir = process.env.UNI_INPUT_DIR || resolve(process.cwd(), "src");
+      const pagesFile = resolve(inputDir, "pages.json");
+      const transactionFile = resolve(inputDir, "../.kratos-uni-app-pages-state.json");
+      recoverBuildTransaction(transactionFile, inputDir, pagesFile);
+      const hostRequire = createRequire(resolve(inputDir, "../package.json"));
+      const originalPages = readFileSync(pagesFile, "utf8");
+      const manifest = JSON.parse(originalPages);
+      manifest.pages ??= [];
+      const pageMap = /* @__PURE__ */ new Map();
+      const moduleRoots = options.modules.map((module) => {
+        const linkedRoot = resolve(inputDir, "../node_modules", ...module.name.split("/"));
+        return {
+          module,
+          root: existsSync(resolve(linkedRoot, "package.json")) ? linkedRoot : dirname(hostRequire.resolve(`${module.name}/package.json`))
+        };
+      });
+      state.moduleRoots = new Map(moduleRoots.map(({ module, root }) => [module.name, root]));
+      moduleRoots.forEach(({ module, root }) => {
+        scanViews(resolve(root, "src/views")).forEach((page) => {
+          const config = module.pages[page.route] ?? {};
+          const route = normalizeRoute(config.route ?? page.route);
+          pageMap.set(route, {
+            route,
+            source: `${module.name}/views/${page.route}.vue`,
+            style: config.style
+          });
+        });
+      });
+      state.inputDir = inputDir;
+      state.pagesFile = pagesFile;
+      state.originalPages = originalPages;
+      state.transactionFile = transactionFile;
+      state.generatedFiles = [...pageMap.values()].map((page) => resolve(inputDir, `${page.route}.vue`)).filter((target) => !existsSync(target));
+      const staticTarget = resolve(inputDir, "static");
+      const staticFiles = collectModuleStaticFiles(
+        moduleRoots.map(({ root }) => resolve(root, "src/static")),
+        staticTarget
+      );
+      state.generatedStaticFiles = staticFiles.map(({ target }) => target);
+      writeFileSync(
+        transactionFile,
+        `${JSON.stringify(
+          {
+            inputDir,
+            pagesFile,
+            originalPages,
+            generatedFiles: state.generatedFiles,
+            generatedStaticFiles: state.generatedStaticFiles,
+            ownerPid: process.pid
+          },
+          null,
+          2
+        )}
+`,
+        { flag: "wx" }
+      );
+      pageMap.forEach((page) => {
+        const target = resolve(inputDir, `${page.route}.vue`);
+        if (existsSync(target))
+          return;
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, createPageWrapper(page));
+        appendPage(manifest, page);
+      });
+      staticFiles.forEach(({ source, target }) => {
+        mkdirSync(dirname(target), { recursive: true });
+        copyFileSync(source, target);
+      });
+      writeFileSync(pagesFile, `${JSON.stringify(manifest, null, 2)}
+`);
+      process.once("exit", cleanup);
+      process.prependOnceListener("SIGINT", handleSigint);
+      process.prependOnceListener("SIGTERM", handleSigterm);
+      return {
+        resolve: {
+          alias: [
+            {
+              find: "@kratos-uni-app-core-source",
+              replacement: resolve(
+                state.moduleRoots.get("@liujitcn/kratos-uni-app-core") ?? "",
+                "src"
+              )
+            },
+            {
+              find: "@kratos-uni-app-system-source",
+              replacement: resolve(
+                state.moduleRoots.get("@liujitcn/kratos-uni-app-system") ?? "",
+                "src"
+              )
+            }
+          ]
+        },
+        optimizeDeps: {
+          exclude: options.modules.map((module) => module.name)
+        }
+      };
+    },
+    configureServer(server) {
+      server.httpServer?.once("close", cleanup);
+    },
+    closeBundle() {
+      if (!state.persistent)
+        cleanup();
+    },
+    closeWatcher: cleanup
+  };
+}
+function recoverBuildTransaction(transactionFile, inputDir, pagesFile) {
+  if (!existsSync(transactionFile))
+    return;
+  const transaction = JSON.parse(readFileSync(transactionFile, "utf8"));
+  if (transaction.inputDir !== inputDir || transaction.pagesFile !== pagesFile) {
+    throw new Error(`uni-app \u6784\u5EFA\u4E8B\u52A1\u76EE\u5F55\u4E0D\u5339\u914D\uFF1A${transactionFile}`);
+  }
+  if (transaction.ownerPid !== void 0 && transaction.ownerPid !== process.pid && isProcessRunning(transaction.ownerPid)) {
+    throw new Error(
+      `\u9875\u9762\u88C5\u914D\u5DF2\u7531\u8FDB\u7A0B ${transaction.ownerPid} \u4F7F\u7528\uFF0C\u8BF7\u5148\u505C\u6B62\u53E6\u4E00\u4E2A H5 \u6216\u5C0F\u7A0B\u5E8F\u5F00\u53D1\u8FDB\u7A0B`
+    );
+  }
+  for (const file of [...transaction.generatedFiles].reverse()) {
+    if (existsSync(file))
+      unlinkSync(file);
+    removeEmptyParents(dirname(file), inputDir);
+  }
+  removeGeneratedStaticFiles(transaction.generatedStaticFiles ?? [], resolve(inputDir, "static"));
+  if (transaction.generatedStatic && transaction.generatedStaticFiles === void 0) {
+    rmSync(resolve(inputDir, "static"), { recursive: true, force: true });
+  }
+  writeFileSync(pagesFile, transaction.originalPages);
+  unlinkSync(transactionFile);
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function collectModuleStaticFiles(sourceRoots, targetRoot) {
+  const fileMap = /* @__PURE__ */ new Map();
+  sourceRoots.forEach((sourceRoot) => {
+    scanFiles(sourceRoot).forEach((source) => {
+      const target = resolve(targetRoot, relative(sourceRoot, source));
+      if (!existsSync(target))
+        fileMap.set(target, { source, target });
+    });
+  });
+  return [...fileMap.values()];
+}
+function scanFiles(root) {
+  if (!existsSync(root))
+    return [];
+  const files = [];
+  const visit = (directory) => {
+    readdirSync(directory).forEach((entry) => {
+      const path = resolve(directory, entry);
+      if (statSync(path).isDirectory())
+        visit(path);
+      else
+        files.push(path);
+    });
+  };
+  visit(root);
+  return files;
+}
+function removeGeneratedStaticFiles(files, staticRoot) {
+  for (const file of [...files].reverse()) {
+    if (existsSync(file))
+      unlinkSync(file);
+    removeEmptyParents(dirname(file), staticRoot);
+  }
+}
+function scanViews(root) {
+  if (!existsSync(root))
+    return [];
+  const files = [];
+  const visit = (directory) => {
+    readdirSync(directory).forEach((entry) => {
+      const path = resolve(directory, entry);
+      if (statSync(path).isDirectory()) {
+        if (entry !== "components")
+          visit(path);
+      } else if (entry.endsWith(".vue")) {
+        files.push(path);
+      }
+    });
+  };
+  visit(root);
+  return files.map((source) => ({
+    route: normalizeRoute(relative(root, source)),
+    source
+  }));
+}
+function appendPage(manifest, page) {
+  const [first, ...rest] = page.route.split("/");
+  if (!first.startsWith("pages") || first === "pages") {
+    manifest.pages.push({ path: page.route, style: page.style });
+    return;
+  }
+  manifest.subPackages ??= [];
+  let subPackage = manifest.subPackages.find((item) => item.root === first);
+  if (!subPackage) {
+    subPackage = { root: first, pages: [] };
+    manifest.subPackages.push(subPackage);
+  }
+  subPackage.pages.push({ path: rest.join("/"), style: page.style });
+}
+function createPageWrapper(page) {
+  const source = page.source.replace(/\\/g, "/");
+  return `<script setup lang="ts">
+import KratosPage from ${JSON.stringify(source)}
+import KratosTabBar from '@liujitcn/kratos-uni-app-core/components/KratosTabBar.vue'
+
+defineOptions({ inheritAttrs: false })
+</script>
+
+<template>
+  <KratosPage />
+  <KratosTabBar route=${JSON.stringify(page.route)} />
+</template>
+`;
+}
+function normalizeRoute(route) {
+  return route.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\.vue$/, "");
+}
+function removeEmptyParents(directory, boundary) {
+  let current = directory;
+  while (current !== boundary && current.startsWith(boundary) && existsSync(current)) {
+    if (readdirSync(current).length)
+      return;
+    rmdirSync(current);
+    current = dirname(current);
+  }
+}
+function resolveSourceFile(target) {
+  const candidates = [
+    target,
+    `${target}.ts`,
+    `${target}.js`,
+    `${target}.vue`,
+    resolve(target, "index.ts"),
+    resolve(target, "index.js")
+  ];
+  const resolved = candidates.find((candidate) => existsSync(candidate) && statSync(candidate).isFile()) ?? target;
+  if (!isAbsolute(resolved))
+    throw new Error(`\u6A21\u5757\u6E90\u7801\u8DEF\u5F84\u4E0D\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF1A${resolved}`);
+  return resolved;
+}
+function dependencyVersionQuery(importer, sourceVersion) {
+  const query = importer?.split("?", 2)[1] ?? "";
+  const version = new URLSearchParams(query).get("v");
+  const params = new URLSearchParams();
+  if (version)
+    params.set("v", version);
+  params.set("kratos", sourceVersion);
+  return params.toString();
+}
+function resolveWorkspacePackageSource(packageRoot, subpath) {
+  if (!subpath)
+    return resolve(packageRoot, "src/index.ts");
+  if (subpath === "module")
+    return resolve(packageRoot, "src/module.ts");
+  if (subpath === "stores")
+    return resolve(packageRoot, "src/stores/index.ts");
+  return resolve(packageRoot, "src", subpath);
+}
+function isWithinRoot(root, target) {
+  const relativePath = relative(root, target);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+export {
+  createKratosUniPlugin,
+  defineConfig,
+  kratosApp,
+  loadEnv
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@liujitcn/kratos-uni-app-core",
+  "description": "Runtime, navigation, authentication, and build foundation for Kratos apps.",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./module": {
+      "types": "./src/module.ts",
+      "import": "./dist/module.mjs",
+      "default": "./dist/module.mjs"
+    },
+    "./api/*": "./src/api/*.ts",
+    "./components/*.vue": "./src/components/*.vue",
+    "./rpc/*": "./src/rpc/*",
+    "./stores": "./src/stores/index.ts",
+    "./static/*": "./src/static/*",
+    "./styles/base.scss": "./src/styles/base.scss",
+    "./uni.scss": "./src/uni.scss",
+    "./utils/*": "./src/utils/*.ts",
+    "./views/*": "./src/views/*",
+    "./vite": {
+      "types": "./src/vite.ts",
+      "import": "./dist/vite.mjs",
+      "default": "./dist/vite.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@dcloudio/uni-app": "3.0.0-5010520260709002",
+    "@dcloudio/uni-ui": "^1.4.28",
+    "@dcloudio/vite-plugin-uni": "3.0.0-5010520260709002",
+    "asmcrypto.js": "^2.3.2",
+    "go-captcha-uni": "1.0.6",
+    "pinia": "^2.0.27",
+    "pinia-plugin-persistedstate": "^3.2.0",
+    "vite": "5.2.8",
+    "vue": "^3.4.21"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "esbuild": "^0.20.2",
+    "vue-tsc": "^1.8.8"
+  },
+  "scripts": {
+    "build": "pnpm run build:entries && pnpm pack --pack-destination ../../dist/npm",
+    "build:entries": "esbuild src/module.ts --bundle --platform=node --format=esm --packages=external --outfile=dist/module.mjs && esbuild src/vite.ts --bundle --platform=node --format=esm --packages=external --outfile=dist/vite.mjs",
+    "tsc": "vue-tsc --noEmit -p tsconfig.json"
+  }
+}

package/src/api/base/config.ts

@@ -0,0 +1,20 @@
+import { http } from '../../utils/http'
+import type { ConfigService, GetConfigRequest, GetConfigResponse } from '../../rpc/base/v1/config'
+
+const CONFIG_URL = '/v1/base/config'
+
+/** 系统配置公共服务 */
+export class ConfigServiceImpl implements ConfigService {
+  /** 获取系统配置 */
+  GetConfig(request: GetConfigRequest): Promise<GetConfigResponse> {
+    return http<GetConfigResponse>({
+      url: `${CONFIG_URL}`,
+      method: 'GET',
+      authMode: 'none',
+      data: request,
+      header: { Authorization: 'no-auth' },
+    })
+  }
+}
+
+export const defConfigService = new ConfigServiceImpl()

package/src/api/base/file.ts

@@ -0,0 +1,79 @@
+import { http } from '../../utils/http'
+import type { DownloadFileRequest, MultiUploadFileResponse, FileInfo } from '../../rpc/base/v1/file'
+
+const FILE_URL = '/v1/base/file'
+
+/** 文件服务 */
+export class FileServiceImpl {
+  /** 多个文件上传 */
+  MultiUploadFile(files: File[], fileType: string): Promise<MultiUploadFileResponse> {
+    const formData = new FormData()
+    files.map((file) => {
+      formData.append(file.name, file)
+    })
+    formData.append('fileType', fileType)
+    return http<MultiUploadFileResponse>({
+      url: `${FILE_URL}/multi`,
+      method: 'POST',
+      authMode: 'required',
+      data: formData,
+      header: {
+        'Content-Type': 'multipart/form-data',
+      },
+    })
+  }
+  /** 单个文件上传 */
+  UploadFile(file: File, fileType: string): Promise<FileInfo> {
+    const formData = new FormData()
+    formData.append('file', file)
+    formData.append('fileType', fileType)
+    return http<FileInfo>({
+      url: `${FILE_URL}`,
+      method: 'POST',
+      authMode: 'required',
+      data: formData,
+      header: {
+        'Content-Type': 'multipart/form-data',
+      },
+    })
+  }
+  /** 下载文件 */
+
+  async DownloadFile(file: string, fileName: string) {
+    try {
+      const response = await http<any>({
+        url: `${FILE_URL}`,
+        method: 'GET',
+        authMode: 'required',
+        data: {
+          name: fileName,
+          path: file,
+        } as DownloadFileRequest,
+        responseType: 'blob', // 明确要求返回 Blob 类型
+      })
+      // 获取文件名
+      const contentDisposition = response.headers['content-disposition']
+      let downloadFilename = fileName
+      if (contentDisposition) {
+        const match = contentDisposition.match(/filename="?(.+?)"?$/)
+        if (match && match[1]) {
+          downloadFilename = match[1]
+        }
+      }
+
+      // 创建下载链接
+      const url = window.URL.createObjectURL(new Blob([response.data]))
+      const a = document.createElement('a')
+      a.href = url
+      a.download = downloadFilename
+      document.body.appendChild(a)
+      a.click()
+      document.body.removeChild(a)
+      window.URL.revokeObjectURL(url)
+    } catch (error) {
+      console.error('下载错误:', error)
+    }
+  }
+}
+
+export const defFileService = new FileServiceImpl()