Repository navigation
Expand file tree
/
Copy pathscore-cache.js
More file actions
115 lines (105 loc) · 3.13 KB
/
Copy pathscore-cache.js
File metadata and controls
115 lines (105 loc) · 3.13 KB
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import { SCORE_CACHE_VERSION } from "./jev.js";
const STORAGE_KEY = "commentScoreCache";
const TTL_MS = 7 * 24 * 60 * 60 * 1000;
const MAX_ENTRIES = 5000;
const LOAD_BUDGET_MS = 75;
export function scoreCacheKey(noteId, commentId) {
if (typeof noteId === "string" && noteId && typeof commentId === "string" && commentId) {
return JSON.stringify([noteId, commentId]);
}
return null;
}
function validScore(value) {
return Number.isFinite(value) && value >= 0 && value <= 1;
}
export function createScoreCache(storage) {
const entries = new Map();
let loaded = false;
let dirty = false;
let writing = false;
function prune(now) {
for (const [key, entry] of entries) {
if (entry.expiresAt <= now) {
entries.delete(key);
dirty = true;
}
}
// Insertion order follows the payload order on load and write order afterward.
while (entries.size > MAX_ENTRIES) {
entries.delete(entries.keys().next().value);
dirty = true;
}
}
function persist() {
if (writing || !dirty) return;
writing = true;
setTimeout(async () => {
try {
while (dirty) {
dirty = false;
await storage.set({
[STORAGE_KEY]: { version: SCORE_CACHE_VERSION, entries: Object.fromEntries(entries) }
});
}
} catch {
// Keep memory hits available and retry the snapshot on a later write.
dirty = true;
} finally {
writing = false;
}
}, 0);
}
const ready = (async () => {
try {
const { [STORAGE_KEY]: saved } = await storage.get(STORAGE_KEY);
if (saved?.version === SCORE_CACHE_VERSION) {
for (const [key, entry] of Object.entries(saved.entries ?? {})) {
if (Number.isFinite(entry?.expiresAt) && validScore(entry.scores?.promotion) &&
validScore(entry.scores?.diandianRequest)) {
entries.set(key, entry);
} else {
dirty = true;
}
}
} else if (saved !== undefined) {
dirty = true;
}
loaded = true;
prune(Date.now());
persist();
} catch {
// A failed read leaves the persistent cache unavailable for this worker.
}
})();
async function read(keys, deadline = Infinity) {
if (keys.some(Boolean) && !loaded) {
const budget = Math.min(LOAD_BUDGET_MS, deadline - Date.now());
if (budget > 0) {
let timer;
await Promise.race([ready, new Promise(resolve => { timer = setTimeout(resolve, budget); })]);
clearTimeout(timer);
}
}
const now = Date.now();
return keys.map(key => {
const entry = entries.get(key);
return now < deadline && entry?.expiresAt > now ? entry.scores : undefined;
});
}
function write(results) {
if (!results.length) return;
void ready.then(() => {
if (!loaded) return;
const now = Date.now();
prune(now);
for (const { key, scores } of results) {
if (entries.has(key)) continue;
entries.set(key, { scores, expiresAt: now + TTL_MS });
dirty = true;
}
prune(now);
persist();
});
}
return { read, write };
}