@johnmorrisdotca/kazu 1.1.0 → 1.2.0

package/dist/juosanMount.js

@@ -0,0 +1,206 @@
+import { checkJuosan } from "./juosanBoard.js";
+import { decodeJuosan, encodeJuosan, hintJuosan, juosanFinished, newJuosan, restartJuosan, setJuosanMark, undoJuosan, } from "./juosanGame.js";
+import { drawJuosan } from "./juosanDraw.js";
+import { KAZU_STYLE } from "./style.js";
+import { JUOSAN_PLAY_STYLE } from "./juosanStyle.js";
+import { juosanWords } from "./juosanStrings.js";
+/** Mounts a touch, mouse, and keyboard player into an existing page element. */
+export function mountJuosan(host, initial) {
+    const doc = host.ownerDocument;
+    let options = { ...initial };
+    let game = initial.progress ? decodeJuosan(initial.progress) : null;
+    game ?? (game = newJuosan(initial.board));
+    let selected = 0;
+    let message = "";
+    let finished = juosanFinished(game);
+    let destroyed = false;
+    const root = doc.createElement("div");
+    const style = doc.createElement("style");
+    const board = doc.createElement("div");
+    const status = doc.createElement("p");
+    const tools = doc.createElement("div");
+    const help = doc.createElement("p");
+    root.className = "js-root";
+    style.textContent = KAZU_STYLE.replace(/\.kazu/g, ".js-palette") + JUOSAN_PLAY_STYLE;
+    board.className = "js-board";
+    status.className = "js-status";
+    status.setAttribute("role", "status");
+    tools.className = "js-tools";
+    help.className = "js-help";
+    root.append(style, board, status, tools, help);
+    host.append(root);
+    const copyGame = () => ({
+        ...game,
+        board: {
+            ...game.board,
+            territories: game.board.territories.map(territory => ({
+                ...territory,
+                cells: [...territory.cells],
+            })),
+        },
+        marks: [...game.marks],
+        history: game.history.map(turn => [...turn]),
+    });
+    const words = () => juosanWords(options.language);
+    const addButton = (label, action, disabled = false) => {
+        const button = doc.createElement("button");
+        button.type = "button";
+        button.textContent = label;
+        button.disabled = disabled;
+        button.onclick = action;
+        tools.append(button);
+    };
+    const changed = () => {
+        message = "";
+        const wasFinished = finished;
+        finished = juosanFinished(game);
+        render();
+        options.onChange?.(copyGame());
+        if (finished && !wasFinished)
+            options.onFinish?.(copyGame());
+    };
+    const apply = (mark) => {
+        if (finished)
+            return;
+        if (mark === 0) {
+            if (!game.marks[selected])
+                return;
+            const marks = [...game.marks];
+            marks[selected] = 0;
+            game = { ...game, marks, history: [...game.history, [...game.marks]] };
+        }
+        else {
+            game = setJuosanMark(game, selected, mark);
+        }
+        changed();
+    };
+    const restart = () => {
+        game = restartJuosan(game);
+        finished = false;
+        changed();
+    };
+    const moveSelection = (cell) => {
+        selected = Math.max(0, Math.min(game.marks.length - 1, cell));
+        render();
+        board.querySelector(`[data-cell="${selected}"]`)?.focus();
+    };
+    const onCellKey = (event, cell) => {
+        const step = {
+            ArrowLeft: -1,
+            ArrowRight: 1,
+            ArrowUp: -game.board.width,
+            ArrowDown: game.board.width,
+        }[event.key];
+        if (step !== undefined) {
+            event.preventDefault();
+            moveSelection(cell + step);
+        }
+        else if (event.key.toLowerCase() === "h") {
+            event.preventDefault();
+            selected = cell;
+            apply(1);
+        }
+        else if (event.key.toLowerCase() === "v") {
+            event.preventDefault();
+            selected = cell;
+            apply(2);
+        }
+        else if (event.key === "Delete" || event.key === "Backspace") {
+            event.preventDefault();
+            selected = cell;
+            apply(0);
+        }
+    };
+    const render = () => {
+        if (destroyed)
+            return;
+        const { board: puzzleBoard } = game;
+        const hadFocus = board.contains(doc.activeElement);
+        board.style.aspectRatio = `${puzzleBoard.width}/${puzzleBoard.height}`;
+        board.style.setProperty("--juosan-width", String(puzzleBoard.width));
+        board.style.setProperty("--juosan-height", String(puzzleBoard.height));
+        board.classList.toggle("js-palette", (options.material ?? "ivory") === "ivory");
+        board.innerHTML = drawJuosan(puzzleBoard, {
+            ...options,
+            marks: game.marks,
+            selected,
+        });
+        const cellButtons = doc.createElement("div");
+        cellButtons.className = "js-cells";
+        for (let cell = 0; cell < game.marks.length; cell += 1) {
+            const button = doc.createElement("button");
+            button.type = "button";
+            button.className = "js-cell";
+            button.tabIndex = cell === selected ? 0 : -1;
+            button.dataset.cell = String(cell);
+            button.setAttribute("aria-label", markLabel(cell));
+            button.addEventListener("click", () => {
+                selected = cell;
+                const next = game.marks[cell] === 0 ? 1 : game.marks[cell] === 1 ? 2 : 0;
+                apply(next);
+            });
+            button.addEventListener("keydown", event => onCellKey(event, cell));
+            cellButtons.append(button);
+        }
+        board.append(cellButtons);
+        if (hadFocus)
+            board.querySelector(`[data-cell="${selected}"]`)?.focus();
+        status.textContent = juosanFinished(game)
+            ? game.helped ? words().assisted : words().won
+            : message || words().ready;
+        help.textContent = words().help;
+        tools.replaceChildren();
+        addButton(words().undo, () => {
+            game = undoJuosan(game);
+            finished = juosanFinished(game);
+            changed();
+        }, game.history.length === 0);
+        addButton(words().hint, giveHint, finished);
+        addButton(words().check, checkCurrent);
+        addButton(words().restart, restart);
+    };
+    const markLabel = (cell) => {
+        const mark = game.marks[cell];
+        const kind = mark === 1
+            ? words().horizontal
+            : mark === 2 ? words().vertical : words().blank;
+        const row = Math.floor(cell / game.board.width) + 1;
+        const column = cell % game.board.width + 1;
+        return `${words().row} ${row}, ${words().column} ${column}: ${kind}`;
+    };
+    const giveHint = () => {
+        const hint = hintJuosan(game);
+        if (!hint) {
+            message = words().wrong;
+            render();
+            return;
+        }
+        selected = hint.cell;
+        game = setJuosanMark(game, hint.cell, hint.mark);
+        game = { ...game, helped: true };
+        changed();
+        message = words().hintWhy;
+        render();
+    };
+    const checkCurrent = () => {
+        const complete = game.marks.every(mark => mark !== 0);
+        message = complete && checkJuosan(game.board, game.marks).ok
+            ? words().checked
+            : words().wrong;
+        render();
+    };
+    render();
+    return {
+        game: copyGame,
+        progress: () => encodeJuosan(game),
+        restart,
+        set: (next) => {
+            options = { ...options, ...next };
+            render();
+        },
+        destroy: () => {
+            destroyed = true;
+            root.remove();
+        },
+    };
+}

