coursecode 0.1.0

package/lib/preview-routes-editing.js

@@ -0,0 +1,159 @@
+/**
+ * @file preview-routes-editing.js
+ * HTTP routing layer for editing operations.
+ * Dispatches to slide-source-editor.js (template/interaction edits)
+ * and course-writer.js (config-object edits).
+ */
+
+import {
+    editThemeToken,
+    editAssessmentSetting,
+    editInteractionField,
+    editContent,
+    editTag,
+    FileNotFoundError
+} from './slide-source-editor.js';
+import { write } from './course-writer.js';
+
+// =============================================================================
+// HTTP HELPERS
+// =============================================================================
+
+function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', chunk => body += chunk);
+        req.on('end', () => {
+            try { resolve(JSON.parse(body)); }
+            catch (err) { reject(err); }
+        });
+        req.on('error', reject);
+    });
+}
+
+function sendJson(res, status, data) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+}
+
+function handleRoute(req, res, handler) {
+    parseJsonBody(req).then(handler).catch(err => {
+        console.error('Route error:', err);
+        sendJson(res, 500, { error: err.message });
+    });
+}
+
+function sendError(res, err) {
+    if (err instanceof FileNotFoundError) {
+        sendJson(res, 404, { error: err.message });
+    } else {
+        sendJson(res, 400, { error: err.message });
+    }
+}
+
+// =============================================================================
+// ROUTE HANDLER
+// =============================================================================
+
+/**
+ * @param {Object} ctx - Shared server context
+ * @param {Object} ctx.paths - { coursePath, viteConfig }
+ * @param {string} ctx.distDir - Path to dist/
+ * @param {Function} ctx.findElementByPath - HTML element path resolver
+ */
+export function handleEditingRoutes(ctx, req, res, url) {
+    const { paths } = ctx;
+
+    // Theme palette edit
+    if (url === '/__theme-edit' && req.method === 'POST') {
+        handleRoute(req, res, ({ token, value }) => {
+            try {
+                const result = editThemeToken(paths.coursePath, token, value);
+                console.log(`   🎨 Theme ${result.action}: ${token}${value ? ` = ${value}` : ''}`);
+                sendJson(res, 200, { success: true, action: result.action });
+            } catch (err) {
+                sendError(res, err);
+            }
+        });
+        return true;
+    }
+
+    // Assessment settings edit
+    if (url === '/__edit-assessment' && req.method === 'POST') {
+        handleRoute(req, res, ({ assessmentId, field, value }) => {
+            try {
+                editAssessmentSetting(paths.coursePath, assessmentId, field, value);
+                console.log(`   📝 Assessment setting updated: ${assessmentId} -> settings.${field} = ${JSON.stringify(value)}`);
+                sendJson(res, 200, { success: true, message: `Updated settings.${field}` });
+            } catch (err) {
+                sendError(res, err);
+            }
+        });
+        return true;
+    }
+
+    // Interaction edit
+    if (url === '/__edit-interaction' && req.method === 'POST') {
+        handleRoute(req, res, ({ slideId, interactionId, field, value }) => {
+            try {
+                editInteractionField(paths.coursePath, slideId, interactionId, field, value);
+                sendJson(res, 200, { success: true, message: `Updated ${field} for ${interactionId}` });
+            } catch (err) {
+                sendError(res, err);
+            }
+        });
+        return true;
+    }
+
+    // Content edit (inner text replacement)
+    if (url === '/__edit' && req.method === 'POST') {
+        handleRoute(req, res, ({ slideFile, editPath, newText }) => {
+            try {
+                const result = editContent(paths.coursePath, slideFile, editPath, newText, ctx.findElementByPath);
+                console.log(`   ✏️  Edit saved: ${slideFile} [${editPath}]`);
+                sendJson(res, 200, { success: true, file: result.file });
+            } catch (err) {
+                sendError(res, err);
+            }
+        });
+        return true;
+    }
+
+    // Tag edit (change element tag + classes)
+    if (url === '/__edit-tag' && req.method === 'POST') {
+        handleRoute(req, res, ({ slideFile, editPath, newTag, newClasses }) => {
+            try {
+                const result = editTag(paths.coursePath, slideFile, editPath, newTag, newClasses, ctx.findElementByPath);
+                console.log(`   🏷️  Tag edit saved: ${slideFile} [${editPath}]`);
+                sendJson(res, 200, { success: true, file: result.file });
+            } catch (err) {
+                sendError(res, err);
+            }
+        });
+        return true;
+    }
+
+
+    // Unified write (course-writer)
+    if (url === '/__write' && req.method === 'POST') {
+        handleRoute(req, res, async ({ target, id, value }) => {
+            if (!target || !id || value === undefined) {
+                sendJson(res, 400, { error: 'Missing required fields: target, id, value' });
+                return;
+            }
+
+            const result = await write(paths.coursePath, target, id, value);
+
+            if (result.success) {
+                console.log(`   📝 Write [${target}]: ${id} = ${JSON.stringify(value)}`);
+                sendJson(res, 200, { success: true });
+            } else {
+                sendJson(res, 400, { error: result.error });
+            }
+        });
+        return true;
+    }
+
+
+    return false;
+}

