tsdf 17.0.0 → 17.0.1
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.js +1 -1
- package/dist/{asyncStorageAdapter-BBKVK1S_.js → asyncStorageAdapter-BuGjbXYA.js} +154 -5
- package/dist/{asyncStorageAdapters-CkGt87Po.js → asyncStorageAdapters-ClUvxNQA.js} +2 -2
- package/dist/indexed-db-storage.js +1 -1
- package/dist/{indexedDbPersistentStorage-D5tGmD77.js → indexedDbPersistentStorage-BSlgLveB.js} +1 -1
- package/dist/main.d.ts +24 -2
- package/dist/main.js +796 -209
- package/dist/opfs-storage.js +1 -1
- package/dist/{opfsPersistentStorage-B_lVflof.js → opfsPersistentStorage-D_k77Srq.js} +1 -1
- package/docs/persistent-storage.md +1 -0
- package/package.json +1 -1
package/dist/async-storage.js
CHANGED
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
import { i as createAsyncStorageAdapter } from "./asyncStorageAdapter-
|
|
1
|
+
import { i as createAsyncStorageAdapter } from "./asyncStorageAdapter-BuGjbXYA.js";
|
|
2
2
|
export { createAsyncStorageAdapter };
|
|
@@ -7,19 +7,76 @@ import { sleep } from "@ls-stack/utils/sleep";
|
|
|
7
7
|
import { rc_array, rc_discriminated_union, rc_literals, rc_number, rc_object, rc_parse, rc_parse_json, rc_record, rc_string, rc_tuple, rc_unknown } from "runcheck";
|
|
8
8
|
import { asPossiblyUndefined } from "@ls-stack/utils/typingFnUtils";
|
|
9
9
|
//#region src/persistentStorage/scheduleIdleCleanup.ts
|
|
10
|
+
const FALLBACK_IDLE_BUDGET_MS = 12;
|
|
11
|
+
const MIN_IDLE_TIME_REMAINING_MS = 1;
|
|
12
|
+
function getMonotonicNow() {
|
|
13
|
+
return performance.now();
|
|
14
|
+
}
|
|
15
|
+
/**
|
|
16
|
+
* Timeout-fired idle callbacks and the timer fallback do not receive a usable
|
|
17
|
+
* browser deadline. Give those ordinary tasks a small synthetic budget so
|
|
18
|
+
* maintenance still yields instead of running to completion on a busy page.
|
|
19
|
+
*/
|
|
20
|
+
function normalizeIdleDeadline(deadline) {
|
|
21
|
+
if (deadline !== void 0 && !deadline.didTimeout) return deadline;
|
|
22
|
+
const startedAt = getMonotonicNow();
|
|
23
|
+
return {
|
|
24
|
+
didTimeout: true,
|
|
25
|
+
timeRemaining: () => Math.max(0, FALLBACK_IDLE_BUDGET_MS - (getMonotonicNow() - startedAt))
|
|
26
|
+
};
|
|
27
|
+
}
|
|
10
28
|
/**
|
|
11
29
|
* Schedules a fire-and-forget cleanup callback during idle time.
|
|
12
|
-
* Uses `requestIdleCallback` when available,
|
|
30
|
+
* Uses `requestIdleCallback` when available, falling back to a timer-backed
|
|
31
|
+
* synthetic 12 ms deadline.
|
|
13
32
|
*/
|
|
14
33
|
function scheduleIdleCleanup(callback) {
|
|
15
34
|
if (typeof requestIdleCallback === "function") {
|
|
16
|
-
const idleCallbackId = requestIdleCallback(() => callback(), { timeout: 3e3 });
|
|
35
|
+
const idleCallbackId = requestIdleCallback((deadline) => callback(normalizeIdleDeadline(deadline)), { timeout: 3e3 });
|
|
17
36
|
return () => cancelIdleCallback(idleCallbackId);
|
|
18
37
|
} else {
|
|
19
|
-
const timeoutId = setTimeout(callback, 2e3);
|
|
38
|
+
const timeoutId = setTimeout(() => callback(normalizeIdleDeadline(void 0)), 2e3);
|
|
20
39
|
return () => clearTimeout(timeoutId);
|
|
21
40
|
}
|
|
22
41
|
}
|
|
42
|
+
/**
|
|
43
|
+
* Tracks the current idle deadline and schedules cancellable continuations
|
|
44
|
+
* when a maintenance pass exhausts it.
|
|
45
|
+
*/
|
|
46
|
+
function createIdleCleanupContext(initialDeadline) {
|
|
47
|
+
let currentDeadline = initialDeadline;
|
|
48
|
+
let continuationCount = 0;
|
|
49
|
+
let canceled = false;
|
|
50
|
+
let cancelContinuation = null;
|
|
51
|
+
let resolveContinuation = null;
|
|
52
|
+
return {
|
|
53
|
+
cancel() {
|
|
54
|
+
if (canceled) return;
|
|
55
|
+
canceled = true;
|
|
56
|
+
cancelContinuation?.();
|
|
57
|
+
cancelContinuation = null;
|
|
58
|
+
resolveContinuation?.(null);
|
|
59
|
+
resolveContinuation = null;
|
|
60
|
+
},
|
|
61
|
+
getContinuationCount: () => continuationCount,
|
|
62
|
+
isCanceled: () => canceled,
|
|
63
|
+
shouldYield: () => canceled || currentDeadline.timeRemaining() <= MIN_IDLE_TIME_REMAINING_MS,
|
|
64
|
+
async yieldIfNeeded() {
|
|
65
|
+
if (canceled) return false;
|
|
66
|
+
if (currentDeadline.timeRemaining() > MIN_IDLE_TIME_REMAINING_MS) return true;
|
|
67
|
+
const nextDeadline = await new Promise((resolve) => {
|
|
68
|
+
resolveContinuation = resolve;
|
|
69
|
+
cancelContinuation = scheduleIdleCleanup(resolve);
|
|
70
|
+
});
|
|
71
|
+
cancelContinuation = null;
|
|
72
|
+
resolveContinuation = null;
|
|
73
|
+
if (nextDeadline === null) return false;
|
|
74
|
+
currentDeadline = nextDeadline;
|
|
75
|
+
continuationCount++;
|
|
76
|
+
return true;
|
|
77
|
+
}
|
|
78
|
+
};
|
|
79
|
+
}
|
|
23
80
|
const INITIAL_MAINTENANCE_CLEANUP_DELAY_MS = 1e4;
|
|
24
81
|
/**
|
|
25
82
|
* Gives startup maintenance a short grace period before using the regular
|
|
@@ -32,7 +89,7 @@ function scheduleInitialMaintenanceCleanup(callback) {
|
|
|
32
89
|
}
|
|
33
90
|
let cancelIdleCleanup = null;
|
|
34
91
|
const timeoutId = setTimeout(() => {
|
|
35
|
-
cancelIdleCleanup = scheduleIdleCleanup(callback);
|
|
92
|
+
cancelIdleCleanup = scheduleIdleCleanup(() => callback());
|
|
36
93
|
}, INITIAL_MAINTENANCE_CLEANUP_DELAY_MS);
|
|
37
94
|
return () => {
|
|
38
95
|
clearTimeout(timeoutId);
|
|
@@ -298,6 +355,8 @@ var OfflineResolutionConflictParseError = class extends Error {
|
|
|
298
355
|
};
|
|
299
356
|
//#endregion
|
|
300
357
|
//#region src/persistentStorage/persistenceUtils.ts
|
|
358
|
+
const MAINTENANCE_SORT_CHUNK_SIZE = 100;
|
|
359
|
+
const MAINTENANCE_LOOP_CHUNK_SIZE = 25;
|
|
301
360
|
/**
|
|
302
361
|
* Creates a key set that auto-clears entries after a microtask.
|
|
303
362
|
* Used to deduplicate sync storage reads within the same event loop tick.
|
|
@@ -399,6 +458,96 @@ function keepEntriesWithinByteBudget(entries, getKey, getLastAccessAt, getSizeBy
|
|
|
399
458
|
unprotectedBytes
|
|
400
459
|
};
|
|
401
460
|
}
|
|
461
|
+
/** Deadline-aware variant used by synchronous localStorage maintenance. */
|
|
462
|
+
async function keepEntriesWithinByteBudgetDuringIdle(entries, getKey, getLastAccessAt, getSizeBytes, isPinned, isProtected, maxBytes, idleContext) {
|
|
463
|
+
const keptKeys = /* @__PURE__ */ new Set();
|
|
464
|
+
let unprotectedBytes = 0;
|
|
465
|
+
for (const [entryIndex, entry] of entries.entries()) {
|
|
466
|
+
if (entryIndex % MAINTENANCE_LOOP_CHUNK_SIZE === 0 && !await idleContext.yieldIfNeeded()) return null;
|
|
467
|
+
if (!isProtected(entry)) unprotectedBytes += getSizeBytes(entry);
|
|
468
|
+
}
|
|
469
|
+
if (unprotectedBytes <= maxBytes) {
|
|
470
|
+
for (const [entryIndex, entry] of entries.entries()) {
|
|
471
|
+
if (entryIndex % MAINTENANCE_LOOP_CHUNK_SIZE === 0 && !await idleContext.yieldIfNeeded()) return null;
|
|
472
|
+
keptKeys.add(getKey(entry));
|
|
473
|
+
}
|
|
474
|
+
return {
|
|
475
|
+
keptKeys,
|
|
476
|
+
unprotectedBytes
|
|
477
|
+
};
|
|
478
|
+
}
|
|
479
|
+
const compareEntries = (left, right) => {
|
|
480
|
+
const leftProtected = isProtected(left);
|
|
481
|
+
const rightProtected = isProtected(right);
|
|
482
|
+
if (leftProtected && !rightProtected) return -1;
|
|
483
|
+
if (!leftProtected && rightProtected) return 1;
|
|
484
|
+
const leftPinned = isPinned(left);
|
|
485
|
+
const rightPinned = isPinned(right);
|
|
486
|
+
if (leftPinned && !rightPinned) return -1;
|
|
487
|
+
if (!leftPinned && rightPinned) return 1;
|
|
488
|
+
return getLastAccessAt(right) - getLastAccessAt(left);
|
|
489
|
+
};
|
|
490
|
+
const sortedChunks = [];
|
|
491
|
+
for (let chunkStart = 0; chunkStart < entries.length; chunkStart += MAINTENANCE_SORT_CHUNK_SIZE) {
|
|
492
|
+
if (!await idleContext.yieldIfNeeded()) return null;
|
|
493
|
+
sortedChunks.push(entries.slice(chunkStart, chunkStart + MAINTENANCE_SORT_CHUNK_SIZE).sort(compareEntries));
|
|
494
|
+
}
|
|
495
|
+
let mergeChunks = sortedChunks;
|
|
496
|
+
while (mergeChunks.length > 1) {
|
|
497
|
+
const nextMergeChunks = [];
|
|
498
|
+
for (let chunkIndex = 0; chunkIndex < mergeChunks.length; chunkIndex += 2) {
|
|
499
|
+
if (!await idleContext.yieldIfNeeded()) return null;
|
|
500
|
+
const leftChunk = mergeChunks[chunkIndex];
|
|
501
|
+
const rightChunk = mergeChunks[chunkIndex + 1];
|
|
502
|
+
if (leftChunk === void 0) continue;
|
|
503
|
+
if (rightChunk === void 0) {
|
|
504
|
+
nextMergeChunks.push(leftChunk);
|
|
505
|
+
continue;
|
|
506
|
+
}
|
|
507
|
+
const mergedChunk = [];
|
|
508
|
+
let leftIndex = 0;
|
|
509
|
+
let rightIndex = 0;
|
|
510
|
+
while (leftIndex < leftChunk.length || rightIndex < rightChunk.length) {
|
|
511
|
+
if (mergedChunk.length % MAINTENANCE_LOOP_CHUNK_SIZE === 0 && !await idleContext.yieldIfNeeded()) return null;
|
|
512
|
+
const leftEntry = leftChunk[leftIndex];
|
|
513
|
+
const rightEntry = rightChunk[rightIndex];
|
|
514
|
+
if (rightEntry === void 0 || leftEntry !== void 0 && compareEntries(leftEntry, rightEntry) <= 0) {
|
|
515
|
+
if (leftEntry !== void 0) mergedChunk.push(leftEntry);
|
|
516
|
+
leftIndex++;
|
|
517
|
+
} else {
|
|
518
|
+
mergedChunk.push(rightEntry);
|
|
519
|
+
rightIndex++;
|
|
520
|
+
}
|
|
521
|
+
}
|
|
522
|
+
nextMergeChunks.push(mergedChunk);
|
|
523
|
+
}
|
|
524
|
+
mergeChunks = nextMergeChunks;
|
|
525
|
+
}
|
|
526
|
+
const sortedEntries = mergeChunks[0] ?? [];
|
|
527
|
+
let keptUnprotectedBytes = 0;
|
|
528
|
+
for (const [entryIndex, entry] of sortedEntries.entries()) {
|
|
529
|
+
if (entryIndex % MAINTENANCE_LOOP_CHUNK_SIZE === 0 && !await idleContext.yieldIfNeeded()) return null;
|
|
530
|
+
const key = getKey(entry);
|
|
531
|
+
if (isProtected(entry)) {
|
|
532
|
+
keptKeys.add(key);
|
|
533
|
+
continue;
|
|
534
|
+
}
|
|
535
|
+
const sizeBytes = getSizeBytes(entry);
|
|
536
|
+
if (isPinned(entry)) {
|
|
537
|
+
keptKeys.add(key);
|
|
538
|
+
keptUnprotectedBytes += sizeBytes;
|
|
539
|
+
continue;
|
|
540
|
+
}
|
|
541
|
+
if (keptUnprotectedBytes + sizeBytes <= maxBytes) {
|
|
542
|
+
keptKeys.add(key);
|
|
543
|
+
keptUnprotectedBytes += sizeBytes;
|
|
544
|
+
}
|
|
545
|
+
}
|
|
546
|
+
return {
|
|
547
|
+
keptKeys,
|
|
548
|
+
unprotectedBytes
|
|
549
|
+
};
|
|
550
|
+
}
|
|
402
551
|
//#endregion
|
|
403
552
|
//#region src/persistentStorage/persistentStorageDefaults.ts
|
|
404
553
|
const defaultMaxBytes = {
|
|
@@ -1962,4 +2111,4 @@ function serializeProtectedRef(ref) {
|
|
|
1962
2111
|
return serializeProtectedRef$1(ref);
|
|
1963
2112
|
}
|
|
1964
2113
|
//#endregion
|
|
1965
|
-
export {
|
|
2114
|
+
export { scheduleIdleCleanup as $, getIsOfflineModeFromStatus as A, createCompactLocalStorageEntry as B, isQuotaExceededError as C, OfflineResolutionConflictParseError as D, serializeJsonForStorage as E, clearSessionProtectedKeysSnapshot as F, getPayloadRecordKey as G, compareMetadata as H, getSessionProtectedKeysSnapshot as I, parseAsyncStorageRecordKey as J, getPersistedNamespaceId as K, setSessionProtectedKeysSnapshot as L, isOfflineModeStatusValue as M, offlineItemEntityRefSchema as N, compactOfflineStatusSnapshotSchema as O, offlineResolutionRecordSchema as P, createIdleCleanupContext as Q, getNavigatorLockManager as R, getSerializedStringSize as S, keepEntriesWithinByteBudgetDuringIdle as T, encodePersistedAsyncNamespaceKind as U, parseCompactLocalStorageEntry as V, getNamespaceId as W, serializeProtectedRef$1 as X, parsePersistedAsyncNamespaceKind as Y, INITIAL_MAINTENANCE_CLEANUP_DELAY_MS as Z, getTSDFDebugTimingMs as _, estimateManagedAsyncStorageEntrySizeBytes as a, createShouldIgnoreItemPredicate as b, readAsyncStorageNamespaceIndexStateUsingDriver as c, unregisterAsyncStartupStoreCleanup as d, parseAsyncStorageNamespaceKind as f, emitTSDFDebugLog as g, logPersistentStorageQuotaCleanup as h, createAsyncStorageAdapter as i, isModeEffectivelyActive as j, defaultOfflineRuntimeConfig as k, registerAsyncStartupStoreCleanup as l, getOfflineSessionStatusStorageKey as m, ASYNC_STORAGE_MAX_AGE_MS as n, getProtectedKeysFromMetadata as o, OFFLINE_SESSION_STATUS_STORE_NAME as p, normalizeStaticPolicy as q, buildPersistedStaticPolicy as r, mergeManagedAsyncStorageCustomMetadata as s, ASYNC_MAINTENANCE_LOCAL_STORAGE_KEY as t, serializeProtectedRef as u, resolveTSDFLogger as v, keepEntriesWithinByteBudget as w, createTimedKeySet as x, getDefaultMaxBytesForScope as y, warnIfNavigatorLockUnavailable as z };
|
|
@@ -1,3 +1,3 @@
|
|
|
1
|
-
import { t as opfsPersistentStorage } from "./opfsPersistentStorage-
|
|
2
|
-
import { n as indexedDbPersistentStorage } from "./indexedDbPersistentStorage-
|
|
1
|
+
import { t as opfsPersistentStorage } from "./opfsPersistentStorage-D_k77Srq.js";
|
|
2
|
+
import { n as indexedDbPersistentStorage } from "./indexedDbPersistentStorage-BSlgLveB.js";
|
|
3
3
|
export { indexedDbPersistentStorage, opfsPersistentStorage };
|
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
import { n as indexedDbPersistentStorage, t as createIndexedDbPersistentStorage } from "./indexedDbPersistentStorage-
|
|
1
|
+
import { n as indexedDbPersistentStorage, t as createIndexedDbPersistentStorage } from "./indexedDbPersistentStorage-BSlgLveB.js";
|
|
2
2
|
export { createIndexedDbPersistentStorage, indexedDbPersistentStorage };
|
package/dist/{indexedDbPersistentStorage-D5tGmD77.js → indexedDbPersistentStorage-BSlgLveB.js}
RENAMED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { E as serializeJsonForStorage, G as getPayloadRecordKey, H as compareMetadata, J as parseAsyncStorageRecordKey, K as getPersistedNamespaceId, U as encodePersistedAsyncNamespaceKind, W as getNamespaceId, X as serializeProtectedRef, Y as parsePersistedAsyncNamespaceKind, _ as getTSDFDebugTimingMs, a as estimateManagedAsyncStorageEntrySizeBytes, g as emitTSDFDebugLog, i as createAsyncStorageAdapter, q as normalizeStaticPolicy } from "./asyncStorageAdapter-BuGjbXYA.js";
|
|
2
2
|
import { __LEGIT_CAST__ } from "@ls-stack/utils/saferTyping";
|
|
3
3
|
import { isObject } from "@ls-stack/utils/typeGuards";
|
|
4
4
|
//#region src/persistentStorage/indexedDbAsyncStorageAdapter.ts
|
package/dist/main.d.ts
CHANGED
|
@@ -1199,8 +1199,18 @@ declare function useGlobalOfflineEntities(sessionKey: string): readonly GlobalOf
|
|
|
1199
1199
|
*/
|
|
1200
1200
|
declare function useGlobalOfflineResolutions(sessionKey: string): readonly OfflineResolutionRecord[];
|
|
1201
1201
|
//#endregion
|
|
1202
|
+
//#region src/persistentStorage/scheduleIdleCleanup.d.ts
|
|
1203
|
+
type IdleCleanupContext = {
|
|
1204
|
+
cancel(): void;
|
|
1205
|
+
getContinuationCount(): number;
|
|
1206
|
+
isCanceled(): boolean;
|
|
1207
|
+
shouldYield(): boolean;
|
|
1208
|
+
yieldIfNeeded(): Promise<boolean>;
|
|
1209
|
+
};
|
|
1210
|
+
//#endregion
|
|
1202
1211
|
//#region src/persistentStorage/localStorageMetadata.d.ts
|
|
1203
1212
|
type ManagedLocalStorageIo = {
|
|
1213
|
+
invalidate?(key: string): void;
|
|
1204
1214
|
getItem(key: string): string | null;
|
|
1205
1215
|
setItem(key: string, value: string): void;
|
|
1206
1216
|
removeItem(key: string): void;
|
|
@@ -1244,6 +1254,16 @@ type UpsertNamespaceEntryParams = {
|
|
|
1244
1254
|
meta?: unknown;
|
|
1245
1255
|
};
|
|
1246
1256
|
declare function upsertManagedLocalStorageNamespaceEntry(params: UpsertNamespaceEntryParams, io?: ManagedLocalStorageIo): string;
|
|
1257
|
+
type ManagedLocalStorageNamespaceRemovalCandidate = {
|
|
1258
|
+
entryKey: string;
|
|
1259
|
+
lastAccessAt: number;
|
|
1260
|
+
offlineProtected: boolean;
|
|
1261
|
+
};
|
|
1262
|
+
type ManagedLocalStorageNamespaceRemovalResult = {
|
|
1263
|
+
processedCount: number;
|
|
1264
|
+
removedEntryKeys: string[];
|
|
1265
|
+
staleEntryKeys: string[];
|
|
1266
|
+
};
|
|
1247
1267
|
//#endregion
|
|
1248
1268
|
//#region src/persistentStorage/storageAdapter.d.ts
|
|
1249
1269
|
type LocalStorageMetadataOptions = {
|
|
@@ -1255,6 +1275,7 @@ type LocalStorageMetadataOptions = {
|
|
|
1255
1275
|
type LocalPersistentStorage = {
|
|
1256
1276
|
kind: 'local-sync';
|
|
1257
1277
|
runLocked<T>(callback: () => T | Promise<T>): Promise<T>;
|
|
1278
|
+
runMaintenanceLocked<T>(context: IdleCleanupContext, callback: () => T | Promise<T>): Promise<T>;
|
|
1258
1279
|
readRaw(key: string): string | null;
|
|
1259
1280
|
write<T>(key: string, value: T): {
|
|
1260
1281
|
rawValue: string;
|
|
@@ -1273,11 +1294,12 @@ type LocalPersistentStorage = {
|
|
|
1273
1294
|
upsertNamespaceEntry(args: Parameters<typeof upsertManagedLocalStorageNamespaceEntry>[0]): string;
|
|
1274
1295
|
touchSingleEntry(payloadKey: string): boolean;
|
|
1275
1296
|
touchNamespaceEntry(payloadKey: string, namespacePrefix: string): boolean;
|
|
1297
|
+
removeNamespaceEntriesIfUnchanged(storagePrefix: string, candidates: ManagedLocalStorageNamespaceRemovalCandidate[], candidateIndex: number, shouldYield: () => boolean): ManagedLocalStorageNamespaceRemovalResult;
|
|
1276
1298
|
clearManifest(manifestKey: string): void;
|
|
1277
1299
|
clearSession(sessionKey: string): void;
|
|
1278
|
-
registerMaintenanceCallback(manifestKey: string, callback: () => Promise<void>): void;
|
|
1300
|
+
registerMaintenanceCallback(manifestKey: string, callback: (context?: IdleCleanupContext) => Promise<void>): void;
|
|
1279
1301
|
unregisterMaintenanceCallback(manifestKey: string): void;
|
|
1280
|
-
runMaintenance(forceManifestKeys
|
|
1302
|
+
runMaintenance(forceManifestKeys: Iterable<string> | undefined, context: IdleCleanupContext): Promise<void>;
|
|
1281
1303
|
readProtectedStorageKeys(sessionKey: string): Set<string>;
|
|
1282
1304
|
syncSessionProtectedKeys(sessionKey: string, protectedKeys: Iterable<string>): void;
|
|
1283
1305
|
};
|