@qnroa/qtype 0.0.9 → 0.1.0

package/dist/core/parser/parseMaterial.js

@@ -1,3 +1,4 @@
+import { computeCardId } from '../cardId.js';
 import { parseMaterialFrontmatter, parseCardFrontmatter } from './frontmatter.js';
 import { textToCharPlans } from '../keystroke/index.js';
 import { validateTypingText } from '../keystroke/textNormalize.js';
@@ -20,13 +21,31 @@ export function parseMaterial(source, filePath = 'inline') {
  * Split the material body (after frontmatter) into per-card chunks,
  * one per H1. Each chunk starts with its `# heading` line and includes
  * everything up to the next H1 (or end-of-file).
+ *
+ * H1 detection is fence-aware — lines that look like `# ...` while
+ * inside a ``` ``` fenced code block are treated as body content (a
+ * shell / Python / Ruby comment), not as a new card. Without this,
+ * material files that embed code with hash comments (e.g. a regex
+ * primer's Python examples) get sliced into dozens of bogus cards
+ * whose ids leak downstream through the `<file>#<idx>` scheme.
  */
 function splitByH1(body) {
     const lines = body.split('\n');
     const chunks = [];
     let current = null;
+    let inFence = false;
     for (const line of lines) {
-        if (/^#\s+/.test(line)) {
+        // Toggle fence state on any line starting with ``` — matches the
+        // opening (with an optional language tag) and the closing (bare)
+        // form. Fence lines themselves count as body if we're already
+        // tracking a card.
+        if (/^```/.test(line)) {
+            inFence = !inFence;
+            if (current)
+                current.push(line);
+            continue;
+        }
+        if (!inFence && /^#\s+/.test(line)) {
             if (current)
                 chunks.push(current.join('\n').trim());
             current = [line];
@@ -97,6 +116,12 @@ function parseCard(chunk, defaultType, defaultTags, filePath, index) {
         return null;
     card.type = cardType;
     card.tags = tags;
+    card.id = computeCardId({
+        materialFile: filePath,
+        title: card.title,
+        answer: card.answer,
+        question: card.question,
+    });
     return card;
 }
 function dedupe(tags) {
@@ -126,7 +151,9 @@ function buildAnnotatedCard(title, body, filePath, index) {
     const h4 = extractHeadingContent(body, 4);
     const charPlans = textToCharPlans(answer);
     return {
-        id: `${filePath}#${index}`,
+        id: '', // filled in by parseCard after content is finalised
+        materialFile: filePath,
+        indexInMaterial: index,
         title: answer,
         answer,
         phonetic: h2 || undefined,
@@ -154,7 +181,9 @@ function buildArticleCard(title, body, filePath, index) {
         return null;
     const charPlans = textToCharPlans(answer);
     return {
-        id: `${filePath}#${index}`,
+        id: '', // filled in by parseCard after content is finalised
+        materialFile: filePath,
+        indexInMaterial: index,
         title,
         answer,
         // `question` carries the raw body so images render in the card
@@ -188,7 +217,9 @@ function buildQACard(title, body, filePath, index) {
         return null;
     const charPlans = textToCharPlans(answer);
     return {
-        id: `${filePath}#${index}`,
+        id: '', // filled in by parseCard after content is finalised
+        materialFile: filePath,
+        indexInMaterial: index,
         title,
         answer,
         question,

package/dist/core/typing/engine/settings.js

@@ -1,7 +1,5 @@
 export const defaultTypingSettings = {
     stopOnError: false,
-    forgiveErrors: false,
-    spaceSkipsWords: false,
     ignoreCase: false,
     ignorePunctuation: false,
     allowBackspace: true,

package/dist/core/typing/engine/stats.js

@@ -1,3 +1,4 @@
+import { round } from '../round.js';
 import { CharAttr, hasAttr } from './chars.js';
 const MS_PER_MINUTE = 60_000;
 export function computeStats(chars, position, completed, now) {
@@ -39,7 +40,3 @@ export function computeStats(chars, position, completed, now) {
         finishedAt,
     };
 }
-function round(n, digits = 2) {
-    const p = 10 ** digits;
-    return Math.round(n * p) / p;
-}

package/dist/core/typing/metrics.js

@@ -1,3 +1,4 @@
+import { round } from './round.js';
 const MS_PER_MINUTE = 60_000;
 export function computeMetrics(s, now = Date.now()) {
     const startedAt = s.startedAt ?? now;
@@ -14,7 +15,3 @@ export function computeMetrics(s, now = Date.now()) {
         elapsedMs,
     };
 }
-function round(n, digits = 2) {
-    const p = 10 ** digits;
-    return Math.round(n * p) / p;
-}

package/dist/core/typing/round.js

@@ -0,0 +1,12 @@
+/**
+ * Fixed-precision round used by the typing metrics + stats modules.
+ *
+ * Lives in its own file only because two consumers (metrics.ts /
+ * engine/stats.ts) both need it — inlining it in either place forces
+ * the other to keep a byte-identical copy, which drifted once and
+ * would drift again.
+ */
+export function round(n, digits = 2) {
+    const p = 10 ** digits;
+    return Math.round(n * p) / p;
+}

package/dist/store/index.js

@@ -41,4 +41,5 @@ export { KvStore, parseKey, getAt, setAt, unsetAt, flatten, } from './kv.js';
 export { enumValidator, nonEmptyStringValidator, boolValidator, positiveIntValidator, absolutePathValidator, predicateValidator, } from './validators.js';
 export { JsonStorage } from './storage/json.js';
 export { BrowserStorage } from './storage/browser.js';
+export { SessionStorage } from './storage/session.js';
 export { MemoryStorage } from './storage/memory.js';

package/dist/store/storage/browser.js

@@ -58,4 +58,53 @@ export class BrowserStorage {
             throw new KvError('err.kv.storage.writeFailed', { origin: this.origin, reason: e.message }, `${this.origin}: write failed — ${e.message}`);
         }
     }
+    // ─── Synchronous variants ───────────────────────────────
+    //
+    // Under the hood `localStorage` is entirely synchronous. The async
+    // signatures above exist to satisfy the shared `Storage` interface
+    // (JsonStorage / MemoryStorage), but the browser side does not need
+    // to pay the cost of a microtask for every read.
+    //
+    // React rendering cannot `await`, so the view layer (`view/state/kv`)
+    // needs to read a value at render time. Rather than have it drop
+    // through to `localStorage.getItem` directly and duplicate all the
+    // parse / validate logic below, expose sync counterparts here.
+    //
+    // Semantics match the async versions except that parse / write
+    // failures on the sync path throw plain `Error` instead of `KvError`
+    // — the view layer wants "no data / broken data" to fall back to
+    // defaults silently, which matches the existing `readBlob` behaviour.
+    /** Synchronous read. Returns `{}` on missing / unavailable /
+     *  malformed data — never throws. */
+    readSync() {
+        const ls = getLocalStorage();
+        if (!ls)
+            return {};
+        const raw = ls.getItem(this.storageKey);
+        if (!raw)
+            return {};
+        try {
+            const data = JSON.parse(raw);
+            if (data && typeof data === 'object' && !Array.isArray(data)) {
+                return data;
+            }
+        }
+        catch {
+            /* fall through */
+        }
+        return {};
+    }
+    /** Synchronous write. Silently drops quota-exceeded / private-mode
+     *  failures — the view layer treats storage as best-effort. */
+    writeSync(data) {
+        const ls = getLocalStorage();
+        if (!ls)
+            return;
+        try {
+            ls.setItem(this.storageKey, JSON.stringify(data));
+        }
+        catch {
+            /* ignore quota / private mode */
+        }
+    }
 }

package/dist/store/storage/session.js

@@ -0,0 +1,92 @@
+import { KvError } from '../types.js';
+function getSessionStorage() {
+    try {
+        const ss = globalThis
+            .sessionStorage;
+        return ss ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export class SessionStorage {
+    scope;
+    storageKey;
+    constructor(scope, storageKey = `qtype.${scope}`) {
+        this.scope = scope;
+        this.storageKey = storageKey;
+    }
+    get origin() {
+        return `sessionStorage:${this.storageKey}`;
+    }
+    async available() {
+        return getSessionStorage() !== null;
+    }
+    async read() {
+        const ss = getSessionStorage();
+        if (!ss)
+            return {};
+        const raw = ss.getItem(this.storageKey);
+        if (!raw)
+            return {};
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch (e) {
+            throw new KvError('err.kv.storage.parseFailed', { origin: this.origin, reason: e.message }, `${this.origin}: JSON parse error — ${e.message}`);
+        }
+        if (data == null)
+            return {};
+        if (typeof data !== 'object' || Array.isArray(data)) {
+            throw new KvError('err.kv.storage.parseFailed', {
+                origin: this.origin,
+                reason: `root must be a JSON object, got ${Array.isArray(data) ? 'array' : typeof data}`,
+            }, `${this.origin}: root must be a JSON object`);
+        }
+        return data;
+    }
+    async write(data) {
+        const ss = getSessionStorage();
+        if (!ss) {
+            throw new KvError('err.kv.storage.unavailable', { scope: this.scope, origin: this.origin }, `${this.origin}: sessionStorage not available`);
+        }
+        try {
+            ss.setItem(this.storageKey, JSON.stringify(data));
+        }
+        catch (e) {
+            throw new KvError('err.kv.storage.writeFailed', { origin: this.origin, reason: e.message }, `${this.origin}: write failed — ${e.message}`);
+        }
+    }
+    /** Synchronous read. Returns `{}` on missing / malformed data. */
+    readSync() {
+        const ss = getSessionStorage();
+        if (!ss)
+            return {};
+        const raw = ss.getItem(this.storageKey);
+        if (!raw)
+            return {};
+        try {
+            const data = JSON.parse(raw);
+            if (data && typeof data === 'object' && !Array.isArray(data)) {
+                return data;
+            }
+        }
+        catch {
+            /* fall through */
+        }
+        return {};
+    }
+    /** Synchronous write. Silently drops quota / private-mode errors. */
+    writeSync(data) {
+        const ss = getSessionStorage();
+        if (!ss)
+            return;
+        try {
+            ss.setItem(this.storageKey, JSON.stringify(data));
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}