package/dist/juosanPlay.types.d.ts

@@ -0,0 +1,24 @@
+import type { JuosanBoard, JuosanGame } from "./juosan.types.ts";
+export type JuosanMaterial = "ivory" | "wood" | "slate";
+export type JuosanPieces = "ink" | "tiles";
+export type JuosanLanguage = "en" | "ja";
+export type JuosanDrawOptions = {
+    marks?: JuosanGame["marks"];
+    selected?: number | null;
+    material?: JuosanMaterial;
+    pieces?: JuosanPieces;
+    language?: JuosanLanguage;
+};
+export type JuosanMountOptions = JuosanDrawOptions & {
+    board: JuosanBoard;
+    progress?: string;
+    onChange?: (game: JuosanGame) => void;
+    onFinish?: (game: JuosanGame) => void;
+};
+export type JuosanMount = {
+    game: () => JuosanGame;
+    progress: () => string;
+    set: (options: JuosanDrawOptions) => void;
+    restart: () => void;
+    destroy: () => void;
+};

package/dist/juosanPlay.types.js

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

package/dist/juosanSolve.d.ts

@@ -0,0 +1,3 @@
+import type { JuosanBoard, JuosanSolve } from "./juosan.types.ts";
+/** Counts labeled solutions up to a limit; `complete` distinguishes exhaustion from cutoff. */
+export declare function solveJuosan(board: JuosanBoard, limit?: number, maxNodes?: number): JuosanSolve;

