@johnmorrisdotca/kazu 1.1.0 → 1.3.0

package/dist/fillominoStrings.d.ts

@@ -0,0 +1,102 @@
+import type { FillominoLanguage } from "./fillominoPlay.types.ts";
+export declare const FILLOMINO_STRINGS: {
+    readonly en: {
+        readonly title: "Fillomino";
+        readonly help: "Fill every cell with a number. Connected regions of equal numbers must have exactly that many cells. Regions of the same size cannot touch. Arrow keys move; type a number to fill a cell. Clear removes your entry.";
+        readonly undo: "Undo";
+        readonly hint: "Hint";
+        readonly check: "Check";
+        readonly restart: "Restart";
+        readonly selectNumber: "Number";
+        readonly fill: "Enter";
+        readonly clear: "Clear";
+        readonly selected: "Selected";
+        readonly row: "Row";
+        readonly column: "column";
+        readonly empty: "empty";
+        readonly clue: "given";
+        readonly filled: "filled";
+        readonly checked: "The filled regions follow the rules so far.";
+        readonly wrong: "Some regions are too large or a clue was changed.";
+        readonly remaining: "Keep filling the empty cells.";
+        readonly solved: "Every region has the right size. Solved!";
+        readonly helped: "Solved with a hint.";
+        readonly hintWhy: "This cell follows from the only complete solution.";
+        readonly noHint: "No proved hint is available from the current entries.";
+        readonly restored: "Progress restored.";
+    };
+    readonly ja: {
+        readonly title: "フィロミノ";
+        readonly help: "すべてのマスに数字を入れます。同じ数字が上下左右につながった領域のマス数は、その数字と同じです。同じ大きさの領域は辺で接しません。矢印キーで移動し、数字を入力します。消去で入力を消します。";
+        readonly undo: "戻す";
+        readonly hint: "ヒント";
+        readonly check: "確かめる";
+        readonly restart: "やり直す";
+        readonly selectNumber: "数字";
+        readonly fill: "入力";
+        readonly clear: "消去";
+        readonly selected: "選択中";
+        readonly row: "行";
+        readonly column: "列";
+        readonly empty: "空き";
+        readonly clue: "ヒント";
+        readonly filled: "入力済み";
+        readonly checked: "ここまでの領域はルールに合っています。";
+        readonly wrong: "大きすぎる領域か、変更されたヒントがあります。";
+        readonly remaining: "空きマスを埋めましょう。";
+        readonly solved: "すべての領域の大きさが合いました。完成！";
+        readonly helped: "ヒントを使って完成！";
+        readonly hintWhy: "唯一の完成形から、このマスが決まります。";
+        readonly noHint: "現在の入力から確かなヒントを出せません。";
+        readonly restored: "続きから再開しました。";
+    };
+};
+export declare function fillominoWords(language?: FillominoLanguage): {
+    readonly title: "Fillomino";
+    readonly help: "Fill every cell with a number. Connected regions of equal numbers must have exactly that many cells. Regions of the same size cannot touch. Arrow keys move; type a number to fill a cell. Clear removes your entry.";
+    readonly undo: "Undo";
+    readonly hint: "Hint";
+    readonly check: "Check";
+    readonly restart: "Restart";
+    readonly selectNumber: "Number";
+    readonly fill: "Enter";
+    readonly clear: "Clear";
+    readonly selected: "Selected";
+    readonly row: "Row";
+    readonly column: "column";
+    readonly empty: "empty";
+    readonly clue: "given";
+    readonly filled: "filled";
+    readonly checked: "The filled regions follow the rules so far.";
+    readonly wrong: "Some regions are too large or a clue was changed.";
+    readonly remaining: "Keep filling the empty cells.";
+    readonly solved: "Every region has the right size. Solved!";
+    readonly helped: "Solved with a hint.";
+    readonly hintWhy: "This cell follows from the only complete solution.";
+    readonly noHint: "No proved hint is available from the current entries.";
+    readonly restored: "Progress restored.";
+} | {
+    readonly title: "フィロミノ";
+    readonly help: "すべてのマスに数字を入れます。同じ数字が上下左右につながった領域のマス数は、その数字と同じです。同じ大きさの領域は辺で接しません。矢印キーで移動し、数字を入力します。消去で入力を消します。";
+    readonly undo: "戻す";
+    readonly hint: "ヒント";
+    readonly check: "確かめる";
+    readonly restart: "やり直す";
+    readonly selectNumber: "数字";
+    readonly fill: "入力";
+    readonly clear: "消去";
+    readonly selected: "選択中";
+    readonly row: "行";
+    readonly column: "列";
+    readonly empty: "空き";
+    readonly clue: "ヒント";
+    readonly filled: "入力済み";
+    readonly checked: "ここまでの領域はルールに合っています。";
+    readonly wrong: "大きすぎる領域か、変更されたヒントがあります。";
+    readonly remaining: "空きマスを埋めましょう。";
+    readonly solved: "すべての領域の大きさが合いました。完成！";
+    readonly helped: "ヒントを使って完成！";
+    readonly hintWhy: "唯一の完成形から、このマスが決まります。";
+    readonly noHint: "現在の入力から確かなヒントを出せません。";
+    readonly restored: "続きから再開しました。";
+};

