@vue-skuilder/db 0.2.24 → 0.2.26
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/{SyncStrategy-CCU1H81I.d.cts → SyncStrategy-BXliog1m.d.cts} +14 -1
- package/dist/{SyncStrategy-CCU1H81I.d.ts → SyncStrategy-BXliog1m.d.ts} +14 -1
- package/dist/{contentSource-jBskhS2Y.d.cts → contentSource-D3c1fMAk.d.cts} +24 -2
- package/dist/{contentSource-Z9lQOuu5.d.ts → contentSource-LPf044hY.d.ts} +24 -2
- package/dist/core/index.d.cts +3 -3
- package/dist/core/index.d.ts +3 -3
- package/dist/core/index.js +2508 -481
- package/dist/core/index.js.map +1 -1
- package/dist/core/index.mjs +2498 -466
- package/dist/core/index.mjs.map +1 -1
- package/dist/{dataLayerProvider-DbA3d_Pd.d.cts → dataLayerProvider-CeLiFbHv.d.cts} +1 -1
- package/dist/{dataLayerProvider-CvSh3KW-.d.ts → dataLayerProvider-DaAootVV.d.ts} +1 -1
- package/dist/impl/couch/index.d.cts +4 -3
- package/dist/impl/couch/index.d.ts +4 -3
- package/dist/impl/couch/index.js +2266 -217
- package/dist/impl/couch/index.js.map +1 -1
- package/dist/impl/couch/index.mjs +2260 -206
- package/dist/impl/couch/index.mjs.map +1 -1
- package/dist/impl/static/index.d.cts +3 -3
- package/dist/impl/static/index.d.ts +3 -3
- package/dist/impl/static/index.js +2353 -320
- package/dist/impl/static/index.js.map +1 -1
- package/dist/impl/static/index.mjs +2343 -305
- package/dist/impl/static/index.mjs.map +1 -1
- package/dist/index.d.cts +3 -3
- package/dist/index.d.ts +3 -3
- package/dist/index.js +8211 -7961
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +8095 -7846
- package/dist/index.mjs.map +1 -1
- package/package.json +3 -3
- package/src/core/interfaces/userDB.ts +10 -0
- package/src/impl/common/BaseUserDB.ts +53 -4
- package/src/impl/common/SyncStrategy.ts +11 -1
- package/src/impl/common/index.ts +1 -0
- package/src/impl/common/types.ts +5 -0
- package/src/impl/couch/CouchDBSyncStrategy.ts +25 -1
- package/src/study/SessionController.ts +6 -2
- package/src/study/SpacedRepetition.ts +11 -2
- package/src/study/services/EloService.ts +20 -1
- package/src/study/services/tagRecent.test.ts +101 -0
- package/src/study/services/tagRecent.ts +70 -0
|
@@ -124,6 +124,12 @@ var init_types_legacy = __esm({
|
|
|
124
124
|
});
|
|
125
125
|
|
|
126
126
|
// src/core/util/index.ts
|
|
127
|
+
function areQuestionRecords(h) {
|
|
128
|
+
return isQuestionRecord(h.records[0]);
|
|
129
|
+
}
|
|
130
|
+
function isQuestionRecord(c) {
|
|
131
|
+
return c.userAnswer !== void 0;
|
|
132
|
+
}
|
|
127
133
|
function getCardHistoryID(courseID, cardID) {
|
|
128
134
|
return `${DocTypePrefixes["CARDRECORD" /* CARDRECORD */]}-${courseID}-${cardID}`;
|
|
129
135
|
}
|
|
@@ -156,96 +162,6 @@ var init_pouchdb_setup = __esm({
|
|
|
156
162
|
}
|
|
157
163
|
});
|
|
158
164
|
|
|
159
|
-
// src/util/dataDirectory.ts
|
|
160
|
-
import * as path from "path";
|
|
161
|
-
import * as os from "os";
|
|
162
|
-
function getAppDataDirectory() {
|
|
163
|
-
if (ENV.LOCAL_STORAGE_PREFIX) {
|
|
164
|
-
return path.join(os.homedir(), `.tuilder`, ENV.LOCAL_STORAGE_PREFIX);
|
|
165
|
-
} else {
|
|
166
|
-
return path.join(os.homedir(), ".tuilder");
|
|
167
|
-
}
|
|
168
|
-
}
|
|
169
|
-
function getDbPath(dbName) {
|
|
170
|
-
return path.join(getAppDataDirectory(), dbName);
|
|
171
|
-
}
|
|
172
|
-
var init_dataDirectory = __esm({
|
|
173
|
-
"src/util/dataDirectory.ts"() {
|
|
174
|
-
"use strict";
|
|
175
|
-
init_logger();
|
|
176
|
-
init_factory();
|
|
177
|
-
}
|
|
178
|
-
});
|
|
179
|
-
|
|
180
|
-
// src/impl/common/userDBHelpers.ts
|
|
181
|
-
import moment from "moment";
|
|
182
|
-
function makeScheduledCardId(reviewTime) {
|
|
183
|
-
return DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */] + moment.utc(reviewTime).format(REVIEW_TIME_FORMAT);
|
|
184
|
-
}
|
|
185
|
-
function filterAllDocsByPrefix(db, prefix, opts) {
|
|
186
|
-
const options = {
|
|
187
|
-
startkey: prefix,
|
|
188
|
-
endkey: prefix + "\uFFF0",
|
|
189
|
-
include_docs: true
|
|
190
|
-
};
|
|
191
|
-
if (opts) {
|
|
192
|
-
Object.assign(options, opts);
|
|
193
|
-
}
|
|
194
|
-
return db.allDocs(options);
|
|
195
|
-
}
|
|
196
|
-
function getStartAndEndKeys(key) {
|
|
197
|
-
return {
|
|
198
|
-
startkey: key,
|
|
199
|
-
endkey: key + "\uFFF0"
|
|
200
|
-
};
|
|
201
|
-
}
|
|
202
|
-
function getLocalUserDB(username) {
|
|
203
|
-
const dbName = `userdb-${username}`;
|
|
204
|
-
if (typeof window === "undefined") {
|
|
205
|
-
return new pouchdb_setup_default(getDbPath(dbName), {});
|
|
206
|
-
} else {
|
|
207
|
-
return new pouchdb_setup_default(dbName, {});
|
|
208
|
-
}
|
|
209
|
-
}
|
|
210
|
-
function scheduleCardReviewLocal(userDB, review) {
|
|
211
|
-
const now = moment.utc();
|
|
212
|
-
logger.info(`Scheduling for review in: ${review.time.diff(now, "h") / 24} days`);
|
|
213
|
-
void userDB.put({
|
|
214
|
-
_id: makeScheduledCardId(review.time),
|
|
215
|
-
cardId: review.card_id,
|
|
216
|
-
reviewTime: review.time.toISOString(),
|
|
217
|
-
courseId: review.course_id,
|
|
218
|
-
scheduledAt: now.toISOString(),
|
|
219
|
-
scheduledFor: review.scheduledFor,
|
|
220
|
-
schedulingAgentId: review.schedulingAgentId
|
|
221
|
-
});
|
|
222
|
-
}
|
|
223
|
-
async function removeScheduledCardReviewLocal(userDB, reviewDocID) {
|
|
224
|
-
const reviewDoc = await userDB.get(reviewDocID);
|
|
225
|
-
userDB.remove(reviewDoc).then((res) => {
|
|
226
|
-
if (res.ok) {
|
|
227
|
-
log(`Removed Review Doc: ${reviewDocID}`);
|
|
228
|
-
}
|
|
229
|
-
}).catch((err) => {
|
|
230
|
-
log(`Failed to remove Review Doc: ${reviewDocID},
|
|
231
|
-
${JSON.stringify(err)}`);
|
|
232
|
-
});
|
|
233
|
-
}
|
|
234
|
-
var REVIEW_TIME_FORMAT, log;
|
|
235
|
-
var init_userDBHelpers = __esm({
|
|
236
|
-
"src/impl/common/userDBHelpers.ts"() {
|
|
237
|
-
"use strict";
|
|
238
|
-
init_core();
|
|
239
|
-
init_logger();
|
|
240
|
-
init_pouchdb_setup();
|
|
241
|
-
init_dataDirectory();
|
|
242
|
-
REVIEW_TIME_FORMAT = "YYYY-MM-DD--kk:mm:ss-SSS";
|
|
243
|
-
log = (s) => {
|
|
244
|
-
logger.info(s);
|
|
245
|
-
};
|
|
246
|
-
}
|
|
247
|
-
});
|
|
248
|
-
|
|
249
165
|
// src/util/Loggable.ts
|
|
250
166
|
var Loggable;
|
|
251
167
|
var init_Loggable = __esm({
|
|
@@ -385,69 +301,6 @@ var init_updateQueue = __esm({
|
|
|
385
301
|
}
|
|
386
302
|
});
|
|
387
303
|
|
|
388
|
-
// src/impl/couch/user-course-relDB.ts
|
|
389
|
-
import moment2 from "moment";
|
|
390
|
-
var UsrCrsData;
|
|
391
|
-
var init_user_course_relDB = __esm({
|
|
392
|
-
"src/impl/couch/user-course-relDB.ts"() {
|
|
393
|
-
"use strict";
|
|
394
|
-
init_logger();
|
|
395
|
-
UsrCrsData = class {
|
|
396
|
-
user;
|
|
397
|
-
_courseId;
|
|
398
|
-
constructor(user, courseId) {
|
|
399
|
-
this.user = user;
|
|
400
|
-
this._courseId = courseId;
|
|
401
|
-
}
|
|
402
|
-
async getReviewsForcast(daysCount) {
|
|
403
|
-
const time = moment2.utc().add(daysCount, "days");
|
|
404
|
-
return this.getReviewstoDate(time);
|
|
405
|
-
}
|
|
406
|
-
async getPendingReviews() {
|
|
407
|
-
const now = moment2.utc();
|
|
408
|
-
return this.getReviewstoDate(now);
|
|
409
|
-
}
|
|
410
|
-
async getScheduledReviewCount() {
|
|
411
|
-
return (await this.getPendingReviews()).length;
|
|
412
|
-
}
|
|
413
|
-
async getCourseSettings() {
|
|
414
|
-
const regDoc = await this.user.getCourseRegistrationsDoc();
|
|
415
|
-
const crsDoc = regDoc.courses.find((c) => c.courseID === this._courseId);
|
|
416
|
-
if (crsDoc && crsDoc.settings) {
|
|
417
|
-
return crsDoc.settings;
|
|
418
|
-
} else {
|
|
419
|
-
logger.warn(`no settings found during lookup on course ${this._courseId}`);
|
|
420
|
-
return {};
|
|
421
|
-
}
|
|
422
|
-
}
|
|
423
|
-
updateCourseSettings(updates) {
|
|
424
|
-
if ("updateCourseSettings" in this.user) {
|
|
425
|
-
void this.user.updateCourseSettings(this._courseId, updates);
|
|
426
|
-
}
|
|
427
|
-
}
|
|
428
|
-
async getStrategyState(strategyKey) {
|
|
429
|
-
return this.user.getStrategyState(this._courseId, strategyKey);
|
|
430
|
-
}
|
|
431
|
-
async putStrategyState(strategyKey, data) {
|
|
432
|
-
return this.user.putStrategyState(this._courseId, strategyKey, data);
|
|
433
|
-
}
|
|
434
|
-
async deleteStrategyState(strategyKey) {
|
|
435
|
-
return this.user.deleteStrategyState(this._courseId, strategyKey);
|
|
436
|
-
}
|
|
437
|
-
async getReviewstoDate(targetDate) {
|
|
438
|
-
const allReviews = await this.user.getPendingReviews(this._courseId);
|
|
439
|
-
logger.debug(
|
|
440
|
-
`Fetching ${this.user.getUsername()}'s scheduled reviews for course ${this._courseId}.`
|
|
441
|
-
);
|
|
442
|
-
return allReviews.filter((review) => {
|
|
443
|
-
const reviewTime = moment2.utc(review.reviewTime);
|
|
444
|
-
return targetDate.isAfter(reviewTime);
|
|
445
|
-
});
|
|
446
|
-
}
|
|
447
|
-
};
|
|
448
|
-
}
|
|
449
|
-
});
|
|
450
|
-
|
|
451
304
|
// src/impl/couch/clientCache.ts
|
|
452
305
|
var init_clientCache = __esm({
|
|
453
306
|
"src/impl/couch/clientCache.ts"() {
|
|
@@ -2663,7 +2516,7 @@ var srs_exports = {};
|
|
|
2663
2516
|
__export(srs_exports, {
|
|
2664
2517
|
default: () => SRSNavigator
|
|
2665
2518
|
});
|
|
2666
|
-
import
|
|
2519
|
+
import moment from "moment";
|
|
2667
2520
|
var DEFAULT_HEALTHY_BACKLOG, BACKLOG_GROWTH_RATE, SRSNavigator;
|
|
2668
2521
|
var init_srs = __esm({
|
|
2669
2522
|
"src/core/navigators/generators/srs.ts"() {
|
|
@@ -2718,8 +2571,8 @@ var init_srs = __esm({
|
|
|
2718
2571
|
}
|
|
2719
2572
|
const courseId = this.course.getCourseID();
|
|
2720
2573
|
const reviews = await this.user.getPendingReviews(courseId);
|
|
2721
|
-
const now =
|
|
2722
|
-
let dueReviews = reviews.filter((r) => now.isAfter(
|
|
2574
|
+
const now = moment.utc();
|
|
2575
|
+
let dueReviews = reviews.filter((r) => now.isAfter(moment.utc(r.reviewTime)));
|
|
2723
2576
|
if (dueReviews.length > 0) {
|
|
2724
2577
|
const dueCardIds = [...new Set(dueReviews.map((r) => r.cardId))];
|
|
2725
2578
|
const tagsByCard = await this.course.getAppliedTagsBatch(dueCardIds);
|
|
@@ -2740,13 +2593,13 @@ var init_srs = __esm({
|
|
|
2740
2593
|
}
|
|
2741
2594
|
}
|
|
2742
2595
|
const backlogMultiplier = this.computeBacklogMultiplier(dueReviews.length);
|
|
2743
|
-
const notDue = reviews.filter((r) => !now.isAfter(
|
|
2596
|
+
const notDue = reviews.filter((r) => !now.isAfter(moment.utc(r.reviewTime)));
|
|
2744
2597
|
let nextDueIn = null;
|
|
2745
2598
|
if (notDue.length > 0) {
|
|
2746
2599
|
const next = notDue.reduce(
|
|
2747
|
-
(a, b) =>
|
|
2600
|
+
(a, b) => moment.utc(a.reviewTime).isBefore(moment.utc(b.reviewTime)) ? a : b
|
|
2748
2601
|
);
|
|
2749
|
-
const until =
|
|
2602
|
+
const until = moment.duration(moment.utc(next.reviewTime).diff(now));
|
|
2750
2603
|
nextDueIn = until.asHours() < 1 ? `${Math.round(until.asMinutes())}m` : until.asHours() < 24 ? `${Math.round(until.asHours())}h` : `${Math.round(until.asDays())}d`;
|
|
2751
2604
|
}
|
|
2752
2605
|
if (dueReviews.length > 0) {
|
|
@@ -2756,11 +2609,11 @@ var init_srs = __esm({
|
|
|
2756
2609
|
);
|
|
2757
2610
|
} else if (reviews.length > 0) {
|
|
2758
2611
|
const sortedByDue = [...reviews].sort(
|
|
2759
|
-
(a, b) =>
|
|
2612
|
+
(a, b) => moment.utc(a.reviewTime).diff(moment.utc(b.reviewTime))
|
|
2760
2613
|
);
|
|
2761
2614
|
const nextDue = sortedByDue[0];
|
|
2762
|
-
const nextDueTime =
|
|
2763
|
-
const untilDue =
|
|
2615
|
+
const nextDueTime = moment.utc(nextDue.reviewTime);
|
|
2616
|
+
const untilDue = moment.duration(nextDueTime.diff(now));
|
|
2764
2617
|
const untilDueStr = untilDue.asHours() < 1 ? `${Math.round(untilDue.asMinutes())}m` : untilDue.asHours() < 24 ? `${Math.round(untilDue.asHours())}h` : `${Math.round(untilDue.asDays())}d`;
|
|
2765
2618
|
logger.info(
|
|
2766
2619
|
`[SRS] Course ${courseId}: 0 reviews due now (${reviews.length} scheduled, next in ${untilDueStr})`
|
|
@@ -2856,8 +2709,8 @@ var init_srs = __esm({
|
|
|
2856
2709
|
* @param backlogMultiplier - Pre-computed backlog multiplier (>= 1.0, unbounded)
|
|
2857
2710
|
*/
|
|
2858
2711
|
computeUrgencyScore(review, now, backlogMultiplier) {
|
|
2859
|
-
const scheduledAt =
|
|
2860
|
-
const due =
|
|
2712
|
+
const scheduledAt = moment.utc(review.scheduledAt);
|
|
2713
|
+
const due = moment.utc(review.reviewTime);
|
|
2861
2714
|
const intervalHours = Math.max(1, due.diff(scheduledAt, "hours"));
|
|
2862
2715
|
const hoursOverdue = now.diff(due, "hours");
|
|
2863
2716
|
const relativeOverdue = hoursOverdue / intervalHours;
|
|
@@ -5278,7 +5131,7 @@ var init_courseDB = __esm({
|
|
|
5278
5131
|
});
|
|
5279
5132
|
|
|
5280
5133
|
// src/impl/couch/classroomDB.ts
|
|
5281
|
-
import
|
|
5134
|
+
import moment2 from "moment";
|
|
5282
5135
|
var init_classroomDB2 = __esm({
|
|
5283
5136
|
"src/impl/couch/classroomDB.ts"() {
|
|
5284
5137
|
"use strict";
|
|
@@ -5340,7 +5193,7 @@ var init_CouchDBSyncStrategy = __esm({
|
|
|
5340
5193
|
|
|
5341
5194
|
// src/impl/couch/index.ts
|
|
5342
5195
|
import fetch3 from "cross-fetch";
|
|
5343
|
-
import
|
|
5196
|
+
import moment3 from "moment";
|
|
5344
5197
|
import process2 from "process";
|
|
5345
5198
|
function createPouchDBConfig() {
|
|
5346
5199
|
const hasExplicitCredentials = ENV.COUCHDB_USERNAME && ENV.COUCHDB_PASSWORD;
|
|
@@ -5391,104 +5244,2267 @@ var init_couch = __esm({
|
|
|
5391
5244
|
}
|
|
5392
5245
|
});
|
|
5393
5246
|
|
|
5394
|
-
// src/
|
|
5395
|
-
import
|
|
5396
|
-
import
|
|
5397
|
-
function
|
|
5398
|
-
let
|
|
5399
|
-
|
|
5400
|
-
|
|
5401
|
-
|
|
5402
|
-
|
|
5403
|
-
})
|
|
5404
|
-
]).finally(() => {
|
|
5405
|
-
if (timer !== void 0) {
|
|
5406
|
-
clearTimeout(timer);
|
|
5407
|
-
}
|
|
5408
|
-
});
|
|
5409
|
-
}
|
|
5410
|
-
function accomodateGuest() {
|
|
5411
|
-
logger.log("[funnel] accomodateGuest() called");
|
|
5412
|
-
if (typeof localStorage === "undefined") {
|
|
5413
|
-
logger.log(
|
|
5414
|
-
"[funnel] localStorage not available (Node.js environment), returning default guest"
|
|
5415
|
-
);
|
|
5416
|
-
return {
|
|
5417
|
-
username: GuestUsername + "nodejs-test",
|
|
5418
|
-
firstVisit: true
|
|
5419
|
-
};
|
|
5247
|
+
// src/study/SpacedRepetition.ts
|
|
5248
|
+
import moment4 from "moment";
|
|
5249
|
+
import { isTaggedPerformance } from "@vue-skuilder/common";
|
|
5250
|
+
function getStreak(records) {
|
|
5251
|
+
let streak = 0;
|
|
5252
|
+
let index = records.length - 1;
|
|
5253
|
+
while (index >= 0 && records[index].isCorrect) {
|
|
5254
|
+
index--;
|
|
5255
|
+
streak++;
|
|
5420
5256
|
}
|
|
5421
|
-
|
|
5422
|
-
|
|
5423
|
-
|
|
5424
|
-
|
|
5425
|
-
|
|
5426
|
-
|
|
5427
|
-
|
|
5428
|
-
|
|
5429
|
-
|
|
5430
|
-
|
|
5431
|
-
|
|
5432
|
-
|
|
5433
|
-
const uuid = generateUUID();
|
|
5434
|
-
logger.log("[funnel] Generated UUID:", uuid);
|
|
5435
|
-
logger.log("[funnel] UUID length:", uuid.length);
|
|
5436
|
-
try {
|
|
5437
|
-
localStorage.setItem(dbUUID, uuid);
|
|
5438
|
-
logger.log("[funnel] Successfully stored UUID in localStorage");
|
|
5439
|
-
const verification = localStorage.getItem(dbUUID);
|
|
5440
|
-
logger.log("[funnel] Verification read from localStorage:", verification);
|
|
5441
|
-
} catch (e) {
|
|
5442
|
-
logger.error("[funnel] ERROR storing UUID:", e);
|
|
5443
|
-
}
|
|
5444
|
-
logger.log(`[funnel] Accommodating a new guest with account: ${uuid}`);
|
|
5257
|
+
return streak;
|
|
5258
|
+
}
|
|
5259
|
+
function getLapses(records) {
|
|
5260
|
+
return records.filter((r) => r.isCorrect === false).length;
|
|
5261
|
+
}
|
|
5262
|
+
var duration;
|
|
5263
|
+
var init_SpacedRepetition = __esm({
|
|
5264
|
+
"src/study/SpacedRepetition.ts"() {
|
|
5265
|
+
"use strict";
|
|
5266
|
+
init_util();
|
|
5267
|
+
init_logger();
|
|
5268
|
+
duration = moment4.duration;
|
|
5445
5269
|
}
|
|
5446
|
-
|
|
5447
|
-
|
|
5448
|
-
|
|
5449
|
-
|
|
5450
|
-
|
|
5451
|
-
|
|
5452
|
-
|
|
5453
|
-
|
|
5454
|
-
|
|
5455
|
-
|
|
5456
|
-
logger.log("[funnel] Inside generateUUID()");
|
|
5457
|
-
if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
|
|
5458
|
-
const uuid2 = crypto.randomUUID();
|
|
5459
|
-
logger.log("[funnel] Generated UUID using crypto.randomUUID():", uuid2);
|
|
5460
|
-
return uuid2;
|
|
5461
|
-
}
|
|
5462
|
-
if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
|
|
5463
|
-
const bytes = new Uint8Array(16);
|
|
5464
|
-
crypto.getRandomValues(bytes);
|
|
5465
|
-
bytes[6] = bytes[6] & 15 | 64;
|
|
5466
|
-
bytes[8] = bytes[8] & 63 | 128;
|
|
5467
|
-
const uuid2 = [
|
|
5468
|
-
Array.from(bytes.slice(0, 4)).map((b) => b.toString(16).padStart(2, "0")).join(""),
|
|
5469
|
-
Array.from(bytes.slice(4, 6)).map((b) => b.toString(16).padStart(2, "0")).join(""),
|
|
5470
|
-
Array.from(bytes.slice(6, 8)).map((b) => b.toString(16).padStart(2, "0")).join(""),
|
|
5471
|
-
Array.from(bytes.slice(8, 10)).map((b) => b.toString(16).padStart(2, "0")).join(""),
|
|
5472
|
-
Array.from(bytes.slice(10, 16)).map((b) => b.toString(16).padStart(2, "0")).join("")
|
|
5473
|
-
].join("-");
|
|
5474
|
-
logger.log("[funnel] Generated UUID using crypto.getRandomValues():", uuid2);
|
|
5475
|
-
return uuid2;
|
|
5476
|
-
}
|
|
5477
|
-
logger.warn("[funnel] crypto API not available, using timestamp-based UUID (NOT SECURE)");
|
|
5478
|
-
let d = (/* @__PURE__ */ new Date()).getTime();
|
|
5479
|
-
if (typeof performance !== "undefined" && typeof performance.now === "function") {
|
|
5480
|
-
d += performance.now();
|
|
5481
|
-
}
|
|
5482
|
-
const uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
|
|
5483
|
-
const r = (d + Math.random() * 16) % 16 | 0;
|
|
5484
|
-
d = Math.floor(d / 16);
|
|
5485
|
-
return (c === "x" ? r : r & 3 | 8).toString(16);
|
|
5486
|
-
});
|
|
5487
|
-
logger.log("[funnel] Generated UUID (fallback):", uuid);
|
|
5488
|
-
return uuid;
|
|
5270
|
+
});
|
|
5271
|
+
|
|
5272
|
+
// src/study/services/SrsService.ts
|
|
5273
|
+
import moment5 from "moment";
|
|
5274
|
+
var init_SrsService = __esm({
|
|
5275
|
+
"src/study/services/SrsService.ts"() {
|
|
5276
|
+
"use strict";
|
|
5277
|
+
init_couch();
|
|
5278
|
+
init_SpacedRepetition();
|
|
5279
|
+
init_logger();
|
|
5489
5280
|
}
|
|
5490
|
-
}
|
|
5491
|
-
|
|
5281
|
+
});
|
|
5282
|
+
|
|
5283
|
+
// src/study/services/tagRecent.ts
|
|
5284
|
+
import {
|
|
5285
|
+
pushTagPresentation
|
|
5286
|
+
} from "@vue-skuilder/common";
|
|
5287
|
+
var init_tagRecent = __esm({
|
|
5288
|
+
"src/study/services/tagRecent.ts"() {
|
|
5289
|
+
"use strict";
|
|
5290
|
+
}
|
|
5291
|
+
});
|
|
5292
|
+
|
|
5293
|
+
// src/study/services/EloService.ts
|
|
5294
|
+
import {
|
|
5295
|
+
adjustCourseScores,
|
|
5296
|
+
adjustCourseScoresPerTag,
|
|
5297
|
+
toCourseElo as toCourseElo7
|
|
5298
|
+
} from "@vue-skuilder/common";
|
|
5299
|
+
var init_EloService = __esm({
|
|
5300
|
+
"src/study/services/EloService.ts"() {
|
|
5301
|
+
"use strict";
|
|
5302
|
+
init_logger();
|
|
5303
|
+
init_tagRecent();
|
|
5304
|
+
}
|
|
5305
|
+
});
|
|
5306
|
+
|
|
5307
|
+
// src/study/services/ResponseProcessor.ts
|
|
5308
|
+
import { isTaggedPerformance as isTaggedPerformance2 } from "@vue-skuilder/common";
|
|
5309
|
+
var init_ResponseProcessor = __esm({
|
|
5310
|
+
"src/study/services/ResponseProcessor.ts"() {
|
|
5311
|
+
"use strict";
|
|
5312
|
+
init_core();
|
|
5313
|
+
init_logger();
|
|
5314
|
+
}
|
|
5315
|
+
});
|
|
5316
|
+
|
|
5317
|
+
// src/study/services/CardHydrationService.ts
|
|
5318
|
+
import {
|
|
5319
|
+
displayableDataToViewData,
|
|
5320
|
+
isCourseElo,
|
|
5321
|
+
toCourseElo as toCourseElo8
|
|
5322
|
+
} from "@vue-skuilder/common";
|
|
5323
|
+
var init_CardHydrationService = __esm({
|
|
5324
|
+
"src/study/services/CardHydrationService.ts"() {
|
|
5325
|
+
"use strict";
|
|
5326
|
+
init_logger();
|
|
5327
|
+
}
|
|
5328
|
+
});
|
|
5329
|
+
|
|
5330
|
+
// src/study/ItemQueue.ts
|
|
5331
|
+
var init_ItemQueue = __esm({
|
|
5332
|
+
"src/study/ItemQueue.ts"() {
|
|
5333
|
+
"use strict";
|
|
5334
|
+
}
|
|
5335
|
+
});
|
|
5336
|
+
|
|
5337
|
+
// src/core/types/studySession.ts
|
|
5338
|
+
var init_studySession = __esm({
|
|
5339
|
+
"src/core/types/studySession.ts"() {
|
|
5340
|
+
"use strict";
|
|
5341
|
+
init_types_legacy();
|
|
5342
|
+
}
|
|
5343
|
+
});
|
|
5344
|
+
|
|
5345
|
+
// src/util/packer/types.ts
|
|
5346
|
+
var init_types3 = __esm({
|
|
5347
|
+
"src/util/packer/types.ts"() {
|
|
5348
|
+
"use strict";
|
|
5349
|
+
}
|
|
5350
|
+
});
|
|
5351
|
+
|
|
5352
|
+
// src/util/packer/CouchDBToStaticPacker.ts
|
|
5353
|
+
var init_CouchDBToStaticPacker = __esm({
|
|
5354
|
+
"src/util/packer/CouchDBToStaticPacker.ts"() {
|
|
5355
|
+
"use strict";
|
|
5356
|
+
init_types_legacy();
|
|
5357
|
+
init_logger();
|
|
5358
|
+
}
|
|
5359
|
+
});
|
|
5360
|
+
|
|
5361
|
+
// src/util/packer/index.ts
|
|
5362
|
+
var init_packer = __esm({
|
|
5363
|
+
"src/util/packer/index.ts"() {
|
|
5364
|
+
"use strict";
|
|
5365
|
+
init_types3();
|
|
5366
|
+
init_CouchDBToStaticPacker();
|
|
5367
|
+
}
|
|
5368
|
+
});
|
|
5369
|
+
|
|
5370
|
+
// src/util/migrator/types.ts
|
|
5371
|
+
var DEFAULT_MIGRATION_OPTIONS;
|
|
5372
|
+
var init_types4 = __esm({
|
|
5373
|
+
"src/util/migrator/types.ts"() {
|
|
5374
|
+
"use strict";
|
|
5375
|
+
DEFAULT_MIGRATION_OPTIONS = {
|
|
5376
|
+
chunkBatchSize: 100,
|
|
5377
|
+
validateRoundTrip: false,
|
|
5378
|
+
cleanupOnFailure: true,
|
|
5379
|
+
timeout: 3e5
|
|
5380
|
+
// 5 minutes
|
|
5381
|
+
};
|
|
5382
|
+
}
|
|
5383
|
+
});
|
|
5384
|
+
|
|
5385
|
+
// src/util/migrator/FileSystemAdapter.ts
|
|
5386
|
+
var FileSystemError;
|
|
5387
|
+
var init_FileSystemAdapter = __esm({
|
|
5388
|
+
"src/util/migrator/FileSystemAdapter.ts"() {
|
|
5389
|
+
"use strict";
|
|
5390
|
+
FileSystemError = class extends Error {
|
|
5391
|
+
constructor(message, operation, filePath, cause) {
|
|
5392
|
+
super(message);
|
|
5393
|
+
this.operation = operation;
|
|
5394
|
+
this.filePath = filePath;
|
|
5395
|
+
this.cause = cause;
|
|
5396
|
+
this.name = "FileSystemError";
|
|
5397
|
+
}
|
|
5398
|
+
};
|
|
5399
|
+
}
|
|
5400
|
+
});
|
|
5401
|
+
|
|
5402
|
+
// src/util/migrator/validation.ts
|
|
5403
|
+
async function validateStaticCourse(staticPath, fs) {
|
|
5404
|
+
const validation = {
|
|
5405
|
+
valid: true,
|
|
5406
|
+
manifestExists: false,
|
|
5407
|
+
chunksExist: false,
|
|
5408
|
+
attachmentsExist: false,
|
|
5409
|
+
errors: [],
|
|
5410
|
+
warnings: []
|
|
5411
|
+
};
|
|
5412
|
+
try {
|
|
5413
|
+
if (fs) {
|
|
5414
|
+
const stats = await fs.stat(staticPath);
|
|
5415
|
+
if (!stats.isDirectory()) {
|
|
5416
|
+
validation.errors.push(`Path is not a directory: ${staticPath}`);
|
|
5417
|
+
validation.valid = false;
|
|
5418
|
+
return validation;
|
|
5419
|
+
}
|
|
5420
|
+
} else if (!nodeFS) {
|
|
5421
|
+
validation.errors.push("File system access not available - validation skipped");
|
|
5422
|
+
validation.valid = false;
|
|
5423
|
+
return validation;
|
|
5424
|
+
} else {
|
|
5425
|
+
const stats = await nodeFS.promises.stat(staticPath);
|
|
5426
|
+
if (!stats.isDirectory()) {
|
|
5427
|
+
validation.errors.push(`Path is not a directory: ${staticPath}`);
|
|
5428
|
+
validation.valid = false;
|
|
5429
|
+
return validation;
|
|
5430
|
+
}
|
|
5431
|
+
}
|
|
5432
|
+
let manifestPath = `${staticPath}/manifest.json`;
|
|
5433
|
+
try {
|
|
5434
|
+
if (fs) {
|
|
5435
|
+
manifestPath = fs.joinPath(staticPath, "manifest.json");
|
|
5436
|
+
if (await fs.exists(manifestPath)) {
|
|
5437
|
+
validation.manifestExists = true;
|
|
5438
|
+
const manifestContent = await fs.readFile(manifestPath);
|
|
5439
|
+
const manifest = JSON.parse(manifestContent);
|
|
5440
|
+
validation.courseId = manifest.courseId;
|
|
5441
|
+
validation.courseName = manifest.courseName;
|
|
5442
|
+
if (!manifest.version || !manifest.courseId || !manifest.chunks || !Array.isArray(manifest.chunks)) {
|
|
5443
|
+
validation.errors.push("Invalid manifest structure");
|
|
5444
|
+
validation.valid = false;
|
|
5445
|
+
}
|
|
5446
|
+
} else {
|
|
5447
|
+
validation.errors.push(`Manifest not found: ${manifestPath}`);
|
|
5448
|
+
validation.valid = false;
|
|
5449
|
+
}
|
|
5450
|
+
} else {
|
|
5451
|
+
manifestPath = `${staticPath}/manifest.json`;
|
|
5452
|
+
await nodeFS.promises.access(manifestPath);
|
|
5453
|
+
validation.manifestExists = true;
|
|
5454
|
+
const manifestContent = await nodeFS.promises.readFile(manifestPath, "utf8");
|
|
5455
|
+
const manifest = JSON.parse(manifestContent);
|
|
5456
|
+
validation.courseId = manifest.courseId;
|
|
5457
|
+
validation.courseName = manifest.courseName;
|
|
5458
|
+
if (!manifest.version || !manifest.courseId || !manifest.chunks || !Array.isArray(manifest.chunks)) {
|
|
5459
|
+
validation.errors.push("Invalid manifest structure");
|
|
5460
|
+
validation.valid = false;
|
|
5461
|
+
}
|
|
5462
|
+
}
|
|
5463
|
+
} catch (error) {
|
|
5464
|
+
const errorMessage = error instanceof FileSystemError ? error.message : `Manifest not found or invalid: ${manifestPath}`;
|
|
5465
|
+
validation.errors.push(errorMessage);
|
|
5466
|
+
validation.valid = false;
|
|
5467
|
+
}
|
|
5468
|
+
let chunksPath = `${staticPath}/chunks`;
|
|
5469
|
+
try {
|
|
5470
|
+
if (fs) {
|
|
5471
|
+
chunksPath = fs.joinPath(staticPath, "chunks");
|
|
5472
|
+
if (await fs.exists(chunksPath)) {
|
|
5473
|
+
const chunksStats = await fs.stat(chunksPath);
|
|
5474
|
+
if (chunksStats.isDirectory()) {
|
|
5475
|
+
validation.chunksExist = true;
|
|
5476
|
+
} else {
|
|
5477
|
+
validation.errors.push(`Chunks path is not a directory: ${chunksPath}`);
|
|
5478
|
+
validation.valid = false;
|
|
5479
|
+
}
|
|
5480
|
+
} else {
|
|
5481
|
+
validation.errors.push(`Chunks directory not found: ${chunksPath}`);
|
|
5482
|
+
validation.valid = false;
|
|
5483
|
+
}
|
|
5484
|
+
} else {
|
|
5485
|
+
chunksPath = `${staticPath}/chunks`;
|
|
5486
|
+
const chunksStats = await nodeFS.promises.stat(chunksPath);
|
|
5487
|
+
if (chunksStats.isDirectory()) {
|
|
5488
|
+
validation.chunksExist = true;
|
|
5489
|
+
} else {
|
|
5490
|
+
validation.errors.push(`Chunks path is not a directory: ${chunksPath}`);
|
|
5491
|
+
validation.valid = false;
|
|
5492
|
+
}
|
|
5493
|
+
}
|
|
5494
|
+
} catch (error) {
|
|
5495
|
+
const errorMessage = error instanceof FileSystemError ? error.message : `Chunks directory not found: ${chunksPath}`;
|
|
5496
|
+
validation.errors.push(errorMessage);
|
|
5497
|
+
validation.valid = false;
|
|
5498
|
+
}
|
|
5499
|
+
let attachmentsPath;
|
|
5500
|
+
try {
|
|
5501
|
+
if (fs) {
|
|
5502
|
+
attachmentsPath = fs.joinPath(staticPath, "attachments");
|
|
5503
|
+
if (await fs.exists(attachmentsPath)) {
|
|
5504
|
+
const attachmentsStats = await fs.stat(attachmentsPath);
|
|
5505
|
+
if (attachmentsStats.isDirectory()) {
|
|
5506
|
+
validation.attachmentsExist = true;
|
|
5507
|
+
}
|
|
5508
|
+
} else {
|
|
5509
|
+
validation.warnings.push(
|
|
5510
|
+
`Attachments directory not found: ${attachmentsPath} (this is OK if course has no attachments)`
|
|
5511
|
+
);
|
|
5512
|
+
}
|
|
5513
|
+
} else {
|
|
5514
|
+
attachmentsPath = `${staticPath}/attachments`;
|
|
5515
|
+
const attachmentsStats = await nodeFS.promises.stat(attachmentsPath);
|
|
5516
|
+
if (attachmentsStats.isDirectory()) {
|
|
5517
|
+
validation.attachmentsExist = true;
|
|
5518
|
+
}
|
|
5519
|
+
}
|
|
5520
|
+
} catch (error) {
|
|
5521
|
+
attachmentsPath = attachmentsPath || `${staticPath}/attachments`;
|
|
5522
|
+
const warningMessage = error instanceof FileSystemError ? error.message : `Attachments directory not found: ${attachmentsPath} (this is OK if course has no attachments)`;
|
|
5523
|
+
validation.warnings.push(warningMessage);
|
|
5524
|
+
}
|
|
5525
|
+
} catch (error) {
|
|
5526
|
+
validation.errors.push(
|
|
5527
|
+
`Failed to validate static course: ${error instanceof Error ? error.message : String(error)}`
|
|
5528
|
+
);
|
|
5529
|
+
validation.valid = false;
|
|
5530
|
+
}
|
|
5531
|
+
return validation;
|
|
5532
|
+
}
|
|
5533
|
+
async function validateMigration(targetDB, expectedCounts, manifest) {
|
|
5534
|
+
const validation = {
|
|
5535
|
+
valid: true,
|
|
5536
|
+
documentCountMatch: false,
|
|
5537
|
+
attachmentIntegrity: false,
|
|
5538
|
+
viewFunctionality: false,
|
|
5539
|
+
issues: []
|
|
5540
|
+
};
|
|
5541
|
+
try {
|
|
5542
|
+
logger.info("Starting migration validation...");
|
|
5543
|
+
const actualCounts = await getActualDocumentCounts(targetDB);
|
|
5544
|
+
validation.documentCountMatch = compareDocumentCounts(
|
|
5545
|
+
expectedCounts,
|
|
5546
|
+
actualCounts,
|
|
5547
|
+
validation.issues
|
|
5548
|
+
);
|
|
5549
|
+
await validateCourseConfig(targetDB, manifest, validation.issues);
|
|
5550
|
+
validation.viewFunctionality = await validateViews(targetDB, manifest, validation.issues);
|
|
5551
|
+
validation.attachmentIntegrity = await validateAttachmentIntegrity(targetDB, validation.issues);
|
|
5552
|
+
validation.valid = validation.documentCountMatch && validation.viewFunctionality && validation.attachmentIntegrity;
|
|
5553
|
+
logger.info(`Migration validation completed. Valid: ${validation.valid}`);
|
|
5554
|
+
if (validation.issues.length > 0) {
|
|
5555
|
+
logger.info(`Validation issues: ${validation.issues.length}`);
|
|
5556
|
+
validation.issues.forEach((issue) => {
|
|
5557
|
+
if (issue.type === "error") {
|
|
5558
|
+
logger.error(`${issue.category}: ${issue.message}`);
|
|
5559
|
+
} else {
|
|
5560
|
+
logger.warn(`${issue.category}: ${issue.message}`);
|
|
5561
|
+
}
|
|
5562
|
+
});
|
|
5563
|
+
}
|
|
5564
|
+
} catch (error) {
|
|
5565
|
+
validation.valid = false;
|
|
5566
|
+
validation.issues.push({
|
|
5567
|
+
type: "error",
|
|
5568
|
+
category: "metadata",
|
|
5569
|
+
message: `Validation failed: ${error instanceof Error ? error.message : String(error)}`
|
|
5570
|
+
});
|
|
5571
|
+
}
|
|
5572
|
+
return validation;
|
|
5573
|
+
}
|
|
5574
|
+
async function getActualDocumentCounts(db) {
|
|
5575
|
+
const counts = {};
|
|
5576
|
+
try {
|
|
5577
|
+
const allDocs = await db.allDocs({ include_docs: true });
|
|
5578
|
+
for (const row of allDocs.rows) {
|
|
5579
|
+
if (row.id.startsWith("_design/")) {
|
|
5580
|
+
counts["_design"] = (counts["_design"] || 0) + 1;
|
|
5581
|
+
continue;
|
|
5582
|
+
}
|
|
5583
|
+
const doc = row.doc;
|
|
5584
|
+
if (doc && doc.docType) {
|
|
5585
|
+
counts[doc.docType] = (counts[doc.docType] || 0) + 1;
|
|
5586
|
+
} else {
|
|
5587
|
+
counts["unknown"] = (counts["unknown"] || 0) + 1;
|
|
5588
|
+
}
|
|
5589
|
+
}
|
|
5590
|
+
} catch (error) {
|
|
5591
|
+
logger.error("Failed to get actual document counts:", error);
|
|
5592
|
+
}
|
|
5593
|
+
return counts;
|
|
5594
|
+
}
|
|
5595
|
+
function compareDocumentCounts(expected, actual, issues) {
|
|
5596
|
+
let countsMatch = true;
|
|
5597
|
+
for (const [docType, expectedCount] of Object.entries(expected)) {
|
|
5598
|
+
const actualCount = actual[docType] || 0;
|
|
5599
|
+
if (actualCount !== expectedCount) {
|
|
5600
|
+
countsMatch = false;
|
|
5601
|
+
issues.push({
|
|
5602
|
+
type: "error",
|
|
5603
|
+
category: "documents",
|
|
5604
|
+
message: `Document count mismatch for ${docType}: expected ${expectedCount}, got ${actualCount}`
|
|
5605
|
+
});
|
|
5606
|
+
}
|
|
5607
|
+
}
|
|
5608
|
+
for (const [docType, actualCount] of Object.entries(actual)) {
|
|
5609
|
+
if (!expected[docType] && docType !== "_design") {
|
|
5610
|
+
issues.push({
|
|
5611
|
+
type: "warning",
|
|
5612
|
+
category: "documents",
|
|
5613
|
+
message: `Unexpected document type found: ${docType} (${actualCount} documents)`
|
|
5614
|
+
});
|
|
5615
|
+
}
|
|
5616
|
+
}
|
|
5617
|
+
return countsMatch;
|
|
5618
|
+
}
|
|
5619
|
+
async function validateCourseConfig(db, manifest, issues) {
|
|
5620
|
+
try {
|
|
5621
|
+
const courseConfig = await db.get("CourseConfig");
|
|
5622
|
+
if (!courseConfig) {
|
|
5623
|
+
issues.push({
|
|
5624
|
+
type: "error",
|
|
5625
|
+
category: "course_config",
|
|
5626
|
+
message: "CourseConfig document not found after migration"
|
|
5627
|
+
});
|
|
5628
|
+
return;
|
|
5629
|
+
}
|
|
5630
|
+
if (!courseConfig.courseID) {
|
|
5631
|
+
issues.push({
|
|
5632
|
+
type: "warning",
|
|
5633
|
+
category: "course_config",
|
|
5634
|
+
message: "CourseConfig document missing courseID field"
|
|
5635
|
+
});
|
|
5636
|
+
}
|
|
5637
|
+
if (courseConfig.courseID !== manifest.courseId) {
|
|
5638
|
+
issues.push({
|
|
5639
|
+
type: "warning",
|
|
5640
|
+
category: "course_config",
|
|
5641
|
+
message: `CourseConfig courseID mismatch: expected ${manifest.courseId}, got ${courseConfig.courseID}`
|
|
5642
|
+
});
|
|
5643
|
+
}
|
|
5644
|
+
logger.debug("CourseConfig document validation passed");
|
|
5645
|
+
} catch (error) {
|
|
5646
|
+
if (error.status === 404) {
|
|
5647
|
+
issues.push({
|
|
5648
|
+
type: "error",
|
|
5649
|
+
category: "course_config",
|
|
5650
|
+
message: "CourseConfig document not found in database"
|
|
5651
|
+
});
|
|
5652
|
+
} else {
|
|
5653
|
+
issues.push({
|
|
5654
|
+
type: "error",
|
|
5655
|
+
category: "course_config",
|
|
5656
|
+
message: `Failed to validate CourseConfig document: ${error instanceof Error ? error.message : String(error)}`
|
|
5657
|
+
});
|
|
5658
|
+
}
|
|
5659
|
+
}
|
|
5660
|
+
}
|
|
5661
|
+
async function validateViews(db, manifest, issues) {
|
|
5662
|
+
let viewsValid = true;
|
|
5663
|
+
try {
|
|
5664
|
+
for (const designDoc of manifest.designDocs) {
|
|
5665
|
+
try {
|
|
5666
|
+
const doc = await db.get(designDoc._id);
|
|
5667
|
+
if (!doc) {
|
|
5668
|
+
viewsValid = false;
|
|
5669
|
+
issues.push({
|
|
5670
|
+
type: "error",
|
|
5671
|
+
category: "views",
|
|
5672
|
+
message: `Design document not found: ${designDoc._id}`
|
|
5673
|
+
});
|
|
5674
|
+
continue;
|
|
5675
|
+
}
|
|
5676
|
+
for (const viewName of Object.keys(designDoc.views)) {
|
|
5677
|
+
try {
|
|
5678
|
+
const viewPath = `${designDoc._id}/${viewName}`;
|
|
5679
|
+
await db.query(viewPath, { limit: 1 });
|
|
5680
|
+
} catch (viewError) {
|
|
5681
|
+
viewsValid = false;
|
|
5682
|
+
issues.push({
|
|
5683
|
+
type: "error",
|
|
5684
|
+
category: "views",
|
|
5685
|
+
message: `View not accessible: ${designDoc._id}/${viewName} - ${viewError}`
|
|
5686
|
+
});
|
|
5687
|
+
}
|
|
5688
|
+
}
|
|
5689
|
+
} catch (error) {
|
|
5690
|
+
viewsValid = false;
|
|
5691
|
+
issues.push({
|
|
5692
|
+
type: "error",
|
|
5693
|
+
category: "views",
|
|
5694
|
+
message: `Failed to validate design document ${designDoc._id}: ${error}`
|
|
5695
|
+
});
|
|
5696
|
+
}
|
|
5697
|
+
}
|
|
5698
|
+
} catch (error) {
|
|
5699
|
+
viewsValid = false;
|
|
5700
|
+
issues.push({
|
|
5701
|
+
type: "error",
|
|
5702
|
+
category: "views",
|
|
5703
|
+
message: `View validation failed: ${error instanceof Error ? error.message : String(error)}`
|
|
5704
|
+
});
|
|
5705
|
+
}
|
|
5706
|
+
return viewsValid;
|
|
5707
|
+
}
|
|
5708
|
+
async function validateAttachmentIntegrity(db, issues) {
|
|
5709
|
+
let attachmentsValid = true;
|
|
5710
|
+
try {
|
|
5711
|
+
const allDocs = await db.allDocs({
|
|
5712
|
+
include_docs: true,
|
|
5713
|
+
limit: 10
|
|
5714
|
+
// Sample first 10 documents for performance
|
|
5715
|
+
});
|
|
5716
|
+
let attachmentCount = 0;
|
|
5717
|
+
let validAttachments = 0;
|
|
5718
|
+
for (const row of allDocs.rows) {
|
|
5719
|
+
const doc = row.doc;
|
|
5720
|
+
if (doc && doc._attachments) {
|
|
5721
|
+
for (const [attachmentName, _attachmentMeta] of Object.entries(doc._attachments)) {
|
|
5722
|
+
attachmentCount++;
|
|
5723
|
+
try {
|
|
5724
|
+
const attachment = await db.getAttachment(doc._id, attachmentName);
|
|
5725
|
+
if (attachment) {
|
|
5726
|
+
validAttachments++;
|
|
5727
|
+
}
|
|
5728
|
+
} catch (attachmentError) {
|
|
5729
|
+
attachmentsValid = false;
|
|
5730
|
+
issues.push({
|
|
5731
|
+
type: "error",
|
|
5732
|
+
category: "attachments",
|
|
5733
|
+
message: `Attachment not accessible: ${doc._id}/${attachmentName} - ${attachmentError}`
|
|
5734
|
+
});
|
|
5735
|
+
}
|
|
5736
|
+
}
|
|
5737
|
+
}
|
|
5738
|
+
}
|
|
5739
|
+
if (attachmentCount === 0) {
|
|
5740
|
+
issues.push({
|
|
5741
|
+
type: "warning",
|
|
5742
|
+
category: "attachments",
|
|
5743
|
+
message: "No attachments found in sampled documents"
|
|
5744
|
+
});
|
|
5745
|
+
} else {
|
|
5746
|
+
logger.info(`Validated ${validAttachments}/${attachmentCount} sampled attachments`);
|
|
5747
|
+
}
|
|
5748
|
+
} catch (error) {
|
|
5749
|
+
attachmentsValid = false;
|
|
5750
|
+
issues.push({
|
|
5751
|
+
type: "error",
|
|
5752
|
+
category: "attachments",
|
|
5753
|
+
message: `Attachment validation failed: ${error instanceof Error ? error.message : String(error)}`
|
|
5754
|
+
});
|
|
5755
|
+
}
|
|
5756
|
+
return attachmentsValid;
|
|
5757
|
+
}
|
|
5758
|
+
var nodeFS;
|
|
5759
|
+
var init_validation = __esm({
|
|
5760
|
+
"src/util/migrator/validation.ts"() {
|
|
5761
|
+
"use strict";
|
|
5762
|
+
init_logger();
|
|
5763
|
+
init_FileSystemAdapter();
|
|
5764
|
+
nodeFS = null;
|
|
5765
|
+
try {
|
|
5766
|
+
if (typeof window === "undefined" && typeof process !== "undefined" && process.versions?.node) {
|
|
5767
|
+
nodeFS = eval("require")("fs");
|
|
5768
|
+
nodeFS.promises = nodeFS.promises || eval("require")("fs").promises;
|
|
5769
|
+
}
|
|
5770
|
+
} catch {
|
|
5771
|
+
}
|
|
5772
|
+
}
|
|
5773
|
+
});
|
|
5774
|
+
|
|
5775
|
+
// src/util/migrator/StaticToCouchDBMigrator.ts
|
|
5776
|
+
var nodeFS2, nodePath, StaticToCouchDBMigrator;
|
|
5777
|
+
var init_StaticToCouchDBMigrator = __esm({
|
|
5778
|
+
"src/util/migrator/StaticToCouchDBMigrator.ts"() {
|
|
5779
|
+
"use strict";
|
|
5780
|
+
init_logger();
|
|
5781
|
+
init_types4();
|
|
5782
|
+
init_validation();
|
|
5783
|
+
init_FileSystemAdapter();
|
|
5784
|
+
nodeFS2 = null;
|
|
5785
|
+
nodePath = null;
|
|
5786
|
+
try {
|
|
5787
|
+
if (typeof window === "undefined" && typeof process !== "undefined" && process.versions?.node) {
|
|
5788
|
+
nodeFS2 = eval("require")("fs");
|
|
5789
|
+
nodePath = eval("require")("path");
|
|
5790
|
+
nodeFS2.promises = nodeFS2.promises || eval("require")("fs").promises;
|
|
5791
|
+
}
|
|
5792
|
+
} catch {
|
|
5793
|
+
}
|
|
5794
|
+
StaticToCouchDBMigrator = class {
|
|
5795
|
+
options;
|
|
5796
|
+
progressCallback;
|
|
5797
|
+
fs;
|
|
5798
|
+
constructor(options = {}, fileSystemAdapter) {
|
|
5799
|
+
this.options = {
|
|
5800
|
+
...DEFAULT_MIGRATION_OPTIONS,
|
|
5801
|
+
...options
|
|
5802
|
+
};
|
|
5803
|
+
this.fs = fileSystemAdapter;
|
|
5804
|
+
}
|
|
5805
|
+
/**
|
|
5806
|
+
* Set a progress callback to receive updates during migration
|
|
5807
|
+
*/
|
|
5808
|
+
setProgressCallback(callback) {
|
|
5809
|
+
this.progressCallback = callback;
|
|
5810
|
+
}
|
|
5811
|
+
/**
|
|
5812
|
+
* Migrate a static course to CouchDB
|
|
5813
|
+
*/
|
|
5814
|
+
async migrateCourse(staticPath, targetDB) {
|
|
5815
|
+
const startTime = Date.now();
|
|
5816
|
+
const result = {
|
|
5817
|
+
success: false,
|
|
5818
|
+
documentsRestored: 0,
|
|
5819
|
+
attachmentsRestored: 0,
|
|
5820
|
+
designDocsRestored: 0,
|
|
5821
|
+
courseConfigRestored: 0,
|
|
5822
|
+
errors: [],
|
|
5823
|
+
warnings: [],
|
|
5824
|
+
migrationTime: 0
|
|
5825
|
+
};
|
|
5826
|
+
try {
|
|
5827
|
+
logger.info(`Starting migration from ${staticPath} to CouchDB`);
|
|
5828
|
+
this.reportProgress("manifest", 0, 1, "Validating static course...");
|
|
5829
|
+
const validation = await validateStaticCourse(staticPath, this.fs);
|
|
5830
|
+
if (!validation.valid) {
|
|
5831
|
+
result.errors.push(...validation.errors);
|
|
5832
|
+
throw new Error(`Static course validation failed: ${validation.errors.join(", ")}`);
|
|
5833
|
+
}
|
|
5834
|
+
result.warnings.push(...validation.warnings);
|
|
5835
|
+
this.reportProgress("manifest", 1, 1, "Loading course manifest...");
|
|
5836
|
+
const manifest = await this.loadManifest(staticPath);
|
|
5837
|
+
logger.info(`Loaded manifest for course: ${manifest.courseId} (${manifest.courseName})`);
|
|
5838
|
+
this.reportProgress(
|
|
5839
|
+
"design_docs",
|
|
5840
|
+
0,
|
|
5841
|
+
manifest.designDocs.length,
|
|
5842
|
+
"Restoring design documents..."
|
|
5843
|
+
);
|
|
5844
|
+
const designDocResults = await this.restoreDesignDocuments(manifest.designDocs, targetDB);
|
|
5845
|
+
result.designDocsRestored = designDocResults.restored;
|
|
5846
|
+
result.errors.push(...designDocResults.errors);
|
|
5847
|
+
result.warnings.push(...designDocResults.warnings);
|
|
5848
|
+
this.reportProgress("course_config", 0, 1, "Restoring CourseConfig document...");
|
|
5849
|
+
const courseConfigResults = await this.restoreCourseConfig(manifest, targetDB);
|
|
5850
|
+
result.courseConfigRestored = courseConfigResults.restored;
|
|
5851
|
+
result.errors.push(...courseConfigResults.errors);
|
|
5852
|
+
result.warnings.push(...courseConfigResults.warnings);
|
|
5853
|
+
this.reportProgress("course_config", 1, 1, "CourseConfig document restored");
|
|
5854
|
+
const expectedCounts = this.calculateExpectedCounts(manifest);
|
|
5855
|
+
this.reportProgress(
|
|
5856
|
+
"documents",
|
|
5857
|
+
0,
|
|
5858
|
+
manifest.documentCount,
|
|
5859
|
+
"Aggregating documents from chunks..."
|
|
5860
|
+
);
|
|
5861
|
+
const documents = await this.aggregateDocuments(staticPath, manifest);
|
|
5862
|
+
const filteredDocuments = documents.filter((doc) => doc._id !== "CourseConfig");
|
|
5863
|
+
if (documents.length !== filteredDocuments.length) {
|
|
5864
|
+
result.warnings.push(
|
|
5865
|
+
`Filtered out ${documents.length - filteredDocuments.length} CourseConfig document(s) from chunks to prevent conflicts`
|
|
5866
|
+
);
|
|
5867
|
+
}
|
|
5868
|
+
this.reportProgress(
|
|
5869
|
+
"documents",
|
|
5870
|
+
filteredDocuments.length,
|
|
5871
|
+
manifest.documentCount,
|
|
5872
|
+
"Uploading documents to CouchDB..."
|
|
5873
|
+
);
|
|
5874
|
+
const docResults = await this.uploadDocuments(filteredDocuments, targetDB);
|
|
5875
|
+
result.documentsRestored = docResults.restored;
|
|
5876
|
+
result.errors.push(...docResults.errors);
|
|
5877
|
+
result.warnings.push(...docResults.warnings);
|
|
5878
|
+
const docsWithAttachments = documents.filter(
|
|
5879
|
+
(doc) => doc._attachments && Object.keys(doc._attachments).length > 0
|
|
5880
|
+
);
|
|
5881
|
+
this.reportProgress("attachments", 0, docsWithAttachments.length, "Uploading attachments...");
|
|
5882
|
+
const attachmentResults = await this.uploadAttachments(
|
|
5883
|
+
staticPath,
|
|
5884
|
+
docsWithAttachments,
|
|
5885
|
+
targetDB
|
|
5886
|
+
);
|
|
5887
|
+
result.attachmentsRestored = attachmentResults.restored;
|
|
5888
|
+
result.errors.push(...attachmentResults.errors);
|
|
5889
|
+
result.warnings.push(...attachmentResults.warnings);
|
|
5890
|
+
if (this.options.validateRoundTrip) {
|
|
5891
|
+
this.reportProgress("validation", 0, 1, "Validating migration...");
|
|
5892
|
+
const validationResult = await validateMigration(targetDB, expectedCounts, manifest);
|
|
5893
|
+
if (!validationResult.valid) {
|
|
5894
|
+
result.warnings.push("Migration validation found issues");
|
|
5895
|
+
validationResult.issues.forEach((issue) => {
|
|
5896
|
+
if (issue.type === "error") {
|
|
5897
|
+
result.errors.push(`Validation: ${issue.message}`);
|
|
5898
|
+
} else {
|
|
5899
|
+
result.warnings.push(`Validation: ${issue.message}`);
|
|
5900
|
+
}
|
|
5901
|
+
});
|
|
5902
|
+
}
|
|
5903
|
+
this.reportProgress("validation", 1, 1, "Migration validation completed");
|
|
5904
|
+
}
|
|
5905
|
+
result.success = result.errors.length === 0;
|
|
5906
|
+
result.migrationTime = Date.now() - startTime;
|
|
5907
|
+
logger.info(`Migration completed in ${result.migrationTime}ms`);
|
|
5908
|
+
logger.info(`Documents restored: ${result.documentsRestored}`);
|
|
5909
|
+
logger.info(`Attachments restored: ${result.attachmentsRestored}`);
|
|
5910
|
+
logger.info(`Design docs restored: ${result.designDocsRestored}`);
|
|
5911
|
+
logger.info(`CourseConfig restored: ${result.courseConfigRestored}`);
|
|
5912
|
+
if (result.errors.length > 0) {
|
|
5913
|
+
logger.error(`Migration completed with ${result.errors.length} errors`);
|
|
5914
|
+
}
|
|
5915
|
+
if (result.warnings.length > 0) {
|
|
5916
|
+
logger.warn(`Migration completed with ${result.warnings.length} warnings`);
|
|
5917
|
+
}
|
|
5918
|
+
} catch (error) {
|
|
5919
|
+
result.success = false;
|
|
5920
|
+
result.migrationTime = Date.now() - startTime;
|
|
5921
|
+
const errorMessage = error instanceof Error ? error.message : String(error);
|
|
5922
|
+
result.errors.push(`Migration failed: ${errorMessage}`);
|
|
5923
|
+
logger.error("Migration failed:", error);
|
|
5924
|
+
if (this.options.cleanupOnFailure) {
|
|
5925
|
+
try {
|
|
5926
|
+
await this.cleanupFailedMigration(targetDB);
|
|
5927
|
+
} catch (cleanupError) {
|
|
5928
|
+
logger.error("Failed to cleanup after migration failure:", cleanupError);
|
|
5929
|
+
result.warnings.push("Failed to cleanup after migration failure");
|
|
5930
|
+
}
|
|
5931
|
+
}
|
|
5932
|
+
}
|
|
5933
|
+
return result;
|
|
5934
|
+
}
|
|
5935
|
+
/**
|
|
5936
|
+
* Load and parse the manifest file
|
|
5937
|
+
*/
|
|
5938
|
+
async loadManifest(staticPath) {
|
|
5939
|
+
try {
|
|
5940
|
+
let manifestContent;
|
|
5941
|
+
let manifestPath;
|
|
5942
|
+
if (this.fs) {
|
|
5943
|
+
manifestPath = this.fs.joinPath(staticPath, "manifest.json");
|
|
5944
|
+
manifestContent = await this.fs.readFile(manifestPath);
|
|
5945
|
+
} else {
|
|
5946
|
+
manifestPath = nodeFS2 && nodePath ? nodePath.join(staticPath, "manifest.json") : `${staticPath}/manifest.json`;
|
|
5947
|
+
if (nodeFS2 && this.isLocalPath(staticPath)) {
|
|
5948
|
+
manifestContent = await nodeFS2.promises.readFile(manifestPath, "utf8");
|
|
5949
|
+
} else {
|
|
5950
|
+
const response = await fetch(manifestPath);
|
|
5951
|
+
if (!response.ok) {
|
|
5952
|
+
throw new Error(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
|
|
5953
|
+
}
|
|
5954
|
+
manifestContent = await response.text();
|
|
5955
|
+
}
|
|
5956
|
+
}
|
|
5957
|
+
const manifest = JSON.parse(manifestContent);
|
|
5958
|
+
if (!manifest.version || !manifest.courseId || !manifest.chunks) {
|
|
5959
|
+
throw new Error("Invalid manifest structure");
|
|
5960
|
+
}
|
|
5961
|
+
return manifest;
|
|
5962
|
+
} catch (error) {
|
|
5963
|
+
const errorMessage = error instanceof FileSystemError ? error.message : `Failed to load manifest: ${error instanceof Error ? error.message : String(error)}`;
|
|
5964
|
+
throw new Error(errorMessage);
|
|
5965
|
+
}
|
|
5966
|
+
}
|
|
5967
|
+
/**
|
|
5968
|
+
* Restore design documents to CouchDB
|
|
5969
|
+
*/
|
|
5970
|
+
async restoreDesignDocuments(designDocs, db) {
|
|
5971
|
+
const result = { restored: 0, errors: [], warnings: [] };
|
|
5972
|
+
for (let i = 0; i < designDocs.length; i++) {
|
|
5973
|
+
const designDoc = designDocs[i];
|
|
5974
|
+
this.reportProgress("design_docs", i, designDocs.length, `Restoring ${designDoc._id}...`);
|
|
5975
|
+
try {
|
|
5976
|
+
let existingDoc;
|
|
5977
|
+
try {
|
|
5978
|
+
existingDoc = await db.get(designDoc._id);
|
|
5979
|
+
} catch {
|
|
5980
|
+
}
|
|
5981
|
+
const docToInsert = {
|
|
5982
|
+
_id: designDoc._id,
|
|
5983
|
+
views: designDoc.views
|
|
5984
|
+
};
|
|
5985
|
+
if (existingDoc) {
|
|
5986
|
+
docToInsert._rev = existingDoc._rev;
|
|
5987
|
+
logger.debug(`Updating existing design document: ${designDoc._id}`);
|
|
5988
|
+
} else {
|
|
5989
|
+
logger.debug(`Creating new design document: ${designDoc._id}`);
|
|
5990
|
+
}
|
|
5991
|
+
await db.put(docToInsert);
|
|
5992
|
+
result.restored++;
|
|
5993
|
+
} catch (error) {
|
|
5994
|
+
const errorMessage = `Failed to restore design document ${designDoc._id}: ${error instanceof Error ? error.message : String(error)}`;
|
|
5995
|
+
result.errors.push(errorMessage);
|
|
5996
|
+
logger.error(errorMessage);
|
|
5997
|
+
}
|
|
5998
|
+
}
|
|
5999
|
+
this.reportProgress(
|
|
6000
|
+
"design_docs",
|
|
6001
|
+
designDocs.length,
|
|
6002
|
+
designDocs.length,
|
|
6003
|
+
`Restored ${result.restored} design documents`
|
|
6004
|
+
);
|
|
6005
|
+
return result;
|
|
6006
|
+
}
|
|
6007
|
+
/**
|
|
6008
|
+
* Aggregate documents from all chunks
|
|
6009
|
+
*/
|
|
6010
|
+
async aggregateDocuments(staticPath, manifest) {
|
|
6011
|
+
const allDocuments = [];
|
|
6012
|
+
const documentMap = /* @__PURE__ */ new Map();
|
|
6013
|
+
for (let i = 0; i < manifest.chunks.length; i++) {
|
|
6014
|
+
const chunk = manifest.chunks[i];
|
|
6015
|
+
this.reportProgress(
|
|
6016
|
+
"documents",
|
|
6017
|
+
allDocuments.length,
|
|
6018
|
+
manifest.documentCount,
|
|
6019
|
+
`Loading chunk ${chunk.id}...`
|
|
6020
|
+
);
|
|
6021
|
+
try {
|
|
6022
|
+
const documents = await this.loadChunk(staticPath, chunk);
|
|
6023
|
+
for (const doc of documents) {
|
|
6024
|
+
if (!doc._id) {
|
|
6025
|
+
logger.warn(`Document without _id found in chunk ${chunk.id}, skipping`);
|
|
6026
|
+
continue;
|
|
6027
|
+
}
|
|
6028
|
+
if (documentMap.has(doc._id)) {
|
|
6029
|
+
logger.warn(`Duplicate document ID found: ${doc._id}, using latest version`);
|
|
6030
|
+
}
|
|
6031
|
+
documentMap.set(doc._id, doc);
|
|
6032
|
+
}
|
|
6033
|
+
} catch (error) {
|
|
6034
|
+
throw new Error(
|
|
6035
|
+
`Failed to load chunk ${chunk.id}: ${error instanceof Error ? error.message : String(error)}`
|
|
6036
|
+
);
|
|
6037
|
+
}
|
|
6038
|
+
}
|
|
6039
|
+
allDocuments.push(...documentMap.values());
|
|
6040
|
+
logger.info(
|
|
6041
|
+
`Aggregated ${allDocuments.length} unique documents from ${manifest.chunks.length} chunks`
|
|
6042
|
+
);
|
|
6043
|
+
return allDocuments;
|
|
6044
|
+
}
|
|
6045
|
+
/**
|
|
6046
|
+
* Load documents from a single chunk file
|
|
6047
|
+
*/
|
|
6048
|
+
async loadChunk(staticPath, chunk) {
|
|
6049
|
+
try {
|
|
6050
|
+
let chunkContent;
|
|
6051
|
+
let chunkPath;
|
|
6052
|
+
if (this.fs) {
|
|
6053
|
+
chunkPath = this.fs.joinPath(staticPath, chunk.path);
|
|
6054
|
+
chunkContent = await this.fs.readFile(chunkPath);
|
|
6055
|
+
} else {
|
|
6056
|
+
chunkPath = nodeFS2 && nodePath ? nodePath.join(staticPath, chunk.path) : `${staticPath}/${chunk.path}`;
|
|
6057
|
+
if (nodeFS2 && this.isLocalPath(staticPath)) {
|
|
6058
|
+
chunkContent = await nodeFS2.promises.readFile(chunkPath, "utf8");
|
|
6059
|
+
} else {
|
|
6060
|
+
const response = await fetch(chunkPath);
|
|
6061
|
+
if (!response.ok) {
|
|
6062
|
+
throw new Error(`Failed to fetch chunk: ${response.status} ${response.statusText}`);
|
|
6063
|
+
}
|
|
6064
|
+
chunkContent = await response.text();
|
|
6065
|
+
}
|
|
6066
|
+
}
|
|
6067
|
+
const documents = JSON.parse(chunkContent);
|
|
6068
|
+
if (!Array.isArray(documents)) {
|
|
6069
|
+
throw new Error("Chunk file does not contain an array of documents");
|
|
6070
|
+
}
|
|
6071
|
+
return documents;
|
|
6072
|
+
} catch (error) {
|
|
6073
|
+
const errorMessage = error instanceof FileSystemError ? error.message : `Failed to load chunk: ${error instanceof Error ? error.message : String(error)}`;
|
|
6074
|
+
throw new Error(errorMessage);
|
|
6075
|
+
}
|
|
6076
|
+
}
|
|
6077
|
+
/**
|
|
6078
|
+
* Upload documents to CouchDB in batches
|
|
6079
|
+
*/
|
|
6080
|
+
async uploadDocuments(documents, db) {
|
|
6081
|
+
const result = { restored: 0, errors: [], warnings: [] };
|
|
6082
|
+
const batchSize = this.options.chunkBatchSize;
|
|
6083
|
+
for (let i = 0; i < documents.length; i += batchSize) {
|
|
6084
|
+
const batch = documents.slice(i, i + batchSize);
|
|
6085
|
+
this.reportProgress(
|
|
6086
|
+
"documents",
|
|
6087
|
+
i,
|
|
6088
|
+
documents.length,
|
|
6089
|
+
`Uploading batch ${Math.floor(i / batchSize) + 1}...`
|
|
6090
|
+
);
|
|
6091
|
+
try {
|
|
6092
|
+
const docsToInsert = batch.map((doc) => {
|
|
6093
|
+
const cleanDoc = { ...doc };
|
|
6094
|
+
delete cleanDoc._rev;
|
|
6095
|
+
delete cleanDoc._attachments;
|
|
6096
|
+
return cleanDoc;
|
|
6097
|
+
});
|
|
6098
|
+
const bulkResult = await db.bulkDocs(docsToInsert);
|
|
6099
|
+
for (let j = 0; j < bulkResult.length; j++) {
|
|
6100
|
+
const docResult = bulkResult[j];
|
|
6101
|
+
const originalDoc = batch[j];
|
|
6102
|
+
if ("error" in docResult) {
|
|
6103
|
+
const errorMessage = `Failed to upload document ${originalDoc._id}: ${docResult.error} - ${docResult.reason}`;
|
|
6104
|
+
result.errors.push(errorMessage);
|
|
6105
|
+
logger.error(errorMessage);
|
|
6106
|
+
} else {
|
|
6107
|
+
result.restored++;
|
|
6108
|
+
}
|
|
6109
|
+
}
|
|
6110
|
+
} catch (error) {
|
|
6111
|
+
let errorMessage;
|
|
6112
|
+
if (error instanceof Error) {
|
|
6113
|
+
errorMessage = `Failed to upload document batch starting at index ${i}: ${error.message}`;
|
|
6114
|
+
} else if (error && typeof error === "object" && "message" in error) {
|
|
6115
|
+
errorMessage = `Failed to upload document batch starting at index ${i}: ${error.message}`;
|
|
6116
|
+
} else {
|
|
6117
|
+
errorMessage = `Failed to upload document batch starting at index ${i}: ${JSON.stringify(error)}`;
|
|
6118
|
+
}
|
|
6119
|
+
result.errors.push(errorMessage);
|
|
6120
|
+
logger.error(errorMessage);
|
|
6121
|
+
}
|
|
6122
|
+
}
|
|
6123
|
+
this.reportProgress(
|
|
6124
|
+
"documents",
|
|
6125
|
+
documents.length,
|
|
6126
|
+
documents.length,
|
|
6127
|
+
`Uploaded ${result.restored} documents`
|
|
6128
|
+
);
|
|
6129
|
+
return result;
|
|
6130
|
+
}
|
|
6131
|
+
/**
|
|
6132
|
+
* Upload attachments from filesystem to CouchDB
|
|
6133
|
+
*/
|
|
6134
|
+
async uploadAttachments(staticPath, documents, db) {
|
|
6135
|
+
const result = { restored: 0, errors: [], warnings: [] };
|
|
6136
|
+
let processedDocs = 0;
|
|
6137
|
+
for (const doc of documents) {
|
|
6138
|
+
this.reportProgress(
|
|
6139
|
+
"attachments",
|
|
6140
|
+
processedDocs,
|
|
6141
|
+
documents.length,
|
|
6142
|
+
`Processing attachments for ${doc._id}...`
|
|
6143
|
+
);
|
|
6144
|
+
processedDocs++;
|
|
6145
|
+
if (!doc._attachments) {
|
|
6146
|
+
continue;
|
|
6147
|
+
}
|
|
6148
|
+
for (const [attachmentName, attachmentMeta] of Object.entries(doc._attachments)) {
|
|
6149
|
+
try {
|
|
6150
|
+
const uploadResult = await this.uploadSingleAttachment(
|
|
6151
|
+
staticPath,
|
|
6152
|
+
doc._id,
|
|
6153
|
+
attachmentName,
|
|
6154
|
+
attachmentMeta,
|
|
6155
|
+
db
|
|
6156
|
+
);
|
|
6157
|
+
if (uploadResult.success) {
|
|
6158
|
+
result.restored++;
|
|
6159
|
+
} else {
|
|
6160
|
+
result.errors.push(uploadResult.error || "Unknown attachment upload error");
|
|
6161
|
+
}
|
|
6162
|
+
} catch (error) {
|
|
6163
|
+
const errorMessage = `Failed to upload attachment ${doc._id}/${attachmentName}: ${error instanceof Error ? error.message : String(error)}`;
|
|
6164
|
+
result.errors.push(errorMessage);
|
|
6165
|
+
logger.error(errorMessage);
|
|
6166
|
+
}
|
|
6167
|
+
}
|
|
6168
|
+
}
|
|
6169
|
+
this.reportProgress(
|
|
6170
|
+
"attachments",
|
|
6171
|
+
documents.length,
|
|
6172
|
+
documents.length,
|
|
6173
|
+
`Uploaded ${result.restored} attachments`
|
|
6174
|
+
);
|
|
6175
|
+
return result;
|
|
6176
|
+
}
|
|
6177
|
+
/**
|
|
6178
|
+
* Upload a single attachment file
|
|
6179
|
+
*/
|
|
6180
|
+
async uploadSingleAttachment(staticPath, docId, attachmentName, attachmentMeta, db) {
|
|
6181
|
+
const result = {
|
|
6182
|
+
success: false,
|
|
6183
|
+
attachmentName,
|
|
6184
|
+
docId
|
|
6185
|
+
};
|
|
6186
|
+
try {
|
|
6187
|
+
if (!attachmentMeta.path) {
|
|
6188
|
+
result.error = "Attachment metadata missing file path";
|
|
6189
|
+
return result;
|
|
6190
|
+
}
|
|
6191
|
+
let attachmentData;
|
|
6192
|
+
let attachmentPath;
|
|
6193
|
+
if (this.fs) {
|
|
6194
|
+
attachmentPath = this.fs.joinPath(staticPath, attachmentMeta.path);
|
|
6195
|
+
attachmentData = await this.fs.readBinary(attachmentPath);
|
|
6196
|
+
} else {
|
|
6197
|
+
attachmentPath = nodeFS2 && nodePath ? nodePath.join(staticPath, attachmentMeta.path) : `${staticPath}/${attachmentMeta.path}`;
|
|
6198
|
+
if (nodeFS2 && this.isLocalPath(staticPath)) {
|
|
6199
|
+
attachmentData = await nodeFS2.promises.readFile(attachmentPath);
|
|
6200
|
+
} else {
|
|
6201
|
+
const response = await fetch(attachmentPath);
|
|
6202
|
+
if (!response.ok) {
|
|
6203
|
+
result.error = `Failed to fetch attachment: ${response.status} ${response.statusText}`;
|
|
6204
|
+
return result;
|
|
6205
|
+
}
|
|
6206
|
+
attachmentData = await response.arrayBuffer();
|
|
6207
|
+
}
|
|
6208
|
+
}
|
|
6209
|
+
const doc = await db.get(docId);
|
|
6210
|
+
await db.putAttachment(
|
|
6211
|
+
docId,
|
|
6212
|
+
attachmentName,
|
|
6213
|
+
doc._rev,
|
|
6214
|
+
attachmentData,
|
|
6215
|
+
// PouchDB accepts both ArrayBuffer and Buffer
|
|
6216
|
+
attachmentMeta.content_type
|
|
6217
|
+
);
|
|
6218
|
+
result.success = true;
|
|
6219
|
+
} catch (error) {
|
|
6220
|
+
result.error = error instanceof Error ? error.message : String(error);
|
|
6221
|
+
}
|
|
6222
|
+
return result;
|
|
6223
|
+
}
|
|
6224
|
+
/**
|
|
6225
|
+
* Restore CourseConfig document from manifest
|
|
6226
|
+
*/
|
|
6227
|
+
async restoreCourseConfig(manifest, targetDB) {
|
|
6228
|
+
const results = {
|
|
6229
|
+
restored: 0,
|
|
6230
|
+
errors: [],
|
|
6231
|
+
warnings: []
|
|
6232
|
+
};
|
|
6233
|
+
try {
|
|
6234
|
+
if (!manifest.courseConfig) {
|
|
6235
|
+
results.warnings.push(
|
|
6236
|
+
"No courseConfig found in manifest, skipping CourseConfig document creation"
|
|
6237
|
+
);
|
|
6238
|
+
return results;
|
|
6239
|
+
}
|
|
6240
|
+
const courseConfigDoc = {
|
|
6241
|
+
_id: "CourseConfig",
|
|
6242
|
+
...manifest.courseConfig,
|
|
6243
|
+
courseID: manifest.courseId
|
|
6244
|
+
};
|
|
6245
|
+
delete courseConfigDoc._rev;
|
|
6246
|
+
await targetDB.put(courseConfigDoc);
|
|
6247
|
+
results.restored = 1;
|
|
6248
|
+
logger.info(`CourseConfig document created for course: ${manifest.courseId}`);
|
|
6249
|
+
} catch (error) {
|
|
6250
|
+
const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
|
|
6251
|
+
results.errors.push(`Failed to restore CourseConfig: ${errorMessage}`);
|
|
6252
|
+
logger.error("CourseConfig restoration failed:", error);
|
|
6253
|
+
}
|
|
6254
|
+
return results;
|
|
6255
|
+
}
|
|
6256
|
+
/**
|
|
6257
|
+
* Calculate expected document counts from manifest
|
|
6258
|
+
*/
|
|
6259
|
+
calculateExpectedCounts(manifest) {
|
|
6260
|
+
const counts = {};
|
|
6261
|
+
for (const chunk of manifest.chunks) {
|
|
6262
|
+
counts[chunk.docType] = (counts[chunk.docType] || 0) + chunk.documentCount;
|
|
6263
|
+
}
|
|
6264
|
+
if (manifest.designDocs.length > 0) {
|
|
6265
|
+
counts["_design"] = manifest.designDocs.length;
|
|
6266
|
+
}
|
|
6267
|
+
return counts;
|
|
6268
|
+
}
|
|
6269
|
+
/**
|
|
6270
|
+
* Clean up database after failed migration
|
|
6271
|
+
*/
|
|
6272
|
+
async cleanupFailedMigration(db) {
|
|
6273
|
+
logger.info("Cleaning up failed migration...");
|
|
6274
|
+
try {
|
|
6275
|
+
const allDocs = await db.allDocs();
|
|
6276
|
+
const docsToDelete = allDocs.rows.map((row) => ({
|
|
6277
|
+
_id: row.id,
|
|
6278
|
+
_rev: row.value.rev,
|
|
6279
|
+
_deleted: true
|
|
6280
|
+
}));
|
|
6281
|
+
if (docsToDelete.length > 0) {
|
|
6282
|
+
await db.bulkDocs(docsToDelete);
|
|
6283
|
+
logger.info(`Cleaned up ${docsToDelete.length} documents from failed migration`);
|
|
6284
|
+
}
|
|
6285
|
+
} catch (error) {
|
|
6286
|
+
logger.error("Failed to cleanup documents:", error);
|
|
6287
|
+
throw error;
|
|
6288
|
+
}
|
|
6289
|
+
}
|
|
6290
|
+
/**
|
|
6291
|
+
* Report progress to callback if available
|
|
6292
|
+
*/
|
|
6293
|
+
reportProgress(phase, current, total, message) {
|
|
6294
|
+
if (this.progressCallback) {
|
|
6295
|
+
this.progressCallback({
|
|
6296
|
+
phase,
|
|
6297
|
+
current,
|
|
6298
|
+
total,
|
|
6299
|
+
message
|
|
6300
|
+
});
|
|
6301
|
+
}
|
|
6302
|
+
}
|
|
6303
|
+
/**
|
|
6304
|
+
* Check if a path is a local file path (vs URL)
|
|
6305
|
+
*/
|
|
6306
|
+
isLocalPath(path2) {
|
|
6307
|
+
return !path2.startsWith("http://") && !path2.startsWith("https://");
|
|
6308
|
+
}
|
|
6309
|
+
};
|
|
6310
|
+
}
|
|
6311
|
+
});
|
|
6312
|
+
|
|
6313
|
+
// src/util/migrator/index.ts
|
|
6314
|
+
var init_migrator = __esm({
|
|
6315
|
+
"src/util/migrator/index.ts"() {
|
|
6316
|
+
"use strict";
|
|
6317
|
+
init_StaticToCouchDBMigrator();
|
|
6318
|
+
init_validation();
|
|
6319
|
+
init_FileSystemAdapter();
|
|
6320
|
+
}
|
|
6321
|
+
});
|
|
6322
|
+
|
|
6323
|
+
// src/util/dataDirectory.ts
|
|
6324
|
+
import * as path from "path";
|
|
6325
|
+
import * as os from "os";
|
|
6326
|
+
function getAppDataDirectory() {
|
|
6327
|
+
if (ENV.LOCAL_STORAGE_PREFIX) {
|
|
6328
|
+
return path.join(os.homedir(), `.tuilder`, ENV.LOCAL_STORAGE_PREFIX);
|
|
6329
|
+
} else {
|
|
6330
|
+
return path.join(os.homedir(), ".tuilder");
|
|
6331
|
+
}
|
|
6332
|
+
}
|
|
6333
|
+
function getDbPath(dbName) {
|
|
6334
|
+
return path.join(getAppDataDirectory(), dbName);
|
|
6335
|
+
}
|
|
6336
|
+
var init_dataDirectory = __esm({
|
|
6337
|
+
"src/util/dataDirectory.ts"() {
|
|
6338
|
+
"use strict";
|
|
6339
|
+
init_logger();
|
|
6340
|
+
init_factory();
|
|
6341
|
+
}
|
|
6342
|
+
});
|
|
6343
|
+
|
|
6344
|
+
// src/util/index.ts
|
|
6345
|
+
var init_util2 = __esm({
|
|
6346
|
+
"src/util/index.ts"() {
|
|
6347
|
+
"use strict";
|
|
6348
|
+
init_Loggable();
|
|
6349
|
+
init_packer();
|
|
6350
|
+
init_migrator();
|
|
6351
|
+
init_dataDirectory();
|
|
6352
|
+
}
|
|
6353
|
+
});
|
|
6354
|
+
|
|
6355
|
+
// src/study/SourceMixer.ts
|
|
6356
|
+
var init_SourceMixer = __esm({
|
|
6357
|
+
"src/study/SourceMixer.ts"() {
|
|
6358
|
+
"use strict";
|
|
6359
|
+
}
|
|
6360
|
+
});
|
|
6361
|
+
|
|
6362
|
+
// src/study/MixerDebugger.ts
|
|
6363
|
+
function printMixerSummary(run) {
|
|
6364
|
+
console.group(`\u{1F3A8} Mixer Run: ${run.mixerType}`);
|
|
6365
|
+
logger.info(`Run ID: ${run.runId}`);
|
|
6366
|
+
logger.info(`Time: ${run.timestamp.toISOString()}`);
|
|
6367
|
+
logger.info(
|
|
6368
|
+
`Config: limit=${run.requestedLimit}${run.quotaPerSource ? `, quota/source=${run.quotaPerSource}` : ""}`
|
|
6369
|
+
);
|
|
6370
|
+
console.group(`\u{1F4E5} Input: ${run.sourceSummaries.length} sources`);
|
|
6371
|
+
for (const src of run.sourceSummaries) {
|
|
6372
|
+
logger.info(
|
|
6373
|
+
` ${src.sourceName || src.sourceId}: ${src.totalCards} cards (${src.reviewCount} reviews, ${src.newCount} new)`
|
|
6374
|
+
);
|
|
6375
|
+
logger.info(` Score range: [${src.scoreRange[0].toFixed(2)}, ${src.scoreRange[1].toFixed(2)}], avg: ${src.avgScore.toFixed(2)}`);
|
|
6376
|
+
}
|
|
6377
|
+
console.groupEnd();
|
|
6378
|
+
console.group(`\u{1F4E4} Output: ${run.finalCount} cards selected (${run.reviewsSelected} reviews, ${run.newSelected} new)`);
|
|
6379
|
+
for (const breakdown of run.sourceBreakdowns) {
|
|
6380
|
+
const name = breakdown.sourceName || breakdown.sourceId;
|
|
6381
|
+
logger.info(
|
|
6382
|
+
` ${name}: ${breakdown.totalSelected} selected (${breakdown.reviewsSelected} reviews, ${breakdown.newSelected} new) - ${breakdown.selectionRate.toFixed(1)}% selection rate`
|
|
6383
|
+
);
|
|
6384
|
+
}
|
|
6385
|
+
console.groupEnd();
|
|
6386
|
+
console.groupEnd();
|
|
6387
|
+
}
|
|
6388
|
+
function mountMixerDebugger() {
|
|
6389
|
+
if (typeof window === "undefined") return;
|
|
6390
|
+
const win = window;
|
|
6391
|
+
win.skuilder = win.skuilder || {};
|
|
6392
|
+
win.skuilder.mixer = mixerDebugAPI;
|
|
6393
|
+
}
|
|
6394
|
+
var runHistory2, mixerDebugAPI;
|
|
6395
|
+
var init_MixerDebugger = __esm({
|
|
6396
|
+
"src/study/MixerDebugger.ts"() {
|
|
6397
|
+
"use strict";
|
|
6398
|
+
init_logger();
|
|
6399
|
+
init_navigators();
|
|
6400
|
+
runHistory2 = [];
|
|
6401
|
+
mixerDebugAPI = {
|
|
6402
|
+
/**
|
|
6403
|
+
* Get raw run history for programmatic access.
|
|
6404
|
+
*/
|
|
6405
|
+
get runs() {
|
|
6406
|
+
return [...runHistory2];
|
|
6407
|
+
},
|
|
6408
|
+
/**
|
|
6409
|
+
* Show summary of a specific mixer run.
|
|
6410
|
+
*/
|
|
6411
|
+
showRun(idOrIndex = 0) {
|
|
6412
|
+
if (runHistory2.length === 0) {
|
|
6413
|
+
logger.info("[Mixer Debug] No runs captured yet.");
|
|
6414
|
+
return;
|
|
6415
|
+
}
|
|
6416
|
+
let run;
|
|
6417
|
+
if (typeof idOrIndex === "number") {
|
|
6418
|
+
run = runHistory2[idOrIndex];
|
|
6419
|
+
if (!run) {
|
|
6420
|
+
logger.info(`[Mixer Debug] No run found at index ${idOrIndex}. History length: ${runHistory2.length}`);
|
|
6421
|
+
return;
|
|
6422
|
+
}
|
|
6423
|
+
} else {
|
|
6424
|
+
run = runHistory2.find((r) => r.runId.endsWith(idOrIndex));
|
|
6425
|
+
if (!run) {
|
|
6426
|
+
logger.info(`[Mixer Debug] No run found matching ID '${idOrIndex}'.`);
|
|
6427
|
+
return;
|
|
6428
|
+
}
|
|
6429
|
+
}
|
|
6430
|
+
printMixerSummary(run);
|
|
6431
|
+
},
|
|
6432
|
+
/**
|
|
6433
|
+
* Show summary of the last mixer run.
|
|
6434
|
+
*/
|
|
6435
|
+
showLastMix() {
|
|
6436
|
+
this.showRun(0);
|
|
6437
|
+
},
|
|
6438
|
+
/**
|
|
6439
|
+
* Explain source balance in the last run.
|
|
6440
|
+
*/
|
|
6441
|
+
explainSourceBalance() {
|
|
6442
|
+
if (runHistory2.length === 0) {
|
|
6443
|
+
logger.info("[Mixer Debug] No runs captured yet.");
|
|
6444
|
+
return;
|
|
6445
|
+
}
|
|
6446
|
+
const run = runHistory2[0];
|
|
6447
|
+
console.group("\u2696\uFE0F Source Balance Analysis");
|
|
6448
|
+
logger.info(`Mixer: ${run.mixerType}`);
|
|
6449
|
+
logger.info(`Requested limit: ${run.requestedLimit}`);
|
|
6450
|
+
if (run.quotaPerSource) {
|
|
6451
|
+
logger.info(`Quota per source: ${run.quotaPerSource}`);
|
|
6452
|
+
}
|
|
6453
|
+
console.group("Input Distribution:");
|
|
6454
|
+
for (const src of run.sourceSummaries) {
|
|
6455
|
+
const name = src.sourceName || src.sourceId;
|
|
6456
|
+
logger.info(`${name}:`);
|
|
6457
|
+
logger.info(` Provided: ${src.totalCards} cards (${src.reviewCount} reviews, ${src.newCount} new)`);
|
|
6458
|
+
logger.info(` Score range: [${src.scoreRange[0].toFixed(2)}, ${src.scoreRange[1].toFixed(2)}]`);
|
|
6459
|
+
}
|
|
6460
|
+
console.groupEnd();
|
|
6461
|
+
console.group("Selection Results:");
|
|
6462
|
+
for (const breakdown of run.sourceBreakdowns) {
|
|
6463
|
+
const name = breakdown.sourceName || breakdown.sourceId;
|
|
6464
|
+
logger.info(`${name}:`);
|
|
6465
|
+
logger.info(
|
|
6466
|
+
` Selected: ${breakdown.totalSelected}/${breakdown.reviewsProvided + breakdown.newProvided} (${breakdown.selectionRate.toFixed(1)}%)`
|
|
6467
|
+
);
|
|
6468
|
+
logger.info(` Reviews: ${breakdown.reviewsSelected}/${breakdown.reviewsProvided}`);
|
|
6469
|
+
logger.info(` New: ${breakdown.newSelected}/${breakdown.newProvided}`);
|
|
6470
|
+
if (breakdown.reviewsProvided > 0 && breakdown.reviewsSelected === 0) {
|
|
6471
|
+
logger.info(` \u26A0\uFE0F Had reviews but none selected!`);
|
|
6472
|
+
}
|
|
6473
|
+
if (breakdown.totalSelected === 0 && breakdown.reviewsProvided + breakdown.newProvided > 0) {
|
|
6474
|
+
logger.info(` \u26A0\uFE0F Had cards but none selected!`);
|
|
6475
|
+
}
|
|
6476
|
+
}
|
|
6477
|
+
console.groupEnd();
|
|
6478
|
+
const selectionRates = run.sourceBreakdowns.map((b) => b.selectionRate);
|
|
6479
|
+
const avgRate = selectionRates.reduce((a, b) => a + b, 0) / selectionRates.length;
|
|
6480
|
+
const maxDeviation = Math.max(...selectionRates.map((r) => Math.abs(r - avgRate)));
|
|
6481
|
+
if (maxDeviation > 20) {
|
|
6482
|
+
logger.info(`
|
|
6483
|
+
\u26A0\uFE0F Significant imbalance detected (max deviation: ${maxDeviation.toFixed(1)}%)`);
|
|
6484
|
+
logger.info("Possible causes:");
|
|
6485
|
+
logger.info(" - Score range differences between sources");
|
|
6486
|
+
logger.info(" - One source has much better quality cards");
|
|
6487
|
+
logger.info(" - Different card availability (reviews vs new)");
|
|
6488
|
+
}
|
|
6489
|
+
console.groupEnd();
|
|
6490
|
+
},
|
|
6491
|
+
/**
|
|
6492
|
+
* Compare score distributions across sources.
|
|
6493
|
+
*/
|
|
6494
|
+
compareScores() {
|
|
6495
|
+
if (runHistory2.length === 0) {
|
|
6496
|
+
logger.info("[Mixer Debug] No runs captured yet.");
|
|
6497
|
+
return;
|
|
6498
|
+
}
|
|
6499
|
+
const run = runHistory2[0];
|
|
6500
|
+
console.group("\u{1F4CA} Score Distribution Comparison");
|
|
6501
|
+
console.table(
|
|
6502
|
+
run.sourceSummaries.map((src) => ({
|
|
6503
|
+
source: src.sourceName || src.sourceId,
|
|
6504
|
+
cards: src.totalCards,
|
|
6505
|
+
min: src.bottomScore.toFixed(3),
|
|
6506
|
+
max: src.topScore.toFixed(3),
|
|
6507
|
+
avg: src.avgScore.toFixed(3),
|
|
6508
|
+
range: (src.topScore - src.bottomScore).toFixed(3)
|
|
6509
|
+
}))
|
|
6510
|
+
);
|
|
6511
|
+
const ranges = run.sourceSummaries.map((s) => s.topScore - s.bottomScore);
|
|
6512
|
+
const avgScores = run.sourceSummaries.map((s) => s.avgScore);
|
|
6513
|
+
const rangeDiff = Math.max(...ranges) - Math.min(...ranges);
|
|
6514
|
+
const avgDiff = Math.max(...avgScores) - Math.min(...avgScores);
|
|
6515
|
+
if (rangeDiff > 0.3 || avgDiff > 0.2) {
|
|
6516
|
+
logger.info("\n\u26A0\uFE0F Significant score distribution differences detected");
|
|
6517
|
+
logger.info(
|
|
6518
|
+
"This may cause one source to dominate selection if using global sorting (not quota-based)"
|
|
6519
|
+
);
|
|
6520
|
+
}
|
|
6521
|
+
console.groupEnd();
|
|
6522
|
+
},
|
|
6523
|
+
/**
|
|
6524
|
+
* Show detailed information for a specific card.
|
|
6525
|
+
*/
|
|
6526
|
+
showCard(cardId) {
|
|
6527
|
+
for (const run of runHistory2) {
|
|
6528
|
+
const card = run.cards.find((c) => c.cardId === cardId);
|
|
6529
|
+
if (card) {
|
|
6530
|
+
const source = run.sourceSummaries.find((s) => s.sourceIndex === card.sourceIndex);
|
|
6531
|
+
console.group(`\u{1F3B4} Card: ${cardId}`);
|
|
6532
|
+
logger.info(`Course: ${card.courseId}`);
|
|
6533
|
+
logger.info(`Source: ${source?.sourceName || source?.sourceId || "unknown"}`);
|
|
6534
|
+
logger.info(`Origin: ${card.origin}`);
|
|
6535
|
+
logger.info(`Score: ${card.score.toFixed(3)}`);
|
|
6536
|
+
if (card.rankInSource) {
|
|
6537
|
+
logger.info(`Rank in source: #${card.rankInSource}`);
|
|
6538
|
+
}
|
|
6539
|
+
if (card.rankInMix) {
|
|
6540
|
+
logger.info(`Rank in mixed results: #${card.rankInMix}`);
|
|
6541
|
+
}
|
|
6542
|
+
logger.info(`Selected: ${card.selected ? "Yes \u2705" : "No \u274C"}`);
|
|
6543
|
+
if (!card.selected && card.rankInSource) {
|
|
6544
|
+
logger.info("\nWhy not selected:");
|
|
6545
|
+
if (run.quotaPerSource && card.rankInSource > run.quotaPerSource) {
|
|
6546
|
+
logger.info(` - Ranked #${card.rankInSource} in source, but quota was ${run.quotaPerSource}`);
|
|
6547
|
+
}
|
|
6548
|
+
logger.info(" - Check score compared to selected cards using .showRun()");
|
|
6549
|
+
}
|
|
6550
|
+
console.groupEnd();
|
|
6551
|
+
return;
|
|
6552
|
+
}
|
|
6553
|
+
}
|
|
6554
|
+
logger.info(`[Mixer Debug] Card '${cardId}' not found in recent runs.`);
|
|
6555
|
+
},
|
|
6556
|
+
/**
|
|
6557
|
+
* Show all runs in compact format.
|
|
6558
|
+
*/
|
|
6559
|
+
listRuns() {
|
|
6560
|
+
if (runHistory2.length === 0) {
|
|
6561
|
+
logger.info("[Mixer Debug] No runs captured yet.");
|
|
6562
|
+
return;
|
|
6563
|
+
}
|
|
6564
|
+
console.table(
|
|
6565
|
+
runHistory2.map((r) => ({
|
|
6566
|
+
id: r.runId.slice(-8),
|
|
6567
|
+
time: r.timestamp.toLocaleTimeString(),
|
|
6568
|
+
mixer: r.mixerType,
|
|
6569
|
+
sources: r.sourceSummaries.length,
|
|
6570
|
+
selected: r.finalCount,
|
|
6571
|
+
reviews: r.reviewsSelected,
|
|
6572
|
+
new: r.newSelected
|
|
6573
|
+
}))
|
|
6574
|
+
);
|
|
6575
|
+
},
|
|
6576
|
+
/**
|
|
6577
|
+
* Export run history as JSON for bug reports.
|
|
6578
|
+
*/
|
|
6579
|
+
export() {
|
|
6580
|
+
const json = JSON.stringify(runHistory2, null, 2);
|
|
6581
|
+
logger.info("[Mixer Debug] Run history exported. Copy the returned string or use:");
|
|
6582
|
+
logger.info(" copy(window.skuilder.mixer.export())");
|
|
6583
|
+
return json;
|
|
6584
|
+
},
|
|
6585
|
+
/**
|
|
6586
|
+
* Clear run history.
|
|
6587
|
+
*/
|
|
6588
|
+
clear() {
|
|
6589
|
+
runHistory2.length = 0;
|
|
6590
|
+
logger.info("[Mixer Debug] Run history cleared.");
|
|
6591
|
+
},
|
|
6592
|
+
/**
|
|
6593
|
+
* Show help.
|
|
6594
|
+
*/
|
|
6595
|
+
help() {
|
|
6596
|
+
logger.info(`
|
|
6597
|
+
\u{1F3A8} Mixer Debug API
|
|
6598
|
+
|
|
6599
|
+
Commands:
|
|
6600
|
+
.showLastMix() Show summary of most recent mixer run
|
|
6601
|
+
.showRun(id|index) Show summary of a specific run (by index or ID suffix)
|
|
6602
|
+
.explainSourceBalance() Analyze source balance and selection patterns
|
|
6603
|
+
.compareScores() Compare score distributions across sources
|
|
6604
|
+
.showCard(cardId) Show mixer decisions for a specific card
|
|
6605
|
+
.listRuns() List all captured runs in table format
|
|
6606
|
+
.export() Export run history as JSON for bug reports
|
|
6607
|
+
.clear() Clear run history
|
|
6608
|
+
.runs Access raw run history array
|
|
6609
|
+
.help() Show this help message
|
|
6610
|
+
|
|
6611
|
+
Example:
|
|
6612
|
+
window.skuilder.mixer.showLastMix()
|
|
6613
|
+
window.skuilder.mixer.explainSourceBalance()
|
|
6614
|
+
window.skuilder.mixer.compareScores()
|
|
6615
|
+
`);
|
|
6616
|
+
}
|
|
6617
|
+
};
|
|
6618
|
+
mountMixerDebugger();
|
|
6619
|
+
}
|
|
6620
|
+
});
|
|
6621
|
+
|
|
6622
|
+
// src/study/SessionOverlay.ts
|
|
6623
|
+
function getActiveController() {
|
|
6624
|
+
return activeController;
|
|
6625
|
+
}
|
|
6626
|
+
function toggleSessionOverlay() {
|
|
6627
|
+
if (typeof document === "undefined") {
|
|
6628
|
+
logger.info("[Session Overlay] No DOM available (non-browser host); overlay unavailable.");
|
|
6629
|
+
return;
|
|
6630
|
+
}
|
|
6631
|
+
if (overlayEl) {
|
|
6632
|
+
teardown();
|
|
6633
|
+
logger.info("[Session Overlay] Hidden.");
|
|
6634
|
+
} else {
|
|
6635
|
+
mount();
|
|
6636
|
+
logger.info("[Session Overlay] Shown. Toggle off with window.skuilder.session.dbgOverlay().");
|
|
6637
|
+
}
|
|
6638
|
+
}
|
|
6639
|
+
function mount() {
|
|
6640
|
+
minified = false;
|
|
6641
|
+
overlayEl = document.createElement("div");
|
|
6642
|
+
overlayEl.id = OVERLAY_ID;
|
|
6643
|
+
Object.assign(overlayEl.style, {
|
|
6644
|
+
position: "fixed",
|
|
6645
|
+
top: "8px",
|
|
6646
|
+
left: "8px",
|
|
6647
|
+
zIndex: "2147483647",
|
|
6648
|
+
maxWidth: "320px",
|
|
6649
|
+
maxHeight: "90vh",
|
|
6650
|
+
overflowY: "auto",
|
|
6651
|
+
padding: "8px 10px",
|
|
6652
|
+
background: "rgba(17, 24, 39, 0.92)",
|
|
6653
|
+
color: "#e5e7eb",
|
|
6654
|
+
font: "11px/1.4 ui-monospace, SFMono-Regular, Menlo, monospace",
|
|
6655
|
+
borderRadius: "6px",
|
|
6656
|
+
boxShadow: "0 4px 16px rgba(0,0,0,0.4)",
|
|
6657
|
+
pointerEvents: "auto",
|
|
6658
|
+
userSelect: "none"
|
|
6659
|
+
});
|
|
6660
|
+
document.body.appendChild(overlayEl);
|
|
6661
|
+
render();
|
|
6662
|
+
pollHandle = setInterval(render, POLL_MS);
|
|
6663
|
+
}
|
|
6664
|
+
function teardown() {
|
|
6665
|
+
if (pollHandle !== null) {
|
|
6666
|
+
clearInterval(pollHandle);
|
|
6667
|
+
pollHandle = null;
|
|
6668
|
+
}
|
|
6669
|
+
if (overlayEl?.parentNode) {
|
|
6670
|
+
overlayEl.parentNode.removeChild(overlayEl);
|
|
6671
|
+
}
|
|
6672
|
+
overlayEl = null;
|
|
6673
|
+
}
|
|
6674
|
+
function render() {
|
|
6675
|
+
if (!overlayEl) return;
|
|
6676
|
+
spinnerFrame++;
|
|
6677
|
+
const ctrl = getActiveController();
|
|
6678
|
+
if (!ctrl) {
|
|
6679
|
+
lastSnapshot = null;
|
|
6680
|
+
overlayEl.innerHTML = headerHtml() + (minified ? "" : `<div style="opacity:.65">No active session.</div>`);
|
|
6681
|
+
attachHandlers();
|
|
6682
|
+
return;
|
|
6683
|
+
}
|
|
6684
|
+
const s = ctrl.getDebugSnapshot();
|
|
6685
|
+
lastSnapshot = s;
|
|
6686
|
+
if (minified) {
|
|
6687
|
+
overlayEl.innerHTML = headerHtml();
|
|
6688
|
+
attachHandlers();
|
|
6689
|
+
return;
|
|
6690
|
+
}
|
|
6691
|
+
overlayEl.innerHTML = headerHtml() + replanHtml(s) + metaHtml(s) + hintsHtml(s.sessionHints) + backlogHtml(s.reviewBacklog) + strategyPressureHtml(s.strategyPressure) + queueHtml("supplyQ", "supplyQ", s.supplyQ) + queueHtml("failedQ", "failedQ", s.failedQ) + drawnHtml("drawn", s.drawnCards);
|
|
6692
|
+
attachHandlers();
|
|
6693
|
+
}
|
|
6694
|
+
function attachHandlers() {
|
|
6695
|
+
if (!overlayEl) return;
|
|
6696
|
+
overlayEl.querySelectorAll("[data-q]").forEach((el) => {
|
|
6697
|
+
el.onclick = () => {
|
|
6698
|
+
const key = el.dataset.q;
|
|
6699
|
+
if (!key) return;
|
|
6700
|
+
expanded[key] = !expanded[key];
|
|
6701
|
+
render();
|
|
6702
|
+
};
|
|
6703
|
+
});
|
|
6704
|
+
const copyBtn = overlayEl.querySelector("[data-copy]");
|
|
6705
|
+
if (copyBtn) {
|
|
6706
|
+
copyBtn.onclick = (ev) => {
|
|
6707
|
+
ev.stopPropagation();
|
|
6708
|
+
copySnapshot();
|
|
6709
|
+
};
|
|
6710
|
+
}
|
|
6711
|
+
const minBtn = overlayEl.querySelector("[data-min]");
|
|
6712
|
+
if (minBtn) {
|
|
6713
|
+
minBtn.onclick = (ev) => {
|
|
6714
|
+
ev.stopPropagation();
|
|
6715
|
+
minified = !minified;
|
|
6716
|
+
render();
|
|
6717
|
+
};
|
|
6718
|
+
}
|
|
6719
|
+
}
|
|
6720
|
+
function copySnapshot() {
|
|
6721
|
+
const text = snapshotToText(lastSnapshot);
|
|
6722
|
+
const flash = () => {
|
|
6723
|
+
copyFlashUntil = Date.now() + 1200;
|
|
6724
|
+
render();
|
|
6725
|
+
};
|
|
6726
|
+
const clip = typeof navigator !== "undefined" ? navigator.clipboard : void 0;
|
|
6727
|
+
if (clip?.writeText) {
|
|
6728
|
+
clip.writeText(text).then(flash, (err) => {
|
|
6729
|
+
logger.warn(`[Session Overlay] Clipboard write failed: ${String(err)}`);
|
|
6730
|
+
});
|
|
6731
|
+
} else {
|
|
6732
|
+
logger.info(`[Session Overlay] Clipboard unavailable; snapshot follows:
|
|
6733
|
+
${text}`);
|
|
6734
|
+
}
|
|
6735
|
+
}
|
|
6736
|
+
function headerHtml() {
|
|
6737
|
+
const flashing = Date.now() < copyFlashUntil;
|
|
6738
|
+
const btnLabel = flashing ? "\u2713 copied" : "\u2398 copy";
|
|
6739
|
+
const btnColor = flashing ? "#86efac" : "#93c5fd";
|
|
6740
|
+
const copyBtn = `<span data-copy style="cursor:pointer;float:right;font-weight:400;color:${btnColor};border:1px solid currentColor;border-radius:4px;padding:0 4px;line-height:1.3">${btnLabel}</span>`;
|
|
6741
|
+
const minBtn = `<span data-min title="${minified ? "Restore" : "Minify"}" style="cursor:pointer;float:right;font-weight:400;color:#93c5fd;border:1px solid currentColor;border-radius:4px;padding:0 5px;margin-right:4px;line-height:1.3">${minified ? "\u25A2" : "\u2014"}</span>`;
|
|
6742
|
+
return `<div style="font-weight:600;color:#93c5fd;margin-bottom:${minified ? 0 : 4}px">${copyBtn}${minBtn}\u2699 SessionController</div>`;
|
|
6743
|
+
}
|
|
6744
|
+
function replanHtml(s) {
|
|
6745
|
+
if (!s.replanActive) {
|
|
6746
|
+
return `<div style="margin-bottom:6px;opacity:.45">\u25CB idle</div>`;
|
|
6747
|
+
}
|
|
6748
|
+
const frame = SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length];
|
|
6749
|
+
const reason = esc(s.replanLabel ?? "(auto)");
|
|
6750
|
+
return `<div style="margin-bottom:6px;color:#fde047">${frame} replanning <span style="opacity:.85">[${reason}]</span></div>`;
|
|
6751
|
+
}
|
|
6752
|
+
function metaHtml(s) {
|
|
6753
|
+
const mmss = formatTime(s.secondsRemaining);
|
|
6754
|
+
const guarantee = s.hasCardGuarantee ? ` \xB7 <span style="color:#fbbf24">guarantee ${s.minCardsGuarantee}</span>` : "";
|
|
6755
|
+
const rows = [
|
|
6756
|
+
`time ${mmss}${guarantee}`,
|
|
6757
|
+
`well-indicated left: ${s.wellIndicatedRemaining}`,
|
|
6758
|
+
`current: ${s.currentCard ? esc(s.currentCard) : '<span style="opacity:.6">\u2014</span>'}`
|
|
6759
|
+
];
|
|
6760
|
+
return `<div style="margin-bottom:6px">${rows.map((r) => `<div>${r}</div>`).join("")}</div>`;
|
|
6761
|
+
}
|
|
6762
|
+
function hintsHtml(h) {
|
|
6763
|
+
const parts = [];
|
|
6764
|
+
if (h) {
|
|
6765
|
+
if (h.boostTags && Object.keys(h.boostTags).length) {
|
|
6766
|
+
parts.push(
|
|
6767
|
+
`boost: ` + Object.entries(h.boostTags).map(([k, v]) => `${esc(k)}<span style="opacity:.6">\xD7${v}</span>`).join(", ")
|
|
6768
|
+
);
|
|
6769
|
+
}
|
|
6770
|
+
if (h.boostCards && Object.keys(h.boostCards).length) {
|
|
6771
|
+
parts.push(
|
|
6772
|
+
`boostCards: ` + Object.entries(h.boostCards).map(([k, v]) => `${esc(k)}<span style="opacity:.6">\xD7${v}</span>`).join(", ")
|
|
6773
|
+
);
|
|
6774
|
+
}
|
|
6775
|
+
if (h.requireCards?.length) parts.push(`require: ${h.requireCards.map(esc).join(", ")}`);
|
|
6776
|
+
if (h.requireTags?.length) parts.push(`requireTags: ${h.requireTags.map(esc).join(", ")}`);
|
|
6777
|
+
if (h.excludeTags?.length) parts.push(`exclude: ${h.excludeTags.map(esc).join(", ")}`);
|
|
6778
|
+
if (h.excludeCards?.length) parts.push(`excludeCards: ${h.excludeCards.map(esc).join(", ")}`);
|
|
6779
|
+
}
|
|
6780
|
+
const body = parts.length ? parts.map((p) => `<div style="margin-left:6px">${p}</div>`).join("") : `<div style="margin-left:6px;opacity:.6">none</div>`;
|
|
6781
|
+
return `<div style="margin-bottom:6px"><div style="color:#86efac">sessionHints</div>${body}</div>`;
|
|
6782
|
+
}
|
|
6783
|
+
function backlogHtml(backlog) {
|
|
6784
|
+
if (!backlog.length) return "";
|
|
6785
|
+
const rows = backlog.map((b) => {
|
|
6786
|
+
const hot = b.backlogMultiplier >= 3;
|
|
6787
|
+
const multColor = b.backlogMultiplier <= 1 ? "#86efac" : hot ? "#fca5a5" : "#fcd34d";
|
|
6788
|
+
const headroom = b.backlogMultiplier > 1 ? `climbing (\xD7${b.backlogGrowthRate.toFixed(2)} per ${b.healthyBacklog}-review excess, unbounded)` : "healthy \u2014 no pressure";
|
|
6789
|
+
const top = b.topReviewScore !== null ? b.topReviewScore.toFixed(2) : "\u2014";
|
|
6790
|
+
const next = b.nextDueIn ? ` <span style="opacity:.6">\xB7 next due ${esc(b.nextDueIn)}</span>` : "";
|
|
6791
|
+
return `<div style="margin-left:6px"><span style="opacity:.7">${esc(b.courseId.slice(0, 8))}</span> due ${b.dueNow}/${b.scheduledTotal} <span style="opacity:.6">(healthy ${b.healthyBacklog})</span>${next}<div style="margin-left:6px">pressure <span style="color:${multColor}">\xD7${b.backlogMultiplier.toFixed(2)}</span> <span style="opacity:.6">${headroom} \xB7 top review ${top}</span></div></div>`;
|
|
6792
|
+
}).join("");
|
|
6793
|
+
return `<div style="margin-bottom:6px"><div style="color:#93c5fd">review backpressure</div>${rows}</div>`;
|
|
6794
|
+
}
|
|
6795
|
+
function pressureColor(multiplier, max) {
|
|
6796
|
+
if (multiplier <= 1.001) return "#86efac";
|
|
6797
|
+
if (max !== void 0 && max > 1) {
|
|
6798
|
+
return (multiplier - 1) / (max - 1) >= 0.75 ? "#fca5a5" : "#fcd34d";
|
|
6799
|
+
}
|
|
6800
|
+
return multiplier >= 3 ? "#fca5a5" : "#fcd34d";
|
|
6801
|
+
}
|
|
6802
|
+
function toggleKey(raw) {
|
|
6803
|
+
return raw.replace(/[^\w:.|-]/g, "_");
|
|
6804
|
+
}
|
|
6805
|
+
function gaugeHtml(sectionKey, g) {
|
|
6806
|
+
const cap = g.max !== void 0 ? `<span style="opacity:.5">/${g.max}</span>` : "";
|
|
6807
|
+
const detail = g.detail ? ` <span style="opacity:.6">${esc(g.detail)}</span>` : "";
|
|
6808
|
+
let html = `<div style="margin-left:6px">${esc(g.label)} <span style="color:${pressureColor(g.multiplier, g.max)}">\xD7${g.multiplier.toFixed(2)}</span>${cap}${detail}`;
|
|
6809
|
+
const items = g.items ?? [];
|
|
6810
|
+
if (items.length > 0) {
|
|
6811
|
+
const key = toggleKey(`sp|${sectionKey}|${g.id}`);
|
|
6812
|
+
const isOpen = !!expanded[key];
|
|
6813
|
+
const shown = isOpen ? items : items.slice(0, INLINE_THRESHOLD);
|
|
6814
|
+
html += `<div style="margin-left:6px">` + shown.map(
|
|
6815
|
+
(it) => `<div style="white-space:nowrap;opacity:.75">${esc(it.label)}${it.value ? ` <span style="opacity:.6">${esc(it.value)}</span>` : ""}</div>`
|
|
6816
|
+
).join("");
|
|
6817
|
+
if (items.length > INLINE_THRESHOLD) {
|
|
6818
|
+
const footer = isOpen ? "\u25BE show less" : `\u2026 +${items.length - shown.length} more`;
|
|
6819
|
+
html += `<div data-q="${key}" style="cursor:pointer;opacity:.6">${footer}</div>`;
|
|
6820
|
+
}
|
|
6821
|
+
html += `</div>`;
|
|
6822
|
+
}
|
|
6823
|
+
return html + `</div>`;
|
|
6824
|
+
}
|
|
6825
|
+
function strategyPressureHtml(list) {
|
|
6826
|
+
if (!list.length) return "";
|
|
6827
|
+
const sections = list.map((s) => {
|
|
6828
|
+
const sectionKey = `${s.source}:${s.courseId.slice(0, 8)}`;
|
|
6829
|
+
const top = s.topScore !== null && s.topScore !== void 0 ? s.topScore.toFixed(2) : "\u2014";
|
|
6830
|
+
const hints = s.hintsLabel ? `<div style="margin-left:6px;opacity:.6">hints: ${esc(s.hintsLabel)}</div>` : "";
|
|
6831
|
+
return `<div style="margin-left:6px"><span style="opacity:.7">${esc(s.source)} \xB7 ${esc(s.courseId.slice(0, 8))}</span> <span style="opacity:.6">top score ${top}</span>` + s.gauges.map((g) => gaugeHtml(sectionKey, g)).join("") + hints + `</div>`;
|
|
6832
|
+
}).join("");
|
|
6833
|
+
return `<div style="margin-bottom:6px"><div style="color:#fdba74">strategy backpressure</div>${sections}</div>`;
|
|
6834
|
+
}
|
|
6835
|
+
function fmtScore(score) {
|
|
6836
|
+
if (score === void 0) return "";
|
|
6837
|
+
if (!Number.isFinite(score)) return "REQ";
|
|
6838
|
+
return score.toFixed(2);
|
|
6839
|
+
}
|
|
6840
|
+
function queueItemHtml(item) {
|
|
6841
|
+
const tagColor = item.origin === "review" ? "#93c5fd" : "#fcd34d";
|
|
6842
|
+
const score = fmtScore(item.score);
|
|
6843
|
+
const label = `${item.origin === "review" ? "r" : "n"}${score ? " " + score : ""}`;
|
|
6844
|
+
return `${esc(item.cardID)}<span style="color:${tagColor};opacity:.85"> [${label}]</span>`;
|
|
6845
|
+
}
|
|
6846
|
+
function queueHtml(key, label, q) {
|
|
6847
|
+
const collapsible = q.length > INLINE_THRESHOLD;
|
|
6848
|
+
const isOpen = collapsible && expanded[key];
|
|
6849
|
+
const caret = collapsible ? expanded[key] ? "\u25BE " : "\u25B8 " : "";
|
|
6850
|
+
const drawn = q.dequeueCount ? ` <span style="opacity:.5">drawn ${q.dequeueCount}</span>` : "";
|
|
6851
|
+
const titleStyle = collapsible ? "cursor:pointer;color:#f9a8d4" : "color:#f9a8d4";
|
|
6852
|
+
const titleAttr = collapsible ? ` data-q="${key}"` : "";
|
|
6853
|
+
const title = `<div${titleAttr} style="${titleStyle}">${caret}${label}: ${q.length}${drawn}</div>`;
|
|
6854
|
+
if (!q.cards.length) {
|
|
6855
|
+
return title + `<div style="margin:1px 0 6px 6px;opacity:.5">empty</div>`;
|
|
6856
|
+
}
|
|
6857
|
+
const shown = isOpen ? q.cards : q.cards.slice(0, INLINE_THRESHOLD);
|
|
6858
|
+
const hiddenCount = q.length - shown.length;
|
|
6859
|
+
const listMarginBottom = collapsible ? 2 : 6;
|
|
6860
|
+
let body = `<ol style="margin:2px 0 ${listMarginBottom}px 0;padding-left:20px">` + shown.map((c) => `<li style="white-space:nowrap">${queueItemHtml(c)}</li>`).join("") + `</ol>`;
|
|
6861
|
+
if (collapsible) {
|
|
6862
|
+
const footer = isOpen ? "\u25BE show less" : `\u2026 +${hiddenCount} more`;
|
|
6863
|
+
body += `<div data-q="${key}" style="cursor:pointer;margin:0 0 6px 20px;opacity:.6">${footer}</div>`;
|
|
6864
|
+
}
|
|
6865
|
+
return title + body;
|
|
6866
|
+
}
|
|
6867
|
+
function outcomeGlyph(correct) {
|
|
6868
|
+
if (correct === true) return `<span style="color:#86efac">\u2713</span>`;
|
|
6869
|
+
if (correct === false) return `<span style="color:#fca5a5">\u2717</span>`;
|
|
6870
|
+
return `<span style="opacity:.5">\xB7</span>`;
|
|
6871
|
+
}
|
|
6872
|
+
function drawnHtml(key, drawn) {
|
|
6873
|
+
const collapsible = drawn.length > INLINE_THRESHOLD;
|
|
6874
|
+
const isOpen = collapsible && expanded[key];
|
|
6875
|
+
const caret = collapsible ? expanded[key] ? "\u25BE " : "\u25B8 " : "";
|
|
6876
|
+
const titleStyle = collapsible ? "cursor:pointer;color:#c4b5fd" : "color:#c4b5fd";
|
|
6877
|
+
const titleAttr = collapsible ? ` data-q="${key}"` : "";
|
|
6878
|
+
const title = `<div${titleAttr} style="${titleStyle}">${caret}drawn: ${drawn.length}</div>`;
|
|
6879
|
+
if (!drawn.length) {
|
|
6880
|
+
return title + `<div style="margin:1px 0 6px 6px;opacity:.5">none yet</div>`;
|
|
6881
|
+
}
|
|
6882
|
+
const shown = isOpen ? drawn : drawn.slice(0, INLINE_THRESHOLD);
|
|
6883
|
+
const hiddenCount = drawn.length - shown.length;
|
|
6884
|
+
const listMarginBottom = collapsible ? 2 : 6;
|
|
6885
|
+
const rows = shown.map((d) => {
|
|
6886
|
+
const retries = d.attempts > 1 ? `<span style="opacity:.5"> \xD7${d.attempts}</span>` : "";
|
|
6887
|
+
const time = `<span style="opacity:.45"> ${Math.round(d.timeSpentMs / 100) / 10}s</span>`;
|
|
6888
|
+
return `<li style="white-space:nowrap">${outcomeGlyph(d.correct)} ${esc(d.cardID)}<span style="opacity:.5"> [${esc(d.status)}]</span>${retries}${time}</li>`;
|
|
6889
|
+
}).join("");
|
|
6890
|
+
let body = `<ol style="margin:2px 0 ${listMarginBottom}px 0;padding-left:20px">${rows}</ol>`;
|
|
6891
|
+
if (collapsible) {
|
|
6892
|
+
const footer = isOpen ? "\u25BE show less" : `\u2026 +${hiddenCount} more`;
|
|
6893
|
+
body += `<div data-q="${key}" style="cursor:pointer;margin:0 0 6px 20px;opacity:.6">${footer}</div>`;
|
|
6894
|
+
}
|
|
6895
|
+
return title + body;
|
|
6896
|
+
}
|
|
6897
|
+
function snapshotToText(s) {
|
|
6898
|
+
if (!s) return "SessionController \u2014 no active session.";
|
|
6899
|
+
const lines = [];
|
|
6900
|
+
lines.push("=== SessionController ===");
|
|
6901
|
+
lines.push(`time ${formatTime(s.secondsRemaining)}`);
|
|
6902
|
+
if (s.hasCardGuarantee) lines.push(`guarantee: ${s.minCardsGuarantee}`);
|
|
6903
|
+
lines.push(`well-indicated left: ${s.wellIndicatedRemaining}`);
|
|
6904
|
+
lines.push(`current: ${s.currentCard ?? "\u2014"}`);
|
|
6905
|
+
lines.push(
|
|
6906
|
+
s.replanActive ? `replan: ACTIVE [${s.replanLabel ?? "(auto)"}]` : "replan: idle"
|
|
6907
|
+
);
|
|
6908
|
+
lines.push("");
|
|
6909
|
+
lines.push("sessionHints:");
|
|
6910
|
+
const h = s.sessionHints;
|
|
6911
|
+
const hintParts = [];
|
|
6912
|
+
if (h) {
|
|
6913
|
+
if (h.boostTags && Object.keys(h.boostTags).length)
|
|
6914
|
+
hintParts.push(` boost: ${Object.entries(h.boostTags).map(([k, v]) => `${k}\xD7${v}`).join(", ")}`);
|
|
6915
|
+
if (h.boostCards && Object.keys(h.boostCards).length)
|
|
6916
|
+
hintParts.push(` boostCards: ${Object.entries(h.boostCards).map(([k, v]) => `${k}\xD7${v}`).join(", ")}`);
|
|
6917
|
+
if (h.requireCards?.length) hintParts.push(` require: ${h.requireCards.join(", ")}`);
|
|
6918
|
+
if (h.requireTags?.length) hintParts.push(` requireTags: ${h.requireTags.join(", ")}`);
|
|
6919
|
+
if (h.excludeTags?.length) hintParts.push(` exclude: ${h.excludeTags.join(", ")}`);
|
|
6920
|
+
if (h.excludeCards?.length) hintParts.push(` excludeCards: ${h.excludeCards.join(", ")}`);
|
|
6921
|
+
}
|
|
6922
|
+
lines.push(hintParts.length ? hintParts.join("\n") : " none");
|
|
6923
|
+
if (s.reviewBacklog.length) {
|
|
6924
|
+
lines.push("");
|
|
6925
|
+
lines.push("review backpressure:");
|
|
6926
|
+
for (const b of s.reviewBacklog) {
|
|
6927
|
+
const headroom = b.backlogMultiplier > 1 ? "climbing" : "healthy";
|
|
6928
|
+
const top = b.topReviewScore !== null ? b.topReviewScore.toFixed(2) : "\u2014";
|
|
6929
|
+
const next = b.nextDueIn ? `, next due ${b.nextDueIn}` : "";
|
|
6930
|
+
lines.push(
|
|
6931
|
+
` ${b.courseId.slice(0, 8)}: due ${b.dueNow}/${b.scheduledTotal} (healthy ${b.healthyBacklog})${next}; pressure \xD7${b.backlogMultiplier.toFixed(2)} ${headroom}; top review ${top}`
|
|
6932
|
+
);
|
|
6933
|
+
}
|
|
6934
|
+
}
|
|
6935
|
+
if (s.strategyPressure.length) {
|
|
6936
|
+
lines.push("");
|
|
6937
|
+
lines.push("strategy backpressure:");
|
|
6938
|
+
for (const sp of s.strategyPressure) {
|
|
6939
|
+
const top = sp.topScore !== null && sp.topScore !== void 0 ? sp.topScore.toFixed(2) : "\u2014";
|
|
6940
|
+
lines.push(` ${sp.source} (${sp.courseId.slice(0, 8)}): top score ${top}`);
|
|
6941
|
+
for (const g of sp.gauges) {
|
|
6942
|
+
const cap = g.max !== void 0 ? `/${g.max}` : "";
|
|
6943
|
+
lines.push(
|
|
6944
|
+
` ${g.label} \xD7${g.multiplier.toFixed(2)}${cap}${g.detail ? ` \u2014 ${g.detail}` : ""}`
|
|
6945
|
+
);
|
|
6946
|
+
for (const it of g.items ?? []) {
|
|
6947
|
+
lines.push(` ${it.label}${it.value ? ` (${it.value})` : ""}`);
|
|
6948
|
+
}
|
|
6949
|
+
}
|
|
6950
|
+
if (sp.hintsLabel) lines.push(` hints: ${sp.hintsLabel}`);
|
|
6951
|
+
}
|
|
6952
|
+
}
|
|
6953
|
+
const queueText = (label, q) => {
|
|
6954
|
+
lines.push("");
|
|
6955
|
+
lines.push(`${label}: ${q.length} (drawn ${q.dequeueCount})`);
|
|
6956
|
+
q.cards.forEach((c, i) => {
|
|
6957
|
+
const score = fmtScore(c.score);
|
|
6958
|
+
const tag = `${c.origin === "review" ? "r" : "n"}${score ? " " + score : ""}`;
|
|
6959
|
+
lines.push(` ${i + 1}. ${c.cardID} [${tag}]`);
|
|
6960
|
+
});
|
|
6961
|
+
};
|
|
6962
|
+
queueText("supplyQ", s.supplyQ);
|
|
6963
|
+
queueText("failedQ", s.failedQ);
|
|
6964
|
+
lines.push("");
|
|
6965
|
+
lines.push(`drawn: ${s.drawnCards.length}`);
|
|
6966
|
+
s.drawnCards.forEach((d, i) => {
|
|
6967
|
+
const mark = d.correct === true ? "\u2713" : d.correct === false ? "\u2717" : "\xB7";
|
|
6968
|
+
const time = `${Math.round(d.timeSpentMs / 100) / 10}s`;
|
|
6969
|
+
lines.push(` ${i + 1}. ${mark} ${d.cardID} [${d.status}] \xD7${d.attempts} ${time}`);
|
|
6970
|
+
});
|
|
6971
|
+
return lines.join("\n");
|
|
6972
|
+
}
|
|
6973
|
+
function formatTime(totalSeconds) {
|
|
6974
|
+
const s = Math.max(0, Math.round(totalSeconds));
|
|
6975
|
+
const m = Math.floor(s / 60);
|
|
6976
|
+
const r = s % 60;
|
|
6977
|
+
return `${m}:${r.toString().padStart(2, "0")}`;
|
|
6978
|
+
}
|
|
6979
|
+
function esc(value) {
|
|
6980
|
+
return value.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
|
6981
|
+
}
|
|
6982
|
+
var activeController, OVERLAY_ID, POLL_MS, INLINE_THRESHOLD, SPINNER_FRAMES, spinnerFrame, overlayEl, pollHandle, lastSnapshot, copyFlashUntil, minified, expanded;
|
|
6983
|
+
var init_SessionOverlay = __esm({
|
|
6984
|
+
"src/study/SessionOverlay.ts"() {
|
|
6985
|
+
"use strict";
|
|
6986
|
+
init_logger();
|
|
6987
|
+
activeController = null;
|
|
6988
|
+
OVERLAY_ID = "skuilder-session-overlay";
|
|
6989
|
+
POLL_MS = 300;
|
|
6990
|
+
INLINE_THRESHOLD = 5;
|
|
6991
|
+
SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
|
|
6992
|
+
spinnerFrame = 0;
|
|
6993
|
+
overlayEl = null;
|
|
6994
|
+
pollHandle = null;
|
|
6995
|
+
lastSnapshot = null;
|
|
6996
|
+
copyFlashUntil = 0;
|
|
6997
|
+
minified = false;
|
|
6998
|
+
expanded = {
|
|
6999
|
+
supplyQ: false,
|
|
7000
|
+
failedQ: false,
|
|
7001
|
+
drawn: false
|
|
7002
|
+
};
|
|
7003
|
+
}
|
|
7004
|
+
});
|
|
7005
|
+
|
|
7006
|
+
// src/study/SessionDebugger.ts
|
|
7007
|
+
function showCurrentQueue() {
|
|
7008
|
+
if (!activeSession) {
|
|
7009
|
+
logger.info("[Session Debug] No active session.");
|
|
7010
|
+
return;
|
|
7011
|
+
}
|
|
7012
|
+
const latest = activeSession.queueSnapshots[activeSession.queueSnapshots.length - 1] || activeSession.initialQueues;
|
|
7013
|
+
console.group("\u{1F4CA} Current Queue State");
|
|
7014
|
+
logger.info(`Supply Queue: ${latest.supplyQLength} cards`);
|
|
7015
|
+
if (latest.supplyQNext3 && latest.supplyQNext3.length > 0) {
|
|
7016
|
+
logger.info(` Next: ${latest.supplyQNext3.join(", ")}`);
|
|
7017
|
+
}
|
|
7018
|
+
logger.info(`Failed Queue: ${latest.failedQLength} cards`);
|
|
7019
|
+
console.groupEnd();
|
|
7020
|
+
}
|
|
7021
|
+
function showPresentationHistory(sessionIndex = 0) {
|
|
7022
|
+
const session = sessionIndex === 0 && activeSession ? activeSession : sessionHistory[sessionIndex];
|
|
7023
|
+
if (!session) {
|
|
7024
|
+
logger.info(`[Session Debug] No session found at index ${sessionIndex}`);
|
|
7025
|
+
return;
|
|
7026
|
+
}
|
|
7027
|
+
console.group(`\u{1F4DC} Session History: ${session.sessionId}`);
|
|
7028
|
+
logger.info(`Started: ${session.startTime.toLocaleTimeString()}`);
|
|
7029
|
+
if (session.endTime) {
|
|
7030
|
+
logger.info(`Ended: ${session.endTime.toLocaleTimeString()}`);
|
|
7031
|
+
}
|
|
7032
|
+
logger.info(`Cards presented: ${session.presentations.length}`);
|
|
7033
|
+
if (session.presentations.length > 0) {
|
|
7034
|
+
console.table(
|
|
7035
|
+
session.presentations.map((p) => ({
|
|
7036
|
+
"#": p.sequenceNumber,
|
|
7037
|
+
course: p.courseName || p.courseId.slice(0, 8),
|
|
7038
|
+
origin: p.origin,
|
|
7039
|
+
queue: p.queueSource,
|
|
7040
|
+
score: p.score?.toFixed(3) || "-",
|
|
7041
|
+
time: p.timestamp.toLocaleTimeString()
|
|
7042
|
+
}))
|
|
7043
|
+
);
|
|
7044
|
+
}
|
|
7045
|
+
console.groupEnd();
|
|
7046
|
+
}
|
|
7047
|
+
function showInterleaving(sessionIndex = 0) {
|
|
7048
|
+
const session = sessionIndex === 0 && activeSession ? activeSession : sessionHistory[sessionIndex];
|
|
7049
|
+
if (!session) {
|
|
7050
|
+
logger.info(`[Session Debug] No session found at index ${sessionIndex}`);
|
|
7051
|
+
return;
|
|
7052
|
+
}
|
|
7053
|
+
console.group("\u{1F500} Interleaving Analysis");
|
|
7054
|
+
const courseCounts = /* @__PURE__ */ new Map();
|
|
7055
|
+
const courseOrigins = /* @__PURE__ */ new Map();
|
|
7056
|
+
session.presentations.forEach((p) => {
|
|
7057
|
+
const name = p.courseName || p.courseId;
|
|
7058
|
+
courseCounts.set(name, (courseCounts.get(name) || 0) + 1);
|
|
7059
|
+
if (!courseOrigins.has(name)) {
|
|
7060
|
+
courseOrigins.set(name, { review: 0, new: 0, failed: 0 });
|
|
7061
|
+
}
|
|
7062
|
+
const origins = courseOrigins.get(name);
|
|
7063
|
+
origins[p.origin]++;
|
|
7064
|
+
});
|
|
7065
|
+
logger.info("Course distribution:");
|
|
7066
|
+
console.table(
|
|
7067
|
+
Array.from(courseCounts.entries()).map(([course, count]) => {
|
|
7068
|
+
const origins = courseOrigins.get(course);
|
|
7069
|
+
return {
|
|
7070
|
+
course,
|
|
7071
|
+
total: count,
|
|
7072
|
+
reviews: origins.review,
|
|
7073
|
+
new: origins.new,
|
|
7074
|
+
failed: origins.failed,
|
|
7075
|
+
percentage: (count / session.presentations.length * 100).toFixed(1) + "%"
|
|
7076
|
+
};
|
|
7077
|
+
})
|
|
7078
|
+
);
|
|
7079
|
+
if (session.presentations.length > 0) {
|
|
7080
|
+
logger.info("\nPresentation sequence (first 20):");
|
|
7081
|
+
const sequence = session.presentations.slice(0, 20).map((p, idx) => `${idx + 1}. ${p.courseName || p.courseId.slice(0, 8)} (${p.origin})`).join("\n");
|
|
7082
|
+
logger.info(sequence);
|
|
7083
|
+
}
|
|
7084
|
+
let maxCluster = 0;
|
|
7085
|
+
let currentCluster = 1;
|
|
7086
|
+
let currentCourse = session.presentations[0]?.courseId;
|
|
7087
|
+
for (let i = 1; i < session.presentations.length; i++) {
|
|
7088
|
+
if (session.presentations[i].courseId === currentCourse) {
|
|
7089
|
+
currentCluster++;
|
|
7090
|
+
maxCluster = Math.max(maxCluster, currentCluster);
|
|
7091
|
+
} else {
|
|
7092
|
+
currentCourse = session.presentations[i].courseId;
|
|
7093
|
+
currentCluster = 1;
|
|
7094
|
+
}
|
|
7095
|
+
}
|
|
7096
|
+
if (maxCluster > 3) {
|
|
7097
|
+
logger.info(`
|
|
7098
|
+
\u26A0\uFE0F Detected clustering: max ${maxCluster} cards from same course in a row`);
|
|
7099
|
+
logger.info("This suggests cards are sorted by score rather than round-robin by course.");
|
|
7100
|
+
}
|
|
7101
|
+
console.groupEnd();
|
|
7102
|
+
}
|
|
7103
|
+
function mountSessionDebugger() {
|
|
7104
|
+
if (typeof window === "undefined") return;
|
|
7105
|
+
const win = window;
|
|
7106
|
+
win.skuilder = win.skuilder || {};
|
|
7107
|
+
win.skuilder.session = sessionDebugAPI;
|
|
7108
|
+
}
|
|
7109
|
+
var activeSession, sessionHistory, sessionDebugAPI;
|
|
7110
|
+
var init_SessionDebugger = __esm({
|
|
7111
|
+
"src/study/SessionDebugger.ts"() {
|
|
7112
|
+
"use strict";
|
|
7113
|
+
init_logger();
|
|
7114
|
+
init_PipelineDebugger();
|
|
7115
|
+
init_SrsDebugger();
|
|
7116
|
+
init_StrategyPressureDebugger();
|
|
7117
|
+
init_SessionOverlay();
|
|
7118
|
+
activeSession = null;
|
|
7119
|
+
sessionHistory = [];
|
|
7120
|
+
sessionDebugAPI = {
|
|
7121
|
+
/**
|
|
7122
|
+
* Get raw session history for programmatic access.
|
|
7123
|
+
*/
|
|
7124
|
+
get sessions() {
|
|
7125
|
+
return [...sessionHistory];
|
|
7126
|
+
},
|
|
7127
|
+
/**
|
|
7128
|
+
* Get active session if any.
|
|
7129
|
+
*/
|
|
7130
|
+
get active() {
|
|
7131
|
+
return activeSession;
|
|
7132
|
+
},
|
|
7133
|
+
/**
|
|
7134
|
+
* Show current queue state.
|
|
7135
|
+
*/
|
|
7136
|
+
showQueue() {
|
|
7137
|
+
showCurrentQueue();
|
|
7138
|
+
},
|
|
7139
|
+
/**
|
|
7140
|
+
* Toggle the pinned, live-updating DOM overlay for the active controller
|
|
7141
|
+
* (queues, session hints, timer). No-ops in non-browser hosts.
|
|
7142
|
+
*/
|
|
7143
|
+
dbgOverlay() {
|
|
7144
|
+
toggleSessionOverlay();
|
|
7145
|
+
},
|
|
7146
|
+
/**
|
|
7147
|
+
* Show presentation history for current or past session.
|
|
7148
|
+
*/
|
|
7149
|
+
showHistory(sessionIndex = 0) {
|
|
7150
|
+
showPresentationHistory(sessionIndex);
|
|
7151
|
+
},
|
|
7152
|
+
/**
|
|
7153
|
+
* Analyze course interleaving pattern.
|
|
7154
|
+
*/
|
|
7155
|
+
showInterleaving(sessionIndex = 0) {
|
|
7156
|
+
showInterleaving(sessionIndex);
|
|
7157
|
+
},
|
|
7158
|
+
/**
|
|
7159
|
+
* List all tracked sessions.
|
|
7160
|
+
*/
|
|
7161
|
+
listSessions() {
|
|
7162
|
+
if (activeSession) {
|
|
7163
|
+
logger.info(`Active session: ${activeSession.sessionId} (${activeSession.presentations.length} cards presented)`);
|
|
7164
|
+
}
|
|
7165
|
+
if (sessionHistory.length === 0) {
|
|
7166
|
+
logger.info("[Session Debug] No completed sessions in history.");
|
|
7167
|
+
return;
|
|
7168
|
+
}
|
|
7169
|
+
console.table(
|
|
7170
|
+
sessionHistory.map((s, idx) => ({
|
|
7171
|
+
index: idx,
|
|
7172
|
+
id: s.sessionId.slice(-8),
|
|
7173
|
+
started: s.startTime.toLocaleTimeString(),
|
|
7174
|
+
ended: s.endTime?.toLocaleTimeString() || "incomplete",
|
|
7175
|
+
cards: s.presentations.length
|
|
7176
|
+
}))
|
|
7177
|
+
);
|
|
7178
|
+
},
|
|
7179
|
+
/**
|
|
7180
|
+
* Export session history as JSON for bug reports.
|
|
7181
|
+
*/
|
|
7182
|
+
export() {
|
|
7183
|
+
const data = {
|
|
7184
|
+
active: activeSession,
|
|
7185
|
+
history: sessionHistory
|
|
7186
|
+
};
|
|
7187
|
+
const json = JSON.stringify(data, null, 2);
|
|
7188
|
+
logger.info("[Session Debug] Session data exported. Copy the returned string or use:");
|
|
7189
|
+
logger.info(" copy(window.skuilder.session.export())");
|
|
7190
|
+
return json;
|
|
7191
|
+
},
|
|
7192
|
+
/**
|
|
7193
|
+
* Clear session history.
|
|
7194
|
+
*/
|
|
7195
|
+
clear() {
|
|
7196
|
+
sessionHistory.length = 0;
|
|
7197
|
+
logger.info("[Session Debug] Session history cleared.");
|
|
7198
|
+
},
|
|
7199
|
+
/**
|
|
7200
|
+
* Show help.
|
|
7201
|
+
*/
|
|
7202
|
+
help() {
|
|
7203
|
+
logger.info(`
|
|
7204
|
+
\u{1F3AF} Session Debug API
|
|
7205
|
+
|
|
7206
|
+
Commands:
|
|
7207
|
+
.dbgOverlay() Toggle the pinned live overlay (queues, hints, timer)
|
|
7208
|
+
.showQueue() Show current queue state (active session only)
|
|
7209
|
+
.showHistory(index?) Show presentation history (0=current/last, 1=previous, etc)
|
|
7210
|
+
.showInterleaving(index?) Analyze course interleaving pattern
|
|
7211
|
+
.listSessions() List all tracked sessions
|
|
7212
|
+
.export() Export session data as JSON for bug reports
|
|
7213
|
+
.clear() Clear session history
|
|
7214
|
+
.sessions Access raw session history array
|
|
7215
|
+
.active Access active session (if any)
|
|
7216
|
+
.help() Show this help message
|
|
7217
|
+
|
|
7218
|
+
Example:
|
|
7219
|
+
window.skuilder.session.showHistory()
|
|
7220
|
+
window.skuilder.session.showInterleaving()
|
|
7221
|
+
window.skuilder.session.showQueue()
|
|
7222
|
+
`);
|
|
7223
|
+
}
|
|
7224
|
+
};
|
|
7225
|
+
mountSessionDebugger();
|
|
7226
|
+
}
|
|
7227
|
+
});
|
|
7228
|
+
|
|
7229
|
+
// src/study/SessionController.ts
|
|
7230
|
+
var init_SessionController = __esm({
|
|
7231
|
+
"src/study/SessionController.ts"() {
|
|
7232
|
+
"use strict";
|
|
7233
|
+
init_SrsService();
|
|
7234
|
+
init_EloService();
|
|
7235
|
+
init_ResponseProcessor();
|
|
7236
|
+
init_CardHydrationService();
|
|
7237
|
+
init_ItemQueue();
|
|
7238
|
+
init_couch();
|
|
7239
|
+
init_core();
|
|
7240
|
+
init_types_legacy();
|
|
7241
|
+
init_studySession();
|
|
7242
|
+
init_recording();
|
|
7243
|
+
init_util2();
|
|
7244
|
+
init_navigators();
|
|
7245
|
+
init_Pipeline();
|
|
7246
|
+
init_SourceMixer();
|
|
7247
|
+
init_MixerDebugger();
|
|
7248
|
+
init_SessionDebugger();
|
|
7249
|
+
init_SessionOverlay();
|
|
7250
|
+
init_logger();
|
|
7251
|
+
}
|
|
7252
|
+
});
|
|
7253
|
+
|
|
7254
|
+
// src/study/TagFilteredContentSource.ts
|
|
7255
|
+
import { hasActiveFilter } from "@vue-skuilder/common";
|
|
7256
|
+
var init_TagFilteredContentSource = __esm({
|
|
7257
|
+
"src/study/TagFilteredContentSource.ts"() {
|
|
7258
|
+
"use strict";
|
|
7259
|
+
init_courseDB();
|
|
7260
|
+
init_logger();
|
|
7261
|
+
}
|
|
7262
|
+
});
|
|
7263
|
+
|
|
7264
|
+
// src/study/index.ts
|
|
7265
|
+
var init_study = __esm({
|
|
7266
|
+
"src/study/index.ts"() {
|
|
7267
|
+
"use strict";
|
|
7268
|
+
init_SessionController();
|
|
7269
|
+
init_SourceMixer();
|
|
7270
|
+
init_SpacedRepetition();
|
|
7271
|
+
init_TagFilteredContentSource();
|
|
7272
|
+
init_MixerDebugger();
|
|
7273
|
+
init_SessionDebugger();
|
|
7274
|
+
init_SessionOverlay();
|
|
7275
|
+
}
|
|
7276
|
+
});
|
|
7277
|
+
|
|
7278
|
+
// src/impl/common/userDBHelpers.ts
|
|
7279
|
+
import moment6 from "moment";
|
|
7280
|
+
function makeScheduledCardId(reviewTime) {
|
|
7281
|
+
return DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */] + moment6.utc(reviewTime).format(REVIEW_TIME_FORMAT2);
|
|
7282
|
+
}
|
|
7283
|
+
function filterAllDocsByPrefix2(db, prefix, opts) {
|
|
7284
|
+
const options = {
|
|
7285
|
+
startkey: prefix,
|
|
7286
|
+
endkey: prefix + "\uFFF0",
|
|
7287
|
+
include_docs: true
|
|
7288
|
+
};
|
|
7289
|
+
if (opts) {
|
|
7290
|
+
Object.assign(options, opts);
|
|
7291
|
+
}
|
|
7292
|
+
return db.allDocs(options);
|
|
7293
|
+
}
|
|
7294
|
+
function getStartAndEndKeys2(key) {
|
|
7295
|
+
return {
|
|
7296
|
+
startkey: key,
|
|
7297
|
+
endkey: key + "\uFFF0"
|
|
7298
|
+
};
|
|
7299
|
+
}
|
|
7300
|
+
function getLocalUserDB(username) {
|
|
7301
|
+
const dbName = `userdb-${username}`;
|
|
7302
|
+
if (typeof window === "undefined") {
|
|
7303
|
+
return new pouchdb_setup_default(getDbPath(dbName), {});
|
|
7304
|
+
} else {
|
|
7305
|
+
return new pouchdb_setup_default(dbName, {});
|
|
7306
|
+
}
|
|
7307
|
+
}
|
|
7308
|
+
function scheduleCardReviewLocal(userDB, review) {
|
|
7309
|
+
const now = moment6.utc();
|
|
7310
|
+
logger.info(`Scheduling for review in: ${review.time.diff(now, "h") / 24} days`);
|
|
7311
|
+
void userDB.put({
|
|
7312
|
+
_id: makeScheduledCardId(review.time),
|
|
7313
|
+
cardId: review.card_id,
|
|
7314
|
+
reviewTime: review.time.toISOString(),
|
|
7315
|
+
courseId: review.course_id,
|
|
7316
|
+
scheduledAt: now.toISOString(),
|
|
7317
|
+
scheduledFor: review.scheduledFor,
|
|
7318
|
+
schedulingAgentId: review.schedulingAgentId
|
|
7319
|
+
});
|
|
7320
|
+
}
|
|
7321
|
+
async function removeScheduledCardReviewLocal(userDB, reviewDocID) {
|
|
7322
|
+
const reviewDoc = await userDB.get(reviewDocID);
|
|
7323
|
+
userDB.remove(reviewDoc).then((res) => {
|
|
7324
|
+
if (res.ok) {
|
|
7325
|
+
log2(`Removed Review Doc: ${reviewDocID}`);
|
|
7326
|
+
}
|
|
7327
|
+
}).catch((err) => {
|
|
7328
|
+
log2(`Failed to remove Review Doc: ${reviewDocID},
|
|
7329
|
+
${JSON.stringify(err)}`);
|
|
7330
|
+
});
|
|
7331
|
+
}
|
|
7332
|
+
var REVIEW_TIME_FORMAT2, log2;
|
|
7333
|
+
var init_userDBHelpers = __esm({
|
|
7334
|
+
"src/impl/common/userDBHelpers.ts"() {
|
|
7335
|
+
"use strict";
|
|
7336
|
+
init_core();
|
|
7337
|
+
init_logger();
|
|
7338
|
+
init_pouchdb_setup();
|
|
7339
|
+
init_dataDirectory();
|
|
7340
|
+
REVIEW_TIME_FORMAT2 = "YYYY-MM-DD--kk:mm:ss-SSS";
|
|
7341
|
+
log2 = (s) => {
|
|
7342
|
+
logger.info(s);
|
|
7343
|
+
};
|
|
7344
|
+
}
|
|
7345
|
+
});
|
|
7346
|
+
|
|
7347
|
+
// src/impl/couch/user-course-relDB.ts
|
|
7348
|
+
import moment7 from "moment";
|
|
7349
|
+
var UsrCrsData;
|
|
7350
|
+
var init_user_course_relDB = __esm({
|
|
7351
|
+
"src/impl/couch/user-course-relDB.ts"() {
|
|
7352
|
+
"use strict";
|
|
7353
|
+
init_logger();
|
|
7354
|
+
UsrCrsData = class {
|
|
7355
|
+
user;
|
|
7356
|
+
_courseId;
|
|
7357
|
+
constructor(user, courseId) {
|
|
7358
|
+
this.user = user;
|
|
7359
|
+
this._courseId = courseId;
|
|
7360
|
+
}
|
|
7361
|
+
async getReviewsForcast(daysCount) {
|
|
7362
|
+
const time = moment7.utc().add(daysCount, "days");
|
|
7363
|
+
return this.getReviewstoDate(time);
|
|
7364
|
+
}
|
|
7365
|
+
async getPendingReviews() {
|
|
7366
|
+
const now = moment7.utc();
|
|
7367
|
+
return this.getReviewstoDate(now);
|
|
7368
|
+
}
|
|
7369
|
+
async getScheduledReviewCount() {
|
|
7370
|
+
return (await this.getPendingReviews()).length;
|
|
7371
|
+
}
|
|
7372
|
+
async getCourseSettings() {
|
|
7373
|
+
const regDoc = await this.user.getCourseRegistrationsDoc();
|
|
7374
|
+
const crsDoc = regDoc.courses.find((c) => c.courseID === this._courseId);
|
|
7375
|
+
if (crsDoc && crsDoc.settings) {
|
|
7376
|
+
return crsDoc.settings;
|
|
7377
|
+
} else {
|
|
7378
|
+
logger.warn(`no settings found during lookup on course ${this._courseId}`);
|
|
7379
|
+
return {};
|
|
7380
|
+
}
|
|
7381
|
+
}
|
|
7382
|
+
updateCourseSettings(updates) {
|
|
7383
|
+
if ("updateCourseSettings" in this.user) {
|
|
7384
|
+
void this.user.updateCourseSettings(this._courseId, updates);
|
|
7385
|
+
}
|
|
7386
|
+
}
|
|
7387
|
+
async getStrategyState(strategyKey) {
|
|
7388
|
+
return this.user.getStrategyState(this._courseId, strategyKey);
|
|
7389
|
+
}
|
|
7390
|
+
async putStrategyState(strategyKey, data) {
|
|
7391
|
+
return this.user.putStrategyState(this._courseId, strategyKey, data);
|
|
7392
|
+
}
|
|
7393
|
+
async deleteStrategyState(strategyKey) {
|
|
7394
|
+
return this.user.deleteStrategyState(this._courseId, strategyKey);
|
|
7395
|
+
}
|
|
7396
|
+
async getReviewstoDate(targetDate) {
|
|
7397
|
+
const allReviews = await this.user.getPendingReviews(this._courseId);
|
|
7398
|
+
logger.debug(
|
|
7399
|
+
`Fetching ${this.user.getUsername()}'s scheduled reviews for course ${this._courseId}.`
|
|
7400
|
+
);
|
|
7401
|
+
return allReviews.filter((review) => {
|
|
7402
|
+
const reviewTime = moment7.utc(review.reviewTime);
|
|
7403
|
+
return targetDate.isAfter(reviewTime);
|
|
7404
|
+
});
|
|
7405
|
+
}
|
|
7406
|
+
};
|
|
7407
|
+
}
|
|
7408
|
+
});
|
|
7409
|
+
|
|
7410
|
+
// src/impl/common/BaseUserDB.ts
|
|
7411
|
+
import { Status as Status3 } from "@vue-skuilder/common";
|
|
7412
|
+
import moment8 from "moment";
|
|
7413
|
+
function withTimeout(p, ms, label) {
|
|
7414
|
+
let timer;
|
|
7415
|
+
return Promise.race([
|
|
7416
|
+
p,
|
|
7417
|
+
new Promise((_resolve, reject) => {
|
|
7418
|
+
timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
|
|
7419
|
+
})
|
|
7420
|
+
]).finally(() => {
|
|
7421
|
+
if (timer !== void 0) {
|
|
7422
|
+
clearTimeout(timer);
|
|
7423
|
+
}
|
|
7424
|
+
});
|
|
7425
|
+
}
|
|
7426
|
+
function accomodateGuest() {
|
|
7427
|
+
logger.log("[funnel] accomodateGuest() called");
|
|
7428
|
+
if (typeof localStorage === "undefined") {
|
|
7429
|
+
logger.log(
|
|
7430
|
+
"[funnel] localStorage not available (Node.js environment), returning default guest"
|
|
7431
|
+
);
|
|
7432
|
+
return {
|
|
7433
|
+
username: GuestUsername + "nodejs-test",
|
|
7434
|
+
firstVisit: true
|
|
7435
|
+
};
|
|
7436
|
+
}
|
|
7437
|
+
const dbUUID = "sk-guest-uuid";
|
|
7438
|
+
let firstVisit;
|
|
7439
|
+
const existingUUID = localStorage.getItem(dbUUID);
|
|
7440
|
+
logger.log("[funnel] Checking localStorage for key:", dbUUID);
|
|
7441
|
+
logger.log("[funnel] Existing UUID value:", existingUUID);
|
|
7442
|
+
logger.log("[funnel] existingUUID !== null:", existingUUID !== null);
|
|
7443
|
+
if (existingUUID !== null) {
|
|
7444
|
+
firstVisit = false;
|
|
7445
|
+
logger.log(`[funnel] Returning guest ${existingUUID} "logging in".`);
|
|
7446
|
+
} else {
|
|
7447
|
+
firstVisit = true;
|
|
7448
|
+
logger.log("[funnel] No existing UUID, generating new one...");
|
|
7449
|
+
const uuid = generateUUID();
|
|
7450
|
+
logger.log("[funnel] Generated UUID:", uuid);
|
|
7451
|
+
logger.log("[funnel] UUID length:", uuid.length);
|
|
7452
|
+
try {
|
|
7453
|
+
localStorage.setItem(dbUUID, uuid);
|
|
7454
|
+
logger.log("[funnel] Successfully stored UUID in localStorage");
|
|
7455
|
+
const verification = localStorage.getItem(dbUUID);
|
|
7456
|
+
logger.log("[funnel] Verification read from localStorage:", verification);
|
|
7457
|
+
} catch (e) {
|
|
7458
|
+
logger.error("[funnel] ERROR storing UUID:", e);
|
|
7459
|
+
}
|
|
7460
|
+
logger.log(`[funnel] Accommodating a new guest with account: ${uuid}`);
|
|
7461
|
+
}
|
|
7462
|
+
const finalUUID = localStorage.getItem(dbUUID);
|
|
7463
|
+
const finalUsername = GuestUsername + finalUUID;
|
|
7464
|
+
logger.log("[funnel] Final UUID from localStorage:", finalUUID);
|
|
7465
|
+
logger.log("[funnel] GuestUsername constant:", GuestUsername);
|
|
7466
|
+
logger.log("[funnel] Final username to return:", finalUsername);
|
|
7467
|
+
return {
|
|
7468
|
+
username: finalUsername,
|
|
7469
|
+
firstVisit
|
|
7470
|
+
};
|
|
7471
|
+
function generateUUID() {
|
|
7472
|
+
logger.log("[funnel] Inside generateUUID()");
|
|
7473
|
+
if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
|
|
7474
|
+
const uuid2 = crypto.randomUUID();
|
|
7475
|
+
logger.log("[funnel] Generated UUID using crypto.randomUUID():", uuid2);
|
|
7476
|
+
return uuid2;
|
|
7477
|
+
}
|
|
7478
|
+
if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
|
|
7479
|
+
const bytes = new Uint8Array(16);
|
|
7480
|
+
crypto.getRandomValues(bytes);
|
|
7481
|
+
bytes[6] = bytes[6] & 15 | 64;
|
|
7482
|
+
bytes[8] = bytes[8] & 63 | 128;
|
|
7483
|
+
const uuid2 = [
|
|
7484
|
+
Array.from(bytes.slice(0, 4)).map((b) => b.toString(16).padStart(2, "0")).join(""),
|
|
7485
|
+
Array.from(bytes.slice(4, 6)).map((b) => b.toString(16).padStart(2, "0")).join(""),
|
|
7486
|
+
Array.from(bytes.slice(6, 8)).map((b) => b.toString(16).padStart(2, "0")).join(""),
|
|
7487
|
+
Array.from(bytes.slice(8, 10)).map((b) => b.toString(16).padStart(2, "0")).join(""),
|
|
7488
|
+
Array.from(bytes.slice(10, 16)).map((b) => b.toString(16).padStart(2, "0")).join("")
|
|
7489
|
+
].join("-");
|
|
7490
|
+
logger.log("[funnel] Generated UUID using crypto.getRandomValues():", uuid2);
|
|
7491
|
+
return uuid2;
|
|
7492
|
+
}
|
|
7493
|
+
logger.warn("[funnel] crypto API not available, using timestamp-based UUID (NOT SECURE)");
|
|
7494
|
+
let d = (/* @__PURE__ */ new Date()).getTime();
|
|
7495
|
+
if (typeof performance !== "undefined" && typeof performance.now === "function") {
|
|
7496
|
+
d += performance.now();
|
|
7497
|
+
}
|
|
7498
|
+
const uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
|
|
7499
|
+
const r = (d + Math.random() * 16) % 16 | 0;
|
|
7500
|
+
d = Math.floor(d / 16);
|
|
7501
|
+
return (c === "x" ? r : r & 3 | 8).toString(16);
|
|
7502
|
+
});
|
|
7503
|
+
logger.log("[funnel] Generated UUID (fallback):", uuid);
|
|
7504
|
+
return uuid;
|
|
7505
|
+
}
|
|
7506
|
+
}
|
|
7507
|
+
async function getOrCreateClassroomRegistrationsDoc(user) {
|
|
5492
7508
|
let ret;
|
|
5493
7509
|
try {
|
|
5494
7510
|
ret = await getLocalUserDB(user).get(userClassroomsDoc);
|
|
@@ -5588,6 +7604,7 @@ var init_BaseUserDB = __esm({
|
|
|
5588
7604
|
init_util();
|
|
5589
7605
|
init_types_legacy();
|
|
5590
7606
|
init_logger();
|
|
7607
|
+
init_study();
|
|
5591
7608
|
init_userDBHelpers();
|
|
5592
7609
|
init_updateQueue();
|
|
5593
7610
|
init_user_course_relDB();
|
|
@@ -5725,6 +7742,40 @@ Currently logged-in as ${this._username}.`
|
|
|
5725
7742
|
}
|
|
5726
7743
|
return loginResult;
|
|
5727
7744
|
}
|
|
7745
|
+
/**
|
|
7746
|
+
* Adopt a remote session that was established outside this client — e.g. a
|
|
7747
|
+
* backend verified a third-party sign-in (Google) and set the session cookie
|
|
7748
|
+
* on its response. Afterwards the user is logged in exactly as after
|
|
7749
|
+
* login(): username switched, guest pointer cleared, init() re-run.
|
|
7750
|
+
*
|
|
7751
|
+
* @param opts.migrateGuestData Carry the current guest account's local data
|
|
7752
|
+
* into the adopted account. Pass true for a freshly created account (as
|
|
7753
|
+
* createAccount() does), false for an existing one (as login() does).
|
|
7754
|
+
*/
|
|
7755
|
+
async adoptSession(opts) {
|
|
7756
|
+
if (!this.syncStrategy.canAuthenticate() || !this.syncStrategy.adoptSession) {
|
|
7757
|
+
throw new Error("Session adoption not supported by current sync strategy");
|
|
7758
|
+
}
|
|
7759
|
+
const guestUsername = this._username.startsWith(GuestUsername) ? this._username : void 0;
|
|
7760
|
+
if (!guestUsername) {
|
|
7761
|
+
throw new Error(`Cannot adopt a session while logged in.
|
|
7762
|
+
Log out of account ${this.getUsername()} first.`);
|
|
7763
|
+
}
|
|
7764
|
+
const result = await this.syncStrategy.adoptSession(
|
|
7765
|
+
opts.migrateGuestData ? guestUsername : void 0
|
|
7766
|
+
);
|
|
7767
|
+
if (result.ok && result.username) {
|
|
7768
|
+
log3(`Adopted session for ${result.username}`);
|
|
7769
|
+
this._username = result.username;
|
|
7770
|
+
try {
|
|
7771
|
+
localStorage.removeItem("sk-guest-uuid");
|
|
7772
|
+
} catch (e) {
|
|
7773
|
+
logger.warn("localStorage not available (Node.js environment):", e);
|
|
7774
|
+
}
|
|
7775
|
+
await this.init();
|
|
7776
|
+
}
|
|
7777
|
+
return result;
|
|
7778
|
+
}
|
|
5728
7779
|
async resetUserData() {
|
|
5729
7780
|
if (this.syncStrategy.canAuthenticate()) {
|
|
5730
7781
|
return {
|
|
@@ -5823,7 +7874,7 @@ Currently logged-in as ${this._username}.`
|
|
|
5823
7874
|
*
|
|
5824
7875
|
*/
|
|
5825
7876
|
async getActiveCards() {
|
|
5826
|
-
const keys =
|
|
7877
|
+
const keys = getStartAndEndKeys2(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */]);
|
|
5827
7878
|
const reviews = await this.remoteDB.allDocs({
|
|
5828
7879
|
startkey: keys.startkey,
|
|
5829
7880
|
endkey: keys.endkey,
|
|
@@ -5900,7 +7951,7 @@ Currently logged-in as ${this._username}.`
|
|
|
5900
7951
|
}
|
|
5901
7952
|
}
|
|
5902
7953
|
async getReviewstoDate(targetDate, course_id) {
|
|
5903
|
-
const keys =
|
|
7954
|
+
const keys = getStartAndEndKeys2(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */]);
|
|
5904
7955
|
const reviews = await this.remoteDB.allDocs({
|
|
5905
7956
|
startkey: keys.startkey,
|
|
5906
7957
|
endkey: keys.endkey,
|
|
@@ -5911,9 +7962,9 @@ Currently logged-in as ${this._username}.`
|
|
|
5911
7962
|
);
|
|
5912
7963
|
return reviews.rows.filter((r) => {
|
|
5913
7964
|
if (r.id.startsWith(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */])) {
|
|
5914
|
-
const date =
|
|
7965
|
+
const date = moment8.utc(
|
|
5915
7966
|
r.id.substr(DocTypePrefixes["SCHEDULED_CARD" /* SCHEDULED_CARD */].length),
|
|
5916
|
-
|
|
7967
|
+
REVIEW_TIME_FORMAT2
|
|
5917
7968
|
);
|
|
5918
7969
|
if (targetDate.isAfter(date)) {
|
|
5919
7970
|
if (course_id === void 0 || r.doc.courseId === course_id) {
|
|
@@ -5924,11 +7975,11 @@ Currently logged-in as ${this._username}.`
|
|
|
5924
7975
|
}).map((r) => r.doc);
|
|
5925
7976
|
}
|
|
5926
7977
|
async getReviewsForcast(daysCount, course_id) {
|
|
5927
|
-
const time =
|
|
7978
|
+
const time = moment8.utc().add(daysCount, "days");
|
|
5928
7979
|
return this.getReviewstoDate(time, course_id);
|
|
5929
7980
|
}
|
|
5930
7981
|
async getPendingReviews(course_id) {
|
|
5931
|
-
const now =
|
|
7982
|
+
const now = moment8.utc();
|
|
5932
7983
|
return this.getReviewstoDate(now, course_id);
|
|
5933
7984
|
}
|
|
5934
7985
|
async getScheduledReviewCount(course_id) {
|
|
@@ -6304,15 +8355,20 @@ Currently logged-in as ${this._username}.`
|
|
|
6304
8355
|
*/
|
|
6305
8356
|
async putCardRecord(record) {
|
|
6306
8357
|
const cardHistoryID = getCardHistoryID(record.courseID, record.cardID);
|
|
6307
|
-
record.timeStamp =
|
|
8358
|
+
record.timeStamp = moment8.utc(record.timeStamp).toString();
|
|
6308
8359
|
try {
|
|
6309
8360
|
const cardHistory = await this.update(
|
|
6310
8361
|
cardHistoryID,
|
|
6311
8362
|
function(h) {
|
|
6312
8363
|
h.records.push(record);
|
|
6313
8364
|
h.bestInterval = h.bestInterval || 0;
|
|
6314
|
-
|
|
6315
|
-
|
|
8365
|
+
if (areQuestionRecords(h)) {
|
|
8366
|
+
h.lapses = getLapses(h.records);
|
|
8367
|
+
h.streak = getStreak(h.records);
|
|
8368
|
+
} else {
|
|
8369
|
+
h.lapses = h.lapses || 0;
|
|
8370
|
+
h.streak = h.streak || 0;
|
|
8371
|
+
}
|
|
6316
8372
|
return h;
|
|
6317
8373
|
}
|
|
6318
8374
|
);
|
|
@@ -6320,7 +8376,7 @@ Currently logged-in as ${this._username}.`
|
|
|
6320
8376
|
const ret = {
|
|
6321
8377
|
...record2
|
|
6322
8378
|
};
|
|
6323
|
-
ret.timeStamp =
|
|
8379
|
+
ret.timeStamp = moment8.utc(record2.timeStamp);
|
|
6324
8380
|
return ret;
|
|
6325
8381
|
});
|
|
6326
8382
|
return cardHistory;
|
|
@@ -6421,7 +8477,7 @@ Currently logged-in as ${this._username}.`
|
|
|
6421
8477
|
if (course_id) {
|
|
6422
8478
|
filterPrefix += `-${course_id}-`;
|
|
6423
8479
|
}
|
|
6424
|
-
const docs = await
|
|
8480
|
+
const docs = await filterAllDocsByPrefix2(this.localDB, filterPrefix, {
|
|
6425
8481
|
include_docs: false
|
|
6426
8482
|
});
|
|
6427
8483
|
const ret = [];
|
|
@@ -6437,7 +8493,7 @@ Currently logged-in as ${this._username}.`
|
|
|
6437
8493
|
* @returns A promise of the cards that the user has seen in the past.
|
|
6438
8494
|
*/
|
|
6439
8495
|
async getHistory() {
|
|
6440
|
-
const cards = await
|
|
8496
|
+
const cards = await filterAllDocsByPrefix2(
|
|
6441
8497
|
this.remoteDB,
|
|
6442
8498
|
DocTypePrefixes["CARDRECORD" /* CARDRECORD */],
|
|
6443
8499
|
{
|
|
@@ -6604,7 +8660,7 @@ Currently logged-in as ${this._username}.`
|
|
|
6604
8660
|
}
|
|
6605
8661
|
async getStudySessions(courseId) {
|
|
6606
8662
|
const prefix = courseId ? `${DocTypePrefixes["STUDY_SESSION" /* STUDY_SESSION */]}::${courseId}::` : `${DocTypePrefixes["STUDY_SESSION" /* STUDY_SESSION */]}::`;
|
|
6607
|
-
const keys =
|
|
8663
|
+
const keys = getStartAndEndKeys2(prefix);
|
|
6608
8664
|
const res = await this.localDB.allDocs({
|
|
6609
8665
|
startkey: keys.startkey,
|
|
6610
8666
|
endkey: keys.endkey,
|
|
@@ -6678,16 +8734,6 @@ var init_factory = __esm({
|
|
|
6678
8734
|
}
|
|
6679
8735
|
});
|
|
6680
8736
|
|
|
6681
|
-
// src/study/TagFilteredContentSource.ts
|
|
6682
|
-
import { hasActiveFilter } from "@vue-skuilder/common";
|
|
6683
|
-
var init_TagFilteredContentSource = __esm({
|
|
6684
|
-
"src/study/TagFilteredContentSource.ts"() {
|
|
6685
|
-
"use strict";
|
|
6686
|
-
init_courseDB();
|
|
6687
|
-
init_logger();
|
|
6688
|
-
}
|
|
6689
|
-
});
|
|
6690
|
-
|
|
6691
8737
|
// src/core/interfaces/contentSource.ts
|
|
6692
8738
|
import { hasActiveFilter as hasActiveFilter2 } from "@vue-skuilder/common";
|
|
6693
8739
|
var init_contentSource = __esm({
|
|
@@ -6757,14 +8803,6 @@ var init_userOutcome = __esm({
|
|
|
6757
8803
|
}
|
|
6758
8804
|
});
|
|
6759
8805
|
|
|
6760
|
-
// src/core/types/studySession.ts
|
|
6761
|
-
var init_studySession = __esm({
|
|
6762
|
-
"src/core/types/studySession.ts"() {
|
|
6763
|
-
"use strict";
|
|
6764
|
-
init_types_legacy();
|
|
6765
|
-
}
|
|
6766
|
-
});
|
|
6767
|
-
|
|
6768
8806
|
// src/core/types/hydration.ts
|
|
6769
8807
|
var HYDRATION_MARKER_ID;
|
|
6770
8808
|
var init_hydration = __esm({
|
|
@@ -6784,7 +8822,7 @@ var init_cardProcessor = __esm({
|
|
|
6784
8822
|
});
|
|
6785
8823
|
|
|
6786
8824
|
// src/core/bulkImport/types.ts
|
|
6787
|
-
var
|
|
8825
|
+
var init_types5 = __esm({
|
|
6788
8826
|
"src/core/bulkImport/types.ts"() {
|
|
6789
8827
|
"use strict";
|
|
6790
8828
|
}
|
|
@@ -6795,7 +8833,7 @@ var init_bulkImport = __esm({
|
|
|
6795
8833
|
"src/core/bulkImport/index.ts"() {
|
|
6796
8834
|
"use strict";
|
|
6797
8835
|
init_cardProcessor();
|
|
6798
|
-
|
|
8836
|
+
init_types5();
|
|
6799
8837
|
}
|
|
6800
8838
|
});
|
|
6801
8839
|
|
|
@@ -6934,7 +8972,7 @@ var init_UserDBDebugger = __esm({
|
|
|
6934
8972
|
const rawDB = getRawDB();
|
|
6935
8973
|
if (!rawDB) return;
|
|
6936
8974
|
try {
|
|
6937
|
-
const result = await
|
|
8975
|
+
const result = await filterAllDocsByPrefix2(rawDB, DocTypePrefixes["CARDRECORD" /* CARDRECORD */]);
|
|
6938
8976
|
const cardHistories = result.rows.filter((row) => row.doc && row.doc.cardID === cardId).map((row) => row.doc);
|
|
6939
8977
|
console.group(`\u{1F3B4} Card History: ${cardId}`);
|
|
6940
8978
|
logger.info(`Total interactions: ${cardHistories.length}`);
|
|
@@ -6971,7 +9009,7 @@ var init_UserDBDebugger = __esm({
|
|
|
6971
9009
|
logger.info(`Unknown document type: ${docType}`);
|
|
6972
9010
|
return;
|
|
6973
9011
|
}
|
|
6974
|
-
const result = await
|
|
9012
|
+
const result = await filterAllDocsByPrefix2(rawDB, prefix);
|
|
6975
9013
|
console.group(`\u{1F4C4} Documents: ${docType}`);
|
|
6976
9014
|
logger.info(`Total: ${result.rows.length}`);
|
|
6977
9015
|
logger.info(`Prefix: ${prefix}`);
|
|
@@ -7154,7 +9192,7 @@ var init_core = __esm({
|
|
|
7154
9192
|
});
|
|
7155
9193
|
|
|
7156
9194
|
// src/impl/static/StaticDataUnpacker.ts
|
|
7157
|
-
var pathUtils,
|
|
9195
|
+
var pathUtils, nodeFS3, StaticDataUnpacker;
|
|
7158
9196
|
var init_StaticDataUnpacker = __esm({
|
|
7159
9197
|
"src/impl/static/StaticDataUnpacker.ts"() {
|
|
7160
9198
|
"use strict";
|
|
@@ -7171,10 +9209,10 @@ var init_StaticDataUnpacker = __esm({
|
|
|
7171
9209
|
return false;
|
|
7172
9210
|
}
|
|
7173
9211
|
};
|
|
7174
|
-
|
|
9212
|
+
nodeFS3 = null;
|
|
7175
9213
|
try {
|
|
7176
9214
|
if (typeof window === "undefined" && typeof process !== "undefined" && process.versions?.node) {
|
|
7177
|
-
|
|
9215
|
+
nodeFS3 = eval("require")("fs");
|
|
7178
9216
|
}
|
|
7179
9217
|
} catch {
|
|
7180
9218
|
}
|
|
@@ -7361,8 +9399,8 @@ var init_StaticDataUnpacker = __esm({
|
|
|
7361
9399
|
const chunkPath = `${this.basePath}/${chunk.path}`;
|
|
7362
9400
|
logger.debug(`Loading chunk from ${chunkPath}`);
|
|
7363
9401
|
let documents;
|
|
7364
|
-
if (this.isLocalPath(chunkPath) &&
|
|
7365
|
-
const fileContent = await
|
|
9402
|
+
if (this.isLocalPath(chunkPath) && nodeFS3) {
|
|
9403
|
+
const fileContent = await nodeFS3.promises.readFile(chunkPath, "utf8");
|
|
7366
9404
|
documents = JSON.parse(fileContent);
|
|
7367
9405
|
} else {
|
|
7368
9406
|
const response = await fetch(chunkPath);
|
|
@@ -7400,8 +9438,8 @@ var init_StaticDataUnpacker = __esm({
|
|
|
7400
9438
|
const indexPath = `${this.basePath}/${indexMeta.path}`;
|
|
7401
9439
|
logger.debug(`Loading index from ${indexPath}`);
|
|
7402
9440
|
let indexData;
|
|
7403
|
-
if (this.isLocalPath(indexPath) &&
|
|
7404
|
-
const fileContent = await
|
|
9441
|
+
if (this.isLocalPath(indexPath) && nodeFS3) {
|
|
9442
|
+
const fileContent = await nodeFS3.promises.readFile(indexPath, "utf8");
|
|
7405
9443
|
indexData = JSON.parse(fileContent);
|
|
7406
9444
|
} else {
|
|
7407
9445
|
const response = await fetch(indexPath);
|
|
@@ -7476,8 +9514,8 @@ var init_StaticDataUnpacker = __esm({
|
|
|
7476
9514
|
return null;
|
|
7477
9515
|
}
|
|
7478
9516
|
try {
|
|
7479
|
-
if (this.isLocalPath(attachmentPath) &&
|
|
7480
|
-
const buffer = await
|
|
9517
|
+
if (this.isLocalPath(attachmentPath) && nodeFS3) {
|
|
9518
|
+
const buffer = await nodeFS3.promises.readFile(attachmentPath);
|
|
7481
9519
|
return buffer;
|
|
7482
9520
|
} else {
|
|
7483
9521
|
const response = await fetch(attachmentPath);
|