package/dist/juosanSolve.js

@@ -0,0 +1,82 @@
+import { JUOSAN_MOST_NODES } from "./juosan.constants.js";
+import { checkJuosan, isJuosanBoard } from "./juosanBoard.js";
+/** Counts labeled solutions up to a limit; `complete` distinguishes exhaustion from cutoff. */
+export function solveJuosan(board, limit = 2, maxNodes = JUOSAN_MOST_NODES) {
+    if (!isJuosanBoard(board) ||
+        !Number.isInteger(limit) ||
+        limit < 1 ||
+        !Number.isInteger(maxNodes) ||
+        maxNodes < 1) {
+        throw new RangeError("Invalid Juosan search settings");
+    }
+    const cellCount = board.width * board.height;
+    const marks = Array(cellCount).fill(0);
+    const solutions = [];
+    const territoryAt = Array(cellCount).fill(-1);
+    board.territories.forEach((territory, index) => {
+        territory.cells.forEach(cell => {
+            territoryAt[cell] = index;
+        });
+    });
+    let nodes = 0;
+    let cutOff = false;
+    const visit = (cell) => {
+        if (solutions.length >= limit)
+            return;
+        if (nodes >= maxNodes) {
+            cutOff = true;
+            return;
+        }
+        nodes += 1;
+        if (cell === cellCount) {
+            const answer = marks;
+            if (checkJuosan(board, answer).ok)
+                solutions.push([...answer]);
+            return;
+        }
+        const x = cell % board.width;
+        const y = Math.floor(cell / board.width);
+        const territory = board.territories[territoryAt[cell]];
+        for (const mark of [1, 2]) {
+            if (mark === 2 &&
+                x >= 2 &&
+                marks[cell - 1] === 2 &&
+                marks[cell - 2] === 2) {
+                continue;
+            }
+            if (mark === 1 &&
+                y >= 2 &&
+                marks[cell - board.width] === 1 &&
+                marks[cell - 2 * board.width] === 1) {
+                continue;
+            }
+            marks[cell] = mark;
+            if (!canStillMeetDifference(territory.cells, marks, territory.difference)) {
+                marks[cell] = 0;
+                continue;
+            }
+            visit(cell + 1);
+            marks[cell] = 0;
+            if (solutions.length >= limit || cutOff)
+                return;
+        }
+    };
+    visit(0);
+    return {
+        count: solutions.length,
+        solution: solutions[0] ?? null,
+        complete: !cutOff && solutions.length < limit,
+        nodes,
+    };
+}
+function canStillMeetDifference(cells, marks, difference) {
+    if (difference === null)
+        return true;
+    const assigned = cells.filter(cell => marks[cell] !== 0);
+    const horizontal = assigned.filter(cell => marks[cell] === 1).length;
+    const vertical = assigned.length - horizontal;
+    const remaining = cells.length - assigned.length;
+    const smallestDifference = Math.max(0, Math.abs(horizontal - vertical) - remaining);
+    const largestDifference = Math.abs(horizontal - vertical) + remaining;
+    return smallestDifference <= difference && largestDifference >= difference;
+}

package/dist/juosanStrings.d.ts

