1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
// Disposable public feed cache. Budget is conservative UTF-16 storage bytes.
// The feeds read most recently keep a full page; the rest keep a few seed
// posts, so switching to any feed paints something before the relays answer.
export const FEED_CACHE_POSTS = 30;
export const FEED_SEED_POSTS = 5;
const FULL_FEEDS = 4, MAX_FEEDS = 12, MAX_UNITS = 256_000, MAX_AGE = 7 * 86400_000;
export function createFeedCache(storage, prefix, now = Date.now) {
const keyOf = (id) => id === 'following' ? prefix : prefix + ':' + id;
const valid = (e) => (e?.kind === 1 || e?.kind === 1068) && typeof e.id === 'string' && typeof e.pubkey === 'string'
&& typeof e.content === 'string' && Number.isFinite(e.created_at) && Array.isArray(e.tags);
function compact(notes, max = FEED_CACHE_POSTS) {
const kept = []; let size = 0;
for (const e of (Array.isArray(notes) ? notes : []).filter(valid).sort((a, b) => b.created_at - a.created_at)) {
const cost = JSON.stringify(e).length;
if (size + cost > MAX_UNITS - 1000) continue;
kept.push(e); size += cost;
if (kept.length === max) break;
}
return kept;
}
function sweep(preferred) {
const entries = [];
for (let i = 0; i < storage.length; i++) {
const key = storage.key(i);
if (key !== prefix && !key?.startsWith(prefix + ':')) continue;
try {
const text = storage.getItem(key);
const raw = JSON.parse(text);
const entry = Array.isArray(raw) ? { at: now(), notes: raw } : raw;
if (!entry || !Number.isFinite(entry.at) || now() - entry.at > MAX_AGE) entries.push({ key });
else entries.push({ key, text, entry });
} catch { entries.push({ key }); }
}
// A feed that was read beats one only warmed in the background (seed).
entries.sort((a, b) => (b.key === preferred) - (a.key === preferred)
|| (!a.entry?.seed) - (!b.entry?.seed) || (b.entry?.at || 0) - (a.entry?.at || 0));
let units = 0, count = 0;
for (const e of entries) {
const max = count < FULL_FEEDS && !e.entry?.seed ? FEED_CACHE_POSTS : FEED_SEED_POSTS;
const value = e.entry && { at: e.entry.at, notes: compact(e.entry.notes, max), ...(e.entry.seed ? { seed: true } : {}) };
const json = value && JSON.stringify(value);
if (!json || count >= MAX_FEEDS || units + json.length > MAX_UNITS) storage.removeItem(e.key);
else { if (e.text !== json) storage.setItem(e.key, json); units += json.length; count++; }
}
}
const peek = (id) => { try { return JSON.parse(storage.getItem(keyOf(id)) || 'null'); } catch { return null; } };
return {
read(id) {
try {
sweep(keyOf(id));
const value = JSON.parse(storage.getItem(keyOf(id)) || 'null');
if (!value) return [];
value.at = now(); storage.setItem(keyOf(id), JSON.stringify(value));
return value.notes;
} catch { return []; }
},
save(id, notes) {
try { storage.setItem(keyOf(id), JSON.stringify({ at: now(), notes: compact(notes) })); sweep(keyOf(id)); } catch {}
},
// Whether a feed already has posts on disk (without counting as a read).
has: (id) => !!peek(id)?.notes?.length,
// A few posts fetched ahead for a feed not yet opened. Never replaces
// posts a read left behind, and ranks below every feed that was read.
seed(id, notes) {
try {
if (peek(id)?.notes?.length) return;
storage.setItem(keyOf(id), JSON.stringify({ at: now(), seed: true, notes: compact(notes, FEED_SEED_POSTS) }));
sweep(null);
} catch {}
},
};
}
|
