@qiaopeng/tanstack-query-plus 0.5.9 → 0.5.10

package/dist/utils/index.cjs

@@ -0,0 +1,234 @@
+'use strict';
+
+var chunkPCNSWVA5_cjs = require('../chunk-PCNSWVA5.cjs');
+require('../chunk-UVF5S6LX.cjs');
+var chunkWEIXCDCA_cjs = require('../chunk-WEIXCDCA.cjs');
+require('../chunk-5J6OXSLW.cjs');
+var chunkAPXNNHBD_cjs = require('../chunk-APXNNHBD.cjs');
+require('../chunk-6MAYHLTE.cjs');
+require('../chunk-OFLCHKKE.cjs');
+
+
+
+Object.defineProperty(exports, "SmartPrefetchManager", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.SmartPrefetchManager; }
+});
+Object.defineProperty(exports, "batchRemoveItems", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.batchRemoveItems; }
+});
+Object.defineProperty(exports, "batchUpdateItems", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.batchUpdateItems; }
+});
+Object.defineProperty(exports, "cancelQueriesBatch", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.cancelQueriesBatch; }
+});
+Object.defineProperty(exports, "compose", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.compose; }
+});
+Object.defineProperty(exports, "conditionalUpdateItems", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.conditionalUpdateItems; }
+});
+Object.defineProperty(exports, "createAddItemConfig", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.createAddItemConfig; }
+});
+Object.defineProperty(exports, "createFieldEnricher", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.createFieldEnricher; }
+});
+Object.defineProperty(exports, "createListOperationConfig", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.createListOperationConfig; }
+});
+Object.defineProperty(exports, "createOptimisticBase", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.createOptimisticBase; }
+});
+Object.defineProperty(exports, "createRemoveItemConfig", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.createRemoveItemConfig; }
+});
+Object.defineProperty(exports, "createTempId", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.createTempId; }
+});
+Object.defineProperty(exports, "createUpdateItemConfig", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.createUpdateItemConfig; }
+});
+Object.defineProperty(exports, "getPrefetchManager", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.getPrefetchManager; }
+});
+Object.defineProperty(exports, "invalidateQueriesBatch", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.invalidateQueriesBatch; }
+});
+Object.defineProperty(exports, "keepPreviousData", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.keepPreviousData; }
+});
+Object.defineProperty(exports, "listUpdater", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.listUpdater; }
+});
+Object.defineProperty(exports, "reorderItems", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.reorderItems; }
+});
+Object.defineProperty(exports, "resetPrefetchManager", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.resetPrefetchManager; }
+});
+Object.defineProperty(exports, "selectById", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectById; }
+});
+Object.defineProperty(exports, "selectByIds", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectByIds; }
+});
+Object.defineProperty(exports, "selectCount", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectCount; }
+});
+Object.defineProperty(exports, "selectField", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectField; }
+});
+Object.defineProperty(exports, "selectFields", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectFields; }
+});
+Object.defineProperty(exports, "selectFirst", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectFirst; }
+});
+Object.defineProperty(exports, "selectItems", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectItems; }
+});
+Object.defineProperty(exports, "selectLast", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectLast; }
+});
+Object.defineProperty(exports, "selectMap", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectMap; }
+});
+Object.defineProperty(exports, "selectTotal", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectTotal; }
+});
+Object.defineProperty(exports, "selectWhere", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectWhere; }
+});
+Object.defineProperty(exports, "selectors", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.selectors; }
+});
+Object.defineProperty(exports, "setQueryDataBatch", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.setQueryDataBatch; }
+});
+Object.defineProperty(exports, "stableListPlaceholder", {
+  enumerable: true,
+  get: function () { return chunkPCNSWVA5_cjs.stableListPlaceholder; }
+});
+Object.defineProperty(exports, "deepClone", {
+  enumerable: true,
+  get: function () { return chunkWEIXCDCA_cjs.deepClone; }
+});
+Object.defineProperty(exports, "formatBytes", {
+  enumerable: true,
+  get: function () { return chunkWEIXCDCA_cjs.formatBytes; }
+});
+Object.defineProperty(exports, "getStorageUsage", {
+  enumerable: true,
+  get: function () { return chunkWEIXCDCA_cjs.getStorageUsage; }
+});
+Object.defineProperty(exports, "isStorageAvailable", {
+  enumerable: true,
+  get: function () { return chunkWEIXCDCA_cjs.isStorageAvailable; }
+});
+Object.defineProperty(exports, "addHashToData", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.addHashToData; }
+});
+Object.defineProperty(exports, "applyDataGuard", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.applyDataGuard; }
+});
+Object.defineProperty(exports, "clearRecentlyUpdated", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.clearRecentlyUpdated; }
+});
+Object.defineProperty(exports, "createQueryKeyFactory", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.createQueryKeyFactory; }
+});
+Object.defineProperty(exports, "createSimpleQueryKeyFactory", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.createSimpleQueryKeyFactory; }
+});
+Object.defineProperty(exports, "deriveFamilyKey", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.deriveFamilyKey; }
+});
+Object.defineProperty(exports, "extractParamsFromKey", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.extractParamsFromKey; }
+});
+Object.defineProperty(exports, "getNetworkInfo", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.getNetworkInfo; }
+});
+Object.defineProperty(exports, "getNetworkSpeed", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.getNetworkSpeed; }
+});
+Object.defineProperty(exports, "hashObject", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.hashObject; }
+});
+Object.defineProperty(exports, "isFastNetwork", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.isFastNetwork; }
+});
+Object.defineProperty(exports, "isListFamilyKey", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.isListFamilyKey; }
+});
+Object.defineProperty(exports, "isQueryKeyEqual", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.isQueryKeyEqual; }
+});
+Object.defineProperty(exports, "isSlowNetwork", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.isSlowNetwork; }
+});
+Object.defineProperty(exports, "markRecentlyUpdated", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.markRecentlyUpdated; }
+});
+Object.defineProperty(exports, "normalizeQueryParams", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.normalizeQueryParams; }
+});
+Object.defineProperty(exports, "startsWithKeyPrefix", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.startsWithKeyPrefix; }
+});
+Object.defineProperty(exports, "updateFamilyMetadata", {
+  enumerable: true,
+  get: function () { return chunkAPXNNHBD_cjs.updateFamilyMetadata; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/utils/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/utils/index.d.cts

@@ -0,0 +1,272 @@
+import { QueryClient, QueryKey, QueryFunction } from '@tanstack/react-query';
+export { keepPreviousData } from '@tanstack/react-query';
+import { N as NetworkInformation, S as StorageType } from '../base-CHnwqfyz.cjs';
+import { s as EntityWithId, O as OptimisticUpdateConfig, g as ListOperationType, L as ListOperationConfig, P as PaginatedData, q as StorageInfo, V as VersionedEntity, a as VersionedPaginatedResponse, c as DataGuardOptions, D as DataGuardStrategy } from '../persistence-MRtkmhqq.cjs';
+
+interface FieldMappingConfig {
+    nameField: string;
+    configKey: string;
+}
+declare function createFieldEnricher<T = any>(queryKey: any, mappings: Record<string, FieldMappingConfig>): (data: T, queryClient: QueryClient) => T;
+declare function createTempId(prefix?: string): string;
+declare function createOptimisticBase(customFields?: Record<string, any>): Record<string, any>;
+
+interface NavigatorWithConnection extends Navigator {
+    connection?: NetworkInformation;
+}
+declare function isSlowNetwork(): boolean;
+declare function getNetworkInfo(): NetworkInformation | null;
+declare function isFastNetwork(): boolean;
+declare function getNetworkSpeed(): "fast" | "medium" | "slow" | "unknown";
+
+declare const listUpdater: {
+    add: <T extends EntityWithId>(items: T[] | undefined, newItem: T) => T[];
+    update: <T extends EntityWithId>(items: T[] | undefined, updatedItem: Partial<T> & {
+        id: T["id"];
+    }) => T[];
+    remove: <T extends EntityWithId>(items: T[] | undefined, itemId: T["id"]) => T[];
+};
+declare function createAddItemConfig<T extends EntityWithId>(queryKey: QueryKey, options?: {
+    addToTop?: boolean;
+    onRollback?: (error: Error) => void;
+}): OptimisticUpdateConfig<T[], T>;
+declare function createUpdateItemConfig<T extends EntityWithId>(queryKey: QueryKey, options?: {
+    onRollback?: (error: Error) => void;
+}): OptimisticUpdateConfig<T[], Partial<T> & {
+    id: T["id"];
+}>;
+declare function createRemoveItemConfig<T extends EntityWithId>(queryKey: QueryKey, options?: {
+    onRollback?: (error: Error) => void;
+}): OptimisticUpdateConfig<T[], T["id"]>;
+type ListOperationVariables<T extends EntityWithId, TOperation extends ListOperationType> = TOperation extends ListOperationType.ADD ? T : TOperation extends ListOperationType.UPDATE ? Partial<T> & {
+    id: T["id"];
+} : TOperation extends ListOperationType.REMOVE ? T["id"] : never;
+declare function createListOperationConfig<T extends EntityWithId, TOperation extends ListOperationType = ListOperationType>(config: ListOperationConfig<T>): OptimisticUpdateConfig<T[], ListOperationVariables<T, TOperation>>;
+declare function batchUpdateItems<T extends EntityWithId>(items: T[] | undefined | null, updates: Array<Partial<T> & {
+    id: T["id"];
+}>): T[];
+declare function batchRemoveItems<T extends EntityWithId>(items: T[] | undefined | null, itemIds: Array<T["id"]>): T[];
+declare function reorderItems<T extends EntityWithId>(items: T[] | undefined | null, fromIndex: number, toIndex: number): T[];
+declare function conditionalUpdateItems<T extends EntityWithId>(items: T[] | undefined | null, predicate: (item: T) => boolean, updater: (item: T) => Partial<T>): T[];
+
+declare function stableListPlaceholder<T = any>(previousData: T | undefined): T | undefined;
+
+interface PrefetchConfig {
+    priority?: "high" | "medium" | "low";
+    delay?: number;
+    staleTime?: number;
+    allowSlowNetwork?: boolean;
+}
+interface PrefetchTask {
+    queryKey: QueryKey;
+    queryFn: QueryFunction<any>;
+    config: PrefetchConfig;
+    timestamp: number;
+    id: string;
+    predictionScore?: number;
+}
+type NetworkSpeed = "slow" | "medium" | "fast" | "unknown";
+interface PrefetchStats {
+    queueSize: number;
+    historySize: number;
+    networkSpeed: NetworkSpeed;
+    isProcessing: boolean;
+    totalPrefetches: number;
+    successfulPrefetches: number;
+    failedPrefetches: number;
+    averagePrefetchTime: number;
+    skippedPrefetches: number;
+}
+interface InteractionRecord {
+    queryKey: QueryKey;
+    timestamp: number;
+    type: "view" | "hover" | "click" | "focus";
+}
+interface PredictionResult {
+    queryKey: QueryKey;
+    score: number;
+    reason: string;
+}
+declare class SmartPrefetchManager {
+    private queryClient;
+    private prefetchQueue;
+    private prefetchHistory;
+    private networkSpeed;
+    private isProcessing;
+    private maxQueueSize;
+    private maxHistorySize;
+    private totalPrefetches;
+    private successfulPrefetches;
+    private failedPrefetches;
+    private skippedPrefetches;
+    private prefetchTimes;
+    private maxPrefetchTimesSize;
+    private interactionHistory;
+    private maxInteractionHistorySize;
+    private queryAccessCounts;
+    private querySequences;
+    private maxSequenceSize;
+    private networkCleanup?;
+    constructor(queryClient: QueryClient);
+    private initNetworkMonitoring;
+    private updateNetworkSpeed;
+    getNetworkSpeed(): NetworkSpeed;
+    isSlowNetwork(): boolean;
+    shouldPrefetch(queryKey: QueryKey, config?: PrefetchConfig): boolean;
+    addPrefetchTask(queryKey: QueryKey, queryFn: QueryFunction<any>, config?: PrefetchConfig): boolean;
+    private processQueue;
+    private getSortedTasks;
+    prefetchNow<TData = unknown>(queryKey: QueryKey, queryFn: QueryFunction<TData>, config?: PrefetchConfig): Promise<void>;
+    private addToHistory;
+    clearHistory(): void;
+    clearQueue(): void;
+    reset(): void;
+    destroy(): void;
+    recordInteraction(queryKey: QueryKey, type?: "view" | "hover" | "click" | "focus"): void;
+    getPredictions(currentQueryKey?: QueryKey, limit?: number): PredictionResult[];
+    prefetchPredicted(currentQueryKey: QueryKey | undefined, queryFnMap: Map<string, QueryFunction<any>>, config?: PrefetchConfig): Promise<void>;
+    clearInteractionHistory(): void;
+    private recordPrefetchTime;
+    private getAveragePrefetchTime;
+    getStats(): PrefetchStats;
+    getPerformanceReport(): {
+        stats: PrefetchStats;
+        successRate: number;
+        predictions: {
+            totalInteractions: number;
+            uniqueQueries: number;
+            sequencePatterns: number;
+        };
+        queue: {
+            size: number;
+            byPriority: {
+                high: number;
+                medium: number;
+                low: number;
+            };
+        };
+    };
+    resetStats(): void;
+    private getQueryKeyString;
+    private delay;
+    setMaxQueueSize(size: number): void;
+    setMaxHistorySize(size: number): void;
+    getQueuedTasks(): PrefetchTask[];
+    removeTask(queryKey: QueryKey): boolean;
+    hasTask(queryKey: QueryKey): boolean;
+    updateTaskPriority(queryKey: QueryKey, priority: "high" | "medium" | "low"): boolean;
+    pauseQueue(): void;
+    resumeQueue(): void;
+}
+declare function getPrefetchManager(queryClient: QueryClient): SmartPrefetchManager;
+declare function resetPrefetchManager(): void;
+
+interface NormalizeConfig<T = any> {
+    required?: (keyof T)[];
+    defaults?: Partial<T>;
+    sortKeys?: boolean;
+    removeEmpty?: boolean;
+}
+declare function normalizeQueryParams<T extends Record<string, any>>(params: T | undefined, config?: NormalizeConfig<T>): Record<string, any>;
+interface QueryKeyFactoryConfig<TParams = any> {
+    namespace: string;
+    normalizeConfig?: NormalizeConfig<TParams>;
+}
+interface QueryKeyFactory<TParams = any> {
+    all: () => readonly [string];
+    lists: () => readonly [string, string];
+    list: (params?: TParams) => readonly [string, string, Record<string, any>];
+    details: () => readonly [string, string];
+    detail: (id: string) => readonly [string, string, string];
+    custom: (queryName: string, params?: any) => readonly [string, string, string, any?];
+}
+declare function createQueryKeyFactory<TParams = any>(config: QueryKeyFactoryConfig<TParams>): QueryKeyFactory<TParams>;
+declare function createSimpleQueryKeyFactory(namespace: string): QueryKeyFactory;
+declare function isQueryKeyEqual(key1: readonly any[], key2: readonly any[]): boolean;
+declare function extractParamsFromKey(queryKey: readonly any[]): Record<string, any> | undefined;
+declare function startsWithKeyPrefix(key: QueryKey, prefix: QueryKey): boolean;
+declare function deriveFamilyKey(queryKey: QueryKey): QueryKey;
+declare function isListFamilyKey(queryKey: QueryKey): boolean;
+
+declare function selectById<T extends EntityWithId>(id: T["id"]): (data: T[] | undefined) => T | undefined;
+declare function selectByIds<T extends EntityWithId>(ids: T["id"][]): (data: T[] | undefined) => T[];
+declare function selectFirst<T>(data: T[] | undefined): T | undefined;
+declare function selectLast<T>(data: T[] | undefined): T | undefined;
+declare function selectCount<T>(data: T[] | undefined): number;
+declare function selectTotal<T extends {
+    total?: number;
+}>(data: T | undefined): number;
+declare function selectItems<TItem, T extends PaginatedData<TItem>>(data: T | undefined): TItem[];
+declare function selectWhere<T>(predicate: (item: T) => boolean): (data: T[] | undefined) => T[];
+declare function selectMap<T, R>(mapper: (item: T) => R): (data: T[] | undefined) => R[];
+declare function selectField<T, K extends keyof T>(field: K): (data: T | undefined) => T[K] | undefined;
+declare function selectFields<T, K extends keyof T>(fields: K[]): (data: T | undefined) => Pick<T, K> | undefined;
+declare function compose<T, R1, R2>(selector1: (data: T) => R1, selector2: (data: R1) => R2): (data: T) => R2;
+declare const selectors: {
+    byId: typeof selectById;
+    byIds: typeof selectByIds;
+    first: typeof selectFirst;
+    last: typeof selectLast;
+    count: typeof selectCount;
+    total: typeof selectTotal;
+    items: typeof selectItems;
+    where: typeof selectWhere;
+    map: typeof selectMap;
+    field: typeof selectField;
+    fields: typeof selectFields;
+    compose: typeof compose;
+};
+
+declare function isStorageAvailable(storageType: StorageType): boolean;
+declare function getStorageUsage(storageType: StorageType): StorageInfo;
+declare function formatBytes(bytes: number): string;
+declare function deepClone<T>(obj: T): T;
+
+/**
+ * 计算对象的哈希值（键排序后计算，确保一致性）
+ */
+declare function hashObject(obj: any): string;
+/**
+ * 自适应数据防护：根据数据特征自动选择最佳防护策略
+ *
+ * 策略优先级：
+ * 1. version（版本号）- 最可靠
+ * 2. updatedAt（时间戳）- 次优
+ * 3. hash（内容哈希）- 兜底
+ */
+declare function applyDataGuard<T extends VersionedEntity>(newData: VersionedPaginatedResponse<T>, cached: VersionedPaginatedResponse<T> | undefined, queryKey: QueryKey, options?: DataGuardOptions): {
+    shouldReject: boolean;
+    reason: string;
+    strategy: DataGuardStrategy;
+    guardDetails: any;
+};
+/**
+ * 为查询数据添加哈希标记
+ */
+declare function addHashToData<T extends VersionedEntity>(data: VersionedPaginatedResponse<T>): VersionedPaginatedResponse<T>;
+/**
+ * 标记最近更新的项
+ */
+declare function markRecentlyUpdated<T extends VersionedEntity>(data: VersionedPaginatedResponse<T>, updatedId: string | number): VersionedPaginatedResponse<T>;
+/**
+ * 清理最近更新的标记
+ */
+declare function clearRecentlyUpdated<T extends VersionedEntity>(data: VersionedPaginatedResponse<T>, updatedId: string | number): VersionedPaginatedResponse<T>;
+/**
+ * 更新所有家族缓存的元数据（版本号、时间戳、哈希）
+ */
+declare function updateFamilyMetadata<T extends VersionedEntity>(queryClient: QueryClient, familyKey: QueryKey, response: Partial<VersionedPaginatedResponse<T>>): void;
+
+interface BatchTask {
+    queryKey: QueryKey;
+    data?: any;
+    exact?: boolean;
+}
+declare function invalidateQueriesBatch(queryClient: QueryClient, tasks: BatchTask[] | QueryKey[]): void;
+declare function cancelQueriesBatch(queryClient: QueryClient, tasks: BatchTask[] | QueryKey[]): void;
+declare function setQueryDataBatch(queryClient: QueryClient, tasks: {
+    queryKey: QueryKey;
+    data: any;
+}[]): void;
+
+export { type BatchTask, type FieldMappingConfig, type InteractionRecord, type ListOperationVariables, type NavigatorWithConnection, type NetworkSpeed, type NormalizeConfig, type PredictionResult, type PrefetchConfig, type PrefetchStats, type PrefetchTask, type QueryKeyFactory, type QueryKeyFactoryConfig, SmartPrefetchManager, addHashToData, applyDataGuard, batchRemoveItems, batchUpdateItems, cancelQueriesBatch, clearRecentlyUpdated, compose, conditionalUpdateItems, createAddItemConfig, createFieldEnricher, createListOperationConfig, createOptimisticBase, createQueryKeyFactory, createRemoveItemConfig, createSimpleQueryKeyFactory, createTempId, createUpdateItemConfig, deepClone, deriveFamilyKey, extractParamsFromKey, formatBytes, getNetworkInfo, getNetworkSpeed, getPrefetchManager, getStorageUsage, hashObject, invalidateQueriesBatch, isFastNetwork, isListFamilyKey, isQueryKeyEqual, isSlowNetwork, isStorageAvailable, listUpdater, markRecentlyUpdated, normalizeQueryParams, reorderItems, resetPrefetchManager, selectById, selectByIds, selectCount, selectField, selectFields, selectFirst, selectItems, selectLast, selectMap, selectTotal, selectWhere, selectors, setQueryDataBatch, stableListPlaceholder, startsWithKeyPrefix, updateFamilyMetadata };