domma-cms 1.8.46 → 1.9.0

package/plugins/crossword/public/lib/layout.js

@@ -1,199 +0,0 @@
-/**
- * Crossword - laying words out in a grid. PURE, and isomorphic: the admin
- * builder runs it in the browser for a live preview, the server runs it again
- * to check what it is given. It holds no puzzle, so it is safe to serve.
- *
- *   cleanAnswer("New York")      -> {letters: 'NEWYORK', enumeration: '3,4'}
- *   generate(words, {seed})      -> {width, height, entries, unplaced}
- *   solutionGrid(layout)         -> rows of letters ('' = a black square), or throws if entries clash
- *   numberEntries(entries)       -> entries numbered in reading order
- *
- * The generator is greedy: longest words first, each placed where it crosses
- * the most letters already down without touching any other word side by side,
- * keeping the grid as square as it can. It tries a number of shuffles from the
- * seed and keeps the best, so the same seed always gives the same grid.
- *
- * @module crossword/public/lib/layout
- */
-
-export const MAX_WORDS = 60;
-export const MAX_LETTERS = 21;
-export const MIN_LETTERS = 2;
-
-/** Letters only, upper case, accents folded; the word lengths for the clue, e.g. "(3,4)". */
-export function cleanAnswer(raw) {
-    const words = String(raw ?? '').normalize('NFKD').replace(/[̀-ͯ]/g, '').toUpperCase()
-        .split(/[\s-]+/).map(w => w.replace(/[^A-Z]/g, '')).filter(Boolean);
-    const letters = words.join('');
-    const hyphenated = /-/.test(String(raw ?? ''));
-    return {letters, enumeration: words.map(w => w.length).join(hyphenated ? '-' : ',')};
-}
-
-/** A small seeded random (mulberry32), so a seed always lays out the same grid. */
-export function seeded(seed) {
-    let a = (Number(seed) >>> 0) || 1;
-    return () => {
-        a = (a + 0x6D2B79F5) >>> 0;
-        let t = a;
-        t = Math.imul(t ^ (t >>> 15), t | 1);
-        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    };
-}
-
-const key = (r, c) => `${r},${c}`;
-const DIRS = {across: [0, 1], down: [1, 0]};
-
-/** One attempt: words in this order, placed greedily on an open board. */
-function attempt(words) {
-    const cells = new Map();   // "r,c" -> {ch, across: bool, down: bool}
-    const placed = [];
-    const unplaced = [];
-    let box = {r0: 0, r1: -1, c0: 0, c1: -1};
-
-    const at = (r, c) => cells.get(key(r, c));
-
-    function fits(w, r, c, dir) {
-        const [dr, dc] = DIRS[dir];
-        // The squares just before and after the word must be empty.
-        if (at(r - dr, c - dc) || at(r + dr * w.length, c + dc * w.length)) return -1;
-        let crossings = 0;
-        for (let i = 0; i < w.length; i++) {
-            const rr = r + dr * i;
-            const cc = c + dc * i;
-            const cell = at(rr, cc);
-            if (cell) {
-                if (cell.ch !== w[i] || cell[dir]) return -1;
-                crossings++;
-                continue;
-            }
-            // An empty square must not sit beside another word's letter (side by side, parallel).
-            if (at(rr + dc, cc + dr) || at(rr - dc, cc - dr)) return -1;
-        }
-        return crossings;
-    }
-
-    function put(w, r, c, dir, item) {
-        const [dr, dc] = DIRS[dir];
-        for (let i = 0; i < w.length; i++) {
-            const k = key(r + dr * i, c + dc * i);
-            const cell = cells.get(k) || {ch: w[i], across: false, down: false};
-            cell[dir] = true;
-            cells.set(k, cell);
-        }
-        const r1 = r + dr * (w.length - 1);
-        const c1 = c + dc * (w.length - 1);
-        box = placed.length
-            ? {r0: Math.min(box.r0, r), r1: Math.max(box.r1, r1), c0: Math.min(box.c0, c), c1: Math.max(box.c1, c1)}
-            : {r0: r, r1, c0: c, c1};
-        placed.push({...item, row: r, col: c, dir});
-    }
-
-    let queue = [...words];
-    let progress = true;
-    // Words that could not cross anything yet get another chance once more are down.
-    while (queue.length && progress) {
-        progress = false;
-        const left = [];
-        for (const item of queue) {
-            const w = item.letters;
-            if (!placed.length) { put(w, 0, 0, 'across', item); progress = true; continue; }
-            let best = null;
-            for (const [k, cell] of cells) {
-                const [cr, cc] = k.split(',').map(Number);
-                for (let i = 0; i < w.length; i++) {
-                    if (w[i] !== cell.ch) continue;
-                    for (const dir of ['across', 'down']) {
-                        if (cell[dir]) continue;
-                        const [dr, dc] = DIRS[dir];
-                        const r = cr - dr * i;
-                        const c = cc - dc * i;
-                        const crossings = fits(w, r, c, dir);
-                        if (crossings < 1) continue;
-                        const r1 = r + dr * (w.length - 1);
-                        const c1 = c + dc * (w.length - 1);
-                        const h = Math.max(box.r1, r1) - Math.min(box.r0, r) + 1;
-                        const wd = Math.max(box.c1, c1) - Math.min(box.c0, c) + 1;
-                        // More crossings, then a smaller, squarer grid.
-                        const score = crossings * 100 - (h * wd) / 4 - Math.abs(h - wd) * 2;
-                        if (!best || score > best.score) best = {score, r, c, dir};
-                    }
-                }
-            }
-            if (best) { put(w, best.r, best.c, best.dir, item); progress = true; }
-            else left.push(item);
-        }
-        queue = left;
-    }
-    unplaced.push(...queue);
-    return {placed, unplaced, box, crossings: [...cells.values()].filter(c => c.across && c.down).length};
-}
-
-/** Entries numbered in reading order: a square that starts any entry gets the next number. */
-export function numberEntries(entries) {
-    const starts = [...new Set(entries.map(e => key(e.row, e.col)))]
-        .map(k => k.split(',').map(Number)).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
-    const num = new Map(starts.map(([r, c], i) => [key(r, c), i + 1]));
-    return entries.map(e => ({...e, number: num.get(key(e.row, e.col))}))
-        .sort((a, b) => (a.dir === b.dir ? a.number - b.number : a.dir === 'across' ? -1 : 1));
-}
-
-/**
- * A layout from a list of {answer, clue}.
- *
- * @param {{answer: string, clue: string}[]} words
- * @param {{seed?: number, tries?: number}} [opts]
- * @returns {{width: number, height: number, entries: object[], unplaced: object[], seed: number}}
- */
-export function generate(words, {seed = 1, tries = 40} = {}) {
-    const items = [];
-    const seen = new Set();
-    for (const w of (words || []).slice(0, MAX_WORDS)) {
-        const {letters, enumeration} = cleanAnswer(w?.answer);
-        if (letters.length < MIN_LETTERS || letters.length > MAX_LETTERS || seen.has(letters)) continue;
-        seen.add(letters);
-        items.push({answer: String(w.answer).trim(), letters, enumeration, clue: String(w?.clue ?? '').trim()});
-    }
-    if (!items.length) return {width: 0, height: 0, entries: [], unplaced: [], seed};
-
-    const rand = seeded(seed);
-    let best = null;
-    for (let t = 0; t < Math.max(1, tries); t++) {
-        // The first try is longest-first; the rest shuffle words of similar length.
-        const order = items.map(it => ({it, k: it.letters.length + (t ? rand() * 4 : 0)})).sort((a, b) => b.k - a.k).map(x => x.it);
-        const res = attempt(order);
-        const h = res.box.r1 - res.box.r0 + 1;
-        const w = res.box.c1 - res.box.c0 + 1;
-        const score = res.placed.length * 1000 + res.crossings * 10 - h * w / 2 - Math.abs(h - w) * 3;
-        if (!best || score > best.score) best = {...res, score, h, w};
-    }
-    const entries = numberEntries(best.placed.map(p => ({
-        answer: p.answer, letters: p.letters, enumeration: p.enumeration, clue: p.clue,
-        row: p.row - best.box.r0, col: p.col - best.box.c0, dir: p.dir
-    })));
-    return {width: best.w, height: best.h, entries, unplaced: best.unplaced.map(u => ({answer: u.answer, clue: u.clue})), seed};
-}
-
-/**
- * The solution as rows of letters ('' = black). Throws when the entries do
- * not fit the size or disagree about a square - a layout from anywhere but
- * generate() is checked this way before it is saved.
- */
-export function solutionGrid({width, height, entries}) {
-    const grid = Array.from({length: height}, () => Array(width).fill(''));
-    for (const e of entries) {
-        const [dr, dc] = DIRS[e.dir] || [];
-        if (dr === undefined) throw new Error('An entry has no direction.');
-        for (let i = 0; i < e.letters.length; i++) {
-            const r = e.row + dr * i;
-            const c = e.col + dc * i;
-            if (r < 0 || c < 0 || r >= height || c >= width) throw new Error(`"${e.answer}" runs off the grid.`);
-            if (grid[r][c] && grid[r][c] !== e.letters[i]) throw new Error(`"${e.answer}" clashes with another answer.`);
-            grid[r][c] = e.letters[i];
-        }
-    }
-    return grid;
-}
-
-/** The grid's shape for the player: '#' black, '.' a square to fill - no letters. */
-export const shapeOf = (grid) => grid.map(row => row.map(ch => (ch ? '.' : '#')).join(''));

