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