yg-yygl 0.0.1

package/dist/store/websocket.d.ts

@@ -0,0 +1,108 @@
+interface WebSocketMessage {
+    message: string;
+    isDot: boolean;
+    type?: string;
+}
+interface WebSocketState {
+    socket: WebSocket | null;
+    data: WebSocketMessage;
+    isConnected: boolean;
+    connectStatus: number;
+    manualDisconnect: boolean;
+    heartbeatInterval: number | null;
+    reconnectTimeout: number | null;
+    reconnectAttempts: number;
+    readonly MAX_RECONNECT_ATTEMPTS: number;
+    readonly HEARTBEAT_INTERVAL: number;
+    readonly RECONNECT_INTERVAL: number;
+    notificationCallback: (() => void) | null;
+    isPageVisible: boolean;
+    connectionStateKey: string;
+}
+export declare const useWebSocketStore: import("pinia").StoreDefinition<"websocket", WebSocketState, {
+    /**
+     * 获取连接状态文本
+     */
+    connectionStatusText(): string;
+    /**
+     * 是否可以发送消息
+     */
+    canSendMessage(): boolean;
+}, {
+    isWebSocketSupported(): boolean;
+    /**
+     * 构建带有认证信息的WebSocket URL
+     */
+    buildWebSocketUrl(baseUrl: string): string;
+    /**
+     * 设置通知刷新回调函数
+     */
+    setNotificationCallback(callback: (() => void) | null): void;
+    /**
+     * 保存连接状态到localStorage
+     */
+    saveConnectionState(isConnected: boolean): void;
+    /**
+     * 获取保存的连接状态
+     */
+    getConnectionState(): boolean;
+    /**
+     * 清除保存的连接状态
+     */
+    clearConnectionState(): void;
+    /**
+     * 动态构建WebSocket URL
+     * 生产环境：根据当前页面域名动态拼接 ws://域名 + 环境变量中的路径
+     * 开发环境：直接使用环境变量中的完整地址
+     */
+    getWebSocketUrl(): string;
+    /**
+     * 建立WebSocket连接
+     */
+    connect(url: string): Promise<void>;
+    /**
+     * 断开WebSocket连接
+     */
+    disconnect(): void;
+    /**
+     * 清理WebSocket相关资源
+     */
+    cleanup(): void;
+    /**
+     * 尝试重连
+     */
+    attemptReconnect(url: string): void;
+    /**
+     * 开始心跳检测
+     */
+    startHeartbeat(): void;
+    /**
+     * 停止心跳检测
+     */
+    stopHeartbeat(): void;
+    /**
+     * 发送消息
+     */
+    sendMessage(msg: string | object): boolean;
+    /**
+     * 处理接收到的消息
+     */
+    handleMessage(event: MessageEvent): void;
+    /**
+     * 设置页面可见性状态
+     */
+    setPageVisible(visible: boolean): void;
+    /**
+     * 初始化页面可见性监听
+     */
+    initPageVisibilityListener(): void;
+    /**
+     * 自动连接（页面加载后）
+     */
+    autoConnect(): void;
+    /**
+     * 重置状态
+     */
+    resetState(): void;
+}>;
+export {};

package/dist/store/websocket.mjs

