@robot-admin/request-core 0.1.2

package/dist/index.js

@@ -0,0 +1,1107 @@
+import axios from 'axios';
+import { shallowRef, ref, reactive, computed } from 'vue';
+import { useMessage, useDialog } from 'naive-ui';
+
+// src/axios/request.ts
+
+// src/axios/utils/helpers.ts
+function sortedStringify(obj, seen = /* @__PURE__ */ new WeakSet()) {
+  if (obj === null || obj === void 0) {
+    return "";
+  }
+  if (typeof obj !== "object") {
+    return String(obj);
+  }
+  if (seen.has(obj)) {
+    throw new Error("\u68C0\u6D4B\u5230\u5FAA\u73AF\u5F15\u7528\uFF0C\u65E0\u6CD5\u751F\u6210\u7A33\u5B9A\u7684\u7F13\u5B58\u952E");
+  }
+  seen.add(obj);
+  if (Array.isArray(obj)) {
+    return JSON.stringify(obj.map((item) => sortedStringify(item, seen)));
+  }
+  const sortedKeys = Object.keys(obj).sort();
+  const sortedObj = {};
+  for (const key of sortedKeys) {
+    sortedObj[key] = obj[key];
+  }
+  return JSON.stringify(sortedObj);
+}
+function generateRequestKey(config) {
+  const { method = "get", url = "", params, data } = config;
+  const parts = [method.toUpperCase(), url];
+  if (params && Object.keys(params).length > 0) {
+    parts.push(sortedStringify(params));
+  }
+  if (data && Object.keys(data).length > 0) {
+    parts.push(sortedStringify(data));
+  }
+  return parts.join("|");
+}
+var MemoryCache = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = 1e3;
+    // 最大缓存数量
+    this.accessOrder = /* @__PURE__ */ new Set();
+  }
+  // 记录访问顺序
+  /**
+   * 获取缓存
+   */
+  get(key) {
+    const item = this.cache.get(key);
+    if (!item) return null;
+    if (Date.now() > item.expireAt) {
+      this.cache.delete(key);
+      this.accessOrder.delete(key);
+      return null;
+    }
+    this.accessOrder.delete(key);
+    this.accessOrder.add(key);
+    return item.data;
+  }
+  /**
+   * 设置缓存
+   */
+  set(key, data, ttl) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      this.evictOldest();
+    }
+    const expireAt = Date.now() + ttl;
+    this.cache.set(key, {
+      data,
+      expireAt
+    });
+    this.accessOrder.delete(key);
+    this.accessOrder.add(key);
+  }
+  /**
+   * 删除缓存
+   */
+  delete(key) {
+    this.accessOrder.delete(key);
+    return this.cache.delete(key);
+  }
+  /**
+   * 清空所有缓存
+   */
+  clear() {
+    this.cache.clear();
+    this.accessOrder.clear();
+  }
+  /**
+   * 清理过期缓存
+   */
+  cleanup() {
+    const now = Date.now();
+    const entries = Array.from(this.cache.entries());
+    for (const [key, item] of entries) {
+      if (now > item.expireAt) {
+        this.cache.delete(key);
+        this.accessOrder.delete(key);
+      }
+    }
+  }
+  /**
+   * 获取缓存大小
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * 设置最大缓存大小
+   */
+  setMaxSize(size) {
+    this.maxSize = size;
+    while (this.cache.size > this.maxSize) {
+      this.evictOldest();
+    }
+  }
+  /**
+   * 清理最旧的缓存（LRU）
+   */
+  evictOldest() {
+    const oldestKey = this.accessOrder.values().next().value;
+    if (oldestKey) {
+      this.cache.delete(oldestKey);
+      this.accessOrder.delete(oldestKey);
+    }
+  }
+};
+var globalCache = new MemoryCache();
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isNetworkError(error) {
+  return !error.response && Boolean(error.code) && error.code !== "ECONNABORTED" && error.code !== "ERR_CANCELED" && error.message !== "canceled" && error.message !== "Request aborted" && error.message !== "Request cancelled";
+}
+function isTimeoutError(error) {
+  return error.code === "ECONNABORTED" && error.message.includes("timeout");
+}
+function isRetryableStatus(status, retryableStatusCodes) {
+  return retryableStatusCodes.includes(status);
+}
+function normalizeConfig(config, defaults) {
+  if (config === true) {
+    return { ...defaults, enabled: true };
+  }
+  if (config === false) {
+    return { ...defaults, enabled: false };
+  }
+  if (typeof config === "object") {
+    return { ...defaults, ...config };
+  }
+  return defaults;
+}
+
+// src/axios/plugins/dedupe.ts
+var DEFAULT_DEDUPE_CONFIG = {
+  enabled: true,
+  keyGenerator: generateRequestKey
+};
+var pendingRequests = /* @__PURE__ */ new Map();
+function cleanupExpiredRequests() {
+  const now = Date.now();
+  const TIMEOUT = 5 * 60 * 1e3;
+  Array.from(pendingRequests.entries()).forEach(([key, controller]) => {
+    const startTime = controller._startTime || now;
+    if (now - startTime > TIMEOUT) {
+      try {
+        controller.abort();
+      } catch (error) {
+        console.warn("Abort error:", error);
+      }
+      pendingRequests.delete(key);
+    }
+  });
+}
+if (typeof window !== "undefined") {
+  setInterval(cleanupExpiredRequests, 3e4);
+}
+function onRequest(config) {
+  const enhancedConfig = config;
+  const dedupeConfig = normalizeConfig(
+    enhancedConfig.dedupe,
+    DEFAULT_DEDUPE_CONFIG
+  );
+  if (!dedupeConfig.enabled) {
+    return config;
+  }
+  if (config.__fromCache) {
+    return config;
+  }
+  const keyGenerator = dedupeConfig.keyGenerator || DEFAULT_DEDUPE_CONFIG.keyGenerator;
+  const requestKey = keyGenerator(config);
+  const existing = pendingRequests.get(requestKey);
+  if (existing) {
+    try {
+      existing.abort();
+    } catch (error) {
+      console.warn("Abort existing request error:", error);
+    }
+    pendingRequests.delete(requestKey);
+  }
+  if (config.signal) {
+    return config;
+  }
+  const controller = new AbortController();
+  controller._startTime = Date.now();
+  config.signal = controller.signal;
+  pendingRequests.set(requestKey, controller);
+  return config;
+}
+function onResponse(response) {
+  const config = response.config;
+  const dedupeConfig = normalizeConfig(
+    config.dedupe,
+    DEFAULT_DEDUPE_CONFIG
+  );
+  if (dedupeConfig.enabled) {
+    const keyGenerator = dedupeConfig.keyGenerator || DEFAULT_DEDUPE_CONFIG.keyGenerator;
+    const requestKey = keyGenerator(config);
+    pendingRequests.delete(requestKey);
+  }
+  return response;
+}
+function onResponseError(error) {
+  const config = error.config;
+  if (config) {
+    const dedupeConfig = normalizeConfig(
+      config.dedupe,
+      DEFAULT_DEDUPE_CONFIG
+    );
+    if (dedupeConfig.enabled) {
+      const keyGenerator = dedupeConfig.keyGenerator || DEFAULT_DEDUPE_CONFIG.keyGenerator;
+      const requestKey = keyGenerator(config);
+      pendingRequests.delete(requestKey);
+    }
+  }
+  return Promise.reject(error);
+}
+function setupDedupePlugin(instance) {
+  instance.interceptors.request.use(onRequest);
+  instance.interceptors.response.use(onResponse, onResponseError);
+}
+function cancelAllPendingRequests() {
+  pendingRequests.forEach((controller) => {
+    try {
+      controller.abort();
+    } catch (error) {
+      console.warn("Error aborting pending request:", error);
+    }
+  });
+  pendingRequests.clear();
+}
+if (typeof window !== "undefined") {
+  window.addEventListener("beforeunload", () => {
+    cancelAllPendingRequests();
+  });
+}
+function getPendingRequestCount() {
+  return pendingRequests.size;
+}
+
+// src/axios/plugins/cache.ts
+var DEFAULT_CACHE_CONFIG = {
+  enabled: false,
+  ttl: 5 * 60 * 1e3,
+  // 5 分钟
+  forceUpdate: false
+};
+function shouldUseCache(config, cacheConfig) {
+  if (config.method?.toUpperCase() !== "GET") {
+    return false;
+  }
+  if (!cacheConfig.enabled) {
+    return false;
+  }
+  if (cacheConfig.forceUpdate) {
+    return false;
+  }
+  return true;
+}
+function createCacheResponse(cachedData, config) {
+  return {
+    data: cachedData.data,
+    status: cachedData.status,
+    statusText: `${cachedData.statusText} (from cache)`,
+    headers: cachedData.headers,
+    config
+  };
+}
+function tryGetFromCache(config, cacheConfig) {
+  if (!shouldUseCache(config, cacheConfig)) {
+    return null;
+  }
+  const requestKey = generateRequestKey(config);
+  const cachedData = globalCache.get(requestKey);
+  if (cachedData) {
+    return createCacheResponse(cachedData, config);
+  }
+  return null;
+}
+function saveToCache(response, config, cacheConfig) {
+  if (config.method?.toUpperCase() === "GET" && cacheConfig.enabled && response.status === 200) {
+    const requestKey = generateRequestKey(config);
+    const ttl = cacheConfig.ttl ?? DEFAULT_CACHE_CONFIG.ttl;
+    const cachedResponse = {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: { ...response.headers }
+    };
+    globalCache.set(requestKey, cachedResponse, ttl);
+  }
+}
+function onRequest2(config) {
+  const enhancedConfig = config;
+  const cacheConfig = normalizeConfig(
+    enhancedConfig.cache,
+    DEFAULT_CACHE_CONFIG
+  );
+  const cachedResponse = tryGetFromCache(config, cacheConfig);
+  if (cachedResponse) {
+    config.__fromCache = true;
+    return Promise.reject({
+      __fromCache: true,
+      __cachedResponse: cachedResponse,
+      config
+    });
+  }
+  return config;
+}
+function onResponse2(response) {
+  const config = response.config;
+  if (config.__fromCache) {
+    return config.__cachedResponse;
+  }
+  const cacheConfig = normalizeConfig(
+    config.cache,
+    DEFAULT_CACHE_CONFIG
+  );
+  saveToCache(response, response.config, cacheConfig);
+  return response;
+}
+function onResponseError2(error) {
+  if (error.__fromCache) {
+    return Promise.resolve(error.__cachedResponse);
+  }
+  return Promise.reject(error);
+}
+function setupCachePlugin(instance) {
+  instance.interceptors.request.use(onRequest2);
+  instance.interceptors.response.use(onResponse2, onResponseError2);
+}
+function clearAllCache() {
+  globalCache.clear();
+}
+function clearCache(config) {
+  const requestKey = generateRequestKey(config);
+  return globalCache.delete(requestKey);
+}
+function cleanupExpiredCache() {
+  globalCache.cleanup();
+}
+function getCacheSize() {
+  return globalCache.size;
+}
+
+// src/axios/plugins/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  enabled: false,
+  count: 3,
+  delay: 1e3,
+  exponentialBackoff: true,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
+};
+function isCancelError(error) {
+  return error.name === "CanceledError" || error.name === "AbortError" || error.code === "ERR_CANCELED" || error.message === "canceled" || error.message?.includes("abort");
+}
+function shouldRetry(error, retryConfig) {
+  if (!retryConfig.enabled) {
+    return false;
+  }
+  const config = error.config;
+  const currentRetryCount = config.__retryCount ?? 0;
+  if (currentRetryCount >= retryConfig.count) {
+    return false;
+  }
+  if (isCancelError(error)) {
+    return false;
+  }
+  if (isNetworkError(error)) {
+    return true;
+  }
+  if (isTimeoutError(error)) {
+    return true;
+  }
+  if (error.response?.status) {
+    return isRetryableStatus(
+      error.response.status,
+      retryConfig.retryableStatusCodes
+    );
+  }
+  return false;
+}
+function getRetryDelay(retryCount, retryConfig) {
+  if (!retryConfig.exponentialBackoff) {
+    return retryConfig.delay;
+  }
+  const calculatedDelay = retryConfig.delay * Math.pow(2, retryCount);
+  return Math.min(calculatedDelay, 3e4);
+}
+function setupRetryPlugin(instance) {
+  const onResponseError4 = async (error) => {
+    const config = error.config;
+    if (!config) {
+      return Promise.reject(error);
+    }
+    const retryConfig = normalizeConfig(
+      config.retry,
+      DEFAULT_RETRY_CONFIG
+    );
+    if (!shouldRetry(error, retryConfig)) {
+      return Promise.reject(error);
+    }
+    config.__retryCount = (config.__retryCount ?? 0) + 1;
+    const retryDelay = getRetryDelay(config.__retryCount, retryConfig);
+    await delay(retryDelay);
+    const retryConfig_ = { ...config };
+    const originalSignal = config.signal;
+    const newController = new AbortController();
+    if (originalSignal && typeof originalSignal.addEventListener === "function") {
+      originalSignal.addEventListener("abort", () => {
+        newController.abort();
+      });
+    }
+    retryConfig_.signal = newController.signal;
+    delete retryConfig_.__cancelId;
+    delete retryConfig_.__managedByCancel;
+    delete retryConfig_.__handling401;
+    return instance.request(retryConfig_);
+  };
+  instance.interceptors.response.use(void 0, onResponseError4);
+}
+
+// src/axios/plugins/cancel.ts
+var DEFAULT_CANCEL_CONFIG = {
+  enabled: true,
+  whitelist: []
+};
+var cancelableRequests = /* @__PURE__ */ new Map();
+var requestId = 0;
+var CLEANUP_INTERVAL = 3e4;
+var REQUEST_TIMEOUT = 3e5;
+var cleanupTimer = null;
+function cleanupExpiredRequests2() {
+  const now = Date.now();
+  const expiredKeys = [];
+  for (const [key, controller] of cancelableRequests.entries()) {
+    const requestStartTime = controller._startTime || now;
+    if (now - requestStartTime > REQUEST_TIMEOUT) {
+      expiredKeys.push(key);
+      try {
+        controller.abort();
+      } catch (error) {
+        console.warn("Error aborting expired request:", error);
+      }
+    }
+  }
+  expiredKeys.forEach((key) => cancelableRequests.delete(key));
+}
+function startCleanupTimer() {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+  }
+  cleanupTimer = setInterval(cleanupExpiredRequests2, CLEANUP_INTERVAL);
+}
+function stopCleanupTimer() {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
+}
+function isInWhitelist(url, whitelist) {
+  return whitelist.some((pattern) => pattern.test(url));
+}
+function onRequest3(config) {
+  if (typeof AbortController === "undefined") {
+    console.warn("AbortController is not supported in this environment");
+    return config;
+  }
+  const enhancedConfig = config;
+  const cancelConfig = normalizeConfig(
+    enhancedConfig.cancel,
+    DEFAULT_CANCEL_CONFIG
+  );
+  if (!cancelConfig.enabled) {
+    return config;
+  }
+  if (config.__fromCache) {
+    return config;
+  }
+  const url = config.url || "";
+  if (isInWhitelist(url, cancelConfig.whitelist)) {
+    return config;
+  }
+  const controller = new AbortController();
+  const id = `request_${++requestId}`;
+  controller._startTime = Date.now();
+  config.signal = controller.signal;
+  config.__cancelId = id;
+  cancelableRequests.set(id, controller);
+  return config;
+}
+function onResponse3(response) {
+  const config = response.config;
+  const cancelId = config.__cancelId;
+  if (cancelId) {
+    cancelableRequests.delete(cancelId);
+  }
+  return response;
+}
+function onResponseError3(error) {
+  const config = error.config;
+  const cancelId = config?.__cancelId;
+  if (cancelId) {
+    cancelableRequests.delete(cancelId);
+  }
+  return Promise.reject(error);
+}
+function setupCancelPlugin(instance) {
+  instance.interceptors.request.use(onRequest3);
+  instance.interceptors.response.use(onResponse3, onResponseError3);
+}
+function cancelAllRequests() {
+  cancelableRequests.forEach((controller) => {
+    try {
+      controller.abort();
+    } catch (error) {
+      console.warn("Error aborting request:", error);
+    }
+  });
+  cancelableRequests.clear();
+}
+if (typeof window !== "undefined") {
+  window.addEventListener("beforeunload", () => {
+    cancelAllRequests();
+    stopCleanupTimer();
+  });
+  startCleanupTimer();
+}
+function getCancelableRequestCount() {
+  return cancelableRequests.size;
+}
+
+// src/axios/plugins/index.ts
+function setupPlugins(instance) {
+  setupCachePlugin(instance);
+  setupCancelPlugin(instance);
+  setupDedupePlugin(instance);
+  setupRetryPlugin(instance);
+}
+
+// src/axios/request.ts
+var globalService = null;
+function createAxiosInstance(config = {}) {
+  const instance = axios.create({
+    timeout: 5e3,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    ...config
+  });
+  setupPlugins(instance);
+  return instance;
+}
+function setGlobalAxiosInstance(instance) {
+  globalService = instance;
+}
+function getGlobalAxiosInstance() {
+  if (!globalService) {
+    throw new Error(
+      "Axios instance not initialized. Please call createRequestCore() first."
+    );
+  }
+  return globalService;
+}
+new Proxy({}, {
+  get(target, prop) {
+    return getGlobalAxiosInstance()[prop];
+  }
+});
+var getData = async (url, config) => {
+  const res = await getGlobalAxiosInstance().get(url, config);
+  return res.data;
+};
+var postData = async (url, data, config) => {
+  const res = await getGlobalAxiosInstance().post(url, data, config);
+  return res.data;
+};
+var putData = async (url, data, config) => {
+  const res = await getGlobalAxiosInstance().put(url, data, config);
+  return res.data;
+};
+var deleteData = async (url, config) => {
+  const res = await getGlobalAxiosInstance().delete(url, config);
+  return res.data;
+};
+var onReLoginSuccess = () => {
+};
+var onReLoginCancel = () => {
+};
+
+// src/core.ts
+var globalConfig = {
+  successCodes: [200, 0, "200", "0"],
+  fieldAliases: {
+    data: ["data", "list", "items", "records"],
+    list: ["list", "items", "records", "rows", "data"],
+    total: ["total", "totalCount", "count", "totalElements"]
+  }
+};
+function getGlobalConfig() {
+  return globalConfig;
+}
+function createRequestCore(config = {}) {
+  const {
+    request = {},
+    interceptors = {},
+    successCodes,
+    fieldAliases
+  } = config;
+  if (successCodes) {
+    globalConfig.successCodes = successCodes;
+  }
+  if (fieldAliases) {
+    globalConfig.fieldAliases = {
+      data: fieldAliases.data || globalConfig.fieldAliases.data,
+      list: fieldAliases.list || globalConfig.fieldAliases.list,
+      total: fieldAliases.total || globalConfig.fieldAliases.total
+    };
+  }
+  const axiosInstance = createAxiosInstance(request);
+  setGlobalAxiosInstance(axiosInstance);
+  if (interceptors.request) {
+    axiosInstance.interceptors.request.use(
+      interceptors.request,
+      interceptors.requestError
+    );
+  }
+  if (interceptors.response) {
+    axiosInstance.interceptors.response.use(
+      interceptors.response,
+      interceptors.responseError
+    );
+  }
+  return {
+    install(app) {
+      app.config.globalProperties.$axios = axiosInstance;
+    },
+    axiosInstance
+  };
+}
+
+// src/composables/useTableCrud/constants.ts
+var DEFAULT_CONFIG = {
+  /** 默认 ID 字段名 */
+  idKey: "id",
+  /** 默认分页大小 */
+  pageSize: 10,
+  /** 默认启用分页 */
+  paginationEnabled: true,
+  /** 默认当前页 */
+  currentPage: 1
+};
+var DATA_FIELD_ALIASES = ["data", "list", "items", "records"];
+var LIST_FIELD_ALIASES = [
+  "list",
+  "items",
+  "records",
+  "rows",
+  "data"
+];
+var TOTAL_FIELD_ALIASES = [
+  "total",
+  "totalCount",
+  "count",
+  "totalElements"
+];
+var SUCCESS_CODES = [200, 0, "200", "0"];
+var DEFAULT_MESSAGES = {
+  createSuccess: "\u65B0\u589E\u6210\u529F",
+  updateSuccess: "\u66F4\u65B0\u6210\u529F",
+  deleteSuccess: "\u5220\u9664\u6210\u529F",
+  saveError: "\u4FDD\u5B58\u5931\u8D25",
+  deleteError: "\u5220\u9664\u5931\u8D25",
+  loadError: "\u6570\u636E\u52A0\u8F7D\u5931\u8D25",
+  detailError: "\u8BE6\u60C5\u83B7\u53D6\u5931\u8D25",
+  noDeleteApi: "\u672A\u914D\u7F6E\u5220\u9664\u63A5\u53E3"
+};
+
+// src/composables/useTableCrud/utils.ts
+function getRuntimeFieldAliases() {
+  const config = getGlobalConfig();
+  return {
+    data: config.fieldAliases.data || DATA_FIELD_ALIASES,
+    list: config.fieldAliases.list || LIST_FIELD_ALIASES,
+    total: config.fieldAliases.total || TOTAL_FIELD_ALIASES
+  };
+}
+function getRuntimeSuccessCodes() {
+  const config = getGlobalConfig();
+  return config.successCodes || SUCCESS_CODES;
+}
+var FieldFinder = {
+  /**
+   * 查找第一个存在的字段值
+   */
+  findFirst(obj, aliases, defaultValue) {
+    if (!obj || typeof obj !== "object") return defaultValue;
+    for (const key of aliases) {
+      if (key in obj && obj[key] !== void 0) {
+        return obj[key];
+      }
+    }
+    return defaultValue;
+  },
+  /**
+   * 查找第一个存在的数字字段
+   */
+  findNumber(obj, aliases, defaultValue = 0) {
+    const value = this.findFirst(obj, aliases, defaultValue);
+    return Number(value) || defaultValue;
+  }
+};
+var ResponseNormalizer = {
+  /**
+   * 判断响应是否成功
+   */
+  isSuccess(res) {
+    if (typeof res.success === "boolean") return res.success;
+    const successCodes = getRuntimeSuccessCodes();
+    return successCodes.includes(res.code) || successCodes.includes(String(res.code));
+  },
+  /**
+   * 标准化响应数据（提取 data 层）
+   */
+  normalize(res) {
+    if (!res || typeof res !== "object" || !("data" in res)) {
+      return { data: res, success: true, raw: res };
+    }
+    const aliases = getRuntimeFieldAliases();
+    return {
+      data: FieldFinder.findFirst(res, aliases.data, res),
+      success: ResponseNormalizer.isSuccess(res),
+      raw: res
+    };
+  }
+};
+var UrlUtils = {
+  /**
+   * 构建 URL（处理路径参数）
+   */
+  buildUrl(endpoint, id) {
+    if (id !== void 0 && endpoint.includes(":id")) {
+      return endpoint.replace(":id", String(id));
+    }
+    return endpoint;
+  }
+};
+var DataExtractor = {
+  /**
+   * 从响应中提取列表数据（支持多种格式）
+   *
+   * 支持的响应结构：
+   * 1. { code: 0, data: { list: [...], total: 10 } }  // 嵌套结构（最常见）
+   * 2. { data: { items: [...], total: 10 } }           // 嵌套结构
+   * 3. { list: [...], total: 10 }                      // 扁平结构
+   * 4. { items: [...], totalCount: 10 }                // 不同字段名
+   * 5. { data: [...] }                                  // 直接数组
+   * 6. [...]                                            // 纯数组
+   */
+  extractList(response) {
+    const normalized = ResponseNormalizer.normalize(response);
+    const dataLayer = normalized.data ?? response;
+    const aliases = getRuntimeFieldAliases();
+    const list = FieldFinder.findFirst(dataLayer, aliases.list, []);
+    const total = FieldFinder.findNumber(dataLayer, aliases.total, 0);
+    return {
+      items: Array.isArray(list) ? list : [],
+      total
+    };
+  },
+  /**
+   * 从响应中提取详情数据
+   */
+  extractDetail(response) {
+    const normalized = ResponseNormalizer.normalize(response);
+    return normalized.data;
+  }
+};
+var RowUtils = {
+  /**
+   * 从数组中查找行索引
+   */
+  findIndex(items, idKey, id) {
+    return items.findIndex((item) => item[idKey] === id);
+  },
+  /**
+   * 从数组中移除行
+   */
+  remove(items, idKey, id) {
+    const index = this.findIndex(items, idKey, id);
+    if (index !== -1) {
+      items.splice(index, 1);
+      return true;
+    }
+    return false;
+  },
+  /**
+   * 生成默认 ID
+   */
+  generateId() {
+    return Date.now() + Math.floor(Math.random() * 1e3);
+  }
+};
+
+// src/composables/useTableCrud/useTableCrud.ts
+function useTableCrud(config) {
+  const {
+    api,
+    columns,
+    customActions = [],
+    detail: detailConfig,
+    idKey = DEFAULT_CONFIG.idKey,
+    defaultPageSize = DEFAULT_CONFIG.pageSize,
+    defaultPaginationEnabled = DEFAULT_CONFIG.paginationEnabled,
+    autoLoad = true,
+    extractListData
+  } = config;
+  const message = useMessage();
+  const dialog = useDialog();
+  const data = shallowRef([]);
+  const total = ref(0);
+  const loading = ref(false);
+  const tableRef = ref();
+  const paginationEnabled = ref(defaultPaginationEnabled);
+  const page = reactive({
+    current: DEFAULT_CONFIG.currentPage,
+    size: defaultPageSize
+  });
+  const detailVisible = ref(false);
+  const detailData = ref(null);
+  const detailTitle = ref("");
+  const detail = {
+    visible: detailVisible,
+    data: detailData,
+    title: detailTitle,
+    show: (row) => {
+      detailData.value = row;
+      detailTitle.value = `\u8BE6\u60C5 - ${row.name || row[idKey]}`;
+      detailVisible.value = true;
+    },
+    close: () => {
+      detailVisible.value = false;
+      detailData.value = null;
+      detailTitle.value = "";
+    }
+  };
+  const refresh = async () => {
+    if (!api.list) return;
+    loading.value = true;
+    try {
+      const queryParams = paginationEnabled.value ? { page: page.current, pageSize: page.size } : {};
+      const response = await getData(api.list, { params: queryParams });
+      const extracted = extractListData ? extractListData(response) : DataExtractor.extractList(response);
+      data.value = extracted.items;
+      total.value = extracted.total;
+    } catch (error) {
+      console.error("[useTableCrud] \u6570\u636E\u52A0\u8F7D\u5931\u8D25:", error);
+      message.error(DEFAULT_MESSAGES.loadError);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const getDetail = async (row) => {
+    if (!api.get) {
+      detail.show(row);
+      return row;
+    }
+    loading.value = true;
+    try {
+      const url = UrlUtils.buildUrl(api.get, row[idKey]);
+      const response = await getData(url, {});
+      const detailData2 = DataExtractor.extractDetail(response);
+      if (detailData2) {
+        detail.show(detailData2);
+        return detailData2;
+      }
+      return null;
+    } catch (error) {
+      console.error("[useTableCrud] \u8BE6\u60C5\u83B7\u53D6\u5931\u8D25:", error);
+      message.error(DEFAULT_MESSAGES.detailError);
+      return null;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const create = async (row) => {
+    if (!api.create) {
+      message.warning("\u672A\u914D\u7F6E\u65B0\u589E\u63A5\u53E3");
+      return;
+    }
+    loading.value = true;
+    try {
+      await postData(api.create, row);
+      message.success(DEFAULT_MESSAGES.createSuccess);
+      await refresh();
+    } catch (error) {
+      console.error("[useTableCrud] \u65B0\u589E\u5931\u8D25:", error);
+      message.error("\u65B0\u589E\u5931\u8D25");
+      throw error;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const save = async (row) => {
+    if (!api.update) {
+      message.warning("\u672A\u914D\u7F6E\u66F4\u65B0\u63A5\u53E3");
+      return;
+    }
+    loading.value = true;
+    try {
+      const url = UrlUtils.buildUrl(api.update, row[idKey]);
+      await putData(url, row);
+      message.success(DEFAULT_MESSAGES.updateSuccess);
+      await refresh();
+    } catch (error) {
+      console.error("[useTableCrud] \u66F4\u65B0\u5931\u8D25:", error);
+      message.error(DEFAULT_MESSAGES.saveError);
+      throw error;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const remove = async (row) => {
+    if (!api.remove) {
+      message.warning(DEFAULT_MESSAGES.noDeleteApi);
+      return;
+    }
+    loading.value = true;
+    try {
+      const url = UrlUtils.buildUrl(api.remove, row[idKey]);
+      await deleteData(url);
+      message.success(DEFAULT_MESSAGES.deleteSuccess);
+      RowUtils.remove(data.value, idKey, row[idKey]);
+      await refresh();
+    } catch (error) {
+      console.error("[useTableCrud] \u5220\u9664\u5931\u8D25:", error);
+      message.error(DEFAULT_MESSAGES.deleteError);
+      throw error;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const batchRemove = async (rows) => {
+    if (!rows || rows.length === 0) {
+      message.warning("\u8BF7\u9009\u62E9\u8981\u5220\u9664\u7684\u6570\u636E");
+      return;
+    }
+    if (!api.remove && !api.batchRemove) {
+      message.warning(DEFAULT_MESSAGES.noDeleteApi);
+      return;
+    }
+    loading.value = true;
+    try {
+      if (api.batchRemove) {
+        const ids = rows.map((row) => row[idKey]);
+        await postData(api.batchRemove, { ids });
+      } else {
+        await Promise.all(
+          rows.map((row) => {
+            const url = UrlUtils.buildUrl(api.remove, row[idKey]);
+            return deleteData(url);
+          })
+        );
+      }
+      message.success(`\u6210\u529F\u5220\u9664 ${rows.length} \u6761\u6570\u636E`);
+      await refresh();
+    } catch (error) {
+      console.error("[useTableCrud] \u6279\u91CF\u5220\u9664\u5931\u8D25:", error);
+      message.error("\u6279\u91CF\u5220\u9664\u5931\u8D25");
+      throw error;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const handleCancel = async () => {
+    await refresh();
+  };
+  const handlePaginationChange = (pageNum, pageSize) => {
+    page.current = pageNum;
+    page.size = pageSize;
+    refresh();
+  };
+  const handleRowDelete = (deletedRow) => {
+    RowUtils.remove(data.value, idKey, deletedRow[idKey]);
+  };
+  const pagination = computed(() => {
+    if (!paginationEnabled.value) return false;
+    return {
+      enabled: true,
+      page: page.current,
+      pageSize: page.size
+    };
+  });
+  const createActionContext = (index) => ({
+    data: data.value,
+    index,
+    page,
+    paginationEnabled: paginationEnabled.value,
+    message,
+    dialog,
+    refresh
+  });
+  const actions = computed(() => {
+    const result = {};
+    if (api.update) {
+      result.edit = async (row) => {
+        try {
+          await save(row);
+          return { data: row, error: null };
+        } catch (error) {
+          return { data: null, error };
+        }
+      };
+    }
+    if (api.remove) {
+      result.delete = async (row) => {
+        try {
+          await remove(row);
+          return { data: { success: true }, error: null };
+        } catch (error) {
+          return { data: null, error };
+        }
+      };
+    }
+    if (api.get) {
+      result.detail = async (row) => {
+        try {
+          const detailData2 = await getDetail(row);
+          return { data: detailData2, error: null };
+        } catch (error) {
+          return { data: null, error };
+        }
+      };
+    }
+    if (customActions.length > 0) {
+      result.custom = customActions.map((action) => ({
+        key: action.key,
+        label: action.label,
+        icon: action.icon,
+        type: action.type || "default",
+        onClick: (row, index) => {
+          const context = createActionContext(index);
+          return action.handler(row, context);
+        }
+      }));
+    }
+    return result;
+  });
+  if (autoLoad) {
+    refresh();
+  }
+  return {
+    // 数据状态
+    data,
+    loading,
+    total,
+    // 表格配置
+    columns: computed(() => columns),
+    actions,
+    tableRef,
+    // 分页
+    page,
+    paginationEnabled,
+    pagination,
+    // 核心方法
+    refresh,
+    create,
+    save,
+    remove,
+    batchRemove,
+    getDetail,
+    // 事件处理
+    handleCancel,
+    handlePaginationChange,
+    handleRowDelete,
+    // 详情弹窗
+    detail,
+    detailConfig
+  };
+}
+
+export { cancelAllPendingRequests, cancelAllRequests, cleanupExpiredCache, clearAllCache, clearCache, createAxiosInstance, createRequestCore, deleteData, getCacheSize, getCancelableRequestCount, getData, getGlobalConfig, getPendingRequestCount, onReLoginCancel, onReLoginSuccess, postData, putData, useTableCrud };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map