package/plugins/quiz/CLAUDE.md

@@ -1,43 +0,0 @@
-# quiz - AI Assistant Guide
-
-## Purpose
-
-Timed quizzes on the public site with name-only players and leaderboards. 1.1.0 (2026-10-21), `tier: free`,
-disabled on arrival. Sibling of `crossword`; both sit in the sidebar's Tools > Games folder (`"group": "Games"`)
-and share `plugins/_lib/games` (server) + `_lib/public/games` (browser) + `_lib/admin/games` (admin kit).
-
-## Files
-
-- `lib/quiz.js` - PURE rules: `cleanQuiz` (the only gate on what the admin saves), `isOpen`, `planPlay` (question
-  order, option order, `draw`, fixed at start), `publicQuestion` (never `correct`), `mark`, `foldAnswer`.
-- `lib/engine.js` - PURE clock: `catchUp`, `serve`, `answer`, `end`, `view`. Each mutates the play and says if it
-  changed; the route saves through `plays.change()` (locked read-modify-write).
-- `lib/store.js` - `quiz-quizzes` collection + `plays = new PlayStore('quiz-plays', {order: 'score'})`.
-- `plugin.js` - routes (header comment lists them), shortcodes, the `top-scores` notification source.
-- `public/quiz.js` - the player (domma-reactive bindings), injected on every page by `inject/body.html`. Exports
-  `mount(el, {test})`, which the admin's Test screen uses.
-- `admin/views/quiz.js` - list, editor, test and plays screens, all domma-reactive through the admin kit
-  (`mountScreen`, `wireRows`, `sortableRows`, `testScreen`, `playsScreen` in `_lib/admin/games/kit.js`). Templates
-  are strings in the JS (a templateUrl goes through `_.render`, which eats data-each `{{ }}`); the questions are an
-  `observableArray` of question models with their answers nested as `{{#each options key=id}}`.
-- Tests: `tests/plugins/games-pure.test.js`, `tests/plugins/games-api.test.js` in the CMS repo.
-
-## Contracts
-
-- **The server keeps time and marks.** A question's clock starts at `serve()` - the GET of `/public/play/:id` -
-  and only then can it be answered (`answer()` refuses an unserved one with `code: 'not-current'`). So the player
-  must GET the next question after each answer, not use the one in the answer response. `GRACE_MS` (3s) covers
-  latency; late answers are marked wrong, never refused.
-- **The play token** (`X-Play-Token`) is returned once by start and compared with `timingSafeEqual`.
-  `PlayStore.adminView` strips it and the state from everything the admin sees.
-- **Leaderboards** rank finished, unhidden plays, best per `nameKey`, score then time (`_lib/games/ranking.js`).
-- **Shortcode prefix trap:** the engine's plugin-shortcode regex is a PREFIX match, so `[quiz` also matches
-  `[quiz-leaderboard`. `quiz-leaderboard` is registered with `{priority: 5}` so it runs first. Keep it that way.
-- **Domma bindings:** a `data-on-submit` handler must return `false` synchronously - an async one returns a
-  Promise and the form submits natively (page reload).
-- Collections' API verbs are all off: nothing here is readable through `/api/v1`.
-- **Test plays** (1.1.0): `GET/POST /quizzes/:id/test` (manage) give the start screen and a play marked `test: true`,
-  for the SAVED quiz whatever its status. It is played through the ordinary `/public/play` routes. `PlayStore` leaves
-  tests out of `forGame` (so boards, places, goes-per-name and the admin list), `todayBadge` skips them,
-  `afterFinish` never notifies for one, and the next test of the game clears them (`clearTests`). `/result` answers
-  `test: true` and `wouldPlace` instead of a place. Tests: `games-api.test.js` "test plays".