@@ -0,0 +1,77 @@
+export declare const JUOSAN_STRINGS: {
+    readonly en: {
+        readonly title: "Juosan";
+        readonly ready: "Fill every cell with a horizontal or vertical mark.";
+        readonly won: "Solved.";
+        readonly assisted: "Solved with a hint.";
+        readonly help: "Click a cell to cycle through horizontal, vertical and empty. Press H / V to write; arrow keys move and Delete clears.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly restart: "Restart";
+        readonly check: "Check";
+        readonly checked: "The marks follow the rules.";
+        readonly wrong: "Some marks break a territory clue or run rule.";
+        readonly horizontal: "horizontal";
+        readonly vertical: "vertical";
+        readonly blank: "unmarked";
+        readonly row: "row";
+        readonly column: "column";
+        readonly hintWhy: "This mark follows the printed territory clue and line rules.";
+    };
+    readonly ja: {
+        readonly title: "じゅうさん";
+        readonly ready: "各マスに横線か縦線を入れます。";
+        readonly won: "できました。";
+        readonly assisted: "ヒントを使ってできました。";
+        readonly help: "マスをクリックすると、横線、縦線、空欄の順に切り替わります。H / V キーで記入し、矢印キーで移動、Delete で消します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly restart: "最初から";
+        readonly check: "確認";
+        readonly checked: "ルールに合っています。";
+        readonly wrong: "陣地の数字か線の並びを確認してください。";
+        readonly horizontal: "横線";
+        readonly vertical: "縦線";
+        readonly blank: "未記入";
+        readonly row: "行";
+        readonly column: "列";
+        readonly hintWhy: "この線は、陣地の数字と線のルールに合います。";
+    };
+};
+export declare function juosanWords(language?: "en" | "ja"): {
+    readonly title: "Juosan";
+    readonly ready: "Fill every cell with a horizontal or vertical mark.";
+    readonly won: "Solved.";
+    readonly assisted: "Solved with a hint.";
+    readonly help: "Click a cell to cycle through horizontal, vertical and empty. Press H / V to write; arrow keys move and Delete clears.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly restart: "Restart";
+    readonly check: "Check";
+    readonly checked: "The marks follow the rules.";
+    readonly wrong: "Some marks break a territory clue or run rule.";
+    readonly horizontal: "horizontal";
+    readonly vertical: "vertical";
+    readonly blank: "unmarked";
+    readonly row: "row";
+    readonly column: "column";
+    readonly hintWhy: "This mark follows the printed territory clue and line rules.";
+} | {
+    readonly title: "じゅうさん";
+    readonly ready: "各マスに横線か縦線を入れます。";
+    readonly won: "できました。";
+    readonly assisted: "ヒントを使ってできました。";
+    readonly help: "マスをクリックすると、横線、縦線、空欄の順に切り替わります。H / V キーで記入し、矢印キーで移動、Delete で消します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly restart: "最初から";
+    readonly check: "確認";
+    readonly checked: "ルールに合っています。";
+    readonly wrong: "陣地の数字か線の並びを確認してください。";
+    readonly horizontal: "横線";
+    readonly vertical: "縦線";
+    readonly blank: "未記入";
+    readonly row: "行";
+    readonly column: "列";
+    readonly hintWhy: "この線は、陣地の数字と線のルールに合います。";
+};

package/dist/juosanStrings.js