package/dist/fillominoStrings.js

@@ -0,0 +1,13 @@
+export const FILLOMINO_STRINGS = {
+    en: {
+        title: "Fillomino", help: "Fill every cell with a number. Connected regions of equal numbers must have exactly that many cells. Regions of the same size cannot touch. Arrow keys move; type a number to fill a cell. Clear removes your entry.",
+        undo: "Undo", hint: "Hint", check: "Check", restart: "Restart", selectNumber: "Number", fill: "Enter", clear: "Clear", selected: "Selected", row: "Row", column: "column", empty: "empty", clue: "given", filled: "filled", checked: "The filled regions follow the rules so far.", wrong: "Some regions are too large or a clue was changed.", remaining: "Keep filling the empty cells.", solved: "Every region has the right size. Solved!", helped: "Solved with a hint.", hintWhy: "This cell follows from the only complete solution.", noHint: "No proved hint is available from the current entries.", restored: "Progress restored.",
+    },
+    ja: {
+        title: "フィロミノ", help: "すべてのマスに数字を入れます。同じ数字が上下左右につながった領域のマス数は、その数字と同じです。同じ大きさの領域は辺で接しません。矢印キーで移動し、数字を入力します。消去で入力を消します。",
+        undo: "戻す", hint: "ヒント", check: "確かめる", restart: "やり直す", selectNumber: "数字", fill: "入力", clear: "消去", selected: "選択中", row: "行", column: "列", empty: "空き", clue: "ヒント", filled: "入力済み", checked: "ここまでの領域はルールに合っています。", wrong: "大きすぎる領域か、変更されたヒントがあります。", remaining: "空きマスを埋めましょう。", solved: "すべての領域の大きさが合いました。完成！", helped: "ヒントを使って完成！", hintWhy: "唯一の完成形から、このマスが決まります。", noHint: "現在の入力から確かなヒントを出せません。", restored: "続きから再開しました。",
+    },
+};
+export function fillominoWords(language = "en") {
+    return FILLOMINO_STRINGS[language];
+}

package/dist/fillominoStyle.d.ts

@@ -0,0 +1 @@
+export declare const FILLOMINO_PLAY_STYLE = "\n.fillomino-play{font:1rem/1.45 system-ui,sans-serif;color:var(--kz-ink,#202521);max-width:58rem;margin:auto}\n.fillomino-status{min-height:1.5em;text-align:center;font-weight:600}\n.fillomino-board{width:min(100%,42rem);margin:1rem auto}\n.fillomino-drawing{position:relative}\n.fillomino-cells{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--fillomino-width),1fr);grid-template-rows:repeat(var(--fillomino-height),1fr)}\n.fillomino-cell{min-width:0;min-height:0;border:0;background:transparent;color:transparent;cursor:pointer}\n.fillomino-cell:focus-visible{outline:3px solid #b5963d;outline-offset:-3px}\n.fillomino-controls{display:flex;flex-wrap:wrap;align-items:center;justify-content:center;gap:.5rem;margin:1rem auto}\n.fillomino-controls button,.fillomino-controls select{font:inherit;min-height:2.75rem;padding:.45rem .8rem;border:1px solid var(--kz-grid,#cfc6b2);border-radius:.55rem;background:var(--kz-paper,#fbf8f1);color:inherit}\n.fillomino-number-label{display:flex;align-items:center;gap:.45rem}\n@media(max-width:700px){.fillomino-controls{gap:.35rem}.fillomino-controls button{flex:1 1 28%}}\n";

