tsdf 17.0.0-alpha.17 → 17.0.0-alpha.18
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 +377 -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/partial-resources.md +24 -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,21 @@ 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 (hasMissingFields && !missingFieldsAreAvailableInState) status = hasCachedDataInState && showPartialAsRefetching ? "refetching" : "loading";
|
|
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
|
+
if (!snapshotIsFullyLoaded(loadedFields, rawItemState, partialResources.inferFields)) status = hasCachedDataInState && showPartialAsRefetching ? "refetching" : "loading";
|
|
13942
|
+
else if (itemFieldInvalidationFields && itemFieldInvalidationFields.length > 0) status = "refetching";
|
|
13768
13943
|
}
|
|
13769
13944
|
if (partialResources && showPartialAsRefetching) {
|
|
13770
13945
|
if (Array.isArray(fields) && fields.length > 0) {
|
|
13771
|
-
const pendingRequestedFields =
|
|
13946
|
+
const pendingRequestedFields = getStaleOrMissingRequestedFields(itemKey, loadedFields, rawItemState, fields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey));
|
|
13772
13947
|
if (pendingRequestedFields.length > 0) loadingFields = pendingRequestedFields;
|
|
13773
|
-
} else if (fields === "*"
|
|
13948
|
+
} else if (fields === "*") {
|
|
13949
|
+
if (hasFullyLoadedFields(loadedFields) && itemFieldInvalidationFields && itemFieldInvalidationFields.length > 0) loadingFields = itemFieldInvalidationFields;
|
|
13950
|
+
}
|
|
13774
13951
|
}
|
|
13775
13952
|
if (partialResources && status === "refetching" && Array.isArray(fields) && fields.length > 0 && itemFieldInvalidationFields && !fields.some((f) => itemFieldInvalidationFields.includes(f))) status = "success";
|
|
13776
13953
|
if (!returnRefetchingStatus && status === "refetching") status = "success";
|
|
@@ -13789,6 +13966,8 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13789
13966
|
});
|
|
13790
13967
|
}, [
|
|
13791
13968
|
activeOfflineOverlays,
|
|
13969
|
+
getUnresolvedPendingInvalidationFields,
|
|
13970
|
+
itemsPendingFullInvalidation,
|
|
13792
13971
|
loadFromStateOnly,
|
|
13793
13972
|
offlineEntitiesByKey,
|
|
13794
13973
|
partialResources,
|
|
@@ -13799,14 +13978,21 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13799
13978
|
return queriesWithId.map(({ itemKey, fields }) => {
|
|
13800
13979
|
const itemQuery = state.itemQueries[itemKey];
|
|
13801
13980
|
const loadedFields = state.itemLoadedFields[itemKey] ?? [];
|
|
13802
|
-
const missingRequestedFields = partialResources && Array.isArray(fields) && fields.length > 0 ?
|
|
13981
|
+
const missingRequestedFields = partialResources && Array.isArray(fields) && fields.length > 0 ? getStaleOrMissingRequestedFields(itemKey, state.itemLoadedFields[itemKey], state.items[itemKey], fields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey)).sort() : [];
|
|
13982
|
+
const needsFullFetch = partialResources && fields === "*" ? !snapshotIsFullyLoaded(loadedFields, state.items[itemKey], partialResources.inferFields) || itemsPendingFullInvalidation.has(itemKey) && !hasFullyLoadedFields(loadedFields) : false;
|
|
13803
13983
|
return {
|
|
13804
13984
|
status: itemQuery?.status ?? null,
|
|
13805
13985
|
refetchOnMount: itemQuery?.refetchOnMount ?? null,
|
|
13806
|
-
missingRequestedFieldsKey: JSON.stringify(missingRequestedFields)
|
|
13986
|
+
missingRequestedFieldsKey: JSON.stringify(missingRequestedFields),
|
|
13987
|
+
needsFullFetch
|
|
13807
13988
|
};
|
|
13808
13989
|
});
|
|
13809
|
-
}, [
|
|
13990
|
+
}, [
|
|
13991
|
+
getUnresolvedPendingInvalidationFields,
|
|
13992
|
+
itemsPendingFullInvalidation,
|
|
13993
|
+
partialResources,
|
|
13994
|
+
queriesWithId
|
|
13995
|
+
]);
|
|
13810
13996
|
const storeState = store.useSelectorRC(resultSelector, { equalityFn: deepEqual });
|
|
13811
13997
|
const visibleStoreState = useMemo(() => {
|
|
13812
13998
|
return storeState.map((result, index) => {
|
|
@@ -13817,7 +14003,7 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13817
14003
|
const fallbackItemState = readFallbackItemState(query.itemKey);
|
|
13818
14004
|
const overlay = activeOfflineOverlays[result.itemStateKey];
|
|
13819
14005
|
const hasOverlay = overlay !== void 0;
|
|
13820
|
-
if (!(!partialResources || query.fields === void 0 || query.fields === "*"
|
|
14006
|
+
if (!(!partialResources || query.fields === void 0 || (query.fields === "*" ? snapshotIsFullyLoaded(fallbackItemState?.loadedFields, fallbackItemState?.item, partialResources.inferFields) : fallbackItemHasRequestedFields(fallbackItemState, query.fields, partialResources.inferFields)))) return result;
|
|
13821
14007
|
const fallbackItemQuery = hasOverlay && overlay.item !== null && fallbackItemState?.itemQuery == null ? {
|
|
13822
14008
|
status: "success",
|
|
13823
14009
|
wasLoaded: true,
|
|
@@ -13937,24 +14123,34 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13937
14123
|
const itemFetchIsActive = itemState?.status === "loading" || itemState?.status === "refetching";
|
|
13938
14124
|
if (partialResources && !shouldFetch) {
|
|
13939
14125
|
const loadedFields = store.state.itemLoadedFields[itemKey] ?? [];
|
|
14126
|
+
const item = store.state.items[itemKey];
|
|
13940
14127
|
const unresolvedPendingInvalidationFields = getUnresolvedPendingInvalidationFields(itemKey);
|
|
13941
|
-
const
|
|
14128
|
+
const hasUnresolvedFullInvalidation = itemsPendingFullInvalidation.has(itemKey) && !hasFullyLoadedFields(loadedFields);
|
|
14129
|
+
const invalidationPriority = unresolvedPendingInvalidationFields.length > 0 || hasUnresolvedFullInvalidation ? itemFieldInvalidationPriorities.get(itemKey) : void 0;
|
|
13942
14130
|
if (Array.isArray(fields) && fields.length > 0) {
|
|
13943
|
-
const
|
|
14131
|
+
const affectedInvalidationFields = fields.filter((field) => unresolvedPendingInvalidationFields.includes(field));
|
|
14132
|
+
const staleOrMissingFields = getStaleOrMissingRequestedFields(itemKey, loadedFields, item, fields, partialResources.inferFields, itemsPendingFullInvalidation, unresolvedPendingInvalidationFields);
|
|
14133
|
+
const missingFields = loadedFields === "*" ? [] : staleOrMissingFields.filter((field) => !loadedFields.includes(field));
|
|
13944
14134
|
const hasMissingFields = missingFields.length > 0;
|
|
13945
|
-
const hasAffectedFieldInvalidation =
|
|
13946
|
-
|
|
14135
|
+
const hasAffectedFieldInvalidation = affectedInvalidationFields.length > 0;
|
|
14136
|
+
const shouldFetchForInvalidation = hasAffectedFieldInvalidation && !ignoreItemsInRefetchOnMount.has(itemKey);
|
|
14137
|
+
if ((hasMissingFields || shouldFetchForInvalidation) && !itemFetchIsActive) {
|
|
13947
14138
|
shouldFetch = true;
|
|
13948
14139
|
requiredFetch = true;
|
|
13949
|
-
fieldsToFetch = missingFields;
|
|
14140
|
+
fieldsToFetch = Array.from(new Set([...missingFields, ...affectedInvalidationFields]));
|
|
13950
14141
|
if (fetchType === "lowPriority") fetchType = "highPriority";
|
|
13951
14142
|
}
|
|
13952
14143
|
if (hasAffectedFieldInvalidation && invalidationPriority && fetchTypePriority[invalidationPriority] > fetchTypePriority[fetchType]) fetchType = invalidationPriority;
|
|
13953
|
-
} else if (fields === "*"
|
|
13954
|
-
|
|
13955
|
-
|
|
13956
|
-
|
|
13957
|
-
|
|
14144
|
+
} else if (fields === "*") {
|
|
14145
|
+
const missingFullItem = !snapshotIsFullyLoaded(loadedFields, item, partialResources.inferFields) || hasUnresolvedFullInvalidation;
|
|
14146
|
+
const shouldFetchForInvalidation = !missingFullItem && unresolvedPendingInvalidationFields.length > 0 && !ignoreItemsInRefetchOnMount.has(itemKey);
|
|
14147
|
+
if ((missingFullItem || shouldFetchForInvalidation) && !itemFetchIsActive) {
|
|
14148
|
+
shouldFetch = true;
|
|
14149
|
+
requiredFetch = true;
|
|
14150
|
+
fieldsToFetch = missingFullItem ? "*" : unresolvedPendingInvalidationFields;
|
|
14151
|
+
if (fetchType === "lowPriority") fetchType = "highPriority";
|
|
14152
|
+
if (invalidationPriority && fetchTypePriority[invalidationPriority] > fetchTypePriority[fetchType]) fetchType = invalidationPriority;
|
|
14153
|
+
}
|
|
13958
14154
|
}
|
|
13959
14155
|
}
|
|
13960
14156
|
if (!shouldFetch && ignoreItemsInRefetchOnMount.has(itemKey)) continue;
|
|
@@ -13975,6 +14171,7 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13975
14171
|
ignoreItemsInRefetchOnMount,
|
|
13976
14172
|
itemFieldInvalidationPriorities,
|
|
13977
14173
|
itemPendingInvalidationFields,
|
|
14174
|
+
itemsPendingFullInvalidation,
|
|
13978
14175
|
loadFromStateOnly,
|
|
13979
14176
|
partialResources,
|
|
13980
14177
|
preloadItems,
|
|
@@ -13986,7 +14183,7 @@ function useMultipleItems(items, { selector, loadFromStateOnly, returnIdleStatus
|
|
|
13986
14183
|
}
|
|
13987
14184
|
//#endregion
|
|
13988
14185
|
//#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) {
|
|
14186
|
+
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
14187
|
const isOffScreenFromContext = useContext(IsOffScreenContext);
|
|
13991
14188
|
const queriesWithId = useMemo(() => {
|
|
13992
14189
|
return queries.map((queryProps) => {
|
|
@@ -14095,6 +14292,8 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14095
14292
|
partialResources
|
|
14096
14293
|
]);
|
|
14097
14294
|
const getUnresolvedPendingInvalidationFields = useCallback((itemKey, state) => {
|
|
14295
|
+
const stateInvalidationFields = (state ? state.itemFieldInvalidationFields : store.state.itemFieldInvalidationFields)[itemKey];
|
|
14296
|
+
if (stateInvalidationFields && stateInvalidationFields.length > 0) return stateInvalidationFields;
|
|
14098
14297
|
return excludeLoadedFields((state ? state.itemLoadedFields : store.state.itemLoadedFields)[itemKey], itemPendingInvalidationFields.get(itemKey));
|
|
14099
14298
|
}, [itemPendingInvalidationFields, store]);
|
|
14100
14299
|
const getHighestPendingInvalidationPriority = useCallback((itemKeys, requestedFields) => {
|
|
@@ -14236,34 +14435,49 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14236
14435
|
const hasCachedItemsInState = effectiveQuery.query.items.some((itemKey) => {
|
|
14237
14436
|
return state.items[itemKey] != null;
|
|
14238
14437
|
});
|
|
14239
|
-
|
|
14240
|
-
|
|
14241
|
-
|
|
14242
|
-
|
|
14243
|
-
|
|
14244
|
-
|
|
14245
|
-
|
|
14246
|
-
|
|
14247
|
-
|
|
14248
|
-
|
|
14249
|
-
|
|
14250
|
-
|
|
14251
|
-
|
|
14438
|
+
let staleOrMissingRequestedFields;
|
|
14439
|
+
let hasAnyIncompleteItem = false;
|
|
14440
|
+
let hasAnyStaleItem = false;
|
|
14441
|
+
const statusCanBeOverridden = status === "success" || status === "refetching";
|
|
14442
|
+
if (partialResources && (statusCanBeOverridden || showPartialAsRefetching)) {
|
|
14443
|
+
if (Array.isArray(fields) && fields.length > 0) {
|
|
14444
|
+
staleOrMissingRequestedFields = /* @__PURE__ */ new Set();
|
|
14445
|
+
for (const itemKey of effectiveQuery.query.items) {
|
|
14446
|
+
for (const field of getStaleOrMissingRequestedFields(itemKey, state.itemLoadedFields[itemKey], state.items[itemKey], fields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey, state))) staleOrMissingRequestedFields.add(field);
|
|
14447
|
+
if (staleOrMissingRequestedFields.size === fields.length || !showPartialAsRefetching && staleOrMissingRequestedFields.size > 0) break;
|
|
14448
|
+
}
|
|
14449
|
+
} else if (fields === "*") {
|
|
14450
|
+
hasAnyIncompleteItem = effectiveQuery.query.items.some((itemKey) => {
|
|
14451
|
+
const item = state.items[itemKey];
|
|
14452
|
+
if (snapshotIsFullyLoaded(state.itemLoadedFields[itemKey], item, partialResources.inferFields)) return false;
|
|
14453
|
+
return !(itemsPendingFullInvalidation.has(itemKey) && item != null);
|
|
14454
|
+
});
|
|
14455
|
+
hasAnyStaleItem = !hasAnyIncompleteItem && effectiveQuery.query.items.some((itemKey) => !snapshotIsFullyLoadedAndFresh(itemKey, state.itemLoadedFields[itemKey], state.items[itemKey], partialResources.inferFields, itemsPendingFullInvalidation));
|
|
14456
|
+
}
|
|
14457
|
+
}
|
|
14458
|
+
if (partialResources && Array.isArray(fields) && statusCanBeOverridden && staleOrMissingRequestedFields && staleOrMissingRequestedFields.size > 0) {
|
|
14459
|
+
const someItemMissingFieldDataInState = effectiveQuery.query.items.some((itemKey) => getFallbackMissingRequestedFields({
|
|
14460
|
+
item: state.items[itemKey],
|
|
14461
|
+
loadedFields: state.itemLoadedFields[itemKey]
|
|
14462
|
+
}, fields, partialResources.inferFields).length > 0);
|
|
14463
|
+
if (!hasCachedItemsInState) status = "loading";
|
|
14464
|
+
else if (someItemMissingFieldDataInState) status = showPartialAsRefetching ? "refetching" : "loading";
|
|
14252
14465
|
else status = "refetching";
|
|
14253
|
-
} else if (partialResources && fields === "*" &&
|
|
14254
|
-
|
|
14466
|
+
} else if (partialResources && fields === "*" && statusCanBeOverridden) {
|
|
14467
|
+
const hasAnyFieldInvalidation = effectiveQuery.query.items.some((itemKey) => {
|
|
14255
14468
|
const itemFieldInvalidationFields = state.itemFieldInvalidationFields[itemKey];
|
|
14256
14469
|
return !!itemFieldInvalidationFields && itemFieldInvalidationFields.length > 0;
|
|
14257
|
-
})
|
|
14470
|
+
});
|
|
14471
|
+
if (hasAnyIncompleteItem) if (!hasCachedItemsInState) status = "loading";
|
|
14472
|
+
else status = showPartialAsRefetching ? "refetching" : "loading";
|
|
14473
|
+
else if (hasAnyStaleItem || hasAnyFieldInvalidation) status = "refetching";
|
|
14258
14474
|
}
|
|
14259
14475
|
if (partialResources && showPartialAsRefetching) {
|
|
14260
14476
|
if (Array.isArray(fields) && fields.length > 0) {
|
|
14261
|
-
const pendingRequestedFields =
|
|
14262
|
-
return !(state.itemLoadedFields[itemKey] ?? []).includes(field);
|
|
14263
|
-
}));
|
|
14477
|
+
const pendingRequestedFields = status === "loading" && effectiveQuery.query.items.length === 0 ? [...fields] : fields.filter((field) => staleOrMissingRequestedFields?.has(field) ?? false);
|
|
14264
14478
|
if (pendingRequestedFields.length > 0) loadingFields = pendingRequestedFields;
|
|
14265
14479
|
} else if (fields === "*") {
|
|
14266
|
-
const pendingInvalidationFields = Array.from(new Set(effectiveQuery.query.items.flatMap((itemKey) => state.itemFieldInvalidationFields[itemKey] ?? []))).sort();
|
|
14480
|
+
const pendingInvalidationFields = hasAnyIncompleteItem || hasAnyStaleItem ? [] : Array.from(new Set(effectiveQuery.query.items.flatMap((itemKey) => state.itemFieldInvalidationFields[itemKey] ?? []))).sort();
|
|
14267
14481
|
if (pendingInvalidationFields.length > 0) loadingFields = pendingInvalidationFields;
|
|
14268
14482
|
}
|
|
14269
14483
|
}
|
|
@@ -14288,8 +14502,10 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14288
14502
|
};
|
|
14289
14503
|
});
|
|
14290
14504
|
}, [
|
|
14505
|
+
getUnresolvedPendingInvalidationFields,
|
|
14291
14506
|
getVisibleQueryItemKeys,
|
|
14292
14507
|
isOfflineMode,
|
|
14508
|
+
itemsPendingFullInvalidation,
|
|
14293
14509
|
offlineEntitiesByKey,
|
|
14294
14510
|
partialResources,
|
|
14295
14511
|
queriesWithId,
|
|
@@ -14307,11 +14523,16 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14307
14523
|
if (fallbackQuery && readFallbackItemState) {
|
|
14308
14524
|
const visibleItemKeys = getVisibleQueryItemKeys(result.queryKey, fallbackQuery.items);
|
|
14309
14525
|
const requestedFields = Array.isArray(queryConfig.fields) ? queryConfig.fields : void 0;
|
|
14526
|
+
const requiresFullItems = queryConfig.fields === "*";
|
|
14310
14527
|
const fallbackItemStatesByKey = /* @__PURE__ */ new Map();
|
|
14311
14528
|
for (const itemKey of visibleItemKeys) {
|
|
14312
14529
|
const fallbackItemState = readFallbackItemState(itemKey);
|
|
14313
14530
|
fallbackItemStatesByKey.set(itemKey, fallbackItemState);
|
|
14314
|
-
if (
|
|
14531
|
+
if (partialResources) {
|
|
14532
|
+
if (requiresFullItems) {
|
|
14533
|
+
if (!snapshotIsFullyLoaded(fallbackItemState?.loadedFields, fallbackItemState?.item, partialResources.inferFields)) return result;
|
|
14534
|
+
} else if (requestedFields && !fallbackItemHasRequestedFields(fallbackItemState, requestedFields, partialResources.inferFields)) return result;
|
|
14535
|
+
}
|
|
14315
14536
|
}
|
|
14316
14537
|
const fallbackItems = selectVisibleItems(visibleItemKeys, queryConfig.fields, (itemKey) => {
|
|
14317
14538
|
const fallbackItemState = fallbackItemStatesByKey.get(itemKey);
|
|
@@ -14368,7 +14589,7 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14368
14589
|
const unresolvedFields = Array.from(new Set(effectiveQuery.query.items.flatMap((itemKey) => getUnresolvedPendingInvalidationFields(itemKey, state)))).sort();
|
|
14369
14590
|
const requestedFields = Array.isArray(queryConfig.fields) ? queryConfig.fields : void 0;
|
|
14370
14591
|
const missingRequestedFields = requestedFields && requestedFields.length > 0 ? effectiveQuery.query.items.flatMap((itemKey) => {
|
|
14371
|
-
return
|
|
14592
|
+
return getStaleOrMissingRequestedFields(itemKey, state.itemLoadedFields[itemKey], state.items[itemKey], requestedFields, partialResources.inferFields, itemsPendingFullInvalidation, getUnresolvedPendingInvalidationFields(itemKey, state));
|
|
14372
14593
|
}).filter((field, index, array) => array.indexOf(field) === index).sort() : [];
|
|
14373
14594
|
let unresolvedInvalidationFieldsKey = "";
|
|
14374
14595
|
if (queryConfig.fields === "*") unresolvedInvalidationFieldsKey = JSON.stringify(unresolvedFields);
|
|
@@ -14387,6 +14608,7 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14387
14608
|
}, [
|
|
14388
14609
|
getHighestPendingInvalidationPriority,
|
|
14389
14610
|
getUnresolvedPendingInvalidationFields,
|
|
14611
|
+
itemsPendingFullInvalidation,
|
|
14390
14612
|
partialResources,
|
|
14391
14613
|
queriesWithId,
|
|
14392
14614
|
resolveEffectiveQuery
|
|
@@ -14475,10 +14697,7 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14475
14697
|
if (partialResources && !shouldFetch && effectiveQueryState) {
|
|
14476
14698
|
const isQueryFetchInFlight = effectiveQueryState.status === "loading" || effectiveQueryState.status === "refetching" || effectiveQueryState.status === "loadingMore";
|
|
14477
14699
|
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) {
|
|
14700
|
+
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
14701
|
shouldFetch = true;
|
|
14483
14702
|
requiredFetch = true;
|
|
14484
14703
|
fieldsToFetch = fields;
|
|
@@ -14495,9 +14714,11 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14495
14714
|
if (invalidationPriority && fetchTypePriority[invalidationPriority] > fetchTypePriority[fetchType]) fetchType = invalidationPriority;
|
|
14496
14715
|
}
|
|
14497
14716
|
} else if (fields === "*") {
|
|
14498
|
-
|
|
14717
|
+
const hasAnyPartialItem = effectiveQueryState.items.some((itemKey) => !snapshotIsFullyLoadedAndFresh(itemKey, store.state.itemLoadedFields[itemKey], store.state.items[itemKey], partialResources.inferFields, itemsPendingFullInvalidation));
|
|
14718
|
+
const hasAnyFieldInvalidation = effectiveQueryState.items.some((itemKey) => {
|
|
14499
14719
|
return getUnresolvedPendingInvalidationFields(itemKey).length > 0;
|
|
14500
|
-
})
|
|
14720
|
+
});
|
|
14721
|
+
if ((hasAnyPartialItem || hasAnyFieldInvalidation) && !isQueryFetchInFlight) {
|
|
14501
14722
|
shouldFetch = true;
|
|
14502
14723
|
requiredFetch = true;
|
|
14503
14724
|
const invalidationPriority = getHighestPendingInvalidationPriority(effectiveQueryState.items, void 0);
|
|
@@ -14533,6 +14754,7 @@ function useMultipleListQueries(queries, { itemSelector, returnIdleStatus: allIt
|
|
|
14533
14754
|
automaticRetryState,
|
|
14534
14755
|
itemFieldInvalidationPriorities,
|
|
14535
14756
|
itemPendingInvalidationFields,
|
|
14757
|
+
itemsPendingFullInvalidation,
|
|
14536
14758
|
getHighestPendingInvalidationPriority,
|
|
14537
14759
|
getUnresolvedPendingInvalidationFields,
|
|
14538
14760
|
stickyDerivedQueryKeys
|
|
@@ -14857,7 +15079,7 @@ function createListQueryStore(storeOptions) {
|
|
|
14857
15079
|
itemKey,
|
|
14858
15080
|
item: store.state.items[itemKey] ?? null,
|
|
14859
15081
|
itemQuery: store.state.itemQueries[itemKey] ?? null,
|
|
14860
|
-
loadedFields: store.state.itemLoadedFields[itemKey]
|
|
15082
|
+
loadedFields: store.state.itemLoadedFields[itemKey]
|
|
14861
15083
|
}));
|
|
14862
15084
|
}
|
|
14863
15085
|
function publishQuerySnapshot(queryKey, consistency = currentBroadcastConsistency) {
|
|
@@ -14884,7 +15106,7 @@ function createListQueryStore(storeOptions) {
|
|
|
14884
15106
|
consistency,
|
|
14885
15107
|
item: store.state.items[itemKey] ?? null,
|
|
14886
15108
|
itemQuery: store.state.itemQueries[itemKey] ?? null,
|
|
14887
|
-
loadedFields: store.state.itemLoadedFields[itemKey]
|
|
15109
|
+
loadedFields: store.state.itemLoadedFields[itemKey]
|
|
14888
15110
|
});
|
|
14889
15111
|
if (!message) return;
|
|
14890
15112
|
recordItemSyncVersion(itemKey, message, consistency);
|
|
@@ -14940,6 +15162,8 @@ function createListQueryStore(storeOptions) {
|
|
|
14940
15162
|
preloaded: results[index] ?? false
|
|
14941
15163
|
}));
|
|
14942
15164
|
}
|
|
15165
|
+
const itemPendingInvalidationFields = /* @__PURE__ */ new Map();
|
|
15166
|
+
const itemsPendingFullInvalidation = /* @__PURE__ */ new Set();
|
|
14943
15167
|
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
15168
|
const queryKey = requests[0]?.requestId;
|
|
14945
15169
|
if (!queryKey) return;
|
|
@@ -15001,12 +15225,12 @@ function createListQueryStore(storeOptions) {
|
|
|
15001
15225
|
});
|
|
15002
15226
|
for (const { itemKey } of successfulItems) publishItemSnapshot(itemKey, "confirmed");
|
|
15003
15227
|
}
|
|
15004
|
-
}, offlineFetchController);
|
|
15005
|
-
const { storeEvents, queryInvalidationWasTriggered, itemInvalidationWasTriggered, itemFieldInvalidationPriorities,
|
|
15228
|
+
}, offlineFetchController, itemPendingInvalidationFields, itemsPendingFullInvalidation);
|
|
15229
|
+
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
15230
|
events.emit("invalidateQuery", event);
|
|
15007
15231
|
}, (event) => {
|
|
15008
15232
|
events.emit("invalidateItem", event);
|
|
15009
|
-
}, blockWindowClose, resolvedOfflineConfig ? offlineMutationController : null, runWithBroadcastConsistency, publishQuerySnapshot, publishItemSnapshot, void 0);
|
|
15233
|
+
}, blockWindowClose, resolvedOfflineConfig ? offlineMutationController : null, runWithBroadcastConsistency, publishQuerySnapshot, publishItemSnapshot, void 0, itemPendingInvalidationFields, itemsPendingFullInvalidation);
|
|
15010
15234
|
if (resolvedPersistentStorageConfig && resolvedOfflineConfig) offlineController = createOfflineStoreController(id, "listQuery", getSessionKeyForRuntime, resolvedPersistentStorageConfig.onPersistentStorageError, import.meta.env.DEV ? storeManager.debugLogger : void 0, resolvedPersistentStorageConfig.adapter, {
|
|
15011
15235
|
normalizeEntityRefs: (entityRefs) => entityRefs.map((ref) => {
|
|
15012
15236
|
const normalizedRef = offlineItemEntityRefSchema.parse(ref).unwrapOrNull();
|
|
@@ -15077,10 +15301,12 @@ function createListQueryStore(storeOptions) {
|
|
|
15077
15301
|
}
|
|
15078
15302
|
}, resolvedOfflineConfig.session, __LEGIT_CAST__(offlineOperationsForRuntime));
|
|
15079
15303
|
function applyLoadedFieldsFromSnapshot(draft, itemKey, loadedFields) {
|
|
15080
|
-
if (loadedFields
|
|
15081
|
-
|
|
15082
|
-
|
|
15083
|
-
|
|
15304
|
+
if (loadedFields === void 0) return;
|
|
15305
|
+
if (loadedFields === "*") draft.itemLoadedFields[itemKey] = "*";
|
|
15306
|
+
else if (loadedFields.length > 0) {
|
|
15307
|
+
const existingLoadedFields = draft.itemLoadedFields[itemKey];
|
|
15308
|
+
if (existingLoadedFields !== "*") draft.itemLoadedFields[itemKey] = Array.from(new Set([...existingLoadedFields ?? [], ...loadedFields])).sort();
|
|
15309
|
+
} else if (draft.itemLoadedFields[itemKey] === void 0) draft.itemLoadedFields[itemKey] = [];
|
|
15084
15310
|
const invalidationFields = draft.itemFieldInvalidationFields[itemKey];
|
|
15085
15311
|
if (!invalidationFields) return;
|
|
15086
15312
|
const remainingFields = excludeLoadedFields(loadedFields, invalidationFields);
|
|
@@ -15090,18 +15316,27 @@ function createListQueryStore(storeOptions) {
|
|
|
15090
15316
|
function pruneItemInvalidationTracking() {
|
|
15091
15317
|
for (const [itemKey, pendingFields] of itemPendingInvalidationFields) {
|
|
15092
15318
|
const remainingFields = excludeLoadedFields(store.state.itemLoadedFields[itemKey], pendingFields);
|
|
15319
|
+
const stateInvalidationFields = store.state.itemFieldInvalidationFields[itemKey];
|
|
15320
|
+
if (stateInvalidationFields && stateInvalidationFields.length > 0) {
|
|
15321
|
+
const mergedFields = Array.from(new Set([...stateInvalidationFields, ...remainingFields])).sort();
|
|
15322
|
+
itemPendingInvalidationFields.set(itemKey, mergedFields);
|
|
15323
|
+
continue;
|
|
15324
|
+
}
|
|
15093
15325
|
if (remainingFields.length > 0) itemPendingInvalidationFields.set(itemKey, remainingFields);
|
|
15094
15326
|
else itemPendingInvalidationFields.delete(itemKey);
|
|
15095
15327
|
}
|
|
15328
|
+
for (const itemKey of itemsPendingFullInvalidation) if (store.state.itemLoadedFields[itemKey] === "*") itemsPendingFullInvalidation.delete(itemKey);
|
|
15096
15329
|
for (const itemKey of itemFieldInvalidationPriorities.keys()) {
|
|
15097
15330
|
const hasPendingStateInvalidation = !!store.state.itemFieldInvalidationFields[itemKey];
|
|
15098
15331
|
const hasPendingTrackedInvalidation = (itemPendingInvalidationFields.get(itemKey)?.length ?? 0) > 0;
|
|
15099
|
-
|
|
15332
|
+
const hasPendingFullInvalidation = itemsPendingFullInvalidation.has(itemKey);
|
|
15333
|
+
if (!hasPendingStateInvalidation && !hasPendingTrackedInvalidation && !hasPendingFullInvalidation) itemFieldInvalidationPriorities.delete(itemKey);
|
|
15100
15334
|
}
|
|
15101
15335
|
}
|
|
15102
15336
|
function cleanupItemStateMetadata(itemKey) {
|
|
15103
15337
|
itemFieldInvalidationPriorities.delete(itemKey);
|
|
15104
15338
|
itemPendingInvalidationFields.delete(itemKey);
|
|
15339
|
+
itemsPendingFullInvalidation.delete(itemKey);
|
|
15105
15340
|
itemInvalidationWasTriggered.delete(itemKey);
|
|
15106
15341
|
itemCacheRuntime.clear(itemKey);
|
|
15107
15342
|
}
|
|
@@ -15159,18 +15394,20 @@ function createListQueryStore(storeOptions) {
|
|
|
15159
15394
|
return partialResources.mergeItems(currentItem ?? void 0, incomingItem);
|
|
15160
15395
|
}
|
|
15161
15396
|
function itemSnapshotSatisfiesRequestedFields(item, loadedFields, requestedFields) {
|
|
15162
|
-
if (!partialResources
|
|
15397
|
+
if (!partialResources) return true;
|
|
15163
15398
|
if (item === null) return true;
|
|
15399
|
+
if (loadedFields !== void 0 && loadedFields !== "*" && loadedFields.length === 0) return false;
|
|
15400
|
+
if (!requestedFields || requestedFields.length === 0) return snapshotIsFullyLoaded(loadedFields, item, partialResources.inferFields);
|
|
15164
15401
|
return fallbackItemHasRequestedFields({
|
|
15165
15402
|
item,
|
|
15166
15403
|
loadedFields
|
|
15167
|
-
}, requestedFields);
|
|
15404
|
+
}, requestedFields, partialResources.inferFields);
|
|
15168
15405
|
}
|
|
15169
15406
|
function querySnapshotSatisfiesPendingQueryFetch(message, snapshotItemsByKey, request) {
|
|
15170
15407
|
const requestedEnd = request.payload.offset + request.payload.limit;
|
|
15171
15408
|
if (message.query.items.length < requestedEnd && message.query.hasMore) return false;
|
|
15172
15409
|
const requestedFields = request.payload.fields;
|
|
15173
|
-
if (!partialResources
|
|
15410
|
+
if (!partialResources) return true;
|
|
15174
15411
|
return message.query.items.slice(request.payload.offset, requestedEnd).every((itemKey) => {
|
|
15175
15412
|
const item = snapshotItemsByKey.get(itemKey);
|
|
15176
15413
|
return !!item && itemSnapshotSatisfiesRequestedFields(item.item, item.loadedFields, requestedFields);
|
|
@@ -15190,6 +15427,7 @@ function createListQueryStore(storeOptions) {
|
|
|
15190
15427
|
};
|
|
15191
15428
|
applyLoadedFieldsFromSnapshot(draft, message.itemKey, message.loadedFields);
|
|
15192
15429
|
if (!message.itemQuery && message.item === null) {
|
|
15430
|
+
delete draft.itemLoadedFields[message.itemKey];
|
|
15193
15431
|
delete draft.itemFieldInvalidationFields[message.itemKey];
|
|
15194
15432
|
for (const query of Object.values(draft.queries)) query.items = query.items.filter((itemId) => itemId !== message.itemKey);
|
|
15195
15433
|
}
|
|
@@ -15309,7 +15547,7 @@ function createListQueryStore(storeOptions) {
|
|
|
15309
15547
|
return state;
|
|
15310
15548
|
}, []);
|
|
15311
15549
|
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);
|
|
15550
|
+
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
15551
|
};
|
|
15314
15552
|
const useListQuery$2 = function useListQuery$1(payload, options = {}) {
|
|
15315
15553
|
return useListQuery(payload, options, store, getQueryKey, scheduleListQueryFetch, useMultipleListQueries$2);
|
|
@@ -15324,7 +15562,7 @@ function createListQueryStore(storeOptions) {
|
|
|
15324
15562
|
return state;
|
|
15325
15563
|
}, []);
|
|
15326
15564
|
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);
|
|
15565
|
+
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
15566
|
};
|
|
15329
15567
|
const useItem$3 = function useItem$2(itemPayload, options = {}) {
|
|
15330
15568
|
return useItem(itemPayload, options, store, scheduleItemFetch, useMultipleItems$3);
|