@@ -0,0 +1,387 @@
+import { defineStore } from "pinia";
+import { useAccessStore, useUserStore } from "@udp/stores";
+import { handleWsNotification } from "./ws-notification.mjs";
+export const useWebSocketStore = defineStore("websocket", {
+  state: () => ({
+    socket: null,
+    data: {
+      message: "",
+      isDot: false
+    },
+    isConnected: false,
+    connectStatus: 0,
+    manualDisconnect: false,
+    heartbeatInterval: null,
+    reconnectTimeout: null,
+    reconnectAttempts: 0,
+    MAX_RECONNECT_ATTEMPTS: 5,
+    HEARTBEAT_INTERVAL: 3e4,
+    RECONNECT_INTERVAL: 2e3,
+    notificationCallback: null,
+    isPageVisible: true,
+    connectionStateKey: "websocket_connection_state"
+  }),
+  actions: {
+    isWebSocketSupported() {
+      return "WebSocket" in window;
+    },
+    /**
+     * 构建带有认证信息的WebSocket URL
+     */
+    buildWebSocketUrl(baseUrl) {
+      const userStore = useUserStore();
+      const accountId = userStore.accountInfo?.id;
+      const wsUrl = accountId ? `${baseUrl}/websocket?accountId=${accountId}` : `${baseUrl}/websocket`;
+      return wsUrl;
+    },
+    /**
+     * 设置通知刷新回调函数
+     */
+    setNotificationCallback(callback) {
+      this.notificationCallback = callback;
+      console.log("\u8BBE\u7F6E\u901A\u77E5\u5237\u65B0\u56DE\u8C03:", callback ? "\u5DF2\u8BBE\u7F6E" : "\u5DF2\u6E05\u9664");
+    },
+    /**
+     * 保存连接状态到localStorage
+     */
+    saveConnectionState(isConnected) {
+      try {
+        const state = {
+          isConnected,
+          timestamp: Date.now(),
+          url: this.socket?.url || ""
+        };
+        localStorage.setItem(this.connectionStateKey, JSON.stringify(state));
+      } catch (error) {
+        console.warn("\u4FDD\u5B58WebSocket\u8FDE\u63A5\u72B6\u6001\u5931\u8D25:", error);
+      }
+    },
+    /**
+     * 获取保存的连接状态
+     */
+    getConnectionState() {
+      try {
+        const stateStr = localStorage.getItem(this.connectionStateKey);
+        if (!stateStr) return false;
+        const state = JSON.parse(stateStr);
+        const now = Date.now();
+        if (now - state.timestamp > 5 * 60 * 1e3) {
+          this.clearConnectionState();
+          return false;
+        }
+        return state.isConnected;
+      } catch (error) {
+        console.warn("\u8BFB\u53D6WebSocket\u8FDE\u63A5\u72B6\u6001\u5931\u8D25:", error);
+        return false;
+      }
+    },
+    /**
+     * 清除保存的连接状态
+     */
+    clearConnectionState() {
+      try {
+        localStorage.removeItem(this.connectionStateKey);
+      } catch (error) {
+        console.warn("\u6E05\u9664WebSocket\u8FDE\u63A5\u72B6\u6001\u5931\u8D25:", error);
+      }
+    },
+    // fjl modify
+    /**
+     * 动态构建WebSocket URL
+     * 生产环境：根据当前页面域名动态拼接 ws://域名 + 环境变量中的路径
+     * 开发环境：直接使用环境变量中的完整地址
+     */
+    getWebSocketUrl() {
+      const envWsUrl = import.meta.env.VITE_WEBSOCKET_URL;
+      if (envWsUrl.startsWith("ws://") || envWsUrl.startsWith("wss://")) {
+        return envWsUrl;
+      }
+      const wsProtocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+      return `${wsProtocol}//${window.location.host}${envWsUrl}`;
+    },
+    /**
+     * 建立WebSocket连接
+     */
+    async connect(url) {
+      if (!this.isWebSocketSupported()) {
+        const error = new Error("WebSocket\u5728\u5F53\u524D\u6D4F\u89C8\u5668\u4E0D\u652F\u6301");
+        console.error(error.message);
+        throw error;
+      }
+      if (this.socket?.readyState === WebSocket.OPEN) {
+        console.log("WebSocket\u5DF2\u8FDE\u63A5\uFF0C\u65E0\u9700\u91CD\u590D\u8FDE\u63A5");
+        return;
+      }
+      if (this.socket?.readyState === WebSocket.CONNECTING) {
+        console.log("WebSocket\u6B63\u5728\u8FDE\u63A5\u4E2D\uFF0C\u8BF7\u7B49\u5F85...");
+        return;
+      }
+      return new Promise((resolve, reject) => {
+        try {
+          this.cleanup();
+          this.manualDisconnect = false;
+          const wsUrl = this.buildWebSocketUrl(url);
+          console.log("\u6B63\u5728\u8FDE\u63A5WebSocket...", wsUrl);
+          this.socket = new WebSocket(wsUrl);
+          this.socket.onopen = () => {
+            console.log("WebSocket\u8FDE\u63A5\u5DF2\u5EFA\u7ACB");
+            this.isConnected = true;
+            this.connectStatus = 1;
+            this.reconnectAttempts = 0;
+            this.startHeartbeat();
+            this.saveConnectionState(true);
+            resolve();
+          };
+          this.socket.onmessage = (event) => {
+            this.handleMessage(event);
+          };
+          this.socket.onclose = (event) => {
+            console.log(
+              "WebSocket\u8FDE\u63A5\u5DF2\u65AD\u5F00, \u72B6\u6001\u7801:",
+              event.code,
+              "\u539F\u56E0:",
+              event.reason
+            );
+            this.isConnected = false;
+            this.connectStatus = 0;
+            this.stopHeartbeat();
+            this.saveConnectionState(false);
+            if (event.code !== 1e3 && event.code !== 1001 && !this.manualDisconnect) {
+              console.log("\u68C0\u6D4B\u5230\u5F02\u5E38\u5173\u95ED\uFF0C\u51C6\u5907\u91CD\u8FDE");
+              this.attemptReconnect(url);
+            } else {
+              console.log("\u6B63\u5E38\u5173\u95ED\u6216\u624B\u52A8\u65AD\u5F00\uFF0C\u4E0D\u8FDB\u884C\u91CD\u8FDE");
+            }
+          };
+          this.socket.onerror = (error) => {
+            console.error("WebSocket\u8FDE\u63A5\u9519\u8BEF:", error);
+            this.isConnected = false;
+            this.connectStatus = -1;
+            this.saveConnectionState(false);
+            reject(error);
+          };
+        } catch (error) {
+          console.error("\u521B\u5EFAWebSocket\u8FDE\u63A5\u5931\u8D25:", error);
+          this.saveConnectionState(false);
+          reject(error);
+        }
+      });
+    },
+    /**
+     * 断开WebSocket连接
+     */
+    disconnect() {
+      this.manualDisconnect = true;
+      this.cleanup();
+      console.log("WebSocket\u4E3B\u52A8\u65AD\u5F00\u8FDE\u63A5");
+    },
+    /**
+     * 清理WebSocket相关资源
+     */
+    cleanup() {
+      this.stopHeartbeat();
+      if (this.reconnectTimeout) {
+        clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = null;
+      }
+      if (this.socket) {
+        this.socket.close(1e3, "\u6B63\u5E38\u5173\u95ED");
+        this.socket = null;
+      }
+      this.isConnected = false;
+      this.connectStatus = 0;
+    },
+    /**
+     * 尝试重连
+     */
+    attemptReconnect(url) {
+      const accessStore = useAccessStore();
+      if (!accessStore.accessToken) {
+        console.log("\u7528\u6237\u5DF2\u767B\u51FA\uFF0C\u505C\u6B62WebSocket\u91CD\u8FDE");
+        return;
+      }
+      if (!this.isPageVisible) {
+        console.log("\u9875\u9762\u4E0D\u53EF\u89C1\uFF0C\u5EF6\u8FDF\u91CD\u8FDE");
+        setTimeout(() => this.attemptReconnect(url), 5e3);
+        return;
+      }
+      if (this.reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS) {
+        const wasConnected = this.getConnectionState();
+        const delay = wasConnected && this.reconnectAttempts === 0 ? 0 : Math.min(
+          this.RECONNECT_INTERVAL * Math.pow(2, this.reconnectAttempts),
+          3e4
+        );
+        console.log(
+          `WebSocket\u91CD\u8FDE\u5C1D\u8BD5 ${this.reconnectAttempts + 1}/${this.MAX_RECONNECT_ATTEMPTS}`
+        );
+        console.log(
+          `\u5EF6\u8FDF ${delay}ms \u540E\u91CD\u8FDE${wasConnected ? "\uFF08\u9875\u9762\u5237\u65B0\u540E\u7ACB\u5373\u91CD\u8FDE\uFF09" : ""}`
+        );
+        this.reconnectTimeout = window.setTimeout(async () => {
+          this.reconnectAttempts++;
+          try {
+            await this.connect(url);
+          } catch (error) {
+            console.error("\u91CD\u8FDE\u5931\u8D25:", error);
+          }
+        }, delay);
+      } else {
+        console.error("WebSocket\u6700\u5927\u91CD\u8FDE\u6B21\u6570\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u5DF2\u505C\u6B62\u91CD\u8FDE");
+        this.connectStatus = -1;
+      }
+    },
+    /**
+     * 开始心跳检测
+     */
+    startHeartbeat() {
+      if (this.heartbeatInterval) {
+        return;
+      }
+      this.heartbeatInterval = window.setInterval(() => {
+        if (this.socket?.readyState === WebSocket.OPEN) {
+          try {
+            this.socket.send("ping");
+            console.log("\u53D1\u9001\u5FC3\u8DF3\u5305");
+          } catch (error) {
+            console.error("\u53D1\u9001\u5FC3\u8DF3\u5305\u5931\u8D25:", error);
+          }
+        } else {
+          console.warn("WebSocket\u672A\u8FDE\u63A5\uFF0C\u505C\u6B62\u5FC3\u8DF3\u68C0\u6D4B");
+          this.stopHeartbeat();
+        }
+      }, this.HEARTBEAT_INTERVAL);
+    },
+    /**
+     * 停止心跳检测
+     */
+    stopHeartbeat() {
+      if (this.heartbeatInterval) {
+        clearInterval(this.heartbeatInterval);
+        this.heartbeatInterval = null;
+      }
+    },
+    /**
+     * 发送消息
+     */
+    sendMessage(msg) {
+      if (this.socket?.readyState === WebSocket.OPEN) {
+        try {
+          const message = typeof msg === "string" ? msg : JSON.stringify(msg);
+          this.socket.send(message);
+          return true;
+        } catch (error) {
+          console.error("\u53D1\u9001\u6D88\u606F\u5931\u8D25:", error);
+          return false;
+        }
+      } else {
+        console.warn("WebSocket\u672A\u8FDE\u63A5\uFF0C\u65E0\u6CD5\u53D1\u9001\u6D88\u606F");
+        return false;
+      }
+    },
+    /**
+     * 处理接收到的消息
+     */
+    handleMessage(event) {
+      try {
+        if (event.data === "pong") {
+          console.log("\u6536\u5230\u5FC3\u8DF3\u54CD\u5E94");
+          return;
+        }
+        const data = JSON.parse(event.data);
+        console.log("\u6536\u5230WebSocket\u6D88\u606F:", data);
+        this.data = data;
+        if (this.notificationCallback) {
+          console.log("\u89E6\u53D1\u901A\u77E5\u5237\u65B0");
+          this.notificationCallback();
+        }
+        handleWsNotification(data);
+      } catch (error) {
+        console.log("\u6536\u5230WebSocket\u6587\u672C\u6D88\u606F:", event.data);
+        if (this.notificationCallback) {
+          console.log("\u89E6\u53D1\u901A\u77E5\u5237\u65B0\uFF08\u6587\u672C\u6D88\u606F\uFF09");
+          this.notificationCallback();
+        }
+      }
+    },
+    /**
+     * 设置页面可见性状态
+     */
+    setPageVisible(visible) {
+      this.isPageVisible = visible;
+      console.log("\u9875\u9762\u53EF\u89C1\u6027\u53D8\u5316:", visible ? "\u53EF\u89C1" : "\u9690\u85CF");
+    },
+    /**
+     * 初始化页面可见性监听
+     */
+    initPageVisibilityListener() {
+      if (typeof document !== "undefined") {
+        const handleVisibilityChange = () => {
+          this.setPageVisible(!document.hidden);
+          if (this.isPageVisible && !this.isConnected && !this.manualDisconnect) {
+            console.log("\u9875\u9762\u91CD\u65B0\u53EF\u89C1\uFF0C\u5C1D\u8BD5\u91CD\u8FDEWebSocket");
+            this.reconnectAttempts = 0;
+            const wsUrl = this.getWebSocketUrl();
+            this.connect(wsUrl).catch((error) => {
+              console.error("\u9875\u9762\u53EF\u89C1\u6027\u91CD\u8FDE\u5931\u8D25:", error);
+            });
+          }
+        };
+        document.addEventListener("visibilitychange", handleVisibilityChange);
+      }
+    },
+    /**
+     * 自动连接（页面加载后）
+     */
+    autoConnect() {
+      setTimeout(() => {
+        const accessStore = useAccessStore();
+        const userStore = useUserStore();
+        if (accessStore.accessToken && userStore.accountInfo?.id) {
+          const wasConnected = this.getConnectionState();
+          if (wasConnected) {
+            console.log("\u68C0\u6D4B\u5230\u9875\u9762\u5237\u65B0\u524D\u6709WebSocket\u8FDE\u63A5\uFF0C\u81EA\u52A8\u91CD\u8FDE");
+          } else {
+            console.log("\u9875\u9762\u52A0\u8F7D\u5B8C\u6210\uFF0C\u81EA\u52A8\u5EFA\u7ACBWebSocket\u8FDE\u63A5");
+          }
+          this.manualDisconnect = false;
+          const wsUrl = this.getWebSocketUrl();
+          this.connect(wsUrl).catch((error) => {
+            console.error("\u9875\u9762\u52A0\u8F7D\u540E\u81EA\u52A8\u8FDE\u63A5\u5931\u8D25:", error);
+          });
+          this.clearConnectionState();
+        } else {
+          console.log("\u7528\u6237\u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7WebSocket\u81EA\u52A8\u8FDE\u63A5");
+          this.clearConnectionState();
+        }
+      }, 1e3);
+    },
+    /**
+     * 重置状态
+     */
+    resetState() {
+      this.disconnect();
+      this.reconnectAttempts = 0;
+      this.data = {
+        message: "",
+        isDot: false
+      };
+    }
+  },
+  getters: {
+    /**
+     * 获取连接状态文本
+     */
+    connectionStatusText() {
+      if (this.isConnected) return "\u5DF2\u8FDE\u63A5";
+      if (this.connectStatus === -1) return "\u8FDE\u63A5\u5931\u8D25";
+      if (this.socket?.readyState === WebSocket.CONNECTING) return "\u8FDE\u63A5\u4E2D";
+      return "\u672A\u8FDE\u63A5";
+    },
+    /**
+     * 是否可以发送消息
+     */
+    canSendMessage() {
+      return this.isConnected && this.socket?.readyState === WebSocket.OPEN;
+    }
+  }
+});

