@johnmorrisdotca/kazu 1.0.0 → 1.2.0

package/dist/rippleMount.js

@@ -0,0 +1,179 @@
+import { KAZU_STYLE } from "./style.js";
+import { checkRipple, progressRipple, rippleRoomSizes } from "./rippleBoard.js";
+import { decodeRipple, encodeRipple, hintRipple, newRipple, rippleFinished, setRippleValue, toggleRippleNote, undoRipple } from "./rippleGame.js";
+import { RIPPLE_PLAY_STYLE } from "./rippleStyle.js";
+import { rippleWords } from "./rippleStrings.js";
+export function mountRipple(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial };
+    let game = initial.progress ? decodeRipple(initial.progress) : null;
+    game ?? (game = newRipple(initial.board));
+    let selected = game.values.findIndex((value, cell) => game.board.clues[cell] === null);
+    if (selected < 0)
+        selected = 0;
+    let pencil = false, errors = [], message = "", dead = false;
+    const root = doc.createElement("section");
+    root.className = "rp-root";
+    const style = doc.createElement("style");
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".rp-palette") + RIPPLE_PLAY_STYLE;
+    const board = doc.createElement("div");
+    board.className = "rp-board";
+    board.setAttribute("role", "grid");
+    const status = doc.createElement("p");
+    status.className = "rp-status";
+    status.setAttribute("role", "status");
+    const help = doc.createElement("p");
+    help.className = "rp-help";
+    const controls = doc.createElement("div");
+    controls.className = "rp-controls";
+    const numpad = doc.createElement("div");
+    numpad.className = "rp-numpad";
+    numpad.setAttribute("aria-label", "Numbers");
+    root.append(style, board, status, help, numpad, controls);
+    host.append(root);
+    const words = () => rippleWords(options.language);
+    const copy = () => ({ ...game, board: { ...game.board, rooms: [...game.board.rooms], clues: [...game.board.clues] }, values: [...game.values], notes: game.notes.map(list => [...list]), history: game.history.map(turn => ({ values: [...turn.values], notes: turn.notes.map(list => [...list]) })) });
+    const changed = () => {
+        errors = [];
+        message = "";
+        render();
+        const snapshot = copy();
+        options.onChange?.(snapshot);
+        root.dispatchEvent(new CustomEvent("ripple-change", { detail: snapshot, bubbles: true }));
+        if (rippleFinished(game)) {
+            options.onFinish?.(snapshot);
+            root.dispatchEvent(new CustomEvent("ripple-finish", { detail: snapshot, bubbles: true }));
+        }
+    };
+    const enter = (value) => {
+        if (game.board.clues[selected] !== null)
+            return;
+        game = pencil ? toggleRippleNote(game, selected, value) : setRippleValue(game, selected, value);
+        changed();
+    };
+    const button = (label, action, disabled = false) => {
+        const item = doc.createElement("button");
+        item.type = "button";
+        item.className = "rp-tool";
+        item.textContent = label;
+        item.disabled = disabled;
+        item.onclick = action;
+        controls.append(item);
+        return item;
+    };
+    const render = () => {
+        if (dead)
+            return;
+        const focused = board.contains(doc.activeElement);
+        const w = words(), current = game.board, sizes = rippleRoomSizes(current), validation = progressRipple(current, game.values);
+        root.dataset.material = options.material ?? "ivory";
+        root.dataset.pieces = options.pieces ?? "ink";
+        root.classList.toggle("rp-tiles", options.pieces === "tiles");
+        root.style.setProperty("--rp-width", String(current.width));
+        board.setAttribute("aria-label", w.title);
+        board.replaceChildren();
+        for (let cell = 0; cell < current.rooms.length; cell += 1) {
+            const x = cell % current.width, y = Math.floor(cell / current.width), room = current.rooms[cell];
+            const control = doc.createElement("button");
+            control.type = "button";
+            control.className = "rp-cell";
+            if (x + 1 < current.width && current.rooms[cell + 1] !== room)
+                control.classList.add("rp-room-right");
+            if (y + 1 < current.height && current.rooms[cell + current.width] !== room)
+                control.classList.add("rp-room-bottom");
+            const clue = current.clues[cell] !== null, value = game.values[cell];
+            control.dataset.cell = String(cell);
+            control.dataset.clue = String(clue);
+            control.dataset.error = String(errors.includes(cell));
+            control.dataset.selected = String(cell === selected);
+            control.setAttribute("aria-disabled", String(clue));
+            control.tabIndex = cell === selected ? 0 : -1;
+            control.setAttribute("role", "gridcell");
+            control.setAttribute("aria-label", `${w.cell.replace("{row}", String(y + 1)).replace("{column}", String(x + 1))}, ${clue ? w.clue.replace("{value}", String(current.clues[cell])) : value ? w.entry.replace("{value}", String(value)) : game.notes[cell].length ? w.note.replace("{values}", game.notes[cell].join(", ")) : w.empty}`);
+            if (clue)
+                control.textContent = String(current.clues[cell]);
+            else if (value)
+                control.textContent = String(value);
+            else if (game.notes[cell].length) {
+                const mini = doc.createElement("span");
+                mini.className = "rp-notes";
+                for (let digit = 1; digit <= sizes[room]; digit += 1) {
+                    const span = doc.createElement("span");
+                    span.textContent = game.notes[cell].includes(digit) ? String(digit) : "";
+                    mini.append(span);
+                }
+                control.append(mini);
+            }
+            control.onclick = () => { selected = cell; render(); };
+            control.onkeydown = event => {
+                if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown"].includes(event.key)) {
+                    event.preventDefault();
+                    move(cell, event.key);
+                }
+                else if (/^[1-9]$/.test(event.key)) {
+                    event.preventDefault();
+                    enter(Number(event.key));
+                }
+                else if (event.key === "Backspace" || event.key === "Delete") {
+                    event.preventDefault();
+                    enter(0);
+                }
+                else if (event.key.toLowerCase() === "p") {
+                    event.preventDefault();
+                    pencil = !pencil;
+                    render();
+                }
+            };
+            board.append(control);
+        }
+        if (focused)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus({ preventScroll: true });
+        numpad.replaceChildren();
+        for (let digit = 1; digit <= Math.max(...sizes); digit += 1) {
+            const key = doc.createElement("button");
+            key.type = "button";
+            key.className = "rp-key";
+            key.textContent = String(digit);
+            key.disabled = digit > sizes[current.rooms[selected]];
+            key.onclick = () => enter(digit);
+            numpad.append(key);
+        }
+        status.textContent = rippleFinished(game) ? (game.helped ? `${w.won} · ${w.hint}` : w.won) : message || (validation.ok ? w.won : w.checked);
+        help.textContent = w.help;
+        controls.replaceChildren();
+        button(w.undo, () => { game = undoRipple(game); changed(); }, !game.history.length);
+        button(w.check, () => { errors = [...checkRipple(current, game.values).errors]; message = checkRipple(current, game.values).ok ? w.won : w.wrong; render(); });
+        button(w.hint, () => { const hint = hintRipple(game); if (!hint) {
+            message = w.noHint;
+            render();
+            return;
+        } game = { ...setRippleValue(game, hint.cell, hint.value), helped: true }; selected = hint.cell; changed(); message = w.hintWhy; render(); });
+        button(pencil ? `${w.pencil} ✓` : w.pencil, () => { pencil = !pencil; render(); });
+        button(w.restart, restart);
+        button(w.view, expand);
+    };
+    function move(cell, direction) {
+        const dx = direction === "ArrowLeft" ? -1 : direction === "ArrowRight" ? 1 : 0;
+        const dy = direction === "ArrowUp" ? -1 : direction === "ArrowDown" ? 1 : 0;
+        const x = cell % game.board.width, y = Math.floor(cell / game.board.width);
+        const nx = Math.min(game.board.width - 1, Math.max(0, x + dx)), ny = Math.min(game.board.height - 1, Math.max(0, y + dy));
+        selected = ny * game.board.width + nx;
+        render();
+        board.querySelector(`[data-cell="${selected}"]`)?.focus();
+    }
+    function restart() { game = newRipple(game.board); selected = game.values.findIndex((value, cell) => game.board.clues[cell] === null); changed(); }
+    function expand() {
+        const dialog = doc.createElement("dialog"), close = doc.createElement("button");
+        dialog.className = "rp-dialog";
+        close.type = "button";
+        close.className = "rp-tool rp-close";
+        close.textContent = words().close;
+        close.onclick = () => dialog.close();
+        dialog.append(close, root);
+        host.append(dialog);
+        dialog.onclose = () => { host.append(root); dialog.remove(); };
+        dialog.showModal();
+    }
+    render();
+    return { game: copy, progress: () => encodeRipple(game), restart, set: (next) => { options = { ...options, ...next }; render(); }, destroy: () => { dead = true; root.remove(); root.closest("dialog")?.remove(); } };
+}

