@qiaopeng/tanstack-query-plus 0.5.9 → 0.5.10

package/dist/chunk-PCNSWVA5.cjs

@@ -0,0 +1,602 @@
+'use strict';
+
+var chunkAPXNNHBD_cjs = require('./chunk-APXNNHBD.cjs');
+var chunk6MAYHLTE_cjs = require('./chunk-6MAYHLTE.cjs');
+var reactQuery = require('@tanstack/react-query');
+
+// src/utils/fieldMapper.ts
+function createFieldEnricher(queryKey, mappings) {
+  return (data, queryClient) => {
+    const config = queryClient.getQueryData(queryKey);
+    if (!config) return data;
+    const result = { ...data };
+    Object.entries(mappings).forEach(([idField, { nameField, configKey }]) => {
+      const idValue = data[idField];
+      if (idValue == null) return;
+      const options = config[configKey];
+      if (!options?.length) return;
+      const optionMap = new Map(options.map((item) => [String(item.value), item.label]));
+      const label = optionMap.get(String(idValue));
+      if (label) {
+        result[nameField] = label;
+      }
+    });
+    return result;
+  };
+}
+function createTempId(prefix = "temp") {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function createOptimisticBase(customFields) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return { createTime: now, updateTime: now, createUser: "", updateUser: "", deleteStatus: 0, ...customFields };
+}
+
+// src/utils/optimisticUtils.ts
+function idsAreEqual(a, b) {
+  if (a === b) return true;
+  if (a === void 0 || a === null || b === void 0 || b === null) return false;
+  return String(a) === String(b);
+}
+var listUpdater = {
+  add: (items, newItem) => {
+    const currentItems = items || [];
+    const existingIndex = currentItems.findIndex((item) => idsAreEqual(item.id, newItem.id));
+    if (existingIndex >= 0) {
+      const updatedItems = [...currentItems];
+      updatedItems[existingIndex] = newItem;
+      return updatedItems;
+    }
+    return [newItem, ...currentItems];
+  },
+  update: (items, updatedItem) => {
+    const currentItems = items || [];
+    return currentItems.map((item) => idsAreEqual(item.id, updatedItem.id) ? { ...item, ...updatedItem } : item);
+  },
+  remove: (items, itemId) => {
+    const currentItems = items || [];
+    return currentItems.filter((item) => !idsAreEqual(item.id, itemId));
+  }
+};
+function createAddItemConfig(queryKey, options) {
+  return { queryKey, updater: (oldData, newItem) => {
+    const currentItems = oldData || [];
+    if (options?.addToTop !== false) {
+      return [newItem, ...currentItems];
+    }
+    return [...currentItems, newItem];
+  }, rollback: options?.onRollback ? (_previousData, error) => {
+    options.onRollback(error);
+  } : void 0, enabled: true };
+}
+function createUpdateItemConfig(queryKey, options) {
+  return { queryKey, updater: (oldData, updatedItem) => {
+    return listUpdater.update(oldData, updatedItem);
+  }, rollback: options?.onRollback ? (_previousData, error) => {
+    options.onRollback(error);
+  } : void 0, enabled: true };
+}
+function createRemoveItemConfig(queryKey, options) {
+  return { queryKey, updater: (oldData, itemId) => {
+    return listUpdater.remove(oldData, itemId);
+  }, rollback: options?.onRollback ? (_previousData, error) => {
+    options.onRollback(error);
+  } : void 0, enabled: true };
+}
+function createListOperationConfig(config) {
+  return {
+    queryKey: config.queryKey,
+    updater: (oldData, variables) => {
+      switch (config.operation) {
+        case "add" /* ADD */:
+          return listUpdater.add(oldData, variables);
+        case "update" /* UPDATE */:
+          return listUpdater.update(oldData, variables);
+        case "remove" /* REMOVE */:
+          return listUpdater.remove(oldData, variables);
+        default:
+          return oldData || [];
+      }
+    },
+    rollback: config.onRollback ? (previousData, error) => {
+      const opType = config.operation === "add" /* ADD */ ? "create" : config.operation === "remove" /* REMOVE */ ? "delete" : "update";
+      config.onRollback(error, { previousData, timestamp: Date.now(), operationType: opType });
+    } : void 0,
+    enabled: true
+  };
+}
+function batchUpdateItems(items, updates) {
+  let currentItems = items || [];
+  updates.forEach((update) => {
+    currentItems = listUpdater.update(currentItems, update);
+  });
+  return currentItems;
+}
+function batchRemoveItems(items, itemIds) {
+  let currentItems = items || [];
+  itemIds.forEach((itemId) => {
+    currentItems = listUpdater.remove(currentItems, itemId);
+  });
+  return currentItems;
+}
+function reorderItems(items, fromIndex, toIndex) {
+  const currentItems = [...items || []];
+  if (fromIndex < 0 || fromIndex >= currentItems.length || toIndex < 0 || toIndex >= currentItems.length) {
+    return currentItems;
+  }
+  const [movedItem] = currentItems.splice(fromIndex, 1);
+  currentItems.splice(toIndex, 0, movedItem);
+  return currentItems;
+}
+function conditionalUpdateItems(items, predicate, updater) {
+  const currentItems = items || [];
+  return currentItems.map((item) => {
+    if (predicate(item)) {
+      return { ...item, ...updater(item) };
+    }
+    return item;
+  });
+}
+function stableListPlaceholder(previousData) {
+  if (previousData === void 0 || previousData === null) return previousData;
+  if (Array.isArray(previousData)) {
+    return [];
+  }
+  if (typeof previousData === "object") {
+    const obj = { ...previousData };
+    if (Array.isArray(obj.Rows)) {
+      obj.Rows = [];
+      if (typeof obj.Total === "number") obj.Total = obj.Total;
+      return obj;
+    }
+    if (Array.isArray(obj.items)) {
+      obj.items = [];
+      if (typeof obj.total === "number") obj.total = obj.total;
+      return obj;
+    }
+    if (Array.isArray(obj.data)) {
+      obj.data = [];
+      return obj;
+    }
+  }
+  return previousData;
+}
+
+// src/utils/prefetchManager.ts
+var SmartPrefetchManager = class {
+  constructor(queryClient) {
+    this.prefetchQueue = /* @__PURE__ */ new Map();
+    this.prefetchHistory = /* @__PURE__ */ new Set();
+    this.networkSpeed = "fast";
+    this.isProcessing = false;
+    this.maxQueueSize = 10;
+    this.maxHistorySize = 100;
+    this.totalPrefetches = 0;
+    this.successfulPrefetches = 0;
+    this.failedPrefetches = 0;
+    this.skippedPrefetches = 0;
+    this.prefetchTimes = [];
+    this.maxPrefetchTimesSize = 50;
+    this.interactionHistory = [];
+    this.maxInteractionHistorySize = 100;
+    this.queryAccessCounts = /* @__PURE__ */ new Map();
+    this.querySequences = [];
+    this.maxSequenceSize = 50;
+    this.queryClient = queryClient;
+    this.initNetworkMonitoring();
+  }
+  initNetworkMonitoring() {
+    const networkInfo = chunkAPXNNHBD_cjs.getNetworkInfo();
+    if (!networkInfo) {
+      return;
+    }
+    this.updateNetworkSpeed();
+    if (typeof navigator !== "undefined" && "connection" in navigator) {
+      const navWithConnection = navigator;
+      const connection = navWithConnection.connection || navWithConnection.mozConnection || navWithConnection.webkitConnection;
+      const handleNetworkChange = () => {
+        this.updateNetworkSpeed();
+      };
+      connection?.addEventListener?.("change", handleNetworkChange);
+      this.networkCleanup = () => {
+        connection?.removeEventListener("change", handleNetworkChange);
+      };
+    }
+  }
+  updateNetworkSpeed() {
+    this.networkSpeed = chunkAPXNNHBD_cjs.getNetworkSpeed();
+  }
+  getNetworkSpeed() {
+    return this.networkSpeed;
+  }
+  isSlowNetwork() {
+    return this.networkSpeed === "slow" || this.networkSpeed === "unknown";
+  }
+  shouldPrefetch(queryKey, config = {}) {
+    const key = this.getQueryKeyString(queryKey);
+    if (this.prefetchQueue.has(key)) return false;
+    if (this.prefetchHistory.has(key)) return false;
+    const cachedData = this.queryClient.getQueryData(queryKey);
+    if (cachedData) return false;
+    if (this.isSlowNetwork() && !config.allowSlowNetwork) return false;
+    if (this.prefetchQueue.size >= this.maxQueueSize) return false;
+    return true;
+  }
+  addPrefetchTask(queryKey, queryFn, config = {}) {
+    if (!this.shouldPrefetch(queryKey, config)) {
+      this.skippedPrefetches++;
+      return false;
+    }
+    const key = this.getQueryKeyString(queryKey);
+    const task = { id: `${key}-${Date.now()}`, queryKey, queryFn, config: { priority: "medium", delay: 0, staleTime: chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME, allowSlowNetwork: false, ...config }, timestamp: Date.now() };
+    this.prefetchQueue.set(key, task);
+    this.processQueue();
+    return true;
+  }
+  async processQueue() {
+    if (this.isProcessing || this.prefetchQueue.size === 0) {
+      return;
+    }
+    this.isProcessing = true;
+    try {
+      const sortedTasks = this.getSortedTasks();
+      for (const task of sortedTasks) {
+        const key = this.getQueryKeyString(task.queryKey);
+        const startTime = Date.now();
+        if (task.config.delay && task.config.delay > 0) {
+          await this.delay(task.config.delay);
+        }
+        try {
+          this.totalPrefetches++;
+          await this.queryClient.prefetchQuery({ queryKey: task.queryKey, queryFn: task.queryFn, staleTime: task.config.staleTime });
+          this.successfulPrefetches++;
+          const duration = Date.now() - startTime;
+          this.recordPrefetchTime(duration);
+          this.addToHistory(key);
+        } catch {
+          this.failedPrefetches++;
+        }
+        this.prefetchQueue.delete(key);
+      }
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  getSortedTasks() {
+    const tasks = Array.from(this.prefetchQueue.values());
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    return tasks.sort((a, b) => {
+      const priorityA = priorityOrder[a.config.priority || "medium"];
+      const priorityB = priorityOrder[b.config.priority || "medium"];
+      if (priorityA !== priorityB) return priorityA - priorityB;
+      if (a.predictionScore !== void 0 && b.predictionScore !== void 0) {
+        if (a.predictionScore !== b.predictionScore) {
+          return b.predictionScore - a.predictionScore;
+        }
+      }
+      return a.timestamp - b.timestamp;
+    });
+  }
+  async prefetchNow(queryKey, queryFn, config = {}) {
+    const key = this.getQueryKeyString(queryKey);
+    const startTime = Date.now();
+    try {
+      this.totalPrefetches++;
+      await this.queryClient.prefetchQuery({ queryKey, queryFn, staleTime: config.staleTime || chunk6MAYHLTE_cjs.DEFAULT_STALE_TIME });
+      this.successfulPrefetches++;
+      const duration = Date.now() - startTime;
+      this.recordPrefetchTime(duration);
+      this.addToHistory(key);
+    } catch (error) {
+      this.failedPrefetches++;
+      throw error;
+    }
+  }
+  addToHistory(key) {
+    this.prefetchHistory.add(key);
+    if (this.prefetchHistory.size > this.maxHistorySize) {
+      const firstKey = this.prefetchHistory.values().next().value;
+      if (firstKey) {
+        this.prefetchHistory.delete(firstKey);
+      }
+    }
+  }
+  clearHistory() {
+    this.prefetchHistory.clear();
+  }
+  clearQueue() {
+    this.prefetchQueue.clear();
+  }
+  reset() {
+    this.clearQueue();
+    this.clearHistory();
+    this.clearInteractionHistory();
+    this.resetStats();
+  }
+  destroy() {
+    if (this.networkCleanup) {
+      this.networkCleanup();
+      this.networkCleanup = void 0;
+    }
+    this.reset();
+  }
+  recordInteraction(queryKey, type = "view") {
+    const interaction = { queryKey, timestamp: Date.now(), type };
+    this.interactionHistory.push(interaction);
+    if (this.interactionHistory.length > this.maxInteractionHistorySize) {
+      this.interactionHistory.shift();
+    }
+    const key = this.getQueryKeyString(queryKey);
+    this.queryAccessCounts.set(key, (this.queryAccessCounts.get(key) || 0) + 1);
+    if (this.interactionHistory.length >= 2) {
+      const prevInteraction = this.interactionHistory[this.interactionHistory.length - 2];
+      const prevKey = this.getQueryKeyString(prevInteraction.queryKey);
+      const existingSequence = this.querySequences.find((s) => s.from === prevKey && s.to === key);
+      if (existingSequence) {
+        existingSequence.count++;
+      } else {
+        this.querySequences.push({ from: prevKey, to: key, count: 1 });
+        if (this.querySequences.length > this.maxSequenceSize) {
+          this.querySequences.shift();
+        }
+      }
+    }
+  }
+  getPredictions(currentQueryKey, limit = 5) {
+    const predictions = [];
+    if (currentQueryKey) {
+      const currentKey = this.getQueryKeyString(currentQueryKey);
+      const sequences = this.querySequences.filter((s) => s.from === currentKey).sort((a, b) => b.count - a.count).slice(0, limit);
+      sequences.forEach((seq) => {
+        try {
+          const queryKey = JSON.parse(seq.to);
+          predictions.push({ queryKey, score: Math.min(seq.count / 10, 1), reason: `Frequently accessed after current query (${seq.count} times)` });
+        } catch {
+        }
+      });
+    }
+    const frequentQueries = Array.from(this.queryAccessCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit);
+    frequentQueries.forEach(([key, count]) => {
+      try {
+        const queryKey = JSON.parse(key);
+        if (!predictions.some((p) => this.getQueryKeyString(p.queryKey) === key)) {
+          predictions.push({ queryKey, score: Math.min(count / 20, 1), reason: `Frequently accessed (${count} times)` });
+        }
+      } catch {
+      }
+    });
+    const recentInteractions = this.interactionHistory.slice(-10).reverse();
+    recentInteractions.forEach((interaction, index) => {
+      const key = this.getQueryKeyString(interaction.queryKey);
+      if (!predictions.some((p) => this.getQueryKeyString(p.queryKey) === key)) {
+        predictions.push({ queryKey: interaction.queryKey, score: Math.max(0.3 - index * 0.03, 0.1), reason: `Recently accessed (${index + 1} queries ago)` });
+      }
+    });
+    return predictions.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  async prefetchPredicted(currentQueryKey, queryFnMap, config = {}) {
+    const predictions = this.getPredictions(currentQueryKey);
+    for (const prediction of predictions) {
+      const key = this.getQueryKeyString(prediction.queryKey);
+      const queryFn = queryFnMap.get(key);
+      if (queryFn) {
+        const taskConfig = { ...config, priority: prediction.score > 0.7 ? "high" : prediction.score > 0.4 ? "medium" : "low" };
+        const added = this.addPrefetchTask(prediction.queryKey, queryFn, taskConfig);
+        if (added) {
+          const task = this.prefetchQueue.get(key);
+          if (task) {
+            task.predictionScore = prediction.score;
+          }
+        }
+      }
+    }
+  }
+  clearInteractionHistory() {
+    this.interactionHistory = [];
+    this.queryAccessCounts.clear();
+    this.querySequences = [];
+  }
+  recordPrefetchTime(duration) {
+    this.prefetchTimes.push(duration);
+    if (this.prefetchTimes.length > this.maxPrefetchTimesSize) {
+      this.prefetchTimes.shift();
+    }
+  }
+  getAveragePrefetchTime() {
+    if (this.prefetchTimes.length === 0) {
+      return 0;
+    }
+    const sum = this.prefetchTimes.reduce((acc, time) => acc + time, 0);
+    return Math.round(sum / this.prefetchTimes.length);
+  }
+  getStats() {
+    return { queueSize: this.prefetchQueue.size, historySize: this.prefetchHistory.size, networkSpeed: this.networkSpeed, isProcessing: this.isProcessing, totalPrefetches: this.totalPrefetches, successfulPrefetches: this.successfulPrefetches, failedPrefetches: this.failedPrefetches, averagePrefetchTime: this.getAveragePrefetchTime(), skippedPrefetches: this.skippedPrefetches };
+  }
+  getPerformanceReport() {
+    const stats = this.getStats();
+    const successRate = stats.totalPrefetches > 0 ? Math.round(stats.successfulPrefetches / stats.totalPrefetches * 100) : 0;
+    const queueTasks = Array.from(this.prefetchQueue.values());
+    const byPriority = { high: queueTasks.filter((t) => t.config.priority === "high").length, medium: queueTasks.filter((t) => t.config.priority === "medium").length, low: queueTasks.filter((t) => t.config.priority === "low").length };
+    return { stats, successRate, predictions: { totalInteractions: this.interactionHistory.length, uniqueQueries: this.queryAccessCounts.size, sequencePatterns: this.querySequences.length }, queue: { size: this.prefetchQueue.size, byPriority } };
+  }
+  resetStats() {
+    this.totalPrefetches = 0;
+    this.successfulPrefetches = 0;
+    this.failedPrefetches = 0;
+    this.skippedPrefetches = 0;
+    this.prefetchTimes = [];
+  }
+  getQueryKeyString(queryKey) {
+    return JSON.stringify(queryKey);
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  setMaxQueueSize(size) {
+    this.maxQueueSize = size;
+  }
+  setMaxHistorySize(size) {
+    this.maxHistorySize = size;
+  }
+  getQueuedTasks() {
+    return Array.from(this.prefetchQueue.values());
+  }
+  removeTask(queryKey) {
+    const key = this.getQueryKeyString(queryKey);
+    return this.prefetchQueue.delete(key);
+  }
+  hasTask(queryKey) {
+    const key = this.getQueryKeyString(queryKey);
+    return this.prefetchQueue.has(key);
+  }
+  updateTaskPriority(queryKey, priority) {
+    const key = this.getQueryKeyString(queryKey);
+    const task = this.prefetchQueue.get(key);
+    if (task) {
+      task.config.priority = priority;
+      return true;
+    }
+    return false;
+  }
+  pauseQueue() {
+    this.isProcessing = true;
+  }
+  resumeQueue() {
+    this.isProcessing = false;
+    this.processQueue();
+  }
+};
+var prefetchManagerInstance = null;
+function getPrefetchManager(queryClient) {
+  if (!prefetchManagerInstance) {
+    prefetchManagerInstance = new SmartPrefetchManager(queryClient);
+  }
+  return prefetchManagerInstance;
+}
+function resetPrefetchManager() {
+  prefetchManagerInstance = null;
+}
+
+// src/utils/selectors.ts
+function selectById(id) {
+  return (data) => {
+    return data?.find((item) => item.id === id);
+  };
+}
+function selectByIds(ids) {
+  return (data) => {
+    if (!data) return [];
+    return data.filter((item) => ids.includes(item.id));
+  };
+}
+function selectFirst(data) {
+  return data?.[0];
+}
+function selectLast(data) {
+  if (!data || data.length === 0) return void 0;
+  return data[data.length - 1];
+}
+function selectCount(data) {
+  return data?.length ?? 0;
+}
+function selectTotal(data) {
+  return data?.total ?? 0;
+}
+function selectItems(data) {
+  return data?.items ?? [];
+}
+function selectWhere(predicate) {
+  return (data) => {
+    if (!data) return [];
+    return data.filter(predicate);
+  };
+}
+function selectMap(mapper) {
+  return (data) => {
+    if (!data) return [];
+    return data.map(mapper);
+  };
+}
+function selectField(field) {
+  return (data) => {
+    return data?.[field];
+  };
+}
+function selectFields(fields) {
+  return (data) => {
+    if (!data) return void 0;
+    const result = {};
+    fields.forEach((field) => {
+      result[field] = data[field];
+    });
+    return result;
+  };
+}
+function compose(selector1, selector2) {
+  return (data) => {
+    return selector2(selector1(data));
+  };
+}
+var selectors = { byId: selectById, byIds: selectByIds, first: selectFirst, last: selectLast, count: selectCount, total: selectTotal, items: selectItems, where: selectWhere, map: selectMap, field: selectField, fields: selectFields, compose };
+
+// src/utils/queryClientUtils.ts
+function invalidateQueriesBatch(queryClient, tasks) {
+  tasks.forEach((task) => {
+    if (Array.isArray(task) || typeof task === "string") {
+      queryClient.invalidateQueries({ queryKey: task });
+    } else {
+      queryClient.invalidateQueries(task);
+    }
+  });
+}
+function cancelQueriesBatch(queryClient, tasks) {
+  tasks.forEach((task) => {
+    if (Array.isArray(task) || typeof task === "string") {
+      queryClient.cancelQueries({ queryKey: task });
+    } else {
+      queryClient.cancelQueries(task);
+    }
+  });
+}
+function setQueryDataBatch(queryClient, tasks) {
+  tasks.forEach((task) => queryClient.setQueryData(task.queryKey, task.data));
+}
+
+Object.defineProperty(exports, "keepPreviousData", {
+  enumerable: true,
+  get: function () { return reactQuery.keepPreviousData; }
+});
+exports.SmartPrefetchManager = SmartPrefetchManager;
+exports.batchRemoveItems = batchRemoveItems;
+exports.batchUpdateItems = batchUpdateItems;
+exports.cancelQueriesBatch = cancelQueriesBatch;
+exports.compose = compose;
+exports.conditionalUpdateItems = conditionalUpdateItems;
+exports.createAddItemConfig = createAddItemConfig;
+exports.createFieldEnricher = createFieldEnricher;
+exports.createListOperationConfig = createListOperationConfig;
+exports.createOptimisticBase = createOptimisticBase;
+exports.createRemoveItemConfig = createRemoveItemConfig;
+exports.createTempId = createTempId;
+exports.createUpdateItemConfig = createUpdateItemConfig;
+exports.getPrefetchManager = getPrefetchManager;
+exports.invalidateQueriesBatch = invalidateQueriesBatch;
+exports.listUpdater = listUpdater;
+exports.reorderItems = reorderItems;
+exports.resetPrefetchManager = resetPrefetchManager;
+exports.selectById = selectById;
+exports.selectByIds = selectByIds;
+exports.selectCount = selectCount;
+exports.selectField = selectField;
+exports.selectFields = selectFields;
+exports.selectFirst = selectFirst;
+exports.selectItems = selectItems;
+exports.selectLast = selectLast;
+exports.selectMap = selectMap;
+exports.selectTotal = selectTotal;
+exports.selectWhere = selectWhere;
+exports.selectors = selectors;
+exports.setQueryDataBatch = setQueryDataBatch;
+exports.stableListPlaceholder = stableListPlaceholder;
+//# sourceMappingURL=chunk-PCNSWVA5.cjs.map
+//# sourceMappingURL=chunk-PCNSWVA5.cjs.map