package/lib/preview-routes-lms.js

@@ -0,0 +1,230 @@
+/**
+ * @file preview-routes-lms.js
+ * Server-side LMS state store and HTTP API for E2E testing.
+ * 
+ * The stub LMS runs in the browser (parent frame). This module holds a
+ * server-side mirror of the LMS state, pushed from the browser via
+ * POST /__lms/sync. E2E tests can then query LMS state via HTTP without
+ * needing to execute code inside the browser — verifying from the LMS
+ * perspective, not the course perspective.
+ */
+
+/**
+ * Creates a fresh LMS state store.
+ * @returns {Object} Server-side LMS state container
+ */
+export function createLmsStore() {
+    return {
+        cmiData: null,
+        activeFormat: null,
+        isInitialized: false,
+        isTerminated: false,
+        strictMode: false,
+        apiLog: [],
+        errorLog: [],
+        xapiLog: [],
+        sessionStartTime: null,
+        lastSyncTime: null
+    };
+}
+
+/**
+ * Handle LMS API routes.
+ * @param {Object} ctx - Shared server context (must include ctx.lmsStore)
+ * @param {Object} req - HTTP request
+ * @param {Object} res - HTTP response
+ * @param {string} url - Parsed URL path
+ * @returns {boolean} true if route was handled
+ */
+export function handleLmsRoutes(ctx, req, res, url) {
+    if (!url.startsWith('/__lms/')) return false;
+
+    const store = ctx.lmsStore;
+    const route = url.slice('/__lms/'.length);
+
+    // CORS headers for all LMS routes
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return true;
+    }
+
+    // POST: Browser → server state sync
+    if (route === 'sync' && req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => { body += chunk; });
+        req.on('end', () => {
+            try {
+                const data = JSON.parse(body);
+                store.cmiData = data.cmiData;
+                store.activeFormat = data.activeFormat;
+                store.isInitialized = data.isInitialized;
+                store.isTerminated = data.isTerminated;
+                store.strictMode = data.strictMode;
+                store.apiLog = data.apiLog || [];
+                store.errorLog = data.errorLog || [];
+                store.xapiLog = data.xapiLog || [];
+                store.sessionStartTime = data.sessionStartTime;
+                store.lastSyncTime = new Date().toISOString();
+                json(res, { ok: true });
+            } catch (err) {
+                json(res, { error: err.message }, 400);
+            }
+        });
+        return true;
+    }
+
+    // POST: Reset LMS state
+    if (route === 'reset' && req.method === 'POST') {
+        Object.assign(store, createLmsStore());
+        json(res, { ok: true, message: 'LMS state cleared' });
+        return true;
+    }
+
+    // POST: Configure LMS
+    if (route === 'configure' && req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => { body += chunk; });
+        req.on('end', () => {
+            try {
+                const config = JSON.parse(body);
+                if (!store.cmiData) store.cmiData = {};
+
+                if (config.learnerId !== undefined) store.cmiData['cmi.learner_id'] = config.learnerId;
+                if (config.learnerName !== undefined) store.cmiData['cmi.learner_name'] = config.learnerName;
+                if (config.mode !== undefined) store.cmiData['cmi.mode'] = config.mode;
+                if (config.credit !== undefined) store.cmiData['cmi.credit'] = config.credit;
+                if (config.strictMode !== undefined) store.strictMode = config.strictMode;
+
+                json(res, { ok: true, applied: Object.keys(config) });
+            } catch (err) {
+                json(res, { error: err.message }, 400);
+            }
+        });
+        return true;
+    }
+
+    // All remaining routes are GET
+    if (req.method !== 'GET') {
+        json(res, { error: 'Method not allowed' }, 405);
+        return true;
+    }
+
+    if (!store.cmiData) {
+        json(res, { error: 'No LMS state available yet. Course has not initialized.' }, 404);
+        return true;
+    }
+
+    switch (route) {
+        case 'state':
+            json(res, {
+                cmiData: store.cmiData,
+                format: store.activeFormat,
+                initialized: store.isInitialized,
+                terminated: store.isTerminated,
+                strict: store.strictMode,
+                lastSync: store.lastSyncTime
+            });
+            break;
+
+        case 'score':
+            json(res, {
+                raw: parseScoreValue(store.cmiData['cmi.score.raw']),
+                scaled: parseScoreValue(store.cmiData['cmi.score.scaled']),
+                min: parseScoreValue(store.cmiData['cmi.score.min']),
+                max: parseScoreValue(store.cmiData['cmi.score.max'])
+            });
+            break;
+
+        case 'completion':
+            json(res, {
+                completion: store.cmiData['cmi.completion_status'] || 'unknown',
+                success: store.cmiData['cmi.success_status'] || 'unknown'
+            });
+            break;
+
+        case 'objectives':
+            json(res, {
+                objectives: store.cmiData._objectives || {},
+                count: Object.keys(store.cmiData._objectives || {}).length
+            });
+            break;
+
+        case 'interactions':
+            json(res, {
+                interactions: store.cmiData._interactions || [],
+                count: (store.cmiData._interactions || []).length
+            });
+            break;
+
+        case 'xapi':
+            json(res, {
+                statements: store.xapiLog,
+                count: store.xapiLog.length
+            });
+            break;
+
+        case 'log':
+            json(res, {
+                entries: store.apiLog,
+                count: store.apiLog.length
+            });
+            break;
+
+        case 'errors':
+            json(res, {
+                errors: store.errorLog.filter(e => !e.isWarning),
+                warnings: store.errorLog.filter(e => e.isWarning),
+                totalErrors: store.errorLog.filter(e => !e.isWarning).length,
+                totalWarnings: store.errorLog.filter(e => e.isWarning).length
+            });
+            break;
+
+        case 'format':
+            json(res, {
+                format: store.activeFormat,
+                strict: store.strictMode
+            });
+            break;
+
+        case 'session':
+            json(res, {
+                initialized: store.isInitialized,
+                terminated: store.isTerminated,
+                format: store.activeFormat,
+                strict: store.strictMode,
+                sessionStartTime: store.sessionStartTime,
+                bookmark: store.cmiData['cmi.location'] || '',
+                entry: store.cmiData['cmi.entry'] || '',
+                exit: store.cmiData['cmi.exit'] || '',
+                sessionTime: store.cmiData['cmi.session_time'] || '',
+                totalTime: store.cmiData['cmi.total_time'] || '',
+                lastSync: store.lastSyncTime
+            });
+            break;
+
+        default:
+            json(res, { error: `Unknown LMS route: ${route}` }, 404);
+    }
+
+    return true;
+}
+
+/**
+ * Parse a SCORM score string into a number, preserving 0 and null.
+ * SCORM stores all values as strings. `"0" || null` would incorrectly discard zero scores.
+ */
+function parseScoreValue(value) {
+    if (value === undefined || value === null || value === '') return null;
+    const num = Number(value);
+    return isNaN(num) ? null : num;
+}
+
+function json(res, data, status = 200) {
+    res.writeHead(status, { 'Content-Type': 'application/json', 'Cache-Control': 'no-cache' });
+    res.end(JSON.stringify(data, null, 2));
+}