package/plugins/quiz/admin/css/index.css

@@ -1,13 +0,0 @@
-/* Quiz admin - the question editor. Shared pieces are in /plugins/_lib/admin/games/games.css. */
-.qza-questions { display: flex; flex-direction: column; gap: .75rem; }
-.qza-question { border: 1px solid var(--gma-line); border-left: 4px solid var(--dm-primary); border-radius: var(--dm-radius-md, 8px);
-    padding: .85rem 1rem; display: flex; flex-direction: column; gap: .6rem; background: var(--dm-background, transparent); }
-.qza-question .form-select { width: auto; }
-.qza-answers { display: flex; flex-direction: column; gap: .4rem; }
-.qza-answer { display: flex; align-items: center; gap: .5rem; padding: .25rem .4rem; border-radius: 6px; }
-.qza-answer.is-right { background: color-mix(in srgb, var(--dm-success) 12%, transparent); }
-.qza-answer .form-input { flex: 1; min-width: 0; }
-.qza-mark { display: inline-flex; align-items: center; cursor: pointer; padding: .2rem; }
-.qza-mark input { width: 1.1rem; height: 1.1rem; accent-color: var(--dm-success); }
-.qza-fixed { flex: 1; font-weight: 500; }
-.qza-more summary { cursor: pointer; color: var(--dm-text-muted); font-size: var(--dm-text-sm); margin-bottom: .5rem; }

package/plugins/quiz/admin/templates/quiz.html

@@ -1 +0,0 @@
-<div class="gma qza" data-quiz-admin></div>