tsdf 17.0.0-alpha.17 → 17.0.0-alpha.19
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/async-storage.d.ts +1 -1
- package/dist/{asyncStorageAdapter-DgbL6kBV.d.ts → asyncStorageAdapter-CMohMeKm.d.ts} +1 -1
- package/dist/{asyncStorageAdapters-xME9-DVC.js → asyncStorageAdapters-BpfM2_Y6.js} +1 -1
- package/dist/indexed-db-storage.d.ts +1 -1
- package/dist/indexed-db-storage.js +1 -1
- package/dist/{indexedDbPersistentStorage-BlhAkfaB.js → indexedDbPersistentStorage-DC9GsYHH.js} +1 -4
- package/dist/main.d.ts +1 -236
- package/dist/main.js +379 -139
- package/dist/opfs-storage.d.ts +1 -1
- package/dist/{opfsPersistentStorage-Brc4BAn4.d.ts → opfsPersistentStorage-Ci0JcCo5.d.ts} +1 -1
- package/dist/{types-CtltNSyd.d.ts → types-D0ttVGmj.d.ts} +256 -1
- package/docs/offset-pagination.md +1 -4
- package/docs/partial-resources.md +26 -1
- package/package.json +1 -1
package/dist/main.js
CHANGED
|
@@ -866,7 +866,7 @@ const persistedCollectionItemDataSchema = rc_object({
|
|
|
866
866
|
const persistedListQueryItemDataSchema = rc_object({
|
|
867
867
|
data: rc_unknown,
|
|
868
868
|
payload: rc_unknown,
|
|
869
|
-
loadedFields: rc_array(rc_string).optional()
|
|
869
|
+
loadedFields: rc_union(rc_array(rc_string), rc_literals("*")).optional()
|
|
870
870
|
});
|
|
871
871
|
const persistedListQueryDataSchema = rc_object({
|
|
872
872
|
payload: rc_unknown,
|
|
@@ -2176,7 +2176,7 @@ async function clearSessionStorage(sessionKey, adapter) {
|
|
|
2176
2176
|
}
|
|
2177
2177
|
/** Clears all persistent storage entries for a given session key across built-in adapters. */
|
|
2178
2178
|
async function clearAllSessionStorage(sessionKey) {
|
|
2179
|
-
const { indexedDbPersistentStorage, opfsPersistentStorage } = await import("./asyncStorageAdapters-
|
|
2179
|
+
const { indexedDbPersistentStorage, opfsPersistentStorage } = await import("./asyncStorageAdapters-BpfM2_Y6.js");
|
|
2180
2180
|
await Promise.all([
|
|
2181
2181
|
clearSessionStorage(sessionKey, "local-sync"),
|
|
2182
2182
|
clearSessionStorage(sessionKey, opfsPersistentStorage),
|
|
@@ -10194,7 +10194,7 @@ function toItemState(persisted, dataSchema, shouldIgnoreItem) {
|
|
|
10194
10194
|
const validated = parsePersistedStoreData(persisted.data, dataSchema);
|
|
10195
10195
|
if (validated === null) return null;
|
|
10196
10196
|
if (shouldIgnoreItem(persisted.payload)) return null;
|
|
10197
|
-
const loadedFields = Array.isArray(persisted.loadedFields) ? Array.from(new Set(persisted.loadedFields)).sort() :
|
|
10197
|
+
const loadedFields = persisted.loadedFields === "*" ? "*" : Array.isArray(persisted.loadedFields) ? Array.from(new Set(persisted.loadedFields)).sort() : void 0;
|
|
10198
10198
|
return {
|
|
10199
10199
|
item: validated,
|
|
10200
10200
|
itemQuery: {
|
|
@@ -10249,7 +10249,7 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
10249
10249
|
deserialize: (value, metadata) => typeof value === "object" && value !== null && "d" in value && ("p" in value || metadata?.p !== void 0) ? parsePersistedListQueryItemData({
|
|
10250
10250
|
data: value.d,
|
|
10251
10251
|
payload: "p" in value ? value.p : metadata?.p,
|
|
10252
|
-
..."lf" in value && Array.isArray(value.lf) ? { loadedFields: value.lf } : {}
|
|
10252
|
+
..."lf" in value && (Array.isArray(value.lf) || value.lf === "*") ? { loadedFields: value.lf } : {}
|
|
10253
10253
|
}, config.itemPayloadSchema, dataSchema) : null
|
|
10254
10254
|
};
|
|
10255
10255
|
const asyncItemStorageValueCodec = {
|
|
@@ -10257,7 +10257,7 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
10257
10257
|
deserialize: (value, metadata) => metadata?.p !== void 0 ? parsePersistedListQueryItemData({
|
|
10258
10258
|
data: value,
|
|
10259
10259
|
payload: metadata.p,
|
|
10260
|
-
...
|
|
10260
|
+
...metadata.f !== void 0 ? { loadedFields: metadata.f } : {}
|
|
10261
10261
|
}, config.itemPayloadSchema, dataSchema) : null
|
|
10262
10262
|
};
|
|
10263
10263
|
const queryStorageValueCodec = {
|
|
@@ -10285,7 +10285,7 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
10285
10285
|
}, {
|
|
10286
10286
|
asyncValueCodec: asyncItemStorageValueCodec,
|
|
10287
10287
|
getManifestMeta: (data) => ({
|
|
10288
|
-
...
|
|
10288
|
+
...data.loadedFields !== void 0 ? { f: data.loadedFields } : {},
|
|
10289
10289
|
p: data.payload
|
|
10290
10290
|
}),
|
|
10291
10291
|
valueCodec: itemStorageValueCodec
|
|
@@ -10390,6 +10390,8 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
10390
10390
|
const querySizeBytesByKey = /* @__PURE__ */ new Map();
|
|
10391
10391
|
const hydratedPersistedItemKeys = /* @__PURE__ */ new Set();
|
|
10392
10392
|
const hydratedPersistedQueryKeys = /* @__PURE__ */ new Set();
|
|
10393
|
+
const budgetEvictedItemRecency = /* @__PURE__ */ new Map();
|
|
10394
|
+
const budgetEvictedQueryRecency = /* @__PURE__ */ new Map();
|
|
10393
10395
|
const syncHydrationItemMissCache = createTimedKeySet();
|
|
10394
10396
|
const syncHydrationQueryMissCache = createTimedKeySet();
|
|
10395
10397
|
let knownPersistedItemKeys = null;
|
|
@@ -10707,13 +10709,42 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
10707
10709
|
querySizeBytesByKey.delete(queryKey);
|
|
10708
10710
|
knownPersistedQueryKeys?.delete(queryKey);
|
|
10709
10711
|
}
|
|
10712
|
+
/**
|
|
10713
|
+
* Resolves the recency an in-state entry without persisted metadata should
|
|
10714
|
+
* compete with in the byte budget. Previously budget-evicted entries keep
|
|
10715
|
+
* their remembered (stale) recency while their content is unchanged, so they
|
|
10716
|
+
* deterministically lose again instead of churning back into storage; a
|
|
10717
|
+
* changed snapshot means the entry was genuinely refetched and counts as
|
|
10718
|
+
* freshly accessed.
|
|
10719
|
+
*/
|
|
10720
|
+
function getBudgetEvictedLastAccessAt(memory, key, value, fallback) {
|
|
10721
|
+
const remembered = memory.get(key);
|
|
10722
|
+
if (remembered === void 0) return fallback;
|
|
10723
|
+
if (remembered.snapshot !== JSON.stringify(value)) {
|
|
10724
|
+
memory.delete(key);
|
|
10725
|
+
return fallback;
|
|
10726
|
+
}
|
|
10727
|
+
return remembered.lastAccessAt;
|
|
10728
|
+
}
|
|
10729
|
+
/**
|
|
10730
|
+
* Remembers an entry evicted by the byte budget while it is still in state,
|
|
10731
|
+
* so later flushes don't re-persist it as if it were freshly accessed (see
|
|
10732
|
+
* budgetEvictedQueryRecency / budgetEvictedItemRecency).
|
|
10733
|
+
*/
|
|
10734
|
+
function rememberBudgetEvictedEntry(memory, key, lastAccessAt, snapshot, isInState) {
|
|
10735
|
+
if (!isInState || snapshot === void 0) return;
|
|
10736
|
+
memory.set(key, {
|
|
10737
|
+
lastAccessAt,
|
|
10738
|
+
snapshot
|
|
10739
|
+
});
|
|
10740
|
+
}
|
|
10710
10741
|
function materializeHydratedItemState(itemKey, itemState) {
|
|
10711
10742
|
if (!storeRef) return;
|
|
10712
10743
|
suppressedPersistedStateFlushes++;
|
|
10713
10744
|
storeRef.produceState((draft) => {
|
|
10714
10745
|
draft.items[itemKey] = itemState.item;
|
|
10715
10746
|
draft.itemQueries[itemKey] = itemState.itemQuery;
|
|
10716
|
-
draft.itemLoadedFields[itemKey] = itemState.loadedFields;
|
|
10747
|
+
if (itemState.loadedFields !== void 0) draft.itemLoadedFields[itemKey] = itemState.loadedFields;
|
|
10717
10748
|
});
|
|
10718
10749
|
}
|
|
10719
10750
|
function materializeHydratedQueryState(queryKey, query) {
|
|
@@ -10930,8 +10961,7 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
10930
10961
|
if (!storeRef) return false;
|
|
10931
10962
|
const existingItemQuery = storeRef.state.itemQueries[itemKey];
|
|
10932
10963
|
const existingItem = storeRef.state.items[itemKey];
|
|
10933
|
-
|
|
10934
|
-
if (existingItemQuery !== void 0 && existingItem !== void 0 && existingLoadedFields !== void 0) return existingItemQuery !== null;
|
|
10964
|
+
if (existingItemQuery !== void 0 && existingItem !== void 0) return existingItemQuery !== null;
|
|
10935
10965
|
if (existingItemQuery === null) return false;
|
|
10936
10966
|
if (localStorageAdapter !== null) {
|
|
10937
10967
|
const itemState = readHydratedItem(itemKey);
|
|
@@ -10956,8 +10986,7 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
10956
10986
|
for (const itemKey of [...new Set(itemKeys)]) {
|
|
10957
10987
|
const existingItemQuery = storeRef.state.itemQueries[itemKey];
|
|
10958
10988
|
const existingItem = storeRef.state.items[itemKey];
|
|
10959
|
-
|
|
10960
|
-
if (existingItemQuery !== void 0 && existingItem !== void 0 && existingLoadedFields !== void 0) {
|
|
10989
|
+
if (existingItemQuery !== void 0 && existingItem !== void 0) {
|
|
10961
10990
|
resultsByKey.set(itemKey, Promise.resolve(existingItemQuery !== null));
|
|
10962
10991
|
continue;
|
|
10963
10992
|
}
|
|
@@ -11128,7 +11157,10 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11128
11157
|
const { keptKeys: keptQueryKeys, unprotectedBytes } = keepEntriesWithinByteBudget(filteredEntries, (entry) => entry.queryKey, (entry) => entry.lastAccessAt, (entry) => entry.sizeBytes, (entry) => pinnedQueryKeys.has(entry.queryKey), (entry) => entry.offlineProtected, maxQueryBytes);
|
|
11129
11158
|
logQueryByteBudgetCleanup("maintenance", filteredEntries.length, keptQueryKeys, unprotectedBytes);
|
|
11130
11159
|
await Promise.all(filteredEntries.filter(({ queryKey }) => !keptQueryKeys.has(queryKey)).map(({ queryKey }) => removeLocalStorageQueryEntry(queryKey)));
|
|
11131
|
-
for (const { queryKey } of filteredEntries) if (!keptQueryKeys.has(queryKey))
|
|
11160
|
+
for (const { queryKey, lastAccessAt } of filteredEntries) if (!keptQueryKeys.has(queryKey)) {
|
|
11161
|
+
rememberBudgetEvictedEntry(budgetEvictedQueryRecency, queryKey, lastAccessAt, querySnapshotByKey.get(queryKey), storeRef !== null && Object.hasOwn(storeRef.state.queries, queryKey));
|
|
11162
|
+
forgetPersistedQuery(queryKey);
|
|
11163
|
+
}
|
|
11132
11164
|
knownPersistedQueryKeys = keptQueryKeys;
|
|
11133
11165
|
return {
|
|
11134
11166
|
keptQueryKeys,
|
|
@@ -11155,7 +11187,10 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11155
11187
|
await Promise.all(validEntries.filter(({ queryKey }) => !keptQueryKeys.has(queryKey)).map(({ queryKey }) => queryNamespace.remove(queryKey)));
|
|
11156
11188
|
for (const entry of validEntries) {
|
|
11157
11189
|
const { queryKey } = entry;
|
|
11158
|
-
if (!keptQueryKeys.has(queryKey))
|
|
11190
|
+
if (!keptQueryKeys.has(queryKey)) {
|
|
11191
|
+
rememberBudgetEvictedEntry(budgetEvictedQueryRecency, queryKey, entry.lastAccessAt, querySnapshotByKey.get(queryKey), storeRef !== null && Object.hasOwn(storeRef.state.queries, queryKey));
|
|
11192
|
+
forgetPersistedQuery(queryKey);
|
|
11193
|
+
}
|
|
11159
11194
|
}
|
|
11160
11195
|
knownPersistedQueryKeys = keptQueryKeys;
|
|
11161
11196
|
return {
|
|
@@ -11197,7 +11232,10 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11197
11232
|
evictedItemKeys.add(itemKey);
|
|
11198
11233
|
return itemNamespace.remove(itemKey);
|
|
11199
11234
|
}));
|
|
11200
|
-
for (const { itemKey } of persistedItemEntries) if (!keptItemKeys.has(itemKey))
|
|
11235
|
+
for (const { itemKey, lastAccessAt } of persistedItemEntries) if (!keptItemKeys.has(itemKey)) {
|
|
11236
|
+
rememberBudgetEvictedEntry(budgetEvictedItemRecency, itemKey, lastAccessAt, itemSnapshotByKey.get(itemKey), storeRef !== null && storeRef.state.items[itemKey] != null);
|
|
11237
|
+
forgetPersistedItem(itemKey);
|
|
11238
|
+
}
|
|
11201
11239
|
knownPersistedItemKeys = keptItemKeys;
|
|
11202
11240
|
if (evictedItemKeys.size === 0 || keptQueryKeys.size === 0) return;
|
|
11203
11241
|
const queryEntries = managedQueryEntriesByKey ? [...managedQueryEntriesByKey.values()].filter(({ queryKey }) => keptQueryKeys.has(queryKey)) : filterAndMap([...keptQueryKeys], (queryKey) => {
|
|
@@ -11244,7 +11282,10 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11244
11282
|
const { keptKeys: keptItemKeys, unprotectedBytes } = keepEntriesWithinByteBudget(persistedItemEntries, (entry) => entry.itemKey, (entry) => entry.lastAccessAt, (entry) => entry.sizeBytes, (entry) => pinnedItemKeys.has(entry.itemKey), (entry) => protectedItemKeys.has(entry.itemKey), maxItemBytes);
|
|
11245
11283
|
logItemByteBudgetCleanup("maintenance", persistedItemEntries.length, keptItemKeys, unprotectedBytes);
|
|
11246
11284
|
await Promise.all(persistedItemEntries.filter(({ itemKey }) => !keptItemKeys.has(itemKey)).map(({ itemKey }) => itemNamespace.remove(itemKey)));
|
|
11247
|
-
for (const { itemKey } of persistedItemEntries) if (!keptItemKeys.has(itemKey))
|
|
11285
|
+
for (const { itemKey, lastAccessAt } of persistedItemEntries) if (!keptItemKeys.has(itemKey)) {
|
|
11286
|
+
rememberBudgetEvictedEntry(budgetEvictedItemRecency, itemKey, lastAccessAt, itemSnapshotByKey.get(itemKey), storeRef !== null && storeRef.state.items[itemKey] != null);
|
|
11287
|
+
forgetPersistedItem(itemKey);
|
|
11288
|
+
}
|
|
11248
11289
|
knownPersistedItemKeys = keptItemKeys;
|
|
11249
11290
|
}
|
|
11250
11291
|
async function flushPersistedState() {
|
|
@@ -11313,13 +11354,20 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11313
11354
|
}
|
|
11314
11355
|
const limitedQuery = limitPersistedQueryItems(queryItemsToPersist, query.hasMore, maxQuerySize);
|
|
11315
11356
|
for (const itemKey of limitedQuery.itemKeys) persistedQueryItemKeys.add(itemKey);
|
|
11316
|
-
nextQueryKeys.add(queryKey);
|
|
11317
11357
|
const nextValue = {
|
|
11318
11358
|
payload: query.payload,
|
|
11319
11359
|
items: limitedQuery.itemKeys,
|
|
11320
11360
|
hasMore: limitedQuery.hasMore
|
|
11321
11361
|
};
|
|
11322
11362
|
const nextSnapshot = JSON.stringify(nextValue);
|
|
11363
|
+
if (!previousKnownLocalQueryKeys.has(queryKey)) {
|
|
11364
|
+
const evictedRecency = budgetEvictedQueryRecency.get(queryKey);
|
|
11365
|
+
if (evictedRecency !== void 0) {
|
|
11366
|
+
if (evictedRecency.snapshot === nextSnapshot) continue;
|
|
11367
|
+
budgetEvictedQueryRecency.delete(queryKey);
|
|
11368
|
+
}
|
|
11369
|
+
}
|
|
11370
|
+
nextQueryKeys.add(queryKey);
|
|
11323
11371
|
if (querySnapshotByKey.get(queryKey) === nextSnapshot && previousKnownLocalQueryKeys.has(queryKey)) continue;
|
|
11324
11372
|
querySnapshotByKey.set(queryKey, nextSnapshot);
|
|
11325
11373
|
if (localStorageAdapter === null) querySizeBytesByKey.set(queryKey, estimateAsyncQueryEntrySizeBytes({
|
|
@@ -11338,11 +11386,12 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11338
11386
|
removedQueryKeys.add(queryKey);
|
|
11339
11387
|
}
|
|
11340
11388
|
for (const [itemKey, item] of itemEntries) {
|
|
11389
|
+
const hasItemInState = Object.hasOwn(state.items, itemKey);
|
|
11341
11390
|
const hasItemQueryInState = Object.hasOwn(state.itemQueries, itemKey);
|
|
11342
11391
|
const hasLoadedFieldsInState = Object.hasOwn(state.itemLoadedFields, itemKey);
|
|
11343
11392
|
const hydratedItem = hasItemQueryInState && hasLoadedFieldsInState ? void 0 : readHydratedItem(itemKey);
|
|
11344
11393
|
const itemQuery = hasItemQueryInState ? state.itemQueries[itemKey] : hydratedItem?.itemQuery;
|
|
11345
|
-
const loadedFields =
|
|
11394
|
+
const loadedFields = hasItemInState ? state.itemLoadedFields[itemKey] : hydratedItem?.loadedFields;
|
|
11346
11395
|
if (item === null || itemQuery == null) {
|
|
11347
11396
|
if (previousKnownLocalItemKeys.has(itemKey)) {
|
|
11348
11397
|
tasks.push(itemNamespace.remove(itemKey));
|
|
@@ -11379,6 +11428,16 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11379
11428
|
loadedFields
|
|
11380
11429
|
};
|
|
11381
11430
|
const nextSnapshot = JSON.stringify(nextValue);
|
|
11431
|
+
if (!previousKnownLocalItemKeys.has(itemKey)) {
|
|
11432
|
+
const evictedRecency = budgetEvictedItemRecency.get(itemKey);
|
|
11433
|
+
if (evictedRecency !== void 0) {
|
|
11434
|
+
if (evictedRecency.snapshot === nextSnapshot) {
|
|
11435
|
+
nextItemKeys.delete(itemKey);
|
|
11436
|
+
continue;
|
|
11437
|
+
}
|
|
11438
|
+
budgetEvictedItemRecency.delete(itemKey);
|
|
11439
|
+
}
|
|
11440
|
+
}
|
|
11382
11441
|
if (itemSnapshotByKey.get(itemKey) === nextSnapshot && previousKnownLocalItemKeys.has(itemKey)) continue;
|
|
11383
11442
|
itemSnapshotByKey.set(itemKey, nextSnapshot);
|
|
11384
11443
|
if (localStorageAdapter === null) itemSizeBytesByKey.set(itemKey, estimateAsyncItemEntrySizeBytes({
|
|
@@ -11402,6 +11461,10 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11402
11461
|
forgetPersistedItem(itemKey);
|
|
11403
11462
|
removedItemKeys.add(itemKey);
|
|
11404
11463
|
}
|
|
11464
|
+
if (removedQueryKeys.size > 0) budgetEvictedQueryRecency.clear();
|
|
11465
|
+
if (removedItemKeys.size > 0) budgetEvictedItemRecency.clear();
|
|
11466
|
+
for (const queryKey of budgetEvictedQueryRecency.keys()) if (!Object.hasOwn(state.queries, queryKey)) budgetEvictedQueryRecency.delete(queryKey);
|
|
11467
|
+
for (const itemKey of budgetEvictedItemRecency.keys()) if (state.items[itemKey] == null) budgetEvictedItemRecency.delete(itemKey);
|
|
11405
11468
|
await Promise.all(tasks);
|
|
11406
11469
|
knownPersistedItemKeys = new Set(previousItemKeys);
|
|
11407
11470
|
for (const itemKey of removedItemKeys) knownPersistedItemKeys.delete(itemKey);
|
|
@@ -11485,17 +11548,21 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11485
11548
|
sizeBytes: rememberQueryMetadataSize(entry.key, entry.sizeBytes)
|
|
11486
11549
|
});
|
|
11487
11550
|
}
|
|
11551
|
+
const inStateQueryLastAccessAt = /* @__PURE__ */ new Map();
|
|
11488
11552
|
for (const [queryKey, queryData] of finalQueryDataByKey) {
|
|
11553
|
+
const existingMetadata = metadataByKey.get(queryKey);
|
|
11554
|
+
const lastAccessAt = existingMetadata?.lastAccessAt ?? getBudgetEvictedLastAccessAt(budgetEvictedQueryRecency, queryKey, queryData, commitTimestamp);
|
|
11555
|
+
inStateQueryLastAccessAt.set(queryKey, lastAccessAt);
|
|
11489
11556
|
const sizeBytes = estimateAsyncQueryEntrySizeBytes({
|
|
11490
|
-
currentCustomMetadata:
|
|
11491
|
-
lastAccessAt
|
|
11557
|
+
currentCustomMetadata: existingMetadata?.customMetadata,
|
|
11558
|
+
lastAccessAt,
|
|
11492
11559
|
protectedKeysSnapshotSet: protectedRefs,
|
|
11493
11560
|
queryKey,
|
|
11494
11561
|
value: queryData
|
|
11495
11562
|
});
|
|
11496
11563
|
finalQuerySizeBytesByKey.set(queryKey, sizeBytes);
|
|
11497
11564
|
candidateEntries.push({
|
|
11498
|
-
lastAccessAt
|
|
11565
|
+
lastAccessAt,
|
|
11499
11566
|
offlineProtected: protectedQueryKeys.has(queryKey) || protectedRefs?.has(serializeProtectedRef$1({
|
|
11500
11567
|
key: queryKey,
|
|
11501
11568
|
kind: "listQuery.query",
|
|
@@ -11509,20 +11576,32 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11509
11576
|
const { keptKeys: keptQueryKeys, unprotectedBytes: queryUnprotectedBytes } = keepEntriesWithinByteBudget(candidateEntries, (entry) => entry.queryKey, (entry) => entry.lastAccessAt, (entry) => entry.sizeBytes, (entry) => pinnedQueryKeys.has(entry.queryKey), (entry) => entry.offlineProtected, maxQueryBytes);
|
|
11510
11577
|
logQueryByteBudgetCleanup("flush", candidateEntries.length, keptQueryKeys, queryUnprotectedBytes);
|
|
11511
11578
|
finalPersistedQueryKeys.clear();
|
|
11512
|
-
for (const queryKey of keptQueryKeys)
|
|
11579
|
+
for (const queryKey of keptQueryKeys) {
|
|
11580
|
+
finalPersistedQueryKeys.add(queryKey);
|
|
11581
|
+
budgetEvictedQueryRecency.delete(queryKey);
|
|
11582
|
+
}
|
|
11583
|
+
for (const queryKey of budgetEvictedQueryRecency.keys()) if (!finalQueryDataByKey.has(queryKey)) budgetEvictedQueryRecency.delete(queryKey);
|
|
11513
11584
|
const evictedQueryKeys = [];
|
|
11514
11585
|
for (const queryKey of finalQueryDataByKey.keys()) if (!finalPersistedQueryKeys.has(queryKey)) evictedQueryKeys.push(queryKey);
|
|
11515
|
-
for (const queryKey of evictedQueryKeys)
|
|
11586
|
+
for (const queryKey of evictedQueryKeys) {
|
|
11587
|
+
const queryData = finalQueryDataByKey.get(queryKey);
|
|
11588
|
+
if (queryData !== void 0) budgetEvictedQueryRecency.set(queryKey, {
|
|
11589
|
+
lastAccessAt: inStateQueryLastAccessAt.get(queryKey) ?? commitTimestamp,
|
|
11590
|
+
snapshot: JSON.stringify(queryData)
|
|
11591
|
+
});
|
|
11592
|
+
finalQueryDataByKey.delete(queryKey);
|
|
11593
|
+
}
|
|
11516
11594
|
const persistedQueryItemKeys = /* @__PURE__ */ new Set();
|
|
11517
11595
|
for (const queryData of finalQueryDataByKey.values()) for (const itemKey of queryData.items) persistedQueryItemKeys.add(itemKey);
|
|
11518
11596
|
const finalItemDataByKey = /* @__PURE__ */ new Map();
|
|
11519
11597
|
const finalPersistedItemKeys = new Set(previousKnownLocalItemKeys);
|
|
11520
11598
|
for (const [itemKey, item] of itemEntries) {
|
|
11599
|
+
const hasItemInState = Object.hasOwn(state.items, itemKey);
|
|
11521
11600
|
const hasItemQueryInState = Object.hasOwn(state.itemQueries, itemKey);
|
|
11522
11601
|
const hasLoadedFieldsInState = Object.hasOwn(state.itemLoadedFields, itemKey);
|
|
11523
11602
|
const hydratedItem = hasItemQueryInState && hasLoadedFieldsInState ? void 0 : readHydratedItem(itemKey);
|
|
11524
11603
|
const itemQuery = hasItemQueryInState ? state.itemQueries[itemKey] : hydratedItem?.itemQuery;
|
|
11525
|
-
const loadedFields =
|
|
11604
|
+
const loadedFields = hasItemInState ? state.itemLoadedFields[itemKey] : hydratedItem?.loadedFields;
|
|
11526
11605
|
if (item === null || itemQuery == null) {
|
|
11527
11606
|
if (previousKnownLocalItemKeys.has(itemKey)) finalPersistedItemKeys.delete(itemKey);
|
|
11528
11607
|
continue;
|
|
@@ -11543,7 +11622,7 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11543
11622
|
};
|
|
11544
11623
|
finalItemDataByKey.set(itemKey, {
|
|
11545
11624
|
metadata: {
|
|
11546
|
-
...
|
|
11625
|
+
...loadedFields !== void 0 ? { f: loadedFields } : {},
|
|
11547
11626
|
p: itemQuery.payload,
|
|
11548
11627
|
...getItemDerivedGroup ? { g: getItemDerivedGroup(item, itemQuery.payload) } : {}
|
|
11549
11628
|
},
|
|
@@ -11576,12 +11655,15 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11576
11655
|
sizeBytes: rememberItemMetadataSize(entry.key, entry.sizeBytes)
|
|
11577
11656
|
});
|
|
11578
11657
|
}
|
|
11658
|
+
const inStateItemLastAccessAt = /* @__PURE__ */ new Map();
|
|
11579
11659
|
for (const [itemKey, entry] of finalItemDataByKey) {
|
|
11580
11660
|
const existingMetadata = itemMetadataByKey.get(itemKey);
|
|
11661
|
+
const lastAccessAt = existingMetadata?.lastAccessAt ?? getBudgetEvictedLastAccessAt(budgetEvictedItemRecency, itemKey, entry.value, itemCommitTimestamp);
|
|
11662
|
+
inStateItemLastAccessAt.set(itemKey, lastAccessAt);
|
|
11581
11663
|
const sizeBytes = estimateAsyncItemEntrySizeBytes({
|
|
11582
11664
|
currentCustomMetadata: existingMetadata?.customMetadata,
|
|
11583
11665
|
itemKey,
|
|
11584
|
-
lastAccessAt
|
|
11666
|
+
lastAccessAt,
|
|
11585
11667
|
nextCustomMetadata: entry.metadata,
|
|
11586
11668
|
protectedKeysSnapshotSet: protectedRefs,
|
|
11587
11669
|
value: entry.value
|
|
@@ -11589,7 +11671,7 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11589
11671
|
finalItemSizeBytesByKey.set(itemKey, sizeBytes);
|
|
11590
11672
|
itemCandidateEntries.push({
|
|
11591
11673
|
itemKey,
|
|
11592
|
-
lastAccessAt
|
|
11674
|
+
lastAccessAt,
|
|
11593
11675
|
offlineProtected: protectedItemKeys.has(itemKey) || protectedRefs?.has(serializeProtectedRef$1({
|
|
11594
11676
|
key: itemKey,
|
|
11595
11677
|
kind: "listQuery.item",
|
|
@@ -11602,10 +11684,21 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11602
11684
|
const { keptKeys: keptItemKeys, unprotectedBytes: itemUnprotectedBytes } = keepEntriesWithinByteBudget(itemCandidateEntries, (entry) => entry.itemKey, (entry) => entry.lastAccessAt, (entry) => entry.sizeBytes, (entry) => pinnedItemKeys.has(entry.itemKey), (entry) => entry.offlineProtected, maxItemBytes);
|
|
11603
11685
|
logItemByteBudgetCleanup("flush", itemCandidateEntries.length, keptItemKeys, itemUnprotectedBytes);
|
|
11604
11686
|
finalPersistedItemKeys.clear();
|
|
11605
|
-
for (const itemKey of keptItemKeys)
|
|
11687
|
+
for (const itemKey of keptItemKeys) {
|
|
11688
|
+
finalPersistedItemKeys.add(itemKey);
|
|
11689
|
+
budgetEvictedItemRecency.delete(itemKey);
|
|
11690
|
+
}
|
|
11691
|
+
for (const itemKey of budgetEvictedItemRecency.keys()) if (!finalItemDataByKey.has(itemKey)) budgetEvictedItemRecency.delete(itemKey);
|
|
11606
11692
|
const evictedItemKeys = [];
|
|
11607
11693
|
for (const itemKey of finalItemDataByKey.keys()) if (!finalPersistedItemKeys.has(itemKey)) evictedItemKeys.push(itemKey);
|
|
11608
|
-
for (const itemKey of evictedItemKeys)
|
|
11694
|
+
for (const itemKey of evictedItemKeys) {
|
|
11695
|
+
const entry = finalItemDataByKey.get(itemKey);
|
|
11696
|
+
if (entry !== void 0) budgetEvictedItemRecency.set(itemKey, {
|
|
11697
|
+
lastAccessAt: inStateItemLastAccessAt.get(itemKey) ?? itemCommitTimestamp,
|
|
11698
|
+
snapshot: JSON.stringify(entry.value)
|
|
11699
|
+
});
|
|
11700
|
+
finalItemDataByKey.delete(itemKey);
|
|
11701
|
+
}
|
|
11609
11702
|
const removedQueryKeys = [...previousKnownLocalQueryKeys].filter((queryKey) => !finalPersistedQueryKeys.has(queryKey));
|
|
11610
11703
|
const removedItemKeys = [...previousKnownLocalItemKeys].filter((itemKey) => !finalPersistedItemKeys.has(itemKey));
|
|
11611
11704
|
const queryUpserts = /* @__PURE__ */ new Map();
|
|
@@ -11738,6 +11831,8 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11738
11831
|
querySnapshotByKey.clear();
|
|
11739
11832
|
itemSizeBytesByKey.clear();
|
|
11740
11833
|
querySizeBytesByKey.clear();
|
|
11834
|
+
budgetEvictedItemRecency.clear();
|
|
11835
|
+
budgetEvictedQueryRecency.clear();
|
|
11741
11836
|
hydratedPersistedItemKeys.clear();
|
|
11742
11837
|
hydratedPersistedQueryKeys.clear();
|
|
11743
11838
|
syncHydrationItemMissCache.clearAll();
|
|
@@ -11763,13 +11858,63 @@ function setupListQueryPersistence(config, options = {}) {
|
|
|
11763
11858
|
}
|
|
11764
11859
|
//#endregion
|
|
11765
11860
|
//#region src/listQueryStore/itemFieldUtils.ts
|
|
11766
|
-
function
|
|
11767
|
-
|
|
11768
|
-
|
|
11861
|
+
function hasFullyLoadedFields(loadedFields) {
|
|
11862
|
+
return loadedFields === "*";
|
|
11863
|
+
}
|
|
11864
|
+
/**
|
|
11865
|
+
* Whether a snapshot should be treated as holding every field of the item.
|
|
11866
|
+
* True when the tracked `loadedFields` is the `'*'` sentinel, or when the
|
|
11867
|
+
* snapshot carries no field metadata but `inferFields` reports the item is
|
|
11868
|
+
* complete (`'*'`) — e.g. manually inserted items, offline optimistic rows, or
|
|
11869
|
+
* persisted fallback snapshots.
|
|
11870
|
+
*/
|
|
11871
|
+
function snapshotIsFullyLoaded(loadedFields, item, inferFields) {
|
|
11872
|
+
if (loadedFields === "*") return true;
|
|
11873
|
+
if (!item) return false;
|
|
11874
|
+
return inferFields(item) === "*";
|
|
11875
|
+
}
|
|
11876
|
+
/**
|
|
11877
|
+
* Like {@link snapshotIsFullyLoaded}, but also returns `false` when the item is
|
|
11878
|
+
* awaiting a full ('*') re-fetch after a full invalidation. A fully-loaded
|
|
11879
|
+
* snapshot that was fully invalidated has its `loadedFields` reset while the
|
|
11880
|
+
* (now stale) item data is still present, so `inferFields` would otherwise
|
|
11881
|
+
* wrongly vouch for it as complete.
|
|
11882
|
+
*/
|
|
11883
|
+
function snapshotIsFullyLoadedAndFresh(itemKey, loadedFields, item, inferFields, itemsPendingFullInvalidation) {
|
|
11884
|
+
if (loadedFields !== "*" && itemsPendingFullInvalidation.has(itemKey)) return false;
|
|
11885
|
+
return snapshotIsFullyLoaded(loadedFields, item, inferFields);
|
|
11886
|
+
}
|
|
11887
|
+
/**
|
|
11888
|
+
* Missing requested fields for an item snapshot, letting `inferFields` vouch
|
|
11889
|
+
* for metadata-free item data (e.g. client-created items) — except for stale
|
|
11890
|
+
* fields awaiting a re-fetch after an invalidation (per-field or full), when
|
|
11891
|
+
* the item's stale data must not be vouched for.
|
|
11892
|
+
*/
|
|
11893
|
+
function getStaleOrMissingRequestedFields(itemKey, loadedFields, item, requestedFields, inferFields, itemsPendingFullInvalidation, pendingInvalidationFields) {
|
|
11894
|
+
const staleRequestedFields = pendingInvalidationFields.length > 0 ? requestedFields.filter((field) => pendingInvalidationFields.includes(field)) : [];
|
|
11895
|
+
const missingLoadedFields = excludeLoadedFields(loadedFields, requestedFields);
|
|
11896
|
+
if (missingLoadedFields.length === 0) return staleRequestedFields;
|
|
11897
|
+
const unvouchedMissingFields = loadedFields !== "*" && itemsPendingFullInvalidation.has(itemKey) || !item ? missingLoadedFields : (() => {
|
|
11898
|
+
const inferredFields = inferFields(item);
|
|
11899
|
+
return missingLoadedFields.filter((field) => inferredFields !== "*" && !inferredFields.includes(field));
|
|
11900
|
+
})();
|
|
11901
|
+
if (staleRequestedFields.length === 0) return unvouchedMissingFields;
|
|
11902
|
+
const resultFields = new Set([...staleRequestedFields, ...unvouchedMissingFields]);
|
|
11903
|
+
return requestedFields.filter((field) => resultFields.has(field));
|
|
11904
|
+
}
|
|
11905
|
+
function fallbackItemHasRequestedFields(fallbackItemState, requestedFields, inferFields) {
|
|
11906
|
+
return getFallbackMissingRequestedFields(fallbackItemState, requestedFields, inferFields).length === 0;
|
|
11907
|
+
}
|
|
11908
|
+
function getFallbackMissingRequestedFields(fallbackItemState, requestedFields, inferFields) {
|
|
11909
|
+
const loadedFields = fallbackItemState?.loadedFields;
|
|
11910
|
+
if (loadedFields === "*") return [];
|
|
11911
|
+
const missingLoadedFields = requestedFields.filter((field) => !(loadedFields?.includes(field) ?? false));
|
|
11912
|
+
if (missingLoadedFields.length === 0) return [];
|
|
11769
11913
|
const item = fallbackItemState?.item;
|
|
11770
|
-
if (!item
|
|
11771
|
-
const
|
|
11772
|
-
|
|
11914
|
+
if (!item) return missingLoadedFields;
|
|
11915
|
+
const inferredFields = inferFields(item);
|
|
11916
|
+
if (inferredFields === "*") return [];
|
|
11917
|
+
return missingLoadedFields.filter((field) => !inferredFields.includes(field));
|
|
11773
11918
|
}
|
|
11774
11919
|
/**
|
|
11775
11920
|
* Returns the fields from `requestedFields` that are not yet present in
|
|
@@ -11777,6 +11922,7 @@ function fallbackItemHasRequestedFields(fallbackItemState, requestedFields) {
|
|
|
11777
11922
|
*/
|
|
11778
11923
|
function excludeLoadedFields(loadedFields, requestedFields) {
|
|
11779
11924
|
if (!requestedFields || requestedFields.length === 0) return [];
|
|
11925
|
+
if (loadedFields === "*") return [];
|
|
11780
11926
|
if (!loadedFields || loadedFields.length === 0) return [...requestedFields];
|
|
11781
11927
|
return requestedFields.filter((field) => !loadedFields.includes(field));
|
|
11782
11928
|
}
|
|
@@ -11791,10 +11937,11 @@ function applyPartialItemMerge(draft, itemKey, data, fields, partialResources) {
|
|
|
11791
11937
|
const merged = partialResources.mergeItems(prev, data);
|
|
11792
11938
|
draft.items[itemKey] = reusePrevIfEqual(prev, merged);
|
|
11793
11939
|
if (fields && fields.length > 0) {
|
|
11794
|
-
const existingFields = draft.itemLoadedFields[itemKey]
|
|
11795
|
-
|
|
11940
|
+
const existingFields = draft.itemLoadedFields[itemKey];
|
|
11941
|
+
if (existingFields === "*") return merged;
|
|
11942
|
+
const fieldSet = new Set([...existingFields ?? [], ...fields]);
|
|
11796
11943
|
draft.itemLoadedFields[itemKey] = Array.from(fieldSet).sort();
|
|
11797
|
-
} else draft.itemLoadedFields[itemKey] =
|
|
11944
|
+
} else draft.itemLoadedFields[itemKey] = "*";
|
|
11798
11945
|
return merged;
|
|
11799
11946
|
}
|
|
11800
11947
|
//#endregion
|
|
@@ -12123,7 +12270,7 @@ async function executeQueryFetch(requests, fetchCtx, store, normalizedFetchListF
|
|
|
12123
12270
|
//#endregion
|
|
12124
12271
|
//#region src/listQueryStore/createFetchApi.ts
|
|
12125
12272
|
/** @internal */
|
|
12126
|
-
function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchItemFn, batchFetchItemFn, getItemsBatchKey, errorNormalizer, partialResources, lowPriorityThrottleMs, getCoalescingWindowMs, mediumPriorityDelayMs, dynamicRealtimeThrottleMs, onSchedulerEvent, usesRealTimeUpdates, defaultQuerySize, maxItemBatchSize, getQueryKey, getItemKey, normalizeFieldsOption, syncHydrationEnabled, preloadQueries_, preloadItems_, persistence, testInitialLastFetchStartTime, onQueryFetchStart, onQueryFetchSettled, onItemFetchStart, onItemFetchSettled, offlineController) {
|
|
12273
|
+
function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchItemFn, batchFetchItemFn, getItemsBatchKey, errorNormalizer, partialResources, lowPriorityThrottleMs, getCoalescingWindowMs, mediumPriorityDelayMs, dynamicRealtimeThrottleMs, onSchedulerEvent, usesRealTimeUpdates, defaultQuerySize, maxItemBatchSize, getQueryKey, getItemKey, normalizeFieldsOption, syncHydrationEnabled, preloadQueries_, preloadItems_, persistence, testInitialLastFetchStartTime, onQueryFetchStart, onQueryFetchSettled, onItemFetchStart, onItemFetchSettled, offlineController, itemPendingInvalidationFields, itemsPendingFullInvalidation) {
|
|
12127
12274
|
const noFetchItemFnError = "No fetchItemFn was provided";
|
|
12128
12275
|
const querySchedulers = /* @__PURE__ */ new Map();
|
|
12129
12276
|
const queryInitialFetchStartTime = /* @__PURE__ */ new Map();
|
|
@@ -12534,7 +12681,7 @@ function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchIte
|
|
|
12534
12681
|
const materializedState = readMaterializedItemState(itemKey);
|
|
12535
12682
|
const hydratedState = persistence.readHydratedItem(itemKey);
|
|
12536
12683
|
const state = materializedState ?? hydratedState;
|
|
12537
|
-
if (!state || state.item == null || state.itemQuery == null || partialResources && fields && fields.length > 0 && !fallbackItemHasRequestedFields(state, fields)) return "skipped";
|
|
12684
|
+
if (!state || state.item == null || state.itemQuery == null || partialResources && fields && fields.length > 0 && !fallbackItemHasRequestedFields(state, fields, partialResources.inferFields)) return "skipped";
|
|
12538
12685
|
appendedItemKeys.push(itemKey);
|
|
12539
12686
|
if (!materializedState && hydratedState) appendedHydratedItems.push({
|
|
12540
12687
|
itemKey,
|
|
@@ -12554,7 +12701,7 @@ function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchIte
|
|
|
12554
12701
|
for (const { itemKey, state } of appendedHydratedItems) {
|
|
12555
12702
|
draft.items[itemKey] = state.item;
|
|
12556
12703
|
draft.itemQueries[itemKey] = state.itemQuery;
|
|
12557
|
-
draft.itemLoadedFields[itemKey] = state.loadedFields;
|
|
12704
|
+
if (state.loadedFields !== void 0) draft.itemLoadedFields[itemKey] = state.loadedFields;
|
|
12558
12705
|
}
|
|
12559
12706
|
}, { action: "persistent-storage-load-more" });
|
|
12560
12707
|
return "triggered";
|
|
@@ -12566,10 +12713,25 @@ function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchIte
|
|
|
12566
12713
|
return item && itemPayload ? itemDataSelector(item, itemPayload, itemKey) : false;
|
|
12567
12714
|
});
|
|
12568
12715
|
}
|
|
12569
|
-
|
|
12570
|
-
|
|
12571
|
-
|
|
12572
|
-
|
|
12716
|
+
/**
|
|
12717
|
+
* Fields of an item still awaiting an invalidation re-fetch. Reads the
|
|
12718
|
+
* state-level record first; when a fetch already consumed it (the record is
|
|
12719
|
+
* deleted before the response lands), falls back to the in-memory pending
|
|
12720
|
+
* list minus the fields that were re-loaded since the invalidation.
|
|
12721
|
+
*/
|
|
12722
|
+
function getUnresolvedPendingInvalidationFields(itemKey) {
|
|
12723
|
+
const stateInvalidationFields = store.state.itemFieldInvalidationFields[itemKey];
|
|
12724
|
+
if (stateInvalidationFields && stateInvalidationFields.length > 0) return stateInvalidationFields;
|
|
12725
|
+
return excludeLoadedFields(store.state.itemLoadedFields[itemKey], itemPendingInvalidationFields.get(itemKey));
|
|
12726
|
+
}
|
|
12727
|
+
/**
|
|
12728
|
+
* Whether an item snapshot is fresh enough for a require-fresh
|
|
12729
|
+
* (`ignoreStaleState: true`) full ('*') read: no unresolved full ('*')
|
|
12730
|
+
* invalidation and no fields still awaiting an invalidation re-fetch.
|
|
12731
|
+
*/
|
|
12732
|
+
function itemSnapshotIsFresh(itemKey) {
|
|
12733
|
+
if (store.state.itemLoadedFields[itemKey] !== "*" && itemsPendingFullInvalidation.has(itemKey)) return false;
|
|
12734
|
+
return getUnresolvedPendingInvalidationFields(itemKey).length === 0;
|
|
12573
12735
|
}
|
|
12574
12736
|
async function awaitListQueryFetch(params, options = {}) {
|
|
12575
12737
|
const queryKey = getQueryKey(params);
|
|
@@ -12605,7 +12767,7 @@ function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchIte
|
|
|
12605
12767
|
if (!hydratedItem) continue;
|
|
12606
12768
|
draft.items[itemKey] = hydratedItem.item;
|
|
12607
12769
|
draft.itemQueries[itemKey] = hydratedItem.itemQuery;
|
|
12608
|
-
draft.itemLoadedFields[itemKey] = hydratedItem.loadedFields;
|
|
12770
|
+
if (hydratedItem.loadedFields !== void 0) draft.itemLoadedFields[itemKey] = hydratedItem.loadedFields;
|
|
12609
12771
|
}
|
|
12610
12772
|
}, { action: "persistent-storage-hydrate" });
|
|
12611
12773
|
}
|
|
@@ -12632,11 +12794,12 @@ function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchIte
|
|
|
12632
12794
|
async function getQueryFromStateOrFetch(params, options = {}) {
|
|
12633
12795
|
const queryKey = getQueryKey(params);
|
|
12634
12796
|
const fields = normalizeFieldsOption(options.fields);
|
|
12797
|
+
const fullFieldsRequested = options.fields === "*";
|
|
12635
12798
|
const query = getQueryStateByKey(queryKey);
|
|
12636
12799
|
const includeStale = !!options.ignoreStaleState;
|
|
12637
12800
|
const cachedQueryCanBeUsed = !!query?.wasLoaded && (!includeStale || query.status === "success" && !query.error && !query.refetchOnMount);
|
|
12638
12801
|
if (query && cachedQueryCanBeUsed) {
|
|
12639
|
-
if (!(partialResources && Array.isArray(fields) && fields.length > 0)) return Result.ok({
|
|
12802
|
+
if (!(partialResources && (Array.isArray(fields) && fields.length > 0 || fullFieldsRequested))) return Result.ok({
|
|
12640
12803
|
items: getQueryItems(query, (data, itemPayload) => ({
|
|
12641
12804
|
data,
|
|
12642
12805
|
itemPayload
|
|
@@ -12645,8 +12808,10 @@ function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchIte
|
|
|
12645
12808
|
});
|
|
12646
12809
|
if (!query.items.some((itemKey) => {
|
|
12647
12810
|
const itemState = readItemState(itemKey);
|
|
12648
|
-
|
|
12649
|
-
|
|
12811
|
+
if (fullFieldsRequested) return !snapshotIsFullyLoaded(itemState?.loadedFields, itemState?.item, partialResources.inferFields) || includeStale && !itemSnapshotIsFresh(itemKey);
|
|
12812
|
+
const requestedFields = Array.isArray(fields) ? fields : [];
|
|
12813
|
+
if (includeStale) return getStaleOrMissingRequestedFields(itemKey, itemState?.loadedFields, itemState?.item, requestedFields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey)).length > 0;
|
|
12814
|
+
return getFallbackMissingRequestedFields(itemState, requestedFields, partialResources.inferFields).length > 0;
|
|
12650
12815
|
})) return Result.ok({
|
|
12651
12816
|
items: getQueryItems(query, (data, itemPayload) => ({
|
|
12652
12817
|
data,
|
|
@@ -12707,7 +12872,7 @@ function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchIte
|
|
|
12707
12872
|
store.produceState((draft) => {
|
|
12708
12873
|
draft.items[itemKey] = hydratedItem.item;
|
|
12709
12874
|
draft.itemQueries[itemKey] = hydratedItem.itemQuery;
|
|
12710
|
-
draft.itemLoadedFields[itemKey] = hydratedItem.loadedFields;
|
|
12875
|
+
if (hydratedItem.loadedFields !== void 0) draft.itemLoadedFields[itemKey] = hydratedItem.loadedFields;
|
|
12711
12876
|
}, { action: "persistent-storage-hydrate" });
|
|
12712
12877
|
}
|
|
12713
12878
|
}
|
|
@@ -12729,20 +12894,19 @@ function createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchIte
|
|
|
12729
12894
|
async function getItemFromStateOrFetch(itemPayload, options = {}) {
|
|
12730
12895
|
const itemKey = getItemKey(itemPayload);
|
|
12731
12896
|
const fields = normalizeFieldsOption(options.fields);
|
|
12897
|
+
const fullFieldsRequested = options.fields === "*";
|
|
12732
12898
|
const itemState = readItemState(itemKey);
|
|
12733
12899
|
const item = itemState?.item;
|
|
12734
12900
|
const itemQuery = itemState?.itemQuery;
|
|
12735
12901
|
const includeStale = !!options.ignoreStaleState;
|
|
12736
|
-
const needsFieldCheck = partialResources && Array.isArray(fields) && fields.length > 0;
|
|
12737
|
-
const itemHasAllFields = !needsFieldCheck || fallbackItemHasRequestedFields(itemState, fields);
|
|
12902
|
+
const needsFieldCheck = partialResources && (Array.isArray(fields) && fields.length > 0 || fullFieldsRequested);
|
|
12903
|
+
const itemHasAllFields = !needsFieldCheck || (fullFieldsRequested ? snapshotIsFullyLoaded(itemState?.loadedFields, itemState?.item, partialResources.inferFields) : fallbackItemHasRequestedFields(itemState, Array.isArray(fields) ? fields : [], partialResources.inferFields));
|
|
12738
12904
|
const itemQueryFresh = itemQuery?.status === "success" && !itemQuery.error && !itemQuery.refetchOnMount;
|
|
12739
|
-
|
|
12905
|
+
const staleOrMissingRequestedFields = needsFieldCheck && !fullFieldsRequested && includeStale ? getStaleOrMissingRequestedFields(itemKey, itemState?.loadedFields, item, Array.isArray(fields) ? fields : [], partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey)) : void 0;
|
|
12906
|
+
if (item != null && itemHasAllFields && (!includeStale || itemQueryFresh && (!needsFieldCheck || (fullFieldsRequested ? itemSnapshotIsFresh(itemKey) : staleOrMissingRequestedFields?.length === 0)))) return Result.ok(item);
|
|
12740
12907
|
if (!fetchItemFn) throw new Error(noFetchItemFnError);
|
|
12741
12908
|
let fieldsToFetch = options.fields;
|
|
12742
|
-
if (needsFieldCheck && item != null && itemQueryFresh)
|
|
12743
|
-
const invalidation = includeStale ? store.state.itemFieldInvalidationFields[itemKey] : void 0;
|
|
12744
|
-
fieldsToFetch = fields.filter((field) => !fallbackItemHasRequestedFields(itemState, [field]) || (invalidation?.includes(field) ?? false));
|
|
12745
|
-
}
|
|
12909
|
+
if (needsFieldCheck && !fullFieldsRequested && item != null && itemQueryFresh) fieldsToFetch = staleOrMissingRequestedFields ?? getFallbackMissingRequestedFields(itemState, Array.isArray(fields) ? fields : [], partialResources.inferFields);
|
|
12746
12910
|
const result = await awaitItemFetch(itemPayload, {
|
|
12747
12911
|
timeoutMs: options.timeoutMs,
|
|
12748
12912
|
fields: fieldsToFetch
|
|
@@ -12840,7 +13004,7 @@ const GET_ALL = () => true;
|
|
|
12840
13004
|
//#endregion
|
|
12841
13005
|
//#region src/listQueryStore/createMutationApi.ts
|
|
12842
13006
|
/** @internal */
|
|
12843
|
-
function createMutationApi(store, fetchItemFn, partialResources, optimisticListUpdates, onInvalidateQuery, onInvalidateItem, onMutationError, errorNormalizer, getItemKey, getQueriesKeyArray, getQueriesRelatedToItem, getItemsKeyArray, getOrCreateItemScheduler, getOrCreateQueryScheduler, deleteItemFetchResources, emitInvalidateQuery, emitInvalidateItem, blockWindowClose, offlineController, runWithBroadcastConsistency, publishQuerySnapshot, publishItemSnapshot, onOfflineTimelineEvent) {
|
|
13007
|
+
function createMutationApi(store, fetchItemFn, partialResources, optimisticListUpdates, onInvalidateQuery, onInvalidateItem, onMutationError, errorNormalizer, getItemKey, getQueriesKeyArray, getQueriesRelatedToItem, getItemsKeyArray, getOrCreateItemScheduler, getOrCreateQueryScheduler, deleteItemFetchResources, emitInvalidateQuery, emitInvalidateItem, blockWindowClose, offlineController, runWithBroadcastConsistency, publishQuerySnapshot, publishItemSnapshot, onOfflineTimelineEvent, itemPendingInvalidationFields, itemsPendingFullInvalidation) {
|
|
12844
13008
|
const storeEvents = evtmitter();
|
|
12845
13009
|
const deferredOptimisticQueryInvalidationsStack = [];
|
|
12846
13010
|
const optimisticMutationQueryContextStack = [];
|
|
@@ -12900,7 +13064,6 @@ function createMutationApi(store, fetchItemFn, partialResources, optimisticListU
|
|
|
12900
13064
|
const queryInvalidationWasTriggered = /* @__PURE__ */ new Set();
|
|
12901
13065
|
const itemInvalidationWasTriggered = /* @__PURE__ */ new Set();
|
|
12902
13066
|
const itemFieldInvalidationPriorities = /* @__PURE__ */ new Map();
|
|
12903
|
-
const itemPendingInvalidationFields = /* @__PURE__ */ new Map();
|
|
12904
13067
|
function invalidateQueryAndItems(args) {
|
|
12905
13068
|
const itemPayload = args.all ? GET_ALL : args.itemPayload;
|
|
12906
13069
|
const queryPayload = args.all ? GET_ALL : args.queryPayload;
|
|
@@ -12940,7 +13103,7 @@ function createMutationApi(store, fetchItemFn, partialResources, optimisticListU
|
|
|
12940
13103
|
for (const { itemKey } of itemsKey) {
|
|
12941
13104
|
const loadedFields = draft.itemLoadedFields[itemKey];
|
|
12942
13105
|
if (!loadedFields) continue;
|
|
12943
|
-
draft.itemLoadedFields[itemKey] = loadedFields.filter((f) => !invalidateFields.includes(f));
|
|
13106
|
+
if (loadedFields !== "*") draft.itemLoadedFields[itemKey] = loadedFields.filter((f) => !invalidateFields.includes(f));
|
|
12944
13107
|
const existingInvalidationFields = draft.itemFieldInvalidationFields[itemKey] ?? [];
|
|
12945
13108
|
draft.itemFieldInvalidationFields[itemKey] = Array.from(new Set([...existingInvalidationFields, ...invalidateFields])).sort();
|
|
12946
13109
|
}
|
|
@@ -12961,10 +13124,28 @@ function createMutationApi(store, fetchItemFn, partialResources, optimisticListU
|
|
|
12961
13124
|
for (const { itemKey, payload } of itemsKey) {
|
|
12962
13125
|
const item = store.state.itemQueries[itemKey];
|
|
12963
13126
|
if (!item) continue;
|
|
12964
|
-
|
|
12965
|
-
|
|
13127
|
+
let effectiveLoadedFields = store.state.itemLoadedFields[itemKey];
|
|
13128
|
+
if (partialResources && effectiveLoadedFields === void 0) {
|
|
13129
|
+
const itemState = store.state.items[itemKey];
|
|
13130
|
+
if (itemState) effectiveLoadedFields = partialResources.inferFields(itemState);
|
|
13131
|
+
}
|
|
13132
|
+
const itemWasFullyLoaded = partialResources && effectiveLoadedFields === "*";
|
|
13133
|
+
const trackedInvalidationFields = partialResources && !itemWasFullyLoaded ? Array.from(new Set([...effectiveLoadedFields === "*" ? [] : effectiveLoadedFields ?? [], ...itemPendingInvalidationFields.get(itemKey) ?? []])).sort() : [];
|
|
13134
|
+
const trackedInvalidationPriority = trackedInvalidationFields.length > 0 || itemsPendingFullInvalidation.has(itemKey) ? itemFieldInvalidationPriorities.get(itemKey) : void 0;
|
|
12966
13135
|
const nextInvalidationPriority = trackedInvalidationPriority && fetchTypePriority[trackedInvalidationPriority] > fetchTypePriority[priority] ? trackedInvalidationPriority : priority;
|
|
12967
13136
|
if ((item.refetchOnMount ? fetchTypePriority[item.refetchOnMount] : -1) >= fetchTypePriority[nextInvalidationPriority]) continue;
|
|
13137
|
+
if (itemWasFullyLoaded) {
|
|
13138
|
+
itemsPendingFullInvalidation.add(itemKey);
|
|
13139
|
+
itemPendingInvalidationFields.delete(itemKey);
|
|
13140
|
+
itemFieldInvalidationPriorities.set(itemKey, nextInvalidationPriority);
|
|
13141
|
+
} else if (trackedInvalidationFields.length > 0) {
|
|
13142
|
+
itemPendingInvalidationFields.set(itemKey, trackedInvalidationFields);
|
|
13143
|
+
itemFieldInvalidationPriorities.set(itemKey, nextInvalidationPriority);
|
|
13144
|
+
} else {
|
|
13145
|
+
itemPendingInvalidationFields.delete(itemKey);
|
|
13146
|
+
itemFieldInvalidationPriorities.delete(itemKey);
|
|
13147
|
+
}
|
|
13148
|
+
itemInvalidationWasTriggered.delete(itemKey);
|
|
12968
13149
|
store.produceState((draft) => {
|
|
12969
13150
|
const query = draft.itemQueries[itemKey];
|
|
12970
13151
|
if (!query) return;
|
|
@@ -12974,14 +13155,6 @@ function createMutationApi(store, fetchItemFn, partialResources, optimisticListU
|
|
|
12974
13155
|
delete draft.itemFieldInvalidationFields[itemKey];
|
|
12975
13156
|
}
|
|
12976
13157
|
}, { action: "invalidate-item" });
|
|
12977
|
-
if (trackedInvalidationFields.length > 0) {
|
|
12978
|
-
itemPendingInvalidationFields.set(itemKey, trackedInvalidationFields);
|
|
12979
|
-
itemFieldInvalidationPriorities.set(itemKey, nextInvalidationPriority);
|
|
12980
|
-
} else {
|
|
12981
|
-
itemPendingInvalidationFields.delete(itemKey);
|
|
12982
|
-
itemFieldInvalidationPriorities.delete(itemKey);
|
|
12983
|
-
}
|
|
12984
|
-
itemInvalidationWasTriggered.delete(itemKey);
|
|
12985
13158
|
emitInvalidateItem({
|
|
12986
13159
|
priority: nextInvalidationPriority,
|
|
12987
13160
|
itemKey
|
|
@@ -13199,6 +13372,7 @@ function createMutationApi(store, fetchItemFn, partialResources, optimisticListU
|
|
|
13199
13372
|
for (const { itemKey } of itemsId) {
|
|
13200
13373
|
itemFieldInvalidationPriorities.delete(itemKey);
|
|
13201
13374
|
itemPendingInvalidationFields.delete(itemKey);
|
|
13375
|
+
itemsPendingFullInvalidation.delete(itemKey);
|
|
13202
13376
|
itemInvalidationWasTriggered.delete(itemKey);
|
|
13203
13377
|
publishItemSnapshot(itemKey);
|
|
13204
13378
|
}
|
|
@@ -13210,6 +13384,7 @@ function createMutationApi(store, fetchItemFn, partialResources, optimisticListU
|
|
|
13210
13384
|
itemInvalidationWasTriggered.clear();
|
|
13211
13385
|
itemFieldInvalidationPriorities.clear();
|
|
13212
13386
|
itemPendingInvalidationFields.clear();
|
|
13387
|
+
itemsPendingFullInvalidation.clear();
|
|
13213
13388
|
}
|
|
13214
13389
|
async function performMutation(payload, { optimisticUpdate, mutation, silentErrors, revalidateOnSuccess, onSuccess, onError, debounce, offline, upload }) {
|
|
13215
13390
|
const payloadToUse = payload === null ? [] : payload;
|
|
@@ -13289,7 +13464,6 @@ function createMutationApi(store, fetchItemFn, partialResources, optimisticListU
|
|
|
13289
13464
|
queryInvalidationWasTriggered,
|
|
13290
13465
|
itemInvalidationWasTriggered,
|
|
13291
13466
|
itemFieldInvalidationPriorities,
|
|
13292
|
-
itemPendingInvalidationFields,
|
|
13293
13467
|
invalidateQueryAndItems,
|
|
13294
13468
|
invalidateItem,
|
|
13295
13469
|
startItemMutation,
|
|
@@ -13654,7 +13828,7 @@ const cacheMissError = {
|
|
|
13654
13828
|
id: "cache-miss",
|
|
13655
13829
|
message: "Cache miss"
|
|
13656
13830
|
};
|
|
13657
|
-
function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus: allItemsReturnIdleStatus, returnRefetchingStatus: allItemsReturnRefetchingStatus, showPartialAsRefetching: allItemsShowPartialAsRefetching, disableRefetches: allItemsDisableRefetches, disableRefetchOnMount: allItemsDisableRefetchOnMount, isOffScreen: allItemsIsOffScreen, debouncePayload }, store, events, getItemKey, registerActiveItems, touchItems, scheduleAutomaticItemFetch, preloadItems, preloadItemsBeforePaint, readFallbackItemState, itemInvalidationWasTriggered, itemFieldInvalidationPriorities, itemPendingInvalidationFields, globalDisableRefetchOnMount, fetchItemFn, partialResources, offlineEntities, offlineOverlays) {
|
|
13831
|
+
function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus: allItemsReturnIdleStatus, returnRefetchingStatus: allItemsReturnRefetchingStatus, showPartialAsRefetching: allItemsShowPartialAsRefetching, disableRefetches: allItemsDisableRefetches, disableRefetchOnMount: allItemsDisableRefetchOnMount, isOffScreen: allItemsIsOffScreen, debouncePayload }, store, events, getItemKey, registerActiveItems, touchItems, scheduleAutomaticItemFetch, preloadItems, preloadItemsBeforePaint, readFallbackItemState, itemInvalidationWasTriggered, itemFieldInvalidationPriorities, itemPendingInvalidationFields, itemsPendingFullInvalidation, globalDisableRefetchOnMount, fetchItemFn, partialResources, offlineEntities, offlineOverlays) {
|
|
13658
13832
|
const isOffScreenFromContext = useContext(IsOffScreenContext);
|
|
13659
13833
|
const queriesWithId = useMemo(() => {
|
|
13660
13834
|
return items.map((itemProps) => {
|
|
@@ -13694,6 +13868,8 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13694
13868
|
const offlineEntitiesByKey = useMemo(() => createOfflineEntityLookup(offlineEntities), [offlineEntities]);
|
|
13695
13869
|
const activeOfflineOverlays = useMemo(() => filterActiveOfflineOverlays(offlineEntitiesByKey, offlineOverlays), [offlineEntitiesByKey, offlineOverlays]);
|
|
13696
13870
|
const getUnresolvedPendingInvalidationFields = useCallback((itemKey) => {
|
|
13871
|
+
const stateInvalidationFields = store.state.itemFieldInvalidationFields[itemKey];
|
|
13872
|
+
if (stateInvalidationFields && stateInvalidationFields.length > 0) return stateInvalidationFields;
|
|
13697
13873
|
return excludeLoadedFields(store.state.itemLoadedFields[itemKey], itemPendingInvalidationFields.get(itemKey));
|
|
13698
13874
|
}, [itemPendingInvalidationFields, store]);
|
|
13699
13875
|
const resultSelector = useCallback((state) => {
|
|
@@ -13757,20 +13933,23 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13757
13933
|
let status = itemQuery.status;
|
|
13758
13934
|
const itemFieldInvalidationFields = state.itemFieldInvalidationFields[itemKey];
|
|
13759
13935
|
if (partialResources && Array.isArray(fields) && fields.length > 0 && (status === "success" || status === "refetching")) {
|
|
13760
|
-
|
|
13761
|
-
|
|
13762
|
-
|
|
13763
|
-
|
|
13764
|
-
|
|
13765
|
-
|
|
13766
|
-
|
|
13767
|
-
if (
|
|
13936
|
+
if (getFallbackMissingRequestedFields({
|
|
13937
|
+
item: rawItemState,
|
|
13938
|
+
loadedFields
|
|
13939
|
+
}, fields, partialResources.inferFields).length > 0) status = hasCachedDataInState && showPartialAsRefetching ? "refetching" : "loading";
|
|
13940
|
+
} else if (partialResources && fields === "*" && (status === "success" || status === "refetching")) {
|
|
13941
|
+
const isIncomplete = !snapshotIsFullyLoaded(loadedFields, rawItemState, partialResources.inferFields) && !(itemsPendingFullInvalidation.has(itemKey) && hasCachedDataInState);
|
|
13942
|
+
const isStale = !isIncomplete && !snapshotIsFullyLoadedAndFresh(itemKey, loadedFields, rawItemState, partialResources.inferFields, itemsPendingFullInvalidation);
|
|
13943
|
+
if (isIncomplete) status = hasCachedDataInState && showPartialAsRefetching ? "refetching" : "loading";
|
|
13944
|
+
else if (isStale || itemFieldInvalidationFields && itemFieldInvalidationFields.length > 0) status = "refetching";
|
|
13768
13945
|
}
|
|
13769
13946
|
if (partialResources && showPartialAsRefetching) {
|
|
13770
13947
|
if (Array.isArray(fields) && fields.length > 0) {
|
|
13771
|
-
const pendingRequestedFields =
|
|
13948
|
+
const pendingRequestedFields = getStaleOrMissingRequestedFields(itemKey, loadedFields, rawItemState, fields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey));
|
|
13772
13949
|
if (pendingRequestedFields.length > 0) loadingFields = pendingRequestedFields;
|
|
13773
|
-
} else if (fields === "*"
|
|
13950
|
+
} else if (fields === "*") {
|
|
13951
|
+
if (hasFullyLoadedFields(loadedFields) && itemFieldInvalidationFields && itemFieldInvalidationFields.length > 0) loadingFields = itemFieldInvalidationFields;
|
|
13952
|
+
}
|
|
13774
13953
|
}
|
|
13775
13954
|
if (partialResources && status === "refetching" && Array.isArray(fields) && fields.length > 0 && itemFieldInvalidationFields && !fields.some((f) => itemFieldInvalidationFields.includes(f))) status = "success";
|
|
13776
13955
|
if (!returnRefetchingStatus && status === "refetching") status = "success";
|
|
@@ -13789,6 +13968,8 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13789
13968
|
});
|
|
13790
13969
|
}, [
|
|
13791
13970
|
activeOfflineOverlays,
|
|
13971
|
+
getUnresolvedPendingInvalidationFields,
|
|
13972
|
+
itemsPendingFullInvalidation,
|
|
13792
13973
|
loadFromStateOnly,
|
|
13793
13974
|
offlineEntitiesByKey,
|
|
13794
13975
|
partialResources,
|
|
@@ -13799,14 +13980,21 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13799
13980
|
return queriesWithId.map(({ itemKey, fields }) => {
|
|
13800
13981
|
const itemQuery = state.itemQueries[itemKey];
|
|
13801
13982
|
const loadedFields = state.itemLoadedFields[itemKey] ?? [];
|
|
13802
|
-
const missingRequestedFields = partialResources && Array.isArray(fields) && fields.length > 0 ?
|
|
13983
|
+
const missingRequestedFields = partialResources && Array.isArray(fields) && fields.length > 0 ? getStaleOrMissingRequestedFields(itemKey, state.itemLoadedFields[itemKey], state.items[itemKey], fields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey)).sort() : [];
|
|
13984
|
+
const needsFullFetch = partialResources && fields === "*" ? !snapshotIsFullyLoaded(loadedFields, state.items[itemKey], partialResources.inferFields) || itemsPendingFullInvalidation.has(itemKey) && !hasFullyLoadedFields(loadedFields) : false;
|
|
13803
13985
|
return {
|
|
13804
13986
|
status: itemQuery?.status ?? null,
|
|
13805
13987
|
refetchOnMount: itemQuery?.refetchOnMount ?? null,
|
|
13806
|
-
missingRequestedFieldsKey: JSON.stringify(missingRequestedFields)
|
|
13988
|
+
missingRequestedFieldsKey: JSON.stringify(missingRequestedFields),
|
|
13989
|
+
needsFullFetch
|
|
13807
13990
|
};
|
|
13808
13991
|
});
|
|
13809
|
-
}, [
|
|
13992
|
+
}, [
|
|
13993
|
+
getUnresolvedPendingInvalidationFields,
|
|
13994
|
+
itemsPendingFullInvalidation,
|
|
13995
|
+
partialResources,
|
|
13996
|
+
queriesWithId
|
|
13997
|
+
]);
|
|
13810
13998
|
const storeState = store.useSelectorRC(resultSelector, { equalityFn: deepEqual });
|
|
13811
13999
|
const visibleStoreState = useMemo(() => {
|
|
13812
14000
|
return storeState.map((result, index) => {
|
|
@@ -13817,7 +14005,7 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13817
14005
|
const fallbackItemState = readFallbackItemState(query.itemKey);
|
|
13818
14006
|
const overlay = activeOfflineOverlays[result.itemStateKey];
|
|
13819
14007
|
const hasOverlay = overlay !== void 0;
|
|
13820
|
-
if (!(!partialResources || query.fields === void 0 || query.fields === "*"
|
|
14008
|
+
if (!(!partialResources || query.fields === void 0 || (query.fields === "*" ? snapshotIsFullyLoaded(fallbackItemState?.loadedFields, fallbackItemState?.item, partialResources.inferFields) : fallbackItemHasRequestedFields(fallbackItemState, query.fields, partialResources.inferFields)))) return result;
|
|
13821
14009
|
const fallbackItemQuery = hasOverlay && overlay.item !== null && fallbackItemState?.itemQuery == null ? {
|
|
13822
14010
|
status: "success",
|
|
13823
14011
|
wasLoaded: true,
|
|
@@ -13937,24 +14125,34 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13937
14125
|
const itemFetchIsActive = itemState?.status === "loading" || itemState?.status === "refetching";
|
|
13938
14126
|
if (partialResources && !shouldFetch) {
|
|
13939
14127
|
const loadedFields = store.state.itemLoadedFields[itemKey] ?? [];
|
|
14128
|
+
const item = store.state.items[itemKey];
|
|
13940
14129
|
const unresolvedPendingInvalidationFields = getUnresolvedPendingInvalidationFields(itemKey);
|
|
13941
|
-
const
|
|
14130
|
+
const hasUnresolvedFullInvalidation = itemsPendingFullInvalidation.has(itemKey) && !hasFullyLoadedFields(loadedFields);
|
|
14131
|
+
const invalidationPriority = unresolvedPendingInvalidationFields.length > 0 || hasUnresolvedFullInvalidation ? itemFieldInvalidationPriorities.get(itemKey) : void 0;
|
|
13942
14132
|
if (Array.isArray(fields) && fields.length > 0) {
|
|
13943
|
-
const
|
|
14133
|
+
const affectedInvalidationFields = fields.filter((field) => unresolvedPendingInvalidationFields.includes(field));
|
|
14134
|
+
const staleOrMissingFields = getStaleOrMissingRequestedFields(itemKey, loadedFields, item, fields, partialResources.inferFields, itemsPendingFullInvalidation, unresolvedPendingInvalidationFields);
|
|
14135
|
+
const missingFields = loadedFields === "*" ? [] : staleOrMissingFields.filter((field) => !loadedFields.includes(field));
|
|
13944
14136
|
const hasMissingFields = missingFields.length > 0;
|
|
13945
|
-
const hasAffectedFieldInvalidation =
|
|
13946
|
-
|
|
14137
|
+
const hasAffectedFieldInvalidation = affectedInvalidationFields.length > 0;
|
|
14138
|
+
const shouldFetchForInvalidation = hasAffectedFieldInvalidation && !ignoreItemsInRefetchOnMount.has(itemKey);
|
|
14139
|
+
if ((hasMissingFields || shouldFetchForInvalidation) && !itemFetchIsActive) {
|
|
13947
14140
|
shouldFetch = true;
|
|
13948
14141
|
requiredFetch = true;
|
|
13949
|
-
fieldsToFetch = missingFields;
|
|
14142
|
+
fieldsToFetch = Array.from(new Set([...missingFields, ...affectedInvalidationFields]));
|
|
13950
14143
|
if (fetchType === "lowPriority") fetchType = "highPriority";
|
|
13951
14144
|
}
|
|
13952
14145
|
if (hasAffectedFieldInvalidation && invalidationPriority && fetchTypePriority[invalidationPriority] > fetchTypePriority[fetchType]) fetchType = invalidationPriority;
|
|
13953
|
-
} else if (fields === "*"
|
|
13954
|
-
|
|
13955
|
-
|
|
13956
|
-
|
|
13957
|
-
|
|
14146
|
+
} else if (fields === "*") {
|
|
14147
|
+
const missingFullItem = !snapshotIsFullyLoaded(loadedFields, item, partialResources.inferFields) || hasUnresolvedFullInvalidation;
|
|
14148
|
+
const shouldFetchForInvalidation = !missingFullItem && unresolvedPendingInvalidationFields.length > 0 && !ignoreItemsInRefetchOnMount.has(itemKey);
|
|
14149
|
+
if ((missingFullItem || shouldFetchForInvalidation) && !itemFetchIsActive) {
|
|
14150
|
+
shouldFetch = true;
|
|
14151
|
+
requiredFetch = true;
|
|
14152
|
+
fieldsToFetch = missingFullItem ? "*" : unresolvedPendingInvalidationFields;
|
|
14153
|
+
if (fetchType === "lowPriority") fetchType = "highPriority";
|
|
14154
|
+
if (invalidationPriority && fetchTypePriority[invalidationPriority] > fetchTypePriority[fetchType]) fetchType = invalidationPriority;
|
|
14155
|
+
}
|
|
13958
14156
|
}
|
|
13959
14157
|
}
|
|
13960
14158
|
if (!shouldFetch && ignoreItemsInRefetchOnMount.has(itemKey)) continue;
|
|
@@ -13975,6 +14173,7 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13975
14173
|
ignoreItemsInRefetchOnMount,
|
|
13976
14174
|
itemFieldInvalidationPriorities,
|
|
13977
14175
|
itemPendingInvalidationFields,
|
|
14176
|
+
itemsPendingFullInvalidation,
|
|
13978
14177
|
loadFromStateOnly,
|
|
13979
14178
|
partialResources,
|
|
13980
14179
|
preloadItems,
|
|
@@ -13986,7 +14185,7 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13986
14185
|
}
|
|
13987
14186
|
//#endregion
|
|
13988
14187
|
//#region src/listQueryStore/useMultipleListQueries.ts
|
|
13989
|
-
function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allItemsReturnIdleStatus, returnRefetchingStatus: allItemsReturnRefetchingStatus, showPartialAsRefetching: allItemsShowPartialAsRefetching, omitPayload: allItemsOmitPayload, disableRefetches: allItemsDisableRefetches, disableRefetchOnMount: allItemsDisableRefetchOnMount, isOffScreen: allItemsIsOffScreen, loadSize: allItemsLoadSize, debouncePayload }, store, events, getQueryKey, registerActiveQueries, touchQueries, getQueryState, readFallbackQueryState, preloadQueries, preloadQueriesBeforePaint, preloadDerivedQueryItems, readFallbackItemState, scheduleAutomaticListQueryFetch, queryInvalidationWasTriggered, itemFieldInvalidationPriorities, itemPendingInvalidationFields, globalDisableRefetchOnMount, partialResources, derivedQueries, isOfflineMode, offlineEntities, offlineOverlays) {
|
|
14188
|
+
function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allItemsReturnIdleStatus, returnRefetchingStatus: allItemsReturnRefetchingStatus, showPartialAsRefetching: allItemsShowPartialAsRefetching, omitPayload: allItemsOmitPayload, disableRefetches: allItemsDisableRefetches, disableRefetchOnMount: allItemsDisableRefetchOnMount, isOffScreen: allItemsIsOffScreen, loadSize: allItemsLoadSize, debouncePayload }, store, events, getQueryKey, registerActiveQueries, touchQueries, getQueryState, readFallbackQueryState, preloadQueries, preloadQueriesBeforePaint, preloadDerivedQueryItems, readFallbackItemState, scheduleAutomaticListQueryFetch, queryInvalidationWasTriggered, itemFieldInvalidationPriorities, itemPendingInvalidationFields, itemsPendingFullInvalidation, globalDisableRefetchOnMount, partialResources, derivedQueries, isOfflineMode, offlineEntities, offlineOverlays) {
|
|
13990
14189
|
const isOffScreenFromContext = useContext(IsOffScreenContext);
|
|
13991
14190
|
const queriesWithId = useMemo(() => {
|
|
13992
14191
|
return queries.map((queryProps) => {
|
|
@@ -14095,6 +14294,8 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14095
14294
|
partialResources
|
|
14096
14295
|
]);
|
|
14097
14296
|
const getUnresolvedPendingInvalidationFields = useCallback((itemKey, state) => {
|
|
14297
|
+
const stateInvalidationFields = (state ? state.itemFieldInvalidationFields : store.state.itemFieldInvalidationFields)[itemKey];
|
|
14298
|
+
if (stateInvalidationFields && stateInvalidationFields.length > 0) return stateInvalidationFields;
|
|
14098
14299
|
return excludeLoadedFields((state ? state.itemLoadedFields : store.state.itemLoadedFields)[itemKey], itemPendingInvalidationFields.get(itemKey));
|
|
14099
14300
|
}, [itemPendingInvalidationFields, store]);
|
|
14100
14301
|
const getHighestPendingInvalidationPriority = useCallback((itemKeys, requestedFields) => {
|
|
@@ -14236,34 +14437,49 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14236
14437
|
const hasCachedItemsInState = effectiveQuery.query.items.some((itemKey) => {
|
|
14237
14438
|
return state.items[itemKey] != null;
|
|
14238
14439
|
});
|
|
14239
|
-
|
|
14240
|
-
|
|
14241
|
-
|
|
14242
|
-
|
|
14243
|
-
|
|
14244
|
-
|
|
14245
|
-
|
|
14246
|
-
|
|
14247
|
-
|
|
14248
|
-
|
|
14249
|
-
|
|
14250
|
-
|
|
14251
|
-
|
|
14440
|
+
let staleOrMissingRequestedFields;
|
|
14441
|
+
let hasAnyIncompleteItem = false;
|
|
14442
|
+
let hasAnyStaleItem = false;
|
|
14443
|
+
const statusCanBeOverridden = status === "success" || status === "refetching";
|
|
14444
|
+
if (partialResources && (statusCanBeOverridden || showPartialAsRefetching)) {
|
|
14445
|
+
if (Array.isArray(fields) && fields.length > 0) {
|
|
14446
|
+
staleOrMissingRequestedFields = /* @__PURE__ */ new Set();
|
|
14447
|
+
for (const itemKey of effectiveQuery.query.items) {
|
|
14448
|
+
for (const field of getStaleOrMissingRequestedFields(itemKey, state.itemLoadedFields[itemKey], state.items[itemKey], fields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey, state))) staleOrMissingRequestedFields.add(field);
|
|
14449
|
+
if (staleOrMissingRequestedFields.size === fields.length || !showPartialAsRefetching && staleOrMissingRequestedFields.size > 0) break;
|
|
14450
|
+
}
|
|
14451
|
+
} else if (fields === "*") {
|
|
14452
|
+
hasAnyIncompleteItem = effectiveQuery.query.items.some((itemKey) => {
|
|
14453
|
+
const item = state.items[itemKey];
|
|
14454
|
+
if (snapshotIsFullyLoaded(state.itemLoadedFields[itemKey], item, partialResources.inferFields)) return false;
|
|
14455
|
+
return !(itemsPendingFullInvalidation.has(itemKey) && item != null);
|
|
14456
|
+
});
|
|
14457
|
+
hasAnyStaleItem = !hasAnyIncompleteItem && effectiveQuery.query.items.some((itemKey) => !snapshotIsFullyLoadedAndFresh(itemKey, state.itemLoadedFields[itemKey], state.items[itemKey], partialResources.inferFields, itemsPendingFullInvalidation));
|
|
14458
|
+
}
|
|
14459
|
+
}
|
|
14460
|
+
if (partialResources && Array.isArray(fields) && statusCanBeOverridden && staleOrMissingRequestedFields && staleOrMissingRequestedFields.size > 0) {
|
|
14461
|
+
const someItemMissingFieldDataInState = effectiveQuery.query.items.some((itemKey) => getFallbackMissingRequestedFields({
|
|
14462
|
+
item: state.items[itemKey],
|
|
14463
|
+
loadedFields: state.itemLoadedFields[itemKey]
|
|
14464
|
+
}, fields, partialResources.inferFields).length > 0);
|
|
14465
|
+
if (!hasCachedItemsInState) status = "loading";
|
|
14466
|
+
else if (someItemMissingFieldDataInState) status = showPartialAsRefetching ? "refetching" : "loading";
|
|
14252
14467
|
else status = "refetching";
|
|
14253
|
-
} else if (partialResources && fields === "*" &&
|
|
14254
|
-
|
|
14468
|
+
} else if (partialResources && fields === "*" && statusCanBeOverridden) {
|
|
14469
|
+
const hasAnyFieldInvalidation = effectiveQuery.query.items.some((itemKey) => {
|
|
14255
14470
|
const itemFieldInvalidationFields = state.itemFieldInvalidationFields[itemKey];
|
|
14256
14471
|
return !!itemFieldInvalidationFields && itemFieldInvalidationFields.length > 0;
|
|
14257
|
-
})
|
|
14472
|
+
});
|
|
14473
|
+
if (hasAnyIncompleteItem) if (!hasCachedItemsInState) status = "loading";
|
|
14474
|
+
else status = showPartialAsRefetching ? "refetching" : "loading";
|
|
14475
|
+
else if (hasAnyStaleItem || hasAnyFieldInvalidation) status = "refetching";
|
|
14258
14476
|
}
|
|
14259
14477
|
if (partialResources && showPartialAsRefetching) {
|
|
14260
14478
|
if (Array.isArray(fields) && fields.length > 0) {
|
|
14261
|
-
const pendingRequestedFields =
|
|
14262
|
-
return !(state.itemLoadedFields[itemKey] ?? []).includes(field);
|
|
14263
|
-
}));
|
|
14479
|
+
const pendingRequestedFields = status === "loading" && effectiveQuery.query.items.length === 0 ? [...fields] : fields.filter((field) => staleOrMissingRequestedFields?.has(field) ?? false);
|
|
14264
14480
|
if (pendingRequestedFields.length > 0) loadingFields = pendingRequestedFields;
|
|
14265
14481
|
} else if (fields === "*") {
|
|
14266
|
-
const pendingInvalidationFields = Array.from(new Set(effectiveQuery.query.items.flatMap((itemKey) => state.itemFieldInvalidationFields[itemKey] ?? []))).sort();
|
|
14482
|
+
const pendingInvalidationFields = hasAnyIncompleteItem || hasAnyStaleItem ? [] : Array.from(new Set(effectiveQuery.query.items.flatMap((itemKey) => state.itemFieldInvalidationFields[itemKey] ?? []))).sort();
|
|
14267
14483
|
if (pendingInvalidationFields.length > 0) loadingFields = pendingInvalidationFields;
|
|
14268
14484
|
}
|
|
14269
14485
|
}
|
|
@@ -14288,8 +14504,10 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14288
14504
|
};
|
|
14289
14505
|
});
|
|
14290
14506
|
}, [
|
|
14507
|
+
getUnresolvedPendingInvalidationFields,
|
|
14291
14508
|
getVisibleQueryItemKeys,
|
|
14292
14509
|
isOfflineMode,
|
|
14510
|
+
itemsPendingFullInvalidation,
|
|
14293
14511
|
offlineEntitiesByKey,
|
|
14294
14512
|
partialResources,
|
|
14295
14513
|
queriesWithId,
|
|
@@ -14307,11 +14525,16 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14307
14525
|
if (fallbackQuery && readFallbackItemState) {
|
|
14308
14526
|
const visibleItemKeys = getVisibleQueryItemKeys(result.queryKey, fallbackQuery.items);
|
|
14309
14527
|
const requestedFields = Array.isArray(queryConfig.fields) ? queryConfig.fields : void 0;
|
|
14528
|
+
const requiresFullItems = queryConfig.fields === "*";
|
|
14310
14529
|
const fallbackItemStatesByKey = /* @__PURE__ */ new Map();
|
|
14311
14530
|
for (const itemKey of visibleItemKeys) {
|
|
14312
14531
|
const fallbackItemState = readFallbackItemState(itemKey);
|
|
14313
14532
|
fallbackItemStatesByKey.set(itemKey, fallbackItemState);
|
|
14314
|
-
if (
|
|
14533
|
+
if (partialResources) {
|
|
14534
|
+
if (requiresFullItems) {
|
|
14535
|
+
if (!snapshotIsFullyLoaded(fallbackItemState?.loadedFields, fallbackItemState?.item, partialResources.inferFields)) return result;
|
|
14536
|
+
} else if (requestedFields && !fallbackItemHasRequestedFields(fallbackItemState, requestedFields, partialResources.inferFields)) return result;
|
|
14537
|
+
}
|
|
14315
14538
|
}
|
|
14316
14539
|
const fallbackItems = selectVisibleItems(visibleItemKeys, queryConfig.fields, (itemKey) => {
|
|
14317
14540
|
const fallbackItemState = fallbackItemStatesByKey.get(itemKey);
|
|
@@ -14368,7 +14591,7 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14368
14591
|
const unresolvedFields = Array.from(new Set(effectiveQuery.query.items.flatMap((itemKey) => getUnresolvedPendingInvalidationFields(itemKey, state)))).sort();
|
|
14369
14592
|
const requestedFields = Array.isArray(queryConfig.fields) ? queryConfig.fields : void 0;
|
|
14370
14593
|
const missingRequestedFields = requestedFields && requestedFields.length > 0 ? effectiveQuery.query.items.flatMap((itemKey) => {
|
|
14371
|
-
return
|
|
14594
|
+
return getStaleOrMissingRequestedFields(itemKey, state.itemLoadedFields[itemKey], state.items[itemKey], requestedFields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey, state));
|
|
14372
14595
|
}).filter((field, index, array) => array.indexOf(field) === index).sort() : [];
|
|
14373
14596
|
let unresolvedInvalidationFieldsKey = "";
|
|
14374
14597
|
if (queryConfig.fields === "*") unresolvedInvalidationFieldsKey = JSON.stringify(unresolvedFields);
|
|
@@ -14387,6 +14610,7 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14387
14610
|
}, [
|
|
14388
14611
|
getHighestPendingInvalidationPriority,
|
|
14389
14612
|
getUnresolvedPendingInvalidationFields,
|
|
14613
|
+
itemsPendingFullInvalidation,
|
|
14390
14614
|
partialResources,
|
|
14391
14615
|
queriesWithId,
|
|
14392
14616
|
resolveEffectiveQuery
|
|
@@ -14475,10 +14699,7 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14475
14699
|
if (partialResources && !shouldFetch && effectiveQueryState) {
|
|
14476
14700
|
const isQueryFetchInFlight = effectiveQueryState.status === "loading" || effectiveQueryState.status === "refetching" || effectiveQueryState.status === "loadingMore";
|
|
14477
14701
|
if (Array.isArray(fields) && fields.length > 0) {
|
|
14478
|
-
if (effectiveQueryState.items.some((itemKey) => {
|
|
14479
|
-
const loadedFields = store.state.itemLoadedFields[itemKey] ?? [];
|
|
14480
|
-
return fields.some((field) => !loadedFields.includes(field));
|
|
14481
|
-
}) && !isQueryFetchInFlight) {
|
|
14702
|
+
if (effectiveQueryState.items.some((itemKey) => getStaleOrMissingRequestedFields(itemKey, store.state.itemLoadedFields[itemKey], store.state.items[itemKey], fields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey)).length > 0) && !isQueryFetchInFlight) {
|
|
14482
14703
|
shouldFetch = true;
|
|
14483
14704
|
requiredFetch = true;
|
|
14484
14705
|
fieldsToFetch = fields;
|
|
@@ -14495,9 +14716,11 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14495
14716
|
if (invalidationPriority && fetchTypePriority[invalidationPriority] > fetchTypePriority[fetchType]) fetchType = invalidationPriority;
|
|
14496
14717
|
}
|
|
14497
14718
|
} else if (fields === "*") {
|
|
14498
|
-
|
|
14719
|
+
const hasAnyPartialItem = effectiveQueryState.items.some((itemKey) => !snapshotIsFullyLoadedAndFresh(itemKey, store.state.itemLoadedFields[itemKey], store.state.items[itemKey], partialResources.inferFields, itemsPendingFullInvalidation));
|
|
14720
|
+
const hasAnyFieldInvalidation = effectiveQueryState.items.some((itemKey) => {
|
|
14499
14721
|
return getUnresolvedPendingInvalidationFields(itemKey).length > 0;
|
|
14500
|
-
})
|
|
14722
|
+
});
|
|
14723
|
+
if ((hasAnyPartialItem || hasAnyFieldInvalidation) && !isQueryFetchInFlight) {
|
|
14501
14724
|
shouldFetch = true;
|
|
14502
14725
|
requiredFetch = true;
|
|
14503
14726
|
const invalidationPriority = getHighestPendingInvalidationPriority(effectiveQueryState.items, void 0);
|
|
@@ -14533,6 +14756,7 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14533
14756
|
automaticRetryState,
|
|
14534
14757
|
itemFieldInvalidationPriorities,
|
|
14535
14758
|
itemPendingInvalidationFields,
|
|
14759
|
+
itemsPendingFullInvalidation,
|
|
14536
14760
|
getHighestPendingInvalidationPriority,
|
|
14537
14761
|
getUnresolvedPendingInvalidationFields,
|
|
14538
14762
|
stickyDerivedQueryKeys
|
|
@@ -14857,7 +15081,7 @@ function createListQueryStore(storeOptions) {
|
|
|
14857
15081
|
itemKey,
|
|
14858
15082
|
item: store.state.items[itemKey] ?? null,
|
|
14859
15083
|
itemQuery: store.state.itemQueries[itemKey] ?? null,
|
|
14860
|
-
loadedFields: store.state.itemLoadedFields[itemKey]
|
|
15084
|
+
loadedFields: store.state.itemLoadedFields[itemKey]
|
|
14861
15085
|
}));
|
|
14862
15086
|
}
|
|
14863
15087
|
function publishQuerySnapshot(queryKey, consistency = currentBroadcastConsistency) {
|
|
@@ -14884,7 +15108,7 @@ function createListQueryStore(storeOptions) {
|
|
|
14884
15108
|
consistency,
|
|
14885
15109
|
item: store.state.items[itemKey] ?? null,
|
|
14886
15110
|
itemQuery: store.state.itemQueries[itemKey] ?? null,
|
|
14887
|
-
loadedFields: store.state.itemLoadedFields[itemKey]
|
|
15111
|
+
loadedFields: store.state.itemLoadedFields[itemKey]
|
|
14888
15112
|
});
|
|
14889
15113
|
if (!message) return;
|
|
14890
15114
|
recordItemSyncVersion(itemKey, message, consistency);
|
|
@@ -14940,6 +15164,8 @@ function createListQueryStore(storeOptions) {
|
|
|
14940
15164
|
preloaded: results[index] ?? false
|
|
14941
15165
|
}));
|
|
14942
15166
|
}
|
|
15167
|
+
const itemPendingInvalidationFields = /* @__PURE__ */ new Map();
|
|
15168
|
+
const itemsPendingFullInvalidation = /* @__PURE__ */ new Set();
|
|
14943
15169
|
const { getQueryState, getQueriesKeyArray, getQueriesState, getQueriesRelatedToItem, getItemsKeyArray, getItemState, scheduleListQueryFetch, loadMore, awaitListQueryFetch, getQueryFromStateOrFetch, scheduleItemFetch, awaitItemFetch, getItemFromStateOrFetch, getOrCreateQueryScheduler, getOrCreateItemScheduler, getKnownQueryScheduler, getKnownItemScheduler, syncRemoteFetchStart, syncRemoteFetchSuccess, deleteQueryFetchResources, deleteItemFetchResources, resetSchedulers } = createFetchApi(store, normalizedFetchListFn, offsetPagination, fetchItemFn, batchFetchItemFn, getItemsBatchKey, errorNormalizer, partialResources, lowPriorityThrottleMs, getCoalescingWindowMs, mediumPriorityDelayMs, wrappedDynamicRealtimeThrottleMs, onSchedulerEvent, usesRealTimeUpdates, defaultQuerySize, maxItemBatchSize, getQueryKey, getItemKey, normalizeFieldsOption, !!persistence && !persistence.hasAsyncPreload, persistence ? (queryKeys) => persistence.preloadQueries(queryKeys) : void 0, persistence ? (itemKeys) => persistence.preloadItems(itemKeys) : void 0, persistence, testOptions?.initialLastFetchStartTime, (requests, startedAt) => {
|
|
14944
15170
|
const queryKey = requests[0]?.requestId;
|
|
14945
15171
|
if (!queryKey) return;
|
|
@@ -15001,12 +15227,12 @@ function createListQueryStore(storeOptions) {
|
|
|
15001
15227
|
});
|
|
15002
15228
|
for (const { itemKey } of successfulItems) publishItemSnapshot(itemKey, "confirmed");
|
|
15003
15229
|
}
|
|
15004
|
-
}, offlineFetchController);
|
|
15005
|
-
const { storeEvents, queryInvalidationWasTriggered, itemInvalidationWasTriggered, itemFieldInvalidationPriorities,
|
|
15230
|
+
}, offlineFetchController, itemPendingInvalidationFields, itemsPendingFullInvalidation);
|
|
15231
|
+
const { storeEvents, queryInvalidationWasTriggered, itemInvalidationWasTriggered, itemFieldInvalidationPriorities, invalidateQueryAndItems, invalidateItem, startItemMutation, updateItemState: updateItemStateBase, addItemToState: addItemToStateBase, deleteItemState: deleteItemStateBase, resetInvalidationTracking, performMutation: performMutationBase } = createMutationApi(store, fetchItemFn, partialResources, optimisticListUpdates, onInvalidateQuery, onInvalidateItem, resolvedOnMutationError, errorNormalizer, getItemKey, getQueriesKeyArray, getQueriesRelatedToItem, getItemsKeyArray, getOrCreateItemScheduler, getOrCreateQueryScheduler, deleteItemFetchResources, (event) => {
|
|
15006
15232
|
events.emit("invalidateQuery", event);
|
|
15007
15233
|
}, (event) => {
|
|
15008
15234
|
events.emit("invalidateItem", event);
|
|
15009
|
-
}, blockWindowClose, resolvedOfflineConfig ? offlineMutationController : null, runWithBroadcastConsistency, publishQuerySnapshot, publishItemSnapshot, void 0);
|
|
15235
|
+
}, blockWindowClose, resolvedOfflineConfig ? offlineMutationController : null, runWithBroadcastConsistency, publishQuerySnapshot, publishItemSnapshot, void 0, itemPendingInvalidationFields, itemsPendingFullInvalidation);
|
|
15010
15236
|
if (resolvedPersistentStorageConfig && resolvedOfflineConfig) offlineController = createOfflineStoreController(id, "listQuery", getSessionKeyForRuntime, resolvedPersistentStorageConfig.onPersistentStorageError, import.meta.env.DEV ? storeManager.debugLogger : void 0, resolvedPersistentStorageConfig.adapter, {
|
|
15011
15237
|
normalizeEntityRefs: (entityRefs) => entityRefs.map((ref) => {
|
|
15012
15238
|
const normalizedRef = offlineItemEntityRefSchema.parse(ref).unwrapOrNull();
|
|
@@ -15077,10 +15303,12 @@ function createListQueryStore(storeOptions) {
|
|
|
15077
15303
|
}
|
|
15078
15304
|
}, resolvedOfflineConfig.session, __LEGIT_CAST__(offlineOperationsForRuntime));
|
|
15079
15305
|
function applyLoadedFieldsFromSnapshot(draft, itemKey, loadedFields) {
|
|
15080
|
-
if (loadedFields
|
|
15081
|
-
|
|
15082
|
-
|
|
15083
|
-
|
|
15306
|
+
if (loadedFields === void 0) return;
|
|
15307
|
+
if (loadedFields === "*") draft.itemLoadedFields[itemKey] = "*";
|
|
15308
|
+
else if (loadedFields.length > 0) {
|
|
15309
|
+
const existingLoadedFields = draft.itemLoadedFields[itemKey];
|
|
15310
|
+
if (existingLoadedFields !== "*") draft.itemLoadedFields[itemKey] = Array.from(new Set([...existingLoadedFields ?? [], ...loadedFields])).sort();
|
|
15311
|
+
} else if (draft.itemLoadedFields[itemKey] === void 0) draft.itemLoadedFields[itemKey] = [];
|
|
15084
15312
|
const invalidationFields = draft.itemFieldInvalidationFields[itemKey];
|
|
15085
15313
|
if (!invalidationFields) return;
|
|
15086
15314
|
const remainingFields = excludeLoadedFields(loadedFields, invalidationFields);
|
|
@@ -15090,18 +15318,27 @@ function createListQueryStore(storeOptions) {
|
|
|
15090
15318
|
function pruneItemInvalidationTracking() {
|
|
15091
15319
|
for (const [itemKey, pendingFields] of itemPendingInvalidationFields) {
|
|
15092
15320
|
const remainingFields = excludeLoadedFields(store.state.itemLoadedFields[itemKey], pendingFields);
|
|
15321
|
+
const stateInvalidationFields = store.state.itemFieldInvalidationFields[itemKey];
|
|
15322
|
+
if (stateInvalidationFields && stateInvalidationFields.length > 0) {
|
|
15323
|
+
const mergedFields = Array.from(new Set([...stateInvalidationFields, ...remainingFields])).sort();
|
|
15324
|
+
itemPendingInvalidationFields.set(itemKey, mergedFields);
|
|
15325
|
+
continue;
|
|
15326
|
+
}
|
|
15093
15327
|
if (remainingFields.length > 0) itemPendingInvalidationFields.set(itemKey, remainingFields);
|
|
15094
15328
|
else itemPendingInvalidationFields.delete(itemKey);
|
|
15095
15329
|
}
|
|
15330
|
+
for (const itemKey of itemsPendingFullInvalidation) if (store.state.itemLoadedFields[itemKey] === "*") itemsPendingFullInvalidation.delete(itemKey);
|
|
15096
15331
|
for (const itemKey of itemFieldInvalidationPriorities.keys()) {
|
|
15097
15332
|
const hasPendingStateInvalidation = !!store.state.itemFieldInvalidationFields[itemKey];
|
|
15098
15333
|
const hasPendingTrackedInvalidation = (itemPendingInvalidationFields.get(itemKey)?.length ?? 0) > 0;
|
|
15099
|
-
|
|
15334
|
+
const hasPendingFullInvalidation = itemsPendingFullInvalidation.has(itemKey);
|
|
15335
|
+
if (!hasPendingStateInvalidation && !hasPendingTrackedInvalidation && !hasPendingFullInvalidation) itemFieldInvalidationPriorities.delete(itemKey);
|
|
15100
15336
|
}
|
|
15101
15337
|
}
|
|
15102
15338
|
function cleanupItemStateMetadata(itemKey) {
|
|
15103
15339
|
itemFieldInvalidationPriorities.delete(itemKey);
|
|
15104
15340
|
itemPendingInvalidationFields.delete(itemKey);
|
|
15341
|
+
itemsPendingFullInvalidation.delete(itemKey);
|
|
15105
15342
|
itemInvalidationWasTriggered.delete(itemKey);
|
|
15106
15343
|
itemCacheRuntime.clear(itemKey);
|
|
15107
15344
|
}
|
|
@@ -15159,18 +15396,20 @@ function createListQueryStore(storeOptions) {
|
|
|
15159
15396
|
return partialResources.mergeItems(currentItem ?? void 0, incomingItem);
|
|
15160
15397
|
}
|
|
15161
15398
|
function itemSnapshotSatisfiesRequestedFields(item, loadedFields, requestedFields) {
|
|
15162
|
-
if (!partialResources
|
|
15399
|
+
if (!partialResources) return true;
|
|
15163
15400
|
if (item === null) return true;
|
|
15401
|
+
if (loadedFields !== void 0 && loadedFields !== "*" && loadedFields.length === 0) return false;
|
|
15402
|
+
if (!requestedFields || requestedFields.length === 0) return snapshotIsFullyLoaded(loadedFields, item, partialResources.inferFields);
|
|
15164
15403
|
return fallbackItemHasRequestedFields({
|
|
15165
15404
|
item,
|
|
15166
15405
|
loadedFields
|
|
15167
|
-
}, requestedFields);
|
|
15406
|
+
}, requestedFields, partialResources.inferFields);
|
|
15168
15407
|
}
|
|
15169
15408
|
function querySnapshotSatisfiesPendingQueryFetch(message, snapshotItemsByKey, request) {
|
|
15170
15409
|
const requestedEnd = request.payload.offset + request.payload.limit;
|
|
15171
15410
|
if (message.query.items.length < requestedEnd && message.query.hasMore) return false;
|
|
15172
15411
|
const requestedFields = request.payload.fields;
|
|
15173
|
-
if (!partialResources
|
|
15412
|
+
if (!partialResources) return true;
|
|
15174
15413
|
return message.query.items.slice(request.payload.offset, requestedEnd).every((itemKey) => {
|
|
15175
15414
|
const item = snapshotItemsByKey.get(itemKey);
|
|
15176
15415
|
return !!item && itemSnapshotSatisfiesRequestedFields(item.item, item.loadedFields, requestedFields);
|
|
@@ -15190,6 +15429,7 @@ function createListQueryStore(storeOptions) {
|
|
|
15190
15429
|
};
|
|
15191
15430
|
applyLoadedFieldsFromSnapshot(draft, message.itemKey, message.loadedFields);
|
|
15192
15431
|
if (!message.itemQuery && message.item === null) {
|
|
15432
|
+
delete draft.itemLoadedFields[message.itemKey];
|
|
15193
15433
|
delete draft.itemFieldInvalidationFields[message.itemKey];
|
|
15194
15434
|
for (const query of Object.values(draft.queries)) query.items = query.items.filter((itemId) => itemId !== message.itemKey);
|
|
15195
15435
|
}
|
|
@@ -15309,7 +15549,7 @@ function createListQueryStore(storeOptions) {
|
|
|
15309
15549
|
return state;
|
|
15310
15550
|
}, []);
|
|
15311
15551
|
const offlineOverlays = offlineOverlayStore.useSelectorRC(offlineOverlaysSelector);
|
|
15312
|
-
return useMultipleListQueries(queries, options, store, events, getQueryKey, registerActiveQueryRefs, touchQueries, getQueryState, persistence?.readHydratedQuery, persistence ? (payloads) => persistence.maybeHydrateQueries(payloads.map((payload) => getQueryKey(payload))) : void 0, !!persistence && !persistence.hasAsyncPreload, persistence && derivedQueries ? (payloads) => persistence.preloadItemsByDerivedQueryGroup(payloads.map((payload) => derivedQueries.getQueryGroup(payload))) : void 0, persistence?.readHydratedItem, scheduleAutomaticListQueryFetch, queryInvalidationWasTriggered, itemFieldInvalidationPriorities, itemPendingInvalidationFields, globalDisableRefetchOnMount, partialResources, derivedQueries, isStoreOfflineMode, offlineEntities, offlineOverlays);
|
|
15552
|
+
return useMultipleListQueries(queries, options, store, events, getQueryKey, registerActiveQueryRefs, touchQueries, getQueryState, persistence?.readHydratedQuery, persistence ? (payloads) => persistence.maybeHydrateQueries(payloads.map((payload) => getQueryKey(payload))) : void 0, !!persistence && !persistence.hasAsyncPreload, persistence && derivedQueries ? (payloads) => persistence.preloadItemsByDerivedQueryGroup(payloads.map((payload) => derivedQueries.getQueryGroup(payload))) : void 0, persistence?.readHydratedItem, scheduleAutomaticListQueryFetch, queryInvalidationWasTriggered, itemFieldInvalidationPriorities, itemPendingInvalidationFields, itemsPendingFullInvalidation, globalDisableRefetchOnMount, partialResources, derivedQueries, isStoreOfflineMode, offlineEntities, offlineOverlays);
|
|
15313
15553
|
};
|
|
15314
15554
|
const useListQuery$2 = function useListQuery$1(payload, options = {}) {
|
|
15315
15555
|
return useListQuery(payload, options, store, getQueryKey, scheduleListQueryFetch, useMultipleListQueries$2);
|
|
@@ -15324,7 +15564,7 @@ function createListQueryStore(storeOptions) {
|
|
|
15324
15564
|
return state;
|
|
15325
15565
|
}, []);
|
|
15326
15566
|
const offlineOverlays = offlineOverlayStore.useSelectorRC(offlineOverlaysSelector);
|
|
15327
|
-
return useMultipleItems(items, options, store, events, getItemKey, registerActiveStandaloneItems, touchItems, scheduleAutomaticItemFetch, persistence ? (payloads) => persistence.maybeHydrateItems(payloads.map((payload) => getItemKey(payload))) : void 0, !!persistence && !persistence.hasAsyncPreload, persistence?.readHydratedItem, itemInvalidationWasTriggered, itemFieldInvalidationPriorities, itemPendingInvalidationFields, globalDisableRefetchOnMount, fetchItemFn, partialResources, offlineEntities, offlineOverlays);
|
|
15567
|
+
return useMultipleItems(items, options, store, events, getItemKey, registerActiveStandaloneItems, touchItems, scheduleAutomaticItemFetch, persistence ? (payloads) => persistence.maybeHydrateItems(payloads.map((payload) => getItemKey(payload))) : void 0, !!persistence && !persistence.hasAsyncPreload, persistence?.readHydratedItem, itemInvalidationWasTriggered, itemFieldInvalidationPriorities, itemPendingInvalidationFields, itemsPendingFullInvalidation, globalDisableRefetchOnMount, fetchItemFn, partialResources, offlineEntities, offlineOverlays);
|
|
15328
15568
|
};
|
|
15329
15569
|
const useItem$3 = function useItem$2(itemPayload, options = {}) {
|
|
15330
15570
|
return useItem(itemPayload, options, store, scheduleItemFetch, useMultipleItems$3);
|