package/dist/store/ws-notification.d.ts

@@ -0,0 +1,25 @@
+declare global {
+    interface Window {
+        __route?: {
+            path: string;
+        };
+        __router?: {
+            push: (options: {
+                path: string;
+                query: Record<string, string | undefined>;
+            }) => void;
+        };
+    }
+}
+interface NotificationData {
+    message: string;
+    isDot: boolean;
+    title?: string;
+    orderId?: string;
+    type?: string;
+}
+/**
+ * 根据 WebSocket 消息类型分发通知
+ */
+export declare function handleWsNotification(data: NotificationData): void;
+export {};

package/dist/store/ws-notification.mjs

@@ -0,0 +1,82 @@
+import { ElNotification } from "element-plus";
+import WujieVue from "wujie-vue3";
+function showSimpleNotification(data) {
+  ElNotification({
+    title: "\u63A5\u6536\u5230\u65B0\u6D88\u606F",
+    message: data.message,
+    type: "success",
+    offset: 30,
+    duration: 3e3
+  });
+}
+function showTaskCreatedNotification(data) {
+  const jumpToWaitTodo = () => {
+    if (window.__route?.path?.startsWith("/sjzx-v3")) {
+      if (WujieVue?.bus) {
+        setTimeout(() => {
+          WujieVue.bus.$emit("route-change", {
+            appCode: "sjzx-v3",
+            path: "/eventCenter/waitTodo",
+            fromNotification: true
+          });
+        }, 100);
+      }
+    } else {
+      window.__router?.push({
+        path: "/sjzx-v3/eventCenter/waitTodo",
+        query: { _subJump: "waitTodoNotice" }
+      });
+    }
+  };
+  ElNotification({
+    title: "",
+    message: `<div style="margin-bottom:6px;font-weight:bold;font-size:16px;">${data?.title}</div><div style="margin-bottom:8px;">${data.message}</div>`,
+    type: "success",
+    offset: 30,
+    duration: 0,
+    dangerouslyUseHTMLString: true,
+    onClick: jumpToWaitTodo
+  });
+}
+function showAiReportCompleteNotification(data) {
+  const jumpToReport = () => {
+    if (window.__route?.path?.startsWith("/sjzx-v3")) {
+      if (WujieVue?.bus) {
+        setTimeout(() => {
+          WujieVue.bus.$emit("route-change", {
+            appCode: "sjzx-v3",
+            path: "/eventCenter/intelligentReport",
+            fromNotification: true
+          });
+        }, 100);
+      }
+    } else {
+      window.__router?.push({
+        path: "/sjzx-v3/eventCenter/intelligentReport",
+        query: { _subJump: "intelligentReportNotice" }
+      });
+    }
+  };
+  ElNotification({
+    title: "",
+    message: `<div style="margin-bottom:6px;font-weight:bold;font-size:16px;">${data?.title}</div><div style="margin-bottom:8px;">${data.message}</div>`,
+    type: "success",
+    offset: 30,
+    duration: 0,
+    dangerouslyUseHTMLString: true,
+    onClick: jumpToReport
+  });
+}
+const notificationHandlers = {
+  "SJCZ_TASK_CREATED": showTaskCreatedNotification,
+  "SJCZ_AI_REPORT_COMPLETE": showAiReportCompleteNotification
+};
+export function handleWsNotification(data) {
+  if (!data.isDot || !data.message) return;
+  const handler = notificationHandlers[data?.type || ""];
+  if (handler) {
+    handler(data);
+  } else if (!data?.type) {
+    showSimpleNotification(data);
+  }
+}

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+import type { Router } from 'vue-router';
+import type { RequestClient } from '@udp/request';
+export interface UserModuleRouteConfig {
+    /** 父路由路径，默认 '/sys' */
+    parentPath?: string;
+    /** 路由名称，默认 'UserManagement' */
+    name?: string;
+    /** 路由路径，默认 'user' */
+    path?: string;
+    /** 路由 meta 信息 */
+    meta?: Record<string, any>;
+    /**
+     * 是否直接注册路由。设为 false 则由消费方的动态菜单系统处理。
+     * 默认 true
+     */
+    registerDirectly?: boolean;
+}
+export interface UserModuleOptions {
+    /** 消费方的 Vue Router 实例 */
+    router: Router;
+    /** 消费方配置好的 RequestClient 实例 */
+    requestClient: RequestClient;
+    /** 路由配置 */
+    route?: UserModuleRouteConfig;
+}