@@ -0,0 +1,43 @@
+export const JUOSAN_STRINGS = {
+    en: {
+        title: "Juosan",
+        ready: "Fill every cell with a horizontal or vertical mark.",
+        won: "Solved.",
+        assisted: "Solved with a hint.",
+        help: "Click a cell to cycle through horizontal, vertical and empty. Press H / V to write; arrow keys move and Delete clears.",
+        undo: "Undo",
+        hint: "Hint",
+        restart: "Restart",
+        check: "Check",
+        checked: "The marks follow the rules.",
+        wrong: "Some marks break a territory clue or run rule.",
+        horizontal: "horizontal",
+        vertical: "vertical",
+        blank: "unmarked",
+        row: "row",
+        column: "column",
+        hintWhy: "This mark follows the printed territory clue and line rules.",
+    },
+    ja: {
+        title: "じゅうさん",
+        ready: "各マスに横線か縦線を入れます。",
+        won: "できました。",
+        assisted: "ヒントを使ってできました。",
+        help: "マスをクリックすると、横線、縦線、空欄の順に切り替わります。H / V キーで記入し、矢印キーで移動、Delete で消します。",
+        undo: "戻す",
+        hint: "ヒント",
+        restart: "最初から",
+        check: "確認",
+        checked: "ルールに合っています。",
+        wrong: "陣地の数字か線の並びを確認してください。",
+        horizontal: "横線",
+        vertical: "縦線",
+        blank: "未記入",
+        row: "行",
+        column: "列",
+        hintWhy: "この線は、陣地の数字と線のルールに合います。",
+    },
+};
+export function juosanWords(language = "en") {
+    return JUOSAN_STRINGS[language];
+}

package/dist/juosanStyle.d.ts

@@ -0,0 +1 @@
+export declare const JUOSAN_PLAY_STYLE = ".js-board{position:relative;outline:none}.js-cells{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--juosan-width),1fr);grid-template-rows:repeat(var(--juosan-height),1fr)}.js-cell{border:0;background:transparent;color:transparent;min-width:0;min-height:0;cursor:pointer}.js-cell:focus-visible{outline:2px solid var(--kz-focus,#316c50);outline-offset:-3px}.js-tools{display:flex;gap:.5rem;flex-wrap:wrap;margin-top:.75rem}.js-tools button{font:inherit;padding:.45rem .8rem;border-radius:.5rem}.js-status{min-height:1.5em}.js-help{opacity:.8;font-size:.9em}";

package/dist/juosanStyle.js

@@ -0,0 +1 @@
+export const JUOSAN_PLAY_STYLE = `.js-board{position:relative;outline:none}.js-cells{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--juosan-width),1fr);grid-template-rows:repeat(var(--juosan-height),1fr)}.js-cell{border:0;background:transparent;color:transparent;min-width:0;min-height:0;cursor:pointer}.js-cell:focus-visible{outline:2px solid var(--kz-focus,#316c50);outline-offset:-3px}.js-tools{display:flex;gap:.5rem;flex-wrap:wrap;margin-top:.75rem}.js-tools button{font:inherit;padding:.45rem .8rem;border-radius:.5rem}.js-status{min-height:1.5em}.js-help{opacity:.8;font-size:.9em}`;

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

@@ -0,0 +1,2 @@
+export { drawKakuro } from "./kakuroDraw.ts";
+export type { KakuroDrawOptions } from "./kakuroDraw.ts";

package/dist/kakuro-draw-entry.js

@@ -0,0 +1 @@
+export { drawKakuro } from "./kakuroDraw.js";

package/dist/kakuro-entry.d.ts

@@ -0,0 +1,12 @@
+export * from "./kakuro.types.ts";
+export * from "./kakuro.constants.ts";
+export * from "./kakuroBoard.ts";
+export * from "./kakuroSolve.ts";
+export * from "./kakuroGenerate.ts";
+export * from "./kakuroGame.ts";
+export { drawKakuro } from "./kakuroDraw.ts";
+export type { KakuroDrawOptions } from "./kakuroDraw.ts";
+export { mountKakuro } from "./kakuroMount.ts";
+export { KAKURO_PLAY_STYLE } from "./kakuroStyle.ts";
+export { KAKURO_STRINGS } from "./kakuroStrings.ts";
+export type * from "./kakuroPlay.types.ts";

package/dist/kakuro-entry.js