package/dist/ripplePlay.types.d.ts

@@ -0,0 +1,23 @@
+import type { RippleBoard, RippleGame, RippleLanguage, RippleMaterial, RipplePieces } from "./ripple.types.ts";
+export type RippleDrawOptions = {
+    values?: readonly number[];
+    notes?: readonly (readonly number[])[];
+    errors?: readonly number[];
+    selected?: number | null;
+    material?: RippleMaterial;
+    pieces?: RipplePieces;
+    language?: RippleLanguage;
+};
+export type RippleMountOptions = RippleDrawOptions & {
+    board: RippleBoard;
+    progress?: string;
+    onChange?: (game: RippleGame) => void;
+    onFinish?: (game: RippleGame) => void;
+};
+export type RippleMount = {
+    game: () => RippleGame;
+    progress: () => string;
+    set: (options: RippleDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/ripplePlay.types.js

@@ -0,0 +1 @@
+export {};

package/dist/rippleSolve.d.ts

@@ -0,0 +1,6 @@
+import type { RippleBoard, RippleSolve } from "./ripple.types.ts";
+/** Counts rule-valid fillings within an explicit node budget. */
+export declare function solveRipple(board: RippleBoard, options?: {
+    limit?: number;
+    nodes?: number;
+}): RippleSolve;

package/dist/rippleSolve.js

@@ -0,0 +1,83 @@
+import { RIPPLE_MAX_NODES } from "./ripple.constants.js";
+import { isRippleBoard, rippleRoomSizes } from "./rippleBoard.js";
+/** Counts rule-valid fillings within an explicit node budget. */
+export function solveRipple(board, options = {}) {
+    if (!isRippleBoard(board))
+        throw new RangeError("Invalid Ripple Effect board");
+    const limit = options.limit ?? 2, budget = options.nodes ?? RIPPLE_MAX_NODES;
+    if (!Number.isInteger(limit) || limit < 1 || !Number.isInteger(budget) || budget < 1)
+        throw new RangeError("Invalid search bounds");
+    const sizes = rippleRoomSizes(board);
+    const values = board.clues.map(clue => clue ?? 0);
+    const roomUsed = sizes.map(() => new Set());
+    let count = 0, nodes = 0, complete = true, solution = null;
+    for (let cell = 0; cell < values.length; cell += 1) {
+        const value = values[cell];
+        if (!value)
+            continue;
+        const room = board.rooms[cell];
+        if (roomUsed[room].has(value) || conflicts(cell, value, values, board)) {
+            return { count: 0, solution: null, complete: true, nodes: 0 };
+        }
+        roomUsed[room].add(value);
+    }
+    const visit = () => {
+        if (count >= limit || !complete) {
+            complete = false;
+            return;
+        }
+        if (++nodes > budget) {
+            complete = false;
+            return;
+        }
+        let bestCell = -1, bestValues = [];
+        for (let cell = 0; cell < values.length; cell += 1) {
+            if (values[cell])
+                continue;
+            const room = board.rooms[cell];
+            const candidates = [];
+            for (let value = 1; value <= sizes[room]; value += 1) {
+                if (!roomUsed[room].has(value) && !conflicts(cell, value, values, board))
+                    candidates.push(value);
+            }
+            if (!candidates.length)
+                return;
+            if (bestCell < 0 || candidates.length < bestValues.length) {
+                bestCell = cell;
+                bestValues = candidates;
+                if (candidates.length === 1)
+                    break;
+            }
+        }
+        if (bestCell < 0) {
+            count += 1;
+            solution ?? (solution = [...values]);
+            return;
+        }
+        const room = board.rooms[bestCell];
+        for (const value of bestValues) {
+            values[bestCell] = value;
+            roomUsed[room].add(value);
+            visit();
+            roomUsed[room].delete(value);
+            values[bestCell] = 0;
+            if (!complete || count >= limit) {
+                complete = false;
+                return;
+            }
+        }
+    };
+    visit();
+    return { count, solution, complete, nodes };
+}
+function conflicts(cell, value, values, board) {
+    const x = cell % board.width, y = Math.floor(cell / board.width);
+    for (let other = 0; other < values.length; other += 1) {
+        if (values[other] !== value || other === cell)
+            continue;
+        const ox = other % board.width, oy = Math.floor(other / board.width);
+        if ((oy === y && Math.abs(ox - x) <= value) || (ox === x && Math.abs(oy - y) <= value))
+            return true;
+    }
+    return false;
+}

package/dist/rippleStrings.d.ts

@@ -0,0 +1,86 @@
+import type { RippleLanguage } from "./ripple.types.ts";
+export declare const RIPPLE_STRINGS: {
+    readonly en: {
+        readonly title: "Ripple Effect";
+        readonly help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.";
+        readonly undo: "Undo";
+        readonly check: "Check";
+        readonly hint: "Hint";
+        readonly restart: "Restart";
+        readonly pencil: "Pencil";
+        readonly won: "Every room and ripple rule is correct.";
+        readonly wrong: "Some entries break a room or ripple rule.";
+        readonly checked: "Fill the rooms and check the spacing.";
+        readonly noHint: "No single proved answer is available yet.";
+        readonly hintWhy: "This value follows from the room and spacing rules.";
+        readonly view: "Just the board";
+        readonly close: "Close";
+        readonly cell: "Row {row}, column {column}";
+        readonly clue: "clue {value}";
+        readonly empty: "empty";
+        readonly entry: "{value}";
+        readonly note: "notes {values}";
+    };
+    readonly ja: {
+        readonly title: "波及効果";
+        readonly help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。";
+        readonly undo: "戻す";
+        readonly check: "確認";
+        readonly hint: "ヒント";
+        readonly restart: "やり直す";
+        readonly pencil: "メモ";
+        readonly won: "部屋と間隔のルールをすべて満たしました。";
+        readonly wrong: "部屋か数字の間隔に誤りがあります。";
+        readonly checked: "部屋を埋めて間隔を確認してください。";
+        readonly noHint: "確定できるヒントはまだありません。";
+        readonly hintWhy: "部屋と間隔のルールから確定する数字です。";
+        readonly view: "盤だけ";
+        readonly close: "閉じる";
+        readonly cell: "{row}行{column}列";
+        readonly clue: "手がかり {value}";
+        readonly empty: "空き";
+        readonly entry: "{value}";
+        readonly note: "メモ {values}";
+    };
+};
+export declare function rippleWords(language?: RippleLanguage): {
+    readonly title: "Ripple Effect";
+    readonly help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.";
+    readonly undo: "Undo";
+    readonly check: "Check";
+    readonly hint: "Hint";
+    readonly restart: "Restart";
+    readonly pencil: "Pencil";
+    readonly won: "Every room and ripple rule is correct.";
+    readonly wrong: "Some entries break a room or ripple rule.";
+    readonly checked: "Fill the rooms and check the spacing.";
+    readonly noHint: "No single proved answer is available yet.";
+    readonly hintWhy: "This value follows from the room and spacing rules.";
+    readonly view: "Just the board";
+    readonly close: "Close";
+    readonly cell: "Row {row}, column {column}";
+    readonly clue: "clue {value}";
+    readonly empty: "empty";
+    readonly entry: "{value}";
+    readonly note: "notes {values}";
+} | {
+    readonly title: "波及効果";
+    readonly help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。";
+    readonly undo: "戻す";
+    readonly check: "確認";
+    readonly hint: "ヒント";
+    readonly restart: "やり直す";
+    readonly pencil: "メモ";
+    readonly won: "部屋と間隔のルールをすべて満たしました。";
+    readonly wrong: "部屋か数字の間隔に誤りがあります。";
+    readonly checked: "部屋を埋めて間隔を確認してください。";
+    readonly noHint: "確定できるヒントはまだありません。";
+    readonly hintWhy: "部屋と間隔のルールから確定する数字です。";
+    readonly view: "盤だけ";
+    readonly close: "閉じる";
+    readonly cell: "{row}行{column}列";
+    readonly clue: "手がかり {value}";
+    readonly empty: "空き";
+    readonly entry: "{value}";
+    readonly note: "メモ {values}";
+};

package/dist/rippleStrings.js

@@ -0,0 +1,5 @@
+export const RIPPLE_STRINGS = {
+    en: { title: "Ripple Effect", help: "Fill each room with 1 through its size. Equal numbers in a row or column need at least that many cells between them.", undo: "Undo", check: "Check", hint: "Hint", restart: "Restart", pencil: "Pencil", won: "Every room and ripple rule is correct.", wrong: "Some entries break a room or ripple rule.", checked: "Fill the rooms and check the spacing.", noHint: "No single proved answer is available yet.", hintWhy: "This value follows from the room and spacing rules.", view: "Just the board", close: "Close", cell: "Row {row}, column {column}", clue: "clue {value}", empty: "empty", entry: "{value}", note: "notes {values}" },
+    ja: { title: "波及効果", help: "部屋には1から部屋の大きさまでの数字を一つずつ入れます。同じ数字を同じ行・列に置くときは、その数字以上のマスを間に空けます。", undo: "戻す", check: "確認", hint: "ヒント", restart: "やり直す", pencil: "メモ", won: "部屋と間隔のルールをすべて満たしました。", wrong: "部屋か数字の間隔に誤りがあります。", checked: "部屋を埋めて間隔を確認してください。", noHint: "確定できるヒントはまだありません。", hintWhy: "部屋と間隔のルールから確定する数字です。", view: "盤だけ", close: "閉じる", cell: "{row}行{column}列", clue: "手がかり {value}", empty: "空き", entry: "{value}", note: "メモ {values}" },
+};
+export function rippleWords(language = "en") { return RIPPLE_STRINGS[language]; }

package/dist/rippleStyle.d.ts

@@ -0,0 +1 @@
+export declare const RIPPLE_PLAY_STYLE = ".rp-root{color:var(--kz-ink,#242621);font:inherit}.rp-board{display:grid;grid-template-columns:repeat(var(--rp-width),minmax(36px,1fr));max-width:620px;margin:auto;touch-action:manipulation}.rp-cell{position:relative;aspect-ratio:1;border:1px solid var(--rp-line);background:var(--rp-surface);color:var(--rp-ink);font:500 clamp(16px,4vw,25px) system-ui;cursor:pointer;padding:0}.rp-cell[data-clue=true]{font-weight:700}.rp-cell[data-error=true]{box-shadow:inset 0 0 0 3px #bd493f}.rp-cell[data-selected=true]{background:#dce9c9;color:#1f3021}.rp-cell:focus-visible,.rp-key:focus-visible,.rp-tool:focus-visible{outline:3px solid #466f41;outline-offset:2px;z-index:1}.rp-room-right{border-right:3px solid var(--rp-ink)}.rp-room-bottom{border-bottom:3px solid var(--rp-ink)}.rp-notes{position:absolute;inset:2px;display:grid;grid-template-columns:repeat(3,1fr);font-size:10px;line-height:1;align-items:center}.rp-controls,.rp-numpad{display:flex;gap:7px;justify-content:center;flex-wrap:wrap;margin:12px auto}.rp-tool,.rp-key{font:inherit;min-height:44px;min-width:44px;border:1px solid var(--rp-line);border-radius:10px;background:var(--rp-surface);color:var(--rp-ink);cursor:pointer}.rp-tool:disabled{opacity:.5}.rp-status{min-height:1.5em;text-align:center}.rp-help{text-align:center;font-size:.9em}.rp-dialog{border:0;border-radius:16px;padding:18px;max-width:min(94vw,720px);background:#f7f3e9}.rp-close{margin-bottom:10px}.rp-tiles .rp-cell[data-clue=true]{box-shadow:inset 0 0 0 4px #c2a875}.rp-palette{display:grid;gap:8px}.rp-root[data-material=wood]{--rp-surface:#e0bf88;--rp-line:#907044;--rp-ink:#392d1f}.rp-root[data-material=slate]{--rp-surface:#364348;--rp-line:#839397;--rp-ink:#f1eee5}.rp-root[data-material=ivory]{--rp-surface:#faf7ef;--rp-line:#cfc6b2;--rp-ink:#252824}";

package/dist/rippleStyle.js

@@ -0,0 +1 @@
+export const RIPPLE_PLAY_STYLE = `.rp-root{color:var(--kz-ink,#242621);font:inherit}.rp-board{display:grid;grid-template-columns:repeat(var(--rp-width),minmax(36px,1fr));max-width:620px;margin:auto;touch-action:manipulation}.rp-cell{position:relative;aspect-ratio:1;border:1px solid var(--rp-line);background:var(--rp-surface);color:var(--rp-ink);font:500 clamp(16px,4vw,25px) system-ui;cursor:pointer;padding:0}.rp-cell[data-clue=true]{font-weight:700}.rp-cell[data-error=true]{box-shadow:inset 0 0 0 3px #bd493f}.rp-cell[data-selected=true]{background:#dce9c9;color:#1f3021}.rp-cell:focus-visible,.rp-key:focus-visible,.rp-tool:focus-visible{outline:3px solid #466f41;outline-offset:2px;z-index:1}.rp-room-right{border-right:3px solid var(--rp-ink)}.rp-room-bottom{border-bottom:3px solid var(--rp-ink)}.rp-notes{position:absolute;inset:2px;display:grid;grid-template-columns:repeat(3,1fr);font-size:10px;line-height:1;align-items:center}.rp-controls,.rp-numpad{display:flex;gap:7px;justify-content:center;flex-wrap:wrap;margin:12px auto}.rp-tool,.rp-key{font:inherit;min-height:44px;min-width:44px;border:1px solid var(--rp-line);border-radius:10px;background:var(--rp-surface);color:var(--rp-ink);cursor:pointer}.rp-tool:disabled{opacity:.5}.rp-status{min-height:1.5em;text-align:center}.rp-help{text-align:center;font-size:.9em}.rp-dialog{border:0;border-radius:16px;padding:18px;max-width:min(94vw,720px);background:#f7f3e9}.rp-close{margin-bottom:10px}.rp-tiles .rp-cell[data-clue=true]{box-shadow:inset 0 0 0 4px #c2a875}.rp-palette{display:grid;gap:8px}.rp-root[data-material=wood]{--rp-surface:#e0bf88;--rp-line:#907044;--rp-ink:#392d1f}.rp-root[data-material=slate]{--rp-surface:#364348;--rp-line:#839397;--rp-ink:#f1eee5}.rp-root[data-material=ivory]{--rp-surface:#faf7ef;--rp-line:#cfc6b2;--rp-ink:#252824}`;

package/dist/shikaku-draw-entry.d.ts

@@ -0,0 +1,2 @@
+export { drawShikaku } from "./shikakuDraw.ts";
+export type { ShikakuDrawOptions } from "./shikakuPlay.types.ts";

package/dist/shikaku-draw-entry.js

@@ -0,0 +1 @@
+export { drawShikaku } from "./shikakuDraw.js";

package/dist/shikaku-entry.d.ts

@@ -0,0 +1,8 @@
+/** Shikaku shares Kazu's number puzzle package, with its own rectangle model. */
+export * from "./shikaku.types.ts";
+export * from "./shikaku.constants.ts";
+export * from "./shikakuBoard.ts";
+export * from "./shikakuSolve.ts";
+export * from "./shikakuGenerate.ts";
+export * from "./shikakuGame.ts";
+export * from "./shikakuPacks.ts";

package/dist/shikaku-entry.js

@@ -0,0 +1,8 @@
+/** Shikaku shares Kazu's number puzzle package, with its own rectangle model. */
+export * from "./shikaku.types.js";
+export * from "./shikaku.constants.js";
+export * from "./shikakuBoard.js";
+export * from "./shikakuSolve.js";
+export * from "./shikakuGenerate.js";
+export * from "./shikakuGame.js";
+export * from "./shikakuPacks.js";

package/dist/shikaku-play-entry.d.ts

@@ -0,0 +1,4 @@
+export { mountShikaku } from "./shikakuMount.ts";
+export { SHIKAKU_PLAY_STYLE } from "./shikakuStyle.ts";
+export { SHIKAKU_STRINGS } from "./shikakuStrings.ts";
+export type * from "./shikakuPlay.types.ts";

package/dist/shikaku-play-entry.js

@@ -0,0 +1,3 @@
+export { mountShikaku } from "./shikakuMount.js";
+export { SHIKAKU_PLAY_STYLE } from "./shikakuStyle.js";
+export { SHIKAKU_STRINGS } from "./shikakuStrings.js";

package/dist/shikaku.constants.d.ts

@@ -0,0 +1,5 @@
+/** Bounds keep custom boards and searches finite. */
+export declare const SHIKAKU_MOST_SIDE = 16;
+export declare const SHIKAKU_MOST_NODES = 100000;
+export declare const SHIKAKU_MOST_ATTEMPTS = 200;
+export declare const SHIKAKU_LEVELS: readonly ["easy", "medium", "hard"];

package/dist/shikaku.constants.js

@@ -0,0 +1,5 @@
+/** Bounds keep custom boards and searches finite. */
+export const SHIKAKU_MOST_SIDE = 16;
+export const SHIKAKU_MOST_NODES = 100000;
+export const SHIKAKU_MOST_ATTEMPTS = 200;
+export const SHIKAKU_LEVELS = ["easy", "medium", "hard"];

package/dist/shikaku.types.d.ts

@@ -0,0 +1,36 @@
+/** A rectangle uses zero-based column and row coordinates. */
+export type ShikakuRectangle = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** One area clue per rectangle; zero is an unnumbered cell. */
+export type ShikakuBoard = {
+    width: number;
+    height: number;
+    clues: readonly number[];
+};
+export type ShikakuLevel = "easy" | "medium" | "hard";
+export type ShikakuPuzzle = ShikakuBoard & {
+    seed: number;
+    level: ShikakuLevel;
+    solution: readonly ShikakuRectangle[];
+};
+export type ShikakuCheck = {
+    ok: boolean;
+    covered: number;
+    errors: readonly number[];
+};
+export type ShikakuSolve = {
+    count: number;
+    solution: readonly ShikakuRectangle[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type ShikakuGame = {
+    board: ShikakuBoard;
+    rectangles: readonly ShikakuRectangle[];
+    history: readonly (readonly ShikakuRectangle[])[];
+    helped: boolean;
+};

package/dist/shikaku.types.js

@@ -0,0 +1 @@
+export {};

package/dist/shikakuBoard.d.ts

@@ -0,0 +1,9 @@
+import type { ShikakuBoard, ShikakuCheck, ShikakuRectangle } from "./shikaku.types.ts";
+/** Whether dimensions and area clues describe a possible partition. */
+export declare function isShikakuBoard(value: unknown): value is ShikakuBoard;
+/** Cells of a bounded rectangle, or null for invalid coordinates. */
+export declare function shikakuCells(board: ShikakuBoard, r: ShikakuRectangle): number[] | null;
+/** A finished partition is checked against the rules, never against a stored answer. */
+export declare function checkShikaku(board: ShikakuBoard, rectangles: readonly ShikakuRectangle[]): ShikakuCheck;
+/** All legal rectangles for a numbered cell, in a stable order. */
+export declare function shikakuCandidates(board: ShikakuBoard, cell: number): ShikakuRectangle[];

package/dist/shikakuBoard.js

@@ -0,0 +1,59 @@
+import { SHIKAKU_MOST_SIDE } from "./shikaku.constants.js";
+/** Whether dimensions and area clues describe a possible partition. */
+export function isShikakuBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const b = value;
+    return Number.isInteger(b.width) && b.width >= 2 && b.width <= SHIKAKU_MOST_SIDE
+        && Number.isInteger(b.height) && b.height >= 2 && b.height <= SHIKAKU_MOST_SIDE
+        && Array.isArray(b.clues) && b.clues.length === b.width * b.height
+        && b.clues.every(n => Number.isInteger(n) && n >= 0 && n <= b.clues.length)
+        && b.clues.reduce((a, n) => a + n, 0) === b.clues.length;
+}
+/** Cells of a bounded rectangle, or null for invalid coordinates. */
+export function shikakuCells(board, r) {
+    if (!r || ![r.x, r.y, r.width, r.height].every(Number.isInteger)
+        || r.x < 0 || r.y < 0 || r.width < 1 || r.height < 1
+        || r.x + r.width > board.width || r.y + r.height > board.height)
+        return null;
+    return Array.from({ length: r.width * r.height }, (_, i) => (r.y + Math.floor(i / r.width)) * board.width + r.x + i % r.width);
+}
+/** A finished partition is checked against the rules, never against a stored answer. */
+export function checkShikaku(board, rectangles) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const occupied = new Set(), errors = [];
+    rectangles.forEach((r, index) => {
+        const cells = shikakuCells(board, r);
+        const clues = cells?.filter(c => board.clues[c] > 0) ?? [];
+        if (!cells || clues.length !== 1 || board.clues[clues[0]] !== cells.length
+            || cells.some(c => occupied.has(c)))
+            errors.push(index);
+        cells?.forEach(c => occupied.add(c));
+    });
+    return { ok: errors.length === 0 && occupied.size === board.clues.length, covered: occupied.size, errors };
+}
+/** All legal rectangles for a numbered cell, in a stable order. */
+export function shikakuCandidates(board, cell) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const area = board.clues[cell], out = [];
+    if (!area)
+        return out;
+    const cx = cell % board.width, cy = Math.floor(cell / board.width);
+    for (let w = 1; w <= board.width; w += 1) {
+        if (area % w)
+            continue;
+        const h = area / w;
+        if (h > board.height)
+            continue;
+        for (let y = Math.max(0, cy - h + 1); y <= Math.min(cy, board.height - h); y += 1) {
+            for (let x = Math.max(0, cx - w + 1); x <= Math.min(cx, board.width - w); x += 1) {
+                const r = { x, y, width: w, height: h };
+                if (shikakuCells(board, r).every(c => c === cell || board.clues[c] === 0))
+                    out.push(r);
+            }
+        }
+    }
+    return out;
+}

package/dist/shikakuDraw.d.ts

@@ -0,0 +1,4 @@
+import type { ShikakuBoard } from "./shikaku.types.ts";
+import type { ShikakuDrawOptions } from "./shikakuPlay.types.ts";
+/** SVG text with only the public clues and the player's rectangles. */
+export declare function drawShikaku(board: ShikakuBoard, options?: ShikakuDrawOptions): string;

package/dist/shikakuDraw.js

@@ -0,0 +1,23 @@
+import { isShikakuBoard, shikakuCells } from "./shikakuBoard.js";
+import { shikakuWords } from "./shikakuStrings.js";
+/** SVG text with only the public clues and the player's rectangles. */
+export function drawShikaku(board, options = {}) {
+    if (!isShikakuBoard(board))
+        throw new RangeError("Invalid Shikaku board");
+    const words = shikakuWords(options.language), size = 48;
+    const palettes = { ivory: ["var(--kz-paper,#fbf8f1)", "var(--kz-ink,#1f2320)", "var(--kz-grid,#cfc6b2)"], wood: ["#e5cda6", "#493e2f", "#bca582"], slate: ["#262a27", "#ece8dc", "#454a44"] };
+    const [paper, ink, grid] = palettes[options.material ?? "ivory"];
+    const marks = [];
+    for (const [index, r] of (options.rectangles ?? []).entries()) {
+        if (!shikakuCells(board, r))
+            continue;
+        const colour = options.errors?.includes(index) ? "var(--kz-bad,#b5452c)" : ink;
+        marks.push(`<rect x="${r.x * size + 3}" y="${r.y * size + 3}" width="${r.width * size - 6}" height="${r.height * size - 6}" rx="3" fill="${colour}" fill-opacity=".10" stroke="${colour}" stroke-width="2.5"/>`);
+    }
+    const cells = board.clues.map((n, c) => {
+        const x = c % board.width * size, y = Math.floor(c / board.width) * size;
+        const active = c === options.selected || c === options.anchor;
+        return `<g data-shikaku-cell="${c}"><rect x="${x}" y="${y}" width="48" height="48" fill="${active ? ink : "transparent"}" fill-opacity="${active ? ".15" : "1"}" stroke="${grid}" stroke-width="1"/>${n ? `${options.pieces === "tiles" ? `<rect x="${x + 10}" y="${y + 10}" width="28" height="28" rx="6" fill="${paper}" stroke="${grid}"/>` : ""}<text x="${x + 24}" y="${y + 25}" dominant-baseline="middle" text-anchor="middle" fill="${ink}" font-size="21" font-weight="700" font-family="system-ui,sans-serif">${n}</text>` : ""}</g>`;
+    }).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="-2 -2 ${board.width * size + 4} ${board.height * size + 4}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${cells}${marks.join("")}<rect width="${board.width * size}" height="${board.height * size}" fill="none" stroke="var(--kz-frame,#a98954)" stroke-width="2"/></svg>`;
+}

package/dist/shikakuGame.d.ts

@@ -0,0 +1,14 @@
+import type { ShikakuBoard, ShikakuGame, ShikakuRectangle } from "./shikaku.types.ts";
+/** Begin with a copy of just the public clues; a generated answer is never kept in play. */
+export declare function newShikaku(board: ShikakuBoard): ShikakuGame;
+/** Place a rectangle, replacing any it touches. Local rule errors are allowed for the player to check. */
+export declare function placeShikaku(game: ShikakuGame, rectangle: ShikakuRectangle): ShikakuGame;
+/** Remove the rectangle containing a cell. */
+export declare function removeShikaku(game: ShikakuGame, cell: number): ShikakuGame;
+export declare function undoShikaku(game: ShikakuGame): ShikakuGame;
+/** A rectangle is offered only when the remaining partition has one proved answer. */
+export declare function hintShikaku(game: ShikakuGame): ShikakuRectangle | null;
+export declare function shikakuFinished(game: ShikakuGame): boolean;
+/** Versioned public puzzle and placement data, with no hidden answer. */
+export declare function encodeShikaku(game: ShikakuGame): string;
+export declare function decodeShikaku(code: string): ShikakuGame | null;