@robot-admin/request-core 0.2.0 → 0.4.1

package/dist/chunk-2JXH7SIL.js

@@ -0,0 +1,711 @@
+import { normalizeRequestError, getData, postData, putData, RequestError, isCanceledError, deleteData, getGlobalConfig } from './chunk-OAZ5BUBU.js';
+import { provide, inject, getCurrentInstance, shallowRef, ref, reactive, computed, getCurrentScope, onScopeDispose, onMounted } from 'vue';
+
+var REQUEST_CLIENT_KEY = /* @__PURE__ */ Symbol.for(
+  "@robot-admin/request-core/vue-client/v1"
+);
+function createRequestPlugin(client) {
+  return {
+    install(app) {
+      app.provide(REQUEST_CLIENT_KEY, client);
+    }
+  };
+}
+function provideRequestClient(client) {
+  provide(REQUEST_CLIENT_KEY, client);
+  return client;
+}
+function useRequestClient(optional = false) {
+  const client = inject(REQUEST_CLIENT_KEY, void 0);
+  if (!client && !optional) {
+    throw new Error(
+      "Request client was not provided. Install createRequestPlugin(client) or pass client explicitly."
+    );
+  }
+  return client;
+}
+
+// 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;
+    const record = obj;
+    for (const key of aliases) {
+      if (key in record && record[key] !== void 0) {
+        return record[key];
+      }
+    }
+    return defaultValue;
+  },
+  /**
+   * 查找第一个存在的数字字段
+   */
+  findNumber(obj, aliases, defaultValue = 0) {
+    const value = this.findFirst(obj, aliases, defaultValue);
+    const numberValue = Number(value);
+    return Number.isFinite(numberValue) ? numberValue : defaultValue;
+  }
+};
+var ResponseNormalizer = {
+  /**
+   * 判断响应是否成功
+   */
+  isSuccess(res) {
+    if (!res || typeof res !== "object") return false;
+    const record = res;
+    if (typeof record.success === "boolean") return record.success;
+    if (!("code" in record)) return true;
+    const successCodes = getRuntimeSuccessCodes();
+    return successCodes.includes(record.code) || successCodes.some((code) => String(code) === String(record.code));
+  },
+  /**
+   * 标准化响应数据（提取 data 层）
+   */
+  normalize(res) {
+    if (!res || typeof res !== "object") {
+      return { data: res, success: true, raw: res };
+    }
+    const aliases = getRuntimeFieldAliases();
+    const record = res;
+    const hasDataLayer = aliases.data.some((key) => key in record);
+    if (!hasDataLayer) {
+      return { data: res, success: ResponseNormalizer.isSuccess(res), raw: res };
+    }
+    return {
+      data: FieldFinder.findFirst(record, 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", encodeURIComponent(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;
+    const aliases = getRuntimeFieldAliases();
+    if (Array.isArray(dataLayer)) {
+      const rootTotal2 = FieldFinder.findNumber(
+        response && typeof response === "object" ? response : null,
+        aliases.total,
+        dataLayer.length
+      );
+      return { items: dataLayer, total: rootTotal2 };
+    }
+    if (!dataLayer || typeof dataLayer !== "object") {
+      return { items: [], total: 0 };
+    }
+    const list = FieldFinder.findFirst(dataLayer, aliases.list, []);
+    const rootTotal = FieldFinder.findNumber(
+      response && typeof response === "object" ? response : null,
+      aliases.total,
+      Array.isArray(list) ? list.length : 0
+    );
+    const total = FieldFinder.findNumber(dataLayer, aliases.total, rootTotal);
+    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
+var noopMessage = {
+  success: () => void 0,
+  error: () => void 0,
+  warning: () => void 0,
+  info: () => void 0
+};
+var noopDialog = {
+  warning: () => void 0,
+  error: () => void 0,
+  success: () => void 0,
+  info: () => void 0
+};
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    try {
+      return structuredClone(value);
+    } catch {
+    }
+  }
+  return Array.isArray(value) ? [...value] : value && typeof value === "object" ? { ...value } : value;
+}
+function recordValue(row, key) {
+  return row[key];
+}
+function asQueryResult(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  return Array.isArray(candidate.items) && Number.isFinite(candidate.total) ? { items: candidate.items, total: Number(candidate.total) } : null;
+}
+function useTableCrud(config) {
+  const {
+    api,
+    query,
+    mutations = {},
+    columns = [],
+    customActions = [],
+    detail: detailConfig,
+    idKey = DEFAULT_CONFIG.idKey,
+    defaultPageSize = DEFAULT_CONFIG.pageSize,
+    defaultPaginationEnabled = DEFAULT_CONFIG.paginationEnabled,
+    initialFilters = {},
+    initialSort = null,
+    createNewRow,
+    autoLoad = true,
+    extractListData,
+    refreshAfterMutation = true,
+    batchConcurrency = 4,
+    detailTitle
+  } = config;
+  if (!query && !api?.list) {
+    throw new Error("useTableCrud requires either query or api.list.");
+  }
+  if (!Number.isInteger(batchConcurrency) || batchConcurrency < 1) {
+    throw new RangeError("batchConcurrency must be an integer greater than 0.");
+  }
+  const injectedClient = getCurrentInstance() ? useRequestClient(true) : void 0;
+  const client = config.client ?? injectedClient;
+  const message = config.ui?.message ?? noopMessage;
+  const dialog = config.ui?.dialog ?? noopDialog;
+  const notify = (type, text) => {
+    try {
+      void Promise.resolve(message[type](text)).catch(() => void 0);
+    } catch {
+    }
+  };
+  const data = shallowRef([]);
+  const total = ref(0);
+  const tableRef = ref();
+  const paginationEnabled = ref(defaultPaginationEnabled);
+  const filters = ref(cloneValue(initialFilters));
+  const sort = ref(cloneValue(initialSort));
+  const error = shallowRef(null);
+  const lastUpdated = ref(null);
+  const page = reactive({
+    current: DEFAULT_CONFIG.currentPage,
+    size: defaultPageSize
+  });
+  const counts = reactive({
+    refresh: 0,
+    detail: 0,
+    create: 0,
+    update: 0,
+    remove: 0
+  });
+  const controllers = /* @__PURE__ */ new Set();
+  let refreshController = null;
+  let refreshSequence = 0;
+  let disposed = false;
+  const loading = computed(() => Object.values(counts).some((count) => count > 0));
+  const isInitialLoading = computed(
+    () => counts.refresh > 0 && lastUpdated.value === null
+  );
+  const isRefreshing = computed(
+    () => counts.refresh > 0 && lastUpdated.value !== null
+  );
+  const creating = computed(() => counts.create > 0);
+  const updating = computed(() => counts.update > 0);
+  const removing = computed(() => counts.remove > 0);
+  const startOperation = (operation) => {
+    counts[operation] += 1;
+    const controller = new AbortController();
+    controllers.add(controller);
+    return controller;
+  };
+  const finishOperation = (operation, controller) => {
+    counts[operation] = Math.max(0, counts[operation] - 1);
+    controllers.delete(controller);
+  };
+  const reportError = async (cause, operation, fallbackMessage) => {
+    const normalized = normalizeRequestError(cause);
+    if (!isCanceledError(normalized)) {
+      error.value = normalized;
+      notify("error", fallbackMessage);
+      try {
+        await config.onError?.(normalized, operation);
+      } catch {
+      }
+    }
+    return normalized;
+  };
+  const detailVisible = ref(false);
+  const detailData = ref(null);
+  const detailTitleState = ref("");
+  const detail = {
+    visible: detailVisible,
+    data: detailData,
+    title: detailTitleState,
+    show: (row) => {
+      detailData.value = row;
+      detailTitleState.value = detailTitle?.(row) ?? `\u8BE6\u60C5 - ${String(
+        row.name ?? recordValue(row, idKey) ?? ""
+      )}`;
+      detailVisible.value = true;
+    },
+    close: () => {
+      detailVisible.value = false;
+      detailData.value = null;
+      detailTitleState.value = "";
+    }
+  };
+  const requestList = async (signal) => {
+    if (query) {
+      return query({
+        page: page.current,
+        pageSize: page.size,
+        paginationEnabled: paginationEnabled.value,
+        filters: filters.value,
+        sort: sort.value,
+        signal
+      });
+    }
+    const paginationParams = paginationEnabled.value ? { page: page.current, pageSize: page.size } : {};
+    const params = {
+      ...paginationParams,
+      ...filters.value,
+      ...sort.value ? { sort: sort.value } : {}
+    };
+    return client ? client.get(api.list, { params, signal, concurrency: "takeLatest" }) : getData(api.list, { params, signal, dedupe: true });
+  };
+  const refresh = async () => {
+    if (disposed) return;
+    refreshController?.abort();
+    const sequence = ++refreshSequence;
+    const controller = startOperation("refresh");
+    refreshController = controller;
+    error.value = null;
+    try {
+      const response = await requestList(controller.signal);
+      if (sequence !== refreshSequence || controller.signal.aborted) return;
+      const extracted = extractListData?.(response) ?? asQueryResult(response) ?? DataExtractor.extractList(response);
+      data.value = [...extracted.items];
+      total.value = extracted.total;
+      lastUpdated.value = Date.now();
+    } catch (cause) {
+      if (!controller.signal.aborted) {
+        await reportError(cause, "refresh", DEFAULT_MESSAGES.loadError);
+      }
+    } finally {
+      if (refreshController === controller) refreshController = null;
+      finishOperation("refresh", controller);
+    }
+  };
+  const maybeRefresh = async () => {
+    if (refreshAfterMutation) await refresh();
+  };
+  const getDetail = async (row) => {
+    if (!mutations.get && !api?.get) {
+      detail.show(row);
+      return row;
+    }
+    const controller = startOperation("detail");
+    try {
+      let result;
+      if (mutations.get) {
+        result = await mutations.get(row, { signal: controller.signal });
+      } else {
+        const url = UrlUtils.buildUrl(api.get, recordValue(row, idKey));
+        const response = client ? await client.get(url, { signal: controller.signal }) : await getData(url, { signal: controller.signal });
+        result = DataExtractor.extractDetail(response);
+      }
+      if (result) detail.show(result);
+      return result;
+    } catch (cause) {
+      if (!controller.signal.aborted) {
+        await reportError(cause, "detail", DEFAULT_MESSAGES.detailError);
+      }
+      return null;
+    } finally {
+      finishOperation("detail", controller);
+    }
+  };
+  const create = async (row) => {
+    if (!mutations.create && !api?.create) {
+      notify("warning", "\u672A\u914D\u7F6E\u65B0\u589E\u64CD\u4F5C");
+      return;
+    }
+    const controller = startOperation("create");
+    try {
+      if (mutations.create) {
+        await mutations.create(row, { signal: controller.signal });
+      } else if (client) {
+        await client.post(api.create, row, { signal: controller.signal });
+      } else {
+        await postData(api.create, row, { signal: controller.signal });
+      }
+      notify("success", DEFAULT_MESSAGES.createSuccess);
+      await maybeRefresh();
+    } catch (cause) {
+      throw await reportError(cause, "create", "\u65B0\u589E\u5931\u8D25");
+    } finally {
+      finishOperation("create", controller);
+    }
+  };
+  const save = async (row) => {
+    if (!mutations.update && !api?.update) {
+      notify("warning", "\u672A\u914D\u7F6E\u66F4\u65B0\u64CD\u4F5C");
+      return;
+    }
+    const controller = startOperation("update");
+    try {
+      if (mutations.update) {
+        await mutations.update(row, { signal: controller.signal });
+      } else {
+        const url = UrlUtils.buildUrl(api.update, recordValue(row, idKey));
+        if (client) await client.put(url, row, { signal: controller.signal });
+        else await putData(url, row, { signal: controller.signal });
+      }
+      notify("success", DEFAULT_MESSAGES.updateSuccess);
+      await maybeRefresh();
+    } catch (cause) {
+      throw await reportError(cause, "update", DEFAULT_MESSAGES.saveError);
+    } finally {
+      finishOperation("update", controller);
+    }
+  };
+  const removeOne = async (row, signal) => {
+    if (mutations.remove) {
+      await mutations.remove(row, { signal });
+      return;
+    }
+    if (!api?.remove) throw new Error("Delete operation is not configured.");
+    const url = UrlUtils.buildUrl(api.remove, recordValue(row, idKey));
+    if (client) await client.delete(url, { signal });
+    else await deleteData(url, { signal });
+  };
+  const removeRowsLocally = (rows) => {
+    let removed = 0;
+    for (const row of rows) {
+      if (RowUtils.remove(data.value, idKey, recordValue(row, idKey))) {
+        removed += 1;
+      }
+    }
+    if (removed > 0) {
+      data.value = [...data.value];
+      total.value = Math.max(0, total.value - removed);
+    }
+  };
+  const remove = async (row) => {
+    if (!mutations.remove && !api?.remove) {
+      notify("warning", DEFAULT_MESSAGES.noDeleteApi);
+      return;
+    }
+    const controller = startOperation("remove");
+    try {
+      await removeOne(row, controller.signal);
+      notify("success", DEFAULT_MESSAGES.deleteSuccess);
+      if (refreshAfterMutation) await refresh();
+      else removeRowsLocally([row]);
+    } catch (cause) {
+      throw await reportError(cause, "remove", DEFAULT_MESSAGES.deleteError);
+    } finally {
+      finishOperation("remove", controller);
+    }
+  };
+  const batchRemove = async (rows) => {
+    if (rows.length === 0) {
+      notify("warning", "\u8BF7\u9009\u62E9\u8981\u5220\u9664\u7684\u6570\u636E");
+      return;
+    }
+    if (!mutations.batchRemove && !mutations.remove && !api?.batchRemove && !api?.remove) {
+      notify("warning", DEFAULT_MESSAGES.noDeleteApi);
+      return;
+    }
+    const controller = startOperation("remove");
+    try {
+      if (mutations.batchRemove) {
+        await mutations.batchRemove(rows, { signal: controller.signal });
+      } else if (api?.batchRemove) {
+        const ids = rows.map((row) => recordValue(row, idKey));
+        if (client) {
+          await client.post(api.batchRemove, { ids }, { signal: controller.signal });
+        } else {
+          await postData(api.batchRemove, { ids }, { signal: controller.signal });
+        }
+      } else {
+        let cursor = 0;
+        const failures = [];
+        const worker = async () => {
+          while (cursor < rows.length && !controller.signal.aborted) {
+            const current = rows[cursor++];
+            try {
+              await removeOne(current, controller.signal);
+            } catch (cause) {
+              failures.push(cause);
+            }
+          }
+        };
+        await Promise.all(
+          Array.from({ length: Math.min(batchConcurrency, rows.length) }, worker)
+        );
+        if (controller.signal.aborted) {
+          throw Object.assign(new Error("canceled"), {
+            name: "AbortError",
+            code: "ERR_CANCELED"
+          });
+        }
+        if (failures.length > 0) {
+          throw new RequestError({
+            kind: "business",
+            message: `${failures.length} delete operation(s) failed.`,
+            data: failures
+          });
+        }
+      }
+      notify("success", `\u6210\u529F\u5220\u9664 ${rows.length} \u6761\u6570\u636E`);
+      if (refreshAfterMutation) await refresh();
+      else removeRowsLocally(rows);
+    } catch (cause) {
+      throw await reportError(cause, "remove", "\u6279\u91CF\u5220\u9664\u5931\u8D25");
+    } finally {
+      finishOperation("remove", controller);
+    }
+  };
+  const search = async (next) => {
+    if (next) Object.assign(filters.value, next);
+    page.current = DEFAULT_CONFIG.currentPage;
+    await refresh();
+  };
+  const resetSearch = async () => {
+    filters.value = cloneValue(initialFilters);
+    page.current = DEFAULT_CONFIG.currentPage;
+    await refresh();
+  };
+  const setSort = async (next) => {
+    sort.value = cloneValue(next);
+    page.current = DEFAULT_CONFIG.currentPage;
+    await refresh();
+  };
+  const handlePaginationChange = (pageNumber, pageSize) => {
+    page.current = pageNumber;
+    page.size = pageSize;
+    void refresh();
+  };
+  const handleRowDelete = (row) => {
+    removeRowsLocally([row]);
+  };
+  const createActionContext = (index) => ({
+    data: data.value,
+    index,
+    page,
+    paginationEnabled: paginationEnabled.value,
+    message,
+    dialog,
+    refresh
+  });
+  const actions = computed(() => {
+    const result = {};
+    if (mutations.update || api?.update) {
+      result.edit = async (row) => {
+        try {
+          await save(row);
+          return { data: row, error: null };
+        } catch (cause) {
+          return { data: null, error: normalizeRequestError(cause) };
+        }
+      };
+    }
+    if (mutations.remove || api?.remove) {
+      result.delete = async (row) => {
+        try {
+          await remove(row);
+          return { data: { success: true }, error: null };
+        } catch (cause) {
+          return { data: null, error: normalizeRequestError(cause) };
+        }
+      };
+    }
+    if (mutations.get || api?.get) {
+      result.detail = async (row) => {
+        const value = await getDetail(row);
+        return { data: value, error: error.value };
+      };
+    }
+    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) => action.handler(row, createActionContext(index))
+      }));
+    }
+    return result;
+  });
+  const pagination = computed(
+    () => paginationEnabled.value ? {
+      enabled: true,
+      page: page.current,
+      pageSize: page.size,
+      itemCount: total.value
+    } : false
+  );
+  const createDraft = () => createNewRow?.() ?? {};
+  const cancel = () => {
+    refreshSequence += 1;
+    refreshController?.abort();
+    refreshController = null;
+    for (const controller of controllers) controller.abort();
+  };
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    cancel();
+  };
+  if (getCurrentScope()) onScopeDispose(dispose);
+  if (autoLoad === "mounted" && getCurrentInstance()) {
+    onMounted(() => void refresh());
+  } else if (autoLoad === "mounted") {
+    void refresh();
+  } else if (autoLoad) void refresh();
+  return {
+    data,
+    rows: data,
+    loading,
+    isInitialLoading,
+    isRefreshing,
+    creating,
+    updating,
+    removing,
+    total,
+    error,
+    lastUpdated,
+    columns: computed(() => columns),
+    actions,
+    tableRef,
+    page,
+    filters,
+    sort,
+    paginationEnabled,
+    pagination,
+    refresh,
+    reload: refresh,
+    search,
+    resetSearch,
+    setSort,
+    create,
+    save,
+    remove,
+    batchRemove,
+    getDetail,
+    createDraft,
+    cancel,
+    dispose,
+    handleCancel: refresh,
+    handlePaginationChange,
+    handleRowDelete,
+    detail,
+    detailConfig
+  };
+}
+
+export { REQUEST_CLIENT_KEY, createRequestPlugin, provideRequestClient, useRequestClient, useTableCrud };
+//# sourceMappingURL=chunk-2JXH7SIL.js.map
+//# sourceMappingURL=chunk-2JXH7SIL.js.map