@@ -0,0 +1,10 @@
+export * from "./kakuro.types.js";
+export * from "./kakuro.constants.js";
+export * from "./kakuroBoard.js";
+export * from "./kakuroSolve.js";
+export * from "./kakuroGenerate.js";
+export * from "./kakuroGame.js";
+export { drawKakuro } from "./kakuroDraw.js";
+export { mountKakuro } from "./kakuroMount.js";
+export { KAKURO_PLAY_STYLE } from "./kakuroStyle.js";
+export { KAKURO_STRINGS } from "./kakuroStrings.js";

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

@@ -0,0 +1,4 @@
+export { mountKakuro } from "./kakuroMount.ts";
+export { KAKURO_PLAY_STYLE } from "./kakuroStyle.ts";
+export { KAKURO_STRINGS } from "./kakuroStrings.ts";
+export type * from "./kakuroPlay.types.ts";

package/dist/kakuro-play-entry.js

@@ -0,0 +1,3 @@
+export { mountKakuro } from "./kakuroMount.js";
+export { KAKURO_PLAY_STYLE } from "./kakuroStyle.js";
+export { KAKURO_STRINGS } from "./kakuroStrings.js";

package/dist/kakuro.constants.d.ts

@@ -0,0 +1,6 @@
+export declare const KAKURO_MIN_SIDE = 3;
+export declare const KAKURO_MAX_SIDE = 10;
+export declare const KAKURO_MAX_NODES = 250000;
+export declare const KAKURO_MAX_ATTEMPTS = 120;
+export declare const KAKURO_GENERATION_ATTEMPTS = 1200;
+export declare const KAKURO_GENERATION_NODES = 1000000;

package/dist/kakuro.constants.js

@@ -0,0 +1,6 @@
+export const KAKURO_MIN_SIDE = 3;
+export const KAKURO_MAX_SIDE = 10;
+export const KAKURO_MAX_NODES = 250000;
+export const KAKURO_MAX_ATTEMPTS = 120;
+export const KAKURO_GENERATION_ATTEMPTS = 1200;
+export const KAKURO_GENERATION_NODES = 1000000;

package/dist/kakuro.types.d.ts

@@ -0,0 +1,46 @@
+export type KakuroCell = {
+    kind: "white";
+} | {
+    kind: "black";
+    across: number | null;
+    down: number | null;
+};
+export type KakuroBoard = {
+    width: number;
+    height: number;
+    cells: readonly KakuroCell[];
+};
+export type KakuroRun = {
+    direction: "across" | "down";
+    clueCell: number;
+    cells: readonly number[];
+    sum: number;
+};
+export type KakuroPuzzle = KakuroBoard & {
+    seed: number;
+    solution: readonly number[];
+};
+export type KakuroCheck = {
+    ok: boolean;
+    complete: boolean;
+    errors: readonly number[];
+};
+export type KakuroSolve = {
+    count: number;
+    solution: readonly number[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type KakuroGame = {
+    board: KakuroBoard;
+    values: readonly number[];
+    notes: readonly (readonly number[])[];
+    history: readonly {
+        values: readonly number[];
+        notes: readonly (readonly number[])[];
+    }[];
+    helped: boolean;
+};
+export type KakuroLanguage = "en" | "ja";
+export type KakuroMaterial = "ivory" | "wood" | "slate";
+export type KakuroPieces = "ink" | "tiles";

package/dist/kakuro.types.js

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

package/dist/kakuroBoard.d.ts

@@ -0,0 +1,8 @@
+import type { KakuroBoard, KakuroCheck, KakuroRun } from "./kakuro.types.ts";
+export declare function isKakuroBoard(value: unknown): value is KakuroBoard;
+export declare function kakuroRuns(board: KakuroBoard): KakuroRun[];
+/** Checks exact run sums and distinct digits independently of a stored answer. */
+export declare function checkKakuro(board: KakuroBoard, values: readonly number[]): KakuroCheck;
+/** Allows unfinished runs while flagging duplicate digits and impossible remaining totals. */
+export declare function progressKakuro(board: KakuroBoard, values: readonly number[]): KakuroCheck;
+export declare function canReach(target: number, slots: number, used: readonly number[]): boolean;