@deppon/create-deppon-app 2.2.0

package/template/src/utils/dictionary.ts

@@ -0,0 +1,188 @@
+/**
+ * 前端字典配置
+ * 用于存储和管理前端字典数据，支持根据 key 动态获取字典
+ */
+
+import type { DictionaryItem, DictionaryConfig } from '@/types/dictionary';
+
+// 重新导出类型，保持向后兼容
+export type { DictionaryItem, DictionaryConfig };
+
+/**
+ * 从配置文件导入字典配置
+ */
+import { dictionaryConfig as configData } from '@/config/dictionaryConfig';
+
+/**
+ * 前端字典配置数据
+ * 配置数据从 @/config/dictionaryConfig 导入
+ * 可以通过 setDictionary、setDictionaries 等方法动态修改
+ */
+const dictionaryConfig: DictionaryConfig = { ...configData };
+
+/**
+ * 根据 key 获取字典列表
+ * @param key - 字典 key
+ * @returns 返回字典项数组，如果不存在则返回空数组
+ */
+export const getDictionary = (key: string): DictionaryItem[] => {
+    return dictionaryConfig[key] || [];
+};
+
+/**
+ * 根据 key 获取字典选项（用于下拉框等组件）
+ * @param key - 字典 key
+ * @param filterDisabled - 是否过滤禁用的项（默认 true）
+ * @returns 返回选项数组，格式为 { label, value, ... }
+ */
+export const getDictionaryOptions = (
+    key: string,
+    filterDisabled: boolean = true
+): Array<{ label: string; value: string; [key: string]: any }> => {
+    const dictList = getDictionary(key);
+    let result = dictList.map(item => ({
+        label: item.label,
+        value: item.code,
+        ...item,
+    }));
+
+    // 过滤禁用的项
+    if (filterDisabled) {
+        result = result.filter(item => !item.disabled);
+    }
+
+    // 按 sort 排序
+    result.sort((a, b) => {
+        const sortA = a.sort ?? 999;
+        const sortB = b.sort ?? 999;
+        return sortA - sortB;
+    });
+
+    return result;
+};
+
+/**
+ * 根据 key 和 code 获取字典项
+ * @param key - 字典 key
+ * @param code - 字典编码
+ * @returns 返回字典项，如果不存在则返回 undefined
+ */
+export const getDictionaryItem = (key: string, code: string): DictionaryItem | undefined => {
+    const dictList = getDictionary(key);
+    return dictList.find(item => item.code === code);
+};
+
+/**
+ * 根据 key 和 code 获取字典标签
+ * @param key - 字典 key
+ * @param code - 字典编码
+ * @param defaultValue - 默认值（如果找不到对应的字典项）
+ * @returns 返回字典标签，如果不存在则返回默认值或 code
+ */
+export const getDictionaryLabel = (
+    key: string,
+    code: string,
+    defaultValue?: string
+): string => {
+    const item = getDictionaryItem(key, code);
+    return item?.label || defaultValue || code;
+};
+
+/**
+ * 设置字典配置
+ * @param key - 字典 key
+ * @param dictList - 字典项数组
+ */
+export const setDictionary = (key: string, dictList: DictionaryItem[]): void => {
+    dictionaryConfig[key] = dictList;
+};
+
+/**
+ * 批量设置字典配置
+ * @param config - 字典配置对象
+ */
+export const setDictionaries = (config: DictionaryConfig): void => {
+    Object.assign(dictionaryConfig, config);
+};
+
+/**
+ * 添加字典项
+ * @param key - 字典 key
+ * @param item - 字典项
+ */
+export const addDictionaryItem = (key: string, item: DictionaryItem): void => {
+    if (!dictionaryConfig[key]) {
+        dictionaryConfig[key] = [];
+    }
+    // 检查是否已存在相同的 code
+    const index = dictionaryConfig[key].findIndex(d => d.code === item.code);
+    if (index >= 0) {
+        // 如果存在，则更新
+        dictionaryConfig[key][index] = item;
+    } else {
+        // 如果不存在，则添加
+        dictionaryConfig[key].push(item);
+    }
+};
+
+/**
+ * 移除字典项
+ * @param key - 字典 key
+ * @param code - 字典编码
+ */
+export const removeDictionaryItem = (key: string, code: string): void => {
+    if (!dictionaryConfig[key]) {
+        return;
+    }
+    dictionaryConfig[key] = dictionaryConfig[key].filter(item => item.code !== code);
+};
+
+/**
+ * 移除整个字典
+ * @param key - 字典 key
+ */
+export const removeDictionary = (key: string): void => {
+    delete dictionaryConfig[key];
+};
+
+/**
+ * 获取所有字典 key
+ * @returns 返回所有字典 key 数组
+ */
+export const getAllDictionaryKeys = (): string[] => {
+    return Object.keys(dictionaryConfig);
+};
+
+/**
+ * 检查字典是否存在
+ * @param key - 字典 key
+ * @returns 返回是否存在
+ */
+export const hasDictionary = (key: string): boolean => {
+    return key in dictionaryConfig && Array.isArray(dictionaryConfig[key]) && dictionaryConfig[key].length > 0;
+};
+
+/**
+ * 清空所有字典配置
+ */
+export const clearAllDictionaries = (): void => {
+    Object.keys(dictionaryConfig).forEach(key => {
+        delete dictionaryConfig[key];
+    });
+};
+
+/**
+ * 导出字典配置（用于备份或调试）
+ * @returns 返回当前所有字典配置
+ */
+export const exportDictionaryConfig = (): DictionaryConfig => {
+    return JSON.parse(JSON.stringify(dictionaryConfig));
+};
+
+/**
+ * 导入字典配置（用于恢复或初始化）
+ * @param config - 字典配置对象
+ */
+export const importDictionaryConfig = (config: DictionaryConfig): void => {
+    Object.assign(dictionaryConfig, config);
+};