package/dist/utils/config-sync.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 将通用配置同步到 localStorage
+ */
+export declare const syncConfigToStorage: (configList: any[]) => void;

package/dist/utils/config-sync.mjs

@@ -0,0 +1,8 @@
+import { baseUrlComponent } from "../api/request.mjs";
+export const syncConfigToStorage = (configList) => {
+  const item = configList.find((item2) => item2.configKey === "file.upload.url");
+  if (item) {
+    item.configValue = `${baseUrlComponent}${item.configValue}`;
+  }
+  localStorage.setItem("commonConfigList", JSON.stringify(configList));
+};

package/dist/utils/file.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 文件相关工具函数
+ */
+/**
+ * 文件大小格式化
+ * @param bytes 字节数
+ * @returns 格式化后的文件大小
+ * @example
+ * formatFileSize(1024) // "1.00 KB"
+ * formatFileSize(1048576) // "1.00 MB"
+ * formatFileSize(0) // "0 B"
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * URL 复制到剪贴板
+ * @param text 要复制的文本
+ * @returns 是否成功
+ */
+export declare function copyToClipboard(text: string): Promise<boolean>;
+/**
+ * 判断是否为图片文件
+ * @param fileType 文件类型（MIME类型）
+ * @returns 是否为图片
+ */
+export declare function isImageFile(fileType: string): boolean;
+/**
+ * 获取文件扩展名
+ * @param fileName 文件名
+ * @returns 文件扩展名
+ */
+export declare function getFileExtension(fileName: string): string;
+/**
+ * 根据文件扩展名获取MIME类型
+ * @param extension 文件扩展名
+ * @returns MIME类型
+ */
+export declare function getMimeType(extension: string): string;