package/dist/fillominoStyle.js

@@ -0,0 +1,13 @@
+export const FILLOMINO_PLAY_STYLE = `
+.fillomino-play{font:1rem/1.45 system-ui,sans-serif;color:var(--kz-ink,#202521);max-width:58rem;margin:auto}
+.fillomino-status{min-height:1.5em;text-align:center;font-weight:600}
+.fillomino-board{width:min(100%,42rem);margin:1rem auto}
+.fillomino-drawing{position:relative}
+.fillomino-cells{position:absolute;inset:0;display:grid;grid-template-columns:repeat(var(--fillomino-width),1fr);grid-template-rows:repeat(var(--fillomino-height),1fr)}
+.fillomino-cell{min-width:0;min-height:0;border:0;background:transparent;color:transparent;cursor:pointer}
+.fillomino-cell:focus-visible{outline:3px solid #b5963d;outline-offset:-3px}
+.fillomino-controls{display:flex;flex-wrap:wrap;align-items:center;justify-content:center;gap:.5rem;margin:1rem auto}
+.fillomino-controls button,.fillomino-controls select{font:inherit;min-height:2.75rem;padding:.45rem .8rem;border:1px solid var(--kz-grid,#cfc6b2);border-radius:.55rem;background:var(--kz-paper,#fbf8f1);color:inherit}
+.fillomino-number-label{display:flex;align-items:center;gap:.45rem}
+@media(max-width:700px){.fillomino-controls{gap:.35rem}.fillomino-controls button{flex:1 1 28%}}
+`;

package/dist/fillominoWorker.d.ts

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

package/dist/fillominoWorker.js

@@ -0,0 +1,10 @@
+import { generateFillomino } from "./fillominoGenerate.js";
+self.onmessage = (event) => {
+    try {
+        const { width, height, level, seed } = event.data;
+        self.postMessage({ puzzle: generateFillomino(width, height, level, seed) });
+    }
+    catch (error) {
+        self.postMessage({ error: error instanceof Error ? error.message : String(error) });
+    }
+};

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

@@ -0,0 +1,2 @@
+export { drawHeyawake } from "./heyawakeDraw.ts";
+export type { HeyawakeDrawOptions } from "./heyawakePlay.types.ts";

package/dist/heyawake-draw-entry.js

@@ -0,0 +1 @@
+export { drawHeyawake } from "./heyawakeDraw.js";

package/dist/heyawake-entry.d.ts

@@ -0,0 +1,13 @@
+/** Heyawake has its own room model alongside Kazu's number puzzles. */
+export * from "./heyawake.types.ts";
+export * from "./heyawake.constants.ts";
+export * from "./heyawakeBoard.ts";
+export * from "./heyawakeSolve.ts";
+export * from "./heyawakeGenerate.ts";
+export * from "./heyawakeGame.ts";
+export { drawHeyawake } from "./heyawakeDraw.ts";
+export type { HeyawakeDrawOptions } from "./heyawakePlay.types.ts";
+export { mountHeyawake } from "./heyawakeMount.ts";
+export { HEYAWAKE_PLAY_STYLE } from "./heyawakeStyle.ts";
+export { heyawakeWords } from "./heyawakeStrings.ts";
+export type * from "./heyawakePlay.types.ts";

package/dist/heyawake-entry.js

@@ -0,0 +1,11 @@
+/** Heyawake has its own room model alongside Kazu's number puzzles. */
+export * from "./heyawake.types.js";
+export * from "./heyawake.constants.js";
+export * from "./heyawakeBoard.js";
+export * from "./heyawakeSolve.js";
+export * from "./heyawakeGenerate.js";
+export * from "./heyawakeGame.js";
+export { drawHeyawake } from "./heyawakeDraw.js";
+export { mountHeyawake } from "./heyawakeMount.js";
+export { HEYAWAKE_PLAY_STYLE } from "./heyawakeStyle.js";
+export { heyawakeWords } from "./heyawakeStrings.js";

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

@@ -0,0 +1,2 @@
+export { mountHeyawake } from "./heyawakeMount.ts";
+export type { HeyawakeMount, HeyawakeMountOptions, HeyawakeAppearance } from "./heyawakePlay.types.ts";

package/dist/heyawake-play-entry.js

@@ -0,0 +1 @@
+export { mountHeyawake } from "./heyawakeMount.js";

package/dist/heyawake.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HEYAWAKE_MOST_SIDE = 12;
+export declare const HEYAWAKE_GENERATOR_MOST_CELLS = 25;
+export declare const HEYAWAKE_MOST_NODES = 250000;
+export declare const HEYAWAKE_MOST_ATTEMPTS = 500;
+export declare const HEYAWAKE_LEVELS: readonly ["easy", "medium", "hard"];

package/dist/heyawake.constants.js

@@ -0,0 +1,5 @@
+export const HEYAWAKE_MOST_SIDE = 12;
+export const HEYAWAKE_GENERATOR_MOST_CELLS = 25;
+export const HEYAWAKE_MOST_NODES = 250000;
+export const HEYAWAKE_MOST_ATTEMPTS = 500;
+export const HEYAWAKE_LEVELS = ["easy", "medium", "hard"];

package/dist/heyawake.types.d.ts

@@ -0,0 +1,35 @@
+export type HeyawakeRoom = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    blacks: number | null;
+};
+export type HeyawakeBoard = {
+    width: number;
+    height: number;
+    rooms: readonly HeyawakeRoom[];
+};
+export type HeyawakeLevel = "easy" | "medium" | "hard";
+export type HeyawakePuzzle = HeyawakeBoard & {
+    seed: number;
+    level: HeyawakeLevel;
+    solution: readonly boolean[];
+};
+export type HeyawakeCheck = {
+    ok: boolean;
+    complete: boolean;
+    errors: readonly number[];
+};
+export type HeyawakeSolve = {
+    count: number;
+    solution: readonly boolean[] | null;
+    complete: boolean;
+    nodes: number;
+};
+export type HeyawakeGame = {
+    board: HeyawakeBoard;
+    entries: readonly (boolean | null)[];
+    history: readonly (readonly (boolean | null)[])[];
+    helped: boolean;
+};

package/dist/heyawake.types.js

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

package/dist/heyawakeBoard.d.ts

@@ -0,0 +1,7 @@
+import type { HeyawakeBoard, HeyawakeCheck, HeyawakeRoom } from "./heyawake.types.ts";
+export declare function heyawakeCells(board: HeyawakeBoard, room: HeyawakeRoom): number[] | null;
+export declare function isHeyawakeBoard(value: unknown): value is HeyawakeBoard;
+export declare function heyawakeNeighbours(board: HeyawakeBoard, cell: number): number[];
+export declare function roomForCell(board: HeyawakeBoard): number[];
+export declare function checkHeyawake(board: HeyawakeBoard, entries: readonly (boolean | null)[]): HeyawakeCheck;
+export declare function checkRoomSpans(board: HeyawakeBoard, entries: readonly (boolean | null)[], roomIds?: number[], errors?: Set<number>): void;

package/dist/heyawakeBoard.js

@@ -0,0 +1,116 @@
+import { HEYAWAKE_MOST_SIDE } from "./heyawake.constants.js";
+export function heyawakeCells(board, room) {
+    if (!room || ![room.x, room.y, room.width, room.height].every(Number.isInteger)
+        || room.x < 0 || room.y < 0 || room.width < 1 || room.height < 1
+        || room.x + room.width > board.width || room.y + room.height > board.height)
+        return null;
+    return Array.from({ length: room.width * room.height }, (_, index) => (room.y + Math.floor(index / room.width)) * board.width + room.x + index % room.width);
+}
+export function isHeyawakeBoard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const board = value;
+    if (!Number.isInteger(board.width) || board.width < 2 || board.width > HEYAWAKE_MOST_SIDE
+        || !Number.isInteger(board.height) || board.height < 2 || board.height > HEYAWAKE_MOST_SIDE
+        || !Array.isArray(board.rooms) || board.rooms.length === 0)
+        return false;
+    const occupied = new Set();
+    for (const room of board.rooms) {
+        if (!room || typeof room !== "object"
+            || ![room.x, room.y, room.width, room.height].every(Number.isInteger)
+            || !(room.blacks === null || Number.isInteger(room.blacks) && room.blacks >= 0 && room.blacks <= room.width * room.height))
+            return false;
+        const cells = heyawakeCells(board, room);
+        if (!cells || cells.some(cell => occupied.has(cell)))
+            return false;
+        cells.forEach(cell => occupied.add(cell));
+    }
+    return occupied.size === board.width * board.height;
+}
+export function heyawakeNeighbours(board, cell) {
+    const x = cell % board.width, y = Math.floor(cell / board.width);
+    return [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]]
+        .filter(([nx, ny]) => nx >= 0 && nx < board.width && ny >= 0 && ny < board.height)
+        .map(([nx, ny]) => ny * board.width + nx);
+}
+export function roomForCell(board) {
+    const lookup = Array(board.width * board.height).fill(-1);
+    board.rooms.forEach((room, index) => heyawakeCells(board, room)?.forEach(cell => { lookup[cell] = index; }));
+    return lookup;
+}
+export function checkHeyawake(board, entries) {
+    if (!isHeyawakeBoard(board))
+        throw new RangeError("Invalid Heyawake board");
+    if (!Array.isArray(entries) || entries.length !== board.width * board.height
+        || entries.some(value => value !== true && value !== false && value !== null))
+        throw new RangeError("Invalid Heyawake entries");
+    const errors = new Set(), complete = entries.every(value => value !== null), ids = roomForCell(board);
+    for (let cell = 0; cell < entries.length; cell += 1) {
+        if (entries[cell] !== true)
+            continue;
+        if (heyawakeNeighbours(board, cell).some(next => entries[next] === true)) {
+            errors.add(cell);
+            heyawakeNeighbours(board, cell).filter(next => entries[next] === true).forEach(next => errors.add(next));
+        }
+    }
+    for (let index = 0; index < board.rooms.length; index += 1) {
+        const room = board.rooms[index];
+        const cells = heyawakeCells(board, room);
+        const marked = cells.filter(cell => entries[cell] === true).length;
+        if (room.blacks !== null && (marked > room.blacks || complete && marked !== room.blacks))
+            cells.forEach(cell => errors.add(cell));
+    }
+    if (complete) {
+        const white = entries.flatMap((value, cell) => value === false ? [cell] : []);
+        const reached = new Set();
+        if (white.length) {
+            const pending = [white[0]];
+            reached.add(white[0]);
+            while (pending.length)
+                for (const next of heyawakeNeighbours(board, pending.pop())) {
+                    if (entries[next] === false && !reached.has(next)) {
+                        reached.add(next);
+                        pending.push(next);
+                    }
+                }
+        }
+        if (reached.size !== white.length)
+            white.filter(cell => !reached.has(cell)).forEach(cell => errors.add(cell));
+        checkRoomSpans(board, entries, ids, errors);
+    }
+    return { ok: errors.size === 0 && complete, complete, errors: [...errors].sort((a, b) => a - b) };
+}
+export function checkRoomSpans(board, entries, roomIds = roomForCell(board), errors = new Set()) {
+    for (let y = 0; y < board.height; y += 1) {
+        let rooms = new Set(), cells = [];
+        for (let x = 0; x <= board.width; x += 1) {
+            const cell = y * board.width + x;
+            if (x < board.width && entries[cell] === false) {
+                cells.push(cell);
+                rooms.add(roomIds[cell]);
+            }
+            else {
+                if (rooms.size > 2)
+                    cells.forEach(value => errors.add(value));
+                rooms = new Set();
+                cells = [];
+            }
+        }
+    }
+    for (let x = 0; x < board.width; x += 1) {
+        let rooms = new Set(), cells = [];
+        for (let y = 0; y <= board.height; y += 1) {
+            const cell = y * board.width + x;
+            if (y < board.height && entries[cell] === false) {
+                cells.push(cell);
+                rooms.add(roomIds[cell]);
+            }
+            else {
+                if (rooms.size > 2)
+                    cells.forEach(value => errors.add(value));
+                rooms = new Set();
+                cells = [];
+            }
+        }
+    }
+}

package/dist/heyawakeDraw.d.ts

@@ -0,0 +1,3 @@
+import type { HeyawakeBoard } from "./heyawake.types.ts";
+import type { HeyawakeDrawOptions } from "./heyawakePlay.types.ts";
+export declare function drawHeyawake(board: HeyawakeBoard, options?: HeyawakeDrawOptions): string;

package/dist/heyawakeDraw.js

@@ -0,0 +1,27 @@
+import { heyawakeCells, isHeyawakeBoard } from "./heyawakeBoard.js";
+import { heyawakeWords } from "./heyawakeStrings.js";
+export function drawHeyawake(board, options = {}) {
+    if (!isHeyawakeBoard(board))
+        throw new RangeError("Invalid Heyawake board");
+    const words = heyawakeWords(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 roomAt = Array(board.width * board.height).fill(-1);
+    board.rooms.forEach((room, index) => heyawakeCells(board, room).forEach(cell => { roomAt[cell] = index; }));
+    const cells = Array.from({ length: board.width * board.height }, (_, cell) => {
+        const x = cell % board.width * size, y = Math.floor(cell / board.width) * size;
+        const entry = options.entries?.[cell], room = board.rooms[roomAt[cell]];
+        const selected = cell === options.selected, error = options.errors?.includes(cell);
+        const color = error ? "var(--kz-bad,#b5452c)" : ink;
+        const top = Math.floor(cell / board.width) === room.y ? 3 : 1;
+        const left = cell % board.width === room.x ? 3 : 1;
+        const right = cell % board.width === room.x + room.width - 1 ? 3 : 1;
+        const bottom = Math.floor(cell / board.width) === room.y + room.height - 1 ? 3 : 1;
+        const clue = cell === room.y * board.width + room.x && room.blacks !== null
+            ? `<text x="${x + 5}" y="${y + 13}" fill="${ink}" font-size="11" font-weight="700">${room.blacks}</text>` : "";
+        const mark = entry === true ? `<rect x="${x + 1}" y="${y + 1}" width="46" height="46" fill="${color}"/>` : entry === false ? `<circle cx="${x + 24}" cy="${y + 24}" r="5" fill="${color}"/>` : "";
+        return `<g data-heyawake-cell="${cell}"><rect x="${x}" y="${y}" width="48" height="48" fill="${selected ? ink : paper}" fill-opacity="${selected ? ".12" : "1"}" stroke="${grid}" stroke-width="${Math.min(top, right, bottom, left)}"/>${clue}${mark}</g>`;
+    }).join("");
+    const roomLines = board.rooms.map(room => `<rect x="${room.x * size + 1.5}" y="${room.y * size + 1.5}" width="${room.width * size - 3}" height="${room.height * size - 3}" fill="none" stroke="${ink}" stroke-width="3" pointer-events="none"/>`).join("");
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${board.width * size} ${board.height * size}" role="img" aria-label="${words.title}" style="display:block;width:100%;height:auto;background:${paper}">${cells}${roomLines}</svg>`;
+}

package/dist/heyawakeGame.d.ts

@@ -0,0 +1,12 @@
+import type { HeyawakeBoard, HeyawakeGame } from "./heyawake.types.ts";
+export declare function newHeyawake(board: HeyawakeBoard): HeyawakeGame;
+export declare function setHeyawakeCell(game: HeyawakeGame, cell: number, value: boolean | null): HeyawakeGame;
+export declare function undoHeyawake(game: HeyawakeGame): HeyawakeGame;
+export declare function restartHeyawake(game: HeyawakeGame): HeyawakeGame;
+export declare function hintHeyawake(game: HeyawakeGame): {
+    cell: number;
+    value: boolean;
+} | null;
+export declare function heyawakeFinished(game: HeyawakeGame): boolean;
+export declare function encodeHeyawake(game: HeyawakeGame): string;
+export declare function decodeHeyawake(code: string): HeyawakeGame | null;

package/dist/heyawakeGame.js

@@ -0,0 +1,51 @@
+import { checkHeyawake, isHeyawakeBoard } from "./heyawakeBoard.js";
+import { solveHeyawake } from "./heyawakeSolve.js";
+export function newHeyawake(board) {
+    if (!isHeyawakeBoard(board))
+        throw new RangeError("Invalid Heyawake board");
+    return { board: publicBoard(board), entries: Array(board.width * board.height).fill(null), history: [], helped: false };
+}
+export function setHeyawakeCell(game, cell, value) {
+    if (value !== null && typeof value !== "boolean" || !Number.isInteger(cell) || cell < 0 || cell >= game.entries.length || game.entries[cell] === value)
+        return game;
+    const entries = [...game.entries];
+    entries[cell] = value;
+    return { ...game, entries, history: [...game.history, game.entries] };
+}
+export function undoHeyawake(game) {
+    const previous = game.history.at(-1);
+    return previous ? { ...game, entries: previous, history: game.history.slice(0, -1) } : game;
+}
+export function restartHeyawake(game) {
+    return { ...game, entries: Array(game.entries.length).fill(null), history: [], helped: false };
+}
+export function hintHeyawake(game) {
+    const result = solveHeyawake(game.board, game.entries);
+    if (!result.complete || result.count !== 1 || !result.solution)
+        return null;
+    const cell = game.entries.findIndex(value => value === null);
+    return cell < 0 ? null : { cell, value: result.solution[cell] };
+}
+export function heyawakeFinished(game) {
+    return checkHeyawake(game.board, game.entries).ok;
+}
+export function encodeHeyawake(game) {
+    return JSON.stringify({ version: 1, board: publicBoard(game.board), entries: game.entries.map(value => value === null ? "?" : value ? "#" : ".").join(""), helped: game.helped });
+}
+export function decodeHeyawake(code) {
+    try {
+        const data = JSON.parse(code);
+        if (data.version !== 1 || !isHeyawakeBoard(data.board) || typeof data.helped !== "boolean" || typeof data.entries !== "string")
+            return null;
+        const entries = [...data.entries].map((value) => value === "?" ? null : value === "#" ? true : value === "." ? false : undefined);
+        if (entries.length !== data.board.width * data.board.height || entries.some((value) => value === undefined))
+            return null;
+        return { board: publicBoard(data.board), entries: entries, history: [], helped: data.helped };
+    }
+    catch {
+        return null;
+    }
+}
+function publicBoard(board) {
+    return { width: board.width, height: board.height, rooms: board.rooms.map(room => ({ x: room.x, y: room.y, width: room.width, height: room.height, blacks: room.blacks })) };
+}

package/dist/heyawakeGenerate.d.ts

@@ -0,0 +1,2 @@
+import type { HeyawakeLevel, HeyawakePuzzle } from "./heyawake.types.ts";
+export declare function generateHeyawake(width?: number, height?: number, level?: HeyawakeLevel, seed?: number): HeyawakePuzzle;

package/dist/heyawakeGenerate.js

@@ -0,0 +1,114 @@
+import { HEYAWAKE_GENERATOR_MOST_CELLS, HEYAWAKE_LEVELS, HEYAWAKE_MOST_ATTEMPTS } from "./heyawake.constants.js";
+import { checkHeyawake, heyawakeNeighbours, roomForCell } from "./heyawakeBoard.js";
+import { solveHeyawake } from "./heyawakeSolve.js";
+import { isKazuSeed, seededRandom, shuffled } from "./random.js";
+export function generateHeyawake(width = 4, height = width, level = "easy", seed = 1) {
+    if (![width, height].every(value => Number.isInteger(value) && value >= 4 && value <= 8) || width * height > HEYAWAKE_GENERATOR_MOST_CELLS
+        || !HEYAWAKE_LEVELS.includes(level) || !isKazuSeed(seed))
+        throw new RangeError("Heyawake generation supports 4–8 cells per side and a valid level and seed");
+    const random = seededRandom(seed);
+    for (let attempt = 0; attempt < HEYAWAKE_MOST_ATTEMPTS; attempt += 1) {
+        const roomLimit = Math.min(10, 5 + Math.floor(attempt / 50));
+        const rooms = partitionRooms(width, height, random, roomLimit);
+        const open = { width, height, rooms: rooms.map(room => ({ ...room, blacks: null })) };
+        const solution = randomSolution(open, random);
+        if (!solution)
+            continue;
+        const order = shuffled(rooms.map((_, index) => index), random);
+        const clueCount = Math.max(2, Math.ceil(rooms.length * ({ easy: 0.95, medium: 0.75, hard: 0.55 }[level])));
+        const revealed = new Set(order.slice(0, clueCount));
+        const hidden = order.slice(clueCount);
+        for (let extra = 0; extra <= hidden.length; extra += 1) {
+            const clues = rooms.map((room, index) => ({ ...room, blacks: revealed.has(index) ? countBlacks(room, width, solution) : null }));
+            const board = { width, height, rooms: clues };
+            const proof = solveHeyawake(board);
+            if (proof.complete && proof.count === 1 && proof.solution && checkHeyawake(board, proof.solution).ok) {
+                return { ...board, seed, level, solution: proof.solution };
+            }
+            if (extra < hidden.length)
+                revealed.add(hidden[extra]);
+        }
+    }
+    throw new Error("No unique Heyawake found within the generation budget; try another seed or smaller board");
+}
+function partitionRooms(width, height, random, maximumRooms) {
+    const pending = [{ x: 0, y: 0, width, height }];
+    const rooms = [];
+    while (pending.length) {
+        const area = pending.pop();
+        if (rooms.length + pending.length >= maximumRooms || area.width * area.height <= 3) {
+            rooms.push({ ...area, blacks: null });
+            continue;
+        }
+        const canVertical = area.width >= 4, canHorizontal = area.height >= 4;
+        if (!canVertical && !canHorizontal) {
+            rooms.push({ ...area, blacks: null });
+            continue;
+        }
+        const vertical = canVertical && (!canHorizontal || random() < 0.5);
+        if (vertical) {
+            const cut = 1 + Math.floor(random() * (area.width - 1));
+            pending.push({ x: area.x + cut, y: area.y, width: area.width - cut, height: area.height });
+            pending.push({ x: area.x, y: area.y, width: cut, height: area.height });
+        }
+        else {
+            const cut = 1 + Math.floor(random() * (area.height - 1));
+            pending.push({ x: area.x, y: area.y + cut, width: area.width, height: area.height - cut });
+            pending.push({ x: area.x, y: area.y, width: area.width, height: cut });
+        }
+    }
+    return rooms;
+}
+function randomSolution(board, random) {
+    const entries = Array(board.width * board.height).fill(null);
+    const roomIds = roomForCell(board);
+    let nodes = 0;
+    const visit = (cell) => {
+        if (++nodes > 12000)
+            return false;
+        if (cell === entries.length) {
+            const blackCount = entries.filter(value => value === true).length;
+            return blackCount >= 2 && checkHeyawake(board, entries).ok;
+        }
+        const choices = random() < 0.31 ? [true, false] : [false, true];
+        for (const black of choices) {
+            if (black && heyawakeNeighbours(board, cell).some(next => entries[next] === true))
+                continue;
+            entries[cell] = black;
+            if (partialRoomSpanIsLegal(board, entries, roomIds) && visit(cell + 1))
+                return true;
+            entries[cell] = null;
+        }
+        return false;
+    };
+    return visit(0) ? entries.map(value => value === true) : null;
+}
+function partialRoomSpanIsLegal(board, entries, roomIds) {
+    const exceeds = (cells) => {
+        let rooms = new Set();
+        for (const cell of cells) {
+            if (entries[cell] === false)
+                rooms.add(roomIds[cell]);
+            else
+                rooms = new Set();
+            if (rooms.size > 2)
+                return true;
+        }
+        return false;
+    };
+    for (let y = 0; y < board.height; y += 1)
+        if (exceeds(Array.from({ length: board.width }, (_, x) => y * board.width + x)))
+            return false;
+    for (let x = 0; x < board.width; x += 1)
+        if (exceeds(Array.from({ length: board.height }, (_, y) => y * board.width + x)))
+            return false;
+    return true;
+}
+function countBlacks(room, width, solution) {
+    let count = 0;
+    for (let y = room.y; y < room.y + room.height; y += 1)
+        for (let x = room.x; x < room.x + room.width; x += 1)
+            if (solution[y * width + x])
+                count += 1;
+    return count;
+}

package/dist/heyawakeMount.d.ts

@@ -0,0 +1,2 @@
+import type { HeyawakeMount, HeyawakeMountOptions } from "./heyawakePlay.types.ts";
+export declare function mountHeyawake(host: HTMLElement, initial: HeyawakeMountOptions): HeyawakeMount;