package/template/src/utils/errorAnalyzer.ts

@@ -0,0 +1,217 @@
+/**
+ * 错误信息分析工具类
+ * 用于分析和序列化来自 resInterceptor.js 的错误对象
+ */
+
+/**
+ * 安全的序列化函数，处理循环引用和不可序列化的值
+ * @param obj - 要序列化的对象
+ * @param space - JSON 格式化的缩进空格数
+ * @returns 序列化后的 JSON 字符串
+ */
+export function safeStringify(obj: any, space: number = 2): string {
+    const seen = new WeakSet();
+    return JSON.stringify(
+        obj,
+        (key, value) => {
+            // 跳过函数
+            if (typeof value === 'function') {
+                return '[Function]';
+            }
+            // 跳过 undefined（返回 undefined 会从结果中移除该属性）
+            if (value === undefined) {
+                return undefined;
+            }
+            // 处理循环引用
+            if (typeof value === 'object' && value !== null) {
+                if (seen.has(value)) {
+                    return '[Circular]';
+                }
+                seen.add(value);
+            }
+            return value;
+        },
+        space
+    );
+}
+
+/**
+ * 兼容的复制函数，支持多种复制方式
+ * @param text - 要复制的文本
+ * @returns Promise<void>
+ */
+export async function copyToClipboard(text: string): Promise<void> {
+    // 方法1: 使用 Clipboard API（现代浏览器）
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+        try {
+            await navigator.clipboard.writeText(text);
+            return;
+        } catch (clipboardErr) {
+            console.warn('Clipboard API 失败，尝试备用方法:', clipboardErr);
+        }
+    }
+
+    // 方法2: 使用 document.execCommand（兼容旧浏览器）
+    const textarea = document.createElement('textarea');
+    textarea.value = text;
+    textarea.style.position = 'fixed';
+    textarea.style.left = '-9999px';
+    textarea.style.top = '-9999px';
+    document.body.appendChild(textarea);
+    textarea.select();
+    textarea.setSelectionRange(0, text.length);
+
+    try {
+        const success = document.execCommand('copy');
+        document.body.removeChild(textarea);
+        if (!success) {
+            throw new Error('execCommand 复制失败');
+        }
+    } catch (execErr) {
+        document.body.removeChild(textarea);
+        throw execErr;
+    }
+}
+
+/**
+ * 错误对象结构（根据 resInterceptor.js）
+ */
+export interface ErrorInfo {
+    // 响应信息
+    status?: number;
+    statusText?: string;
+    response?: any;
+    // 请求信息
+    request?: {
+        url?: string;
+        method?: string;
+        params?: any;
+        data?: any;
+        headers?: any;
+        timeout?: number;
+    };
+}
+
+/**
+ * 分析错误对象，提取关键信息
+ * @param error - 错误对象（来自 resInterceptor.js）
+ * @returns 分析后的错误信息对象
+ */
+export function analyzeError(error: any): {
+    errorMessage: string;
+    status: number | undefined;
+    statusText: string | undefined;
+    requestUrl: string | undefined;
+    requestMethod: string | undefined;
+    hasRequestData: boolean;
+    hasResponseData: boolean;
+    errorKeys: string[];
+} {
+    return {
+        errorMessage: error?.response?.message || error?.statusText || '未知错误',
+        status: error?.status,
+        statusText: error?.statusText,
+        requestUrl: error?.request?.url || error?.config?.url,
+        requestMethod: error?.request?.method || error?.config?.method,
+        hasRequestData: !!(error?.request?.data || error?.config?.data),
+        hasResponseData: !!error?.response,
+        errorKeys: Object.keys(error || {}),
+    };
+}
+
+/**
+ * 按照 resInterceptor.js 的结构组织错误信息
+ * @param error - 错误对象（来自 resInterceptor.js）
+ * @returns 按照 resInterceptor.js 结构组织的错误信息对象
+ */
+export function formatErrorInfo(error: any): ErrorInfo {
+    // 如果错误对象已经是 resInterceptor.js 的结构，直接使用
+    if (error?.status !== undefined && error?.request !== undefined) {
+        // 确保 request 对象存在且包含必要的字段
+        const request = error.request || {};
+        
+        return {
+            // 只返回 error 中存在的字段，不强制添加 status 和 statusText
+            ...(error.status !== undefined && { status: error.status }),
+            ...(error.statusText !== undefined && { statusText: error.statusText }),
+            response: error.response,
+            request: {
+                url: request.url || '',
+                method: request.method || 'GET',
+                params: request.params || {},
+                data: request.data || {},
+                headers: request.headers || {},
+                timeout: request.timeout,
+            },
+        };
+    }
+
+    // 否则，从 error.response 和 error.config 中提取信息（兼容 axios 原始错误）
+    const res = error?.response || error;
+
+    // 获取完整的请求 headers（优先使用 _requestHeaders）
+    const requestHeaders = res?.config?._requestHeaders || res?.config?.headers || {};
+    
+    // 清理 headers，移除 Axios 内部使用的字段
+    const cleanedHeaders: any = {};
+    const excludeKeys = ['common', 'delete', 'get', 'head', 'post', 'put', 'patch'];
+    
+    for (const key in requestHeaders) {
+        if (!excludeKeys.includes(key)) {
+            cleanedHeaders[key] = requestHeaders[key];
+        }
+    }
+
+    return {
+        // 只返回存在的字段，不强制添加 status 和 statusText
+        ...(res?.status !== undefined && { status: res.status }),
+        ...(res?.statusText !== undefined && { statusText: res.statusText }),
+        response: res?.data,
+        // 请求信息（从 config 中获取，包含完整的 headers）
+        request: {
+            url: res?.config?.url || res?.config?.baseURL || '',
+            method: res?.config?.method?.toUpperCase() || 'GET',
+            params: res?.config?.params || {},
+            data: res?.config?.data || {},
+            headers: cleanedHeaders,
+            timeout: res?.config?.timeout,
+        },
+    };
+}
+
+/**
+ * 序列化错误对象为可复制的 JSON 字符串
+ * 按照 resInterceptor.js 的结构组织错误信息
+ * @param error - 错误对象（来自 resInterceptor.js）
+ * @returns 序列化后的 JSON 字符串
+ */
+export function serializeError(error: any): string {
+    try {
+        const errorInfo = formatErrorInfo(error);
+        return safeStringify(errorInfo, 2);
+    } catch (stringifyErr) {
+        console.error('序列化错误失败:', stringifyErr);
+        // 如果序列化失败，返回简单的错误信息
+        return JSON.stringify({
+            error: '序列化失败',
+            message: error?.message || String(error),
+            timestamp: new Date().toISOString(),
+        }, null, 2);
+    }
+}
+
+/**
+ * 复制错误信息到剪贴板
+ * @param error - 错误对象（来自 resInterceptor.js）或错误消息字符串
+ * @returns Promise<void>
+ */
+export async function copyErrorToClipboard(error: any): Promise<void> {
+    // 如果传入的是字符串，直接复制字符串
+    if (typeof error === 'string') {
+        await copyToClipboard(error);
+        return;
+    }
+    // 如果是对象，序列化后复制
+    const errorText = serializeError(error);
+    await copyToClipboard(errorText);
+}

package/template/src/utils/messageVNode.ts

@@ -0,0 +1,15 @@
+import { h } from 'vue';
+import ExpandableMessage from '@/components/ExpandableMessage.vue';
+
+/**
+ * 创建可展开/收缩的错误消息 vnode
+ * @param errorMessage - 错误消息文本
+ * @param maxLines - 默认显示的最大行数，超出后显示展开按钮，默认 3
+ * @returns 返回一个 vnode
+ */
+export const createExpandableMessageVNode = (errorMessage: string, maxLines: number = 3) => {
+    return h(ExpandableMessage, {
+        message: errorMessage,
+        maxLines: maxLines
+    });
+};