chesspal 0.0.1 → 0.2.0

package/dist/page/theme.css

@@ -0,0 +1,292 @@
+/* The page's colours, light and dark, and the skins the settings choose for the board, the pieces and the marks (D-56) */
+
+/* The page in Zoe's Salotto azzurro (D-46), light and dark. Its ground mixes the board's dark square, which the settings set before the page draws: without
+   them, as without scripts, the page has no ground of its own */
+:root {
+    --page: color-mix(in oklab, var(--dark-square) 12%, #fbfbfa);
+    --card: color-mix(in oklab, var(--dark-square) 3%, #ffffff);
+    --ink: #1d2733;
+    --soft: #626d7b;
+    --line: color-mix(in oklab, var(--dark-square) 24%, #f1f1ef);
+    --accent: #2d6aa8;
+    --on-accent: #ffffff;
+    --quote: color-mix(in oklab, var(--dark-square) 9%, #fafafa);
+    --say: color-mix(in oklab, var(--dark-square) 38%, #fafafa);
+    --say-ink: #1d2733;
+    --warn-back: #fff4d6;
+    /* The squares, their highlights, the marks and the pieces take their colours from the skins the settings choose, further on */
+    --mated: rgba(214, 40, 40, 0.8);
+    --low-time: #c62828;
+    --hint: rgba(0, 0, 0, 0.14);
+    --explain-ink: #1d2733;
+    --lift-shadow: rgba(16, 28, 44, 0.32);
+    --ghost: 0.35;
+    /* The four colours of PGN's %cal and %csl, for what the AI draws (D-69) */
+    --drawn-green: #15a34a;
+    --drawn-red: #dc2626;
+    --drawn-yellow: #eab308;
+    --drawn-blue: #2563eb;
+    /* Ink that stays dark in both themes: on the light squares and on White's chips */
+    --fixed-ink: #1d2733;
+    /* The helps (D-78, Zoe's sketch B): one ink for all they draw, never one of the AI's colours, a fill or a ring. The board says where, the card says what */
+    --help-ink: #11161d;
+    --help-on: #fff;
+    --help-line: rgba(17, 22, 29, 0.78);
+    --help-halo: rgba(255, 255, 255, 0.85);
+    --torretta-body: #6d9fd1;
+    --torretta-shade: #4b7cb0;
+    --torretta-screen: #16263a;
+    --torretta-face: #f2f7fc;
+    --torretta-light: #f4c84c;
+    --torretta-alarm: #ef6a4c;
+    --torretta-ponder: #8f9a8a;
+    /* The badges of the moves (D-69): white signs, dark on the yellow one; each disc at least 3:1 with its sign */
+    --badge-ink: #fff;
+    /* How a game went for the player, in the Analysis window's list: the colours of the move badges (D-69) */
+    --result-win: var(--badge-best);
+    --result-loss: var(--badge-blunder);
+    --result-draw: var(--badge-note);
+    --badge-note: #7b8794;
+    --badge-brilliant: #0f9a9e;
+    --badge-great: #2f74c8;
+    --badge-best: #3c9a3a;
+    --badge-excellent: #6b9c2c;
+    --badge-good: #7d9a62;
+    --badge-book: #94704c;
+    --badge-inaccuracy: #e6b422;
+    --badge-inaccuracy-ink: #3b2c00;
+    --badge-mistake: #d4650f;
+    --badge-miss: #c2407d;
+    --badge-blunder: #d22c2c;
+    --shadow: 0 1px 2px rgba(29, 39, 51, 0.06), 0 6px 18px rgba(29, 39, 51, 0.06);
+    /* On a light page the board keeps a thin edge in its dark squares colour, and a deeper shadow, so its light squares do not melt into the page */
+    --board-shadow: 0 0 0 1px color-mix(in oklab, var(--dark-square) 55%, transparent), 0 2px 4px rgba(29, 39, 51, 0.1), 0 10px 28px rgba(29, 39, 51, 0.12);
+    --gap: 20px;
+    --left: 300px;
+    --right: 300px;
+    /* The board's least size beside the talk: room for the AI's words, the box and both cards; a lower window scrolls */
+    --least: 440px;
+    --tab: 16px;
+    --rail: 56px;
+    --coin: 40px;
+    /* How far from the board's top and bottom edges the faces sit, in the cards and folded, and the tabs */
+    --ear: 36px;
+    --tuck: 10px;
+    --bar: 36px;
+    /* The cards' corners, as the board's; the room between the cards, and between them and the board */
+    --radius: 6px;
+    --between: 10px;
+    --bubble: 14px;
+    color-scheme: light;
+}
+
+:root[data-theme="dark"] {
+    --page: color-mix(in oklab, var(--dark-square) 13%, #0b0d10);
+    --card: color-mix(in oklab, var(--dark-square) 16%, #14171b);
+    --ink: #e6ebf1;
+    --soft: #8d98a7;
+    --line: color-mix(in oklab, var(--dark-square) 24%, #1b1f24);
+    --accent: #7cb0e4;
+    --on-accent: #0f1a28;
+    --low-time: #ff6b6b;
+    --quote: color-mix(in oklab, var(--dark-square) 20%, #1a1d22);
+    --say: color-mix(in oklab, var(--dark-square) 34%, #15181c);
+    --say-ink: #e6ebf1;
+    --warn-back: #2a2616;
+    --hint: rgba(0, 0, 0, 0.17);
+    --lift-shadow: rgba(0, 0, 0, 0.5);
+    --torretta-screen: #0f1a28;
+    --badge-great: #3577c9;
+    --badge-book: #9c7650;
+    --badge-miss: #c9478a;
+    --badge-blunder: #d93434;
+    --shadow: 0 1px 2px rgba(0, 0, 0, 0.3), 0 8px 22px rgba(0, 0, 0, 0.25);
+    --board-shadow: var(--shadow);
+    color-scheme: dark;
+}
+
+/* Zoe's palettes: on the page's root and on each swatch of the settings. Board skins, each with its own highlights */
+:root[data-board="azzurro"],
+[data-board="azzurro"] {
+    --light-square: #eaf1f8;
+    --dark-square: #86abd0;
+    --last-move: rgba(255, 206, 70, 0.65);
+    --selected: rgba(255, 190, 50, 0.85);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="azzurro"],
+:root[data-theme="dark"] [data-board="azzurro"] {
+    --light-square: #a9bccd;
+    --dark-square: #61809e;
+}
+
+:root[data-board="verde"],
+[data-board="verde"] {
+    --light-square: #eeeed2;
+    --dark-square: #769656;
+    --last-move: rgba(255, 255, 51, 0.5);
+    --selected: rgba(255, 236, 40, 0.75);
+    --hover-edge: #f6f669;
+}
+
+:root[data-theme="dark"][data-board="verde"],
+:root[data-theme="dark"] [data-board="verde"] {
+    --light-square: #c3c7a8;
+    --dark-square: #5f7c45;
+}
+
+:root[data-board="noce"],
+[data-board="noce"] {
+    --light-square: #e9d8bd;
+    --dark-square: #a6866a;
+    --last-move: rgba(200, 212, 40, 0.55);
+    --selected: rgba(185, 205, 20, 0.75);
+    --hover-edge: #cdd26a;
+}
+
+:root[data-theme="dark"][data-board="noce"],
+:root[data-theme="dark"] [data-board="noce"] {
+    --light-square: #c4b096;
+    --dark-square: #80654d;
+}
+
+:root[data-board="ardesia"],
+[data-board="ardesia"] {
+    --light-square: #dfe3e8;
+    --dark-square: #8b97a4;
+    --last-move: rgba(255, 206, 70, 0.6);
+    --selected: rgba(255, 190, 50, 0.8);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="ardesia"],
+:root[data-theme="dark"] [data-board="ardesia"] {
+    --light-square: #a7b0ba;
+    --dark-square: #65707c;
+}
+
+:root[data-board="grigio"],
+[data-board="grigio"] {
+    --light-square: #ededed;
+    --dark-square: #9a9a9a;
+    --last-move: rgba(255, 206, 70, 0.6);
+    --selected: rgba(255, 190, 50, 0.8);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="grigio"],
+:root[data-theme="dark"] [data-board="grigio"] {
+    --light-square: #b9b9b9;
+    --dark-square: #707070;
+}
+
+:root[data-board="lavanda"],
+[data-board="lavanda"] {
+    --light-square: #ece6f2;
+    --dark-square: #9a86b8;
+    --last-move: rgba(255, 214, 90, 0.6);
+    --selected: rgba(255, 200, 60, 0.8);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="lavanda"],
+:root[data-theme="dark"] [data-board="lavanda"] {
+    --light-square: #b8adc6;
+    --dark-square: #6f5e8c;
+}
+
+:root[data-board="ciliegio"],
+[data-board="ciliegio"] {
+    --light-square: #ecd3b6;
+    --dark-square: #9a5a3e;
+    --last-move: rgba(230, 220, 70, 0.55);
+    --selected: rgba(220, 210, 40, 0.75);
+    --hover-edge: #e6dc46;
+}
+
+:root[data-theme="dark"][data-board="ciliegio"],
+:root[data-theme="dark"] [data-board="ciliegio"] {
+    --light-square: #c6ab8f;
+    --dark-square: #73412c;
+}
+
+:root[data-board="menta"],
+[data-board="menta"] {
+    --light-square: #e9f3ec;
+    --dark-square: #7cb396;
+    --last-move: rgba(255, 218, 80, 0.6);
+    --selected: rgba(255, 204, 50, 0.8);
+    --hover-edge: #f4c84c;
+}
+
+:root[data-theme="dark"][data-board="menta"],
+:root[data-theme="dark"] [data-board="menta"] {
+    --light-square: #b3c6b9;
+    --dark-square: #58876d;
+}
+
+:root[data-board="carta"],
+[data-board="carta"] {
+    --light-square: #f3f1ea;
+    --dark-square: #b8b2a2;
+    --last-move: rgba(110, 165, 225, 0.5);
+    --selected: rgba(80, 145, 215, 0.7);
+    --hover-edge: #4a8ad0;
+}
+
+:root[data-theme="dark"][data-board="carta"],
+:root[data-theme="dark"] [data-board="carta"] {
+    --light-square: #c9c5b9;
+    --dark-square: #8a8577;
+}
+
+/* Piece colours for Nitida and Torretta */
+:root[data-pieces="classico"],
+[data-pieces="classico"] {
+    --white-piece: #fff;
+    --black-piece: #000;
+}
+
+:root[data-pieces="avorio"],
+[data-pieces="avorio"] {
+    --white-piece: #f4ead3;
+    --black-piece: #2a1c12;
+}
+
+:root[data-pieces="notte"],
+[data-pieces="notte"] {
+    --white-piece: #fff;
+    --black-piece: #1a3050;
+}
+
+:root[data-pieces="bordeaux"],
+[data-pieces="bordeaux"] {
+    --white-piece: #fff;
+    --black-piece: #5e161c;
+}
+
+/* Marks with the right button */
+:root[data-marks="arancione"],
+[data-marks="arancione"] {
+    --mark: #f07c1e;
+    --mark-square: rgba(240, 124, 30, 0.65);
+}
+
+:root[data-marks="rosso"],
+[data-marks="rosso"] {
+    --mark: #d6342c;
+    --mark-square: rgba(214, 52, 44, 0.6);
+}
+
+:root[data-marks="blu"],
+[data-marks="blu"] {
+    --mark: #2335a8;
+    --mark-square: rgba(35, 53, 168, 0.62);
+}
+
+:root[data-marks="verde"],
+[data-marks="verde"] {
+    --mark: #0f6b30;
+    --mark-square: rgba(15, 107, 48, 0.7);
+}

package/dist/profiles/avatar.d.ts

@@ -0,0 +1,23 @@
+/** The types of image a profile takes, by the file names they have there. */
+export declare const imageTypes: {
+    readonly png: "image/png";
+    readonly jpg: "image/jpeg";
+    readonly webp: "image/webp";
+};
+export type ImageType = keyof typeof imageTypes;
+/** The largest image the page may send: it sends a small one, made from the player's photo. */
+export declare const sentImageLimit: number;
+/** The player's own image: its bytes, its type as its first bytes tell it, and a stamp that changes with it; undefined when there is none, or it is no image. */
+export declare function ownImage(root: string, id: string): {
+    bytes: Buffer;
+    type: ImageType;
+    stamp: string;
+} | undefined;
+/** The stamp of the player's own image, which the page adds to its address; undefined when there is none. Only its first bytes are read. */
+export declare function ownImageStamp(root: string, id: string): string | undefined;
+/** Saves an image the page sent as the player's own, in place of any other: a PNG, JPEG or WebP, as its first bytes tell, within the limit. */
+export declare function saveOwnImage(root: string, id: string, bytes: Uint8Array): void;
+/** Removes the player's own images, but the one kept: a drawn avatar chosen on the page shows in their place. */
+export declare function removeOwnImage(root: string, id: string, kept?: string): void;
+/** An image's type by its first bytes: never by its name, which anything may have. */
+export declare function imageTypeOf(bytes: Uint8Array): ImageType | undefined;

package/dist/profiles/avatar.js

@@ -0,0 +1,84 @@
+// The player's own picture (D-45): an image in the profile's folder, put there by hand or sent from the page, which shows instead of a drawn avatar.
+import { closeSync, openSync, readFileSync, readSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { writeAtomically } from "../games/index.js";
+import { profileFolder } from "./profiles.js";
+/** The types of image a profile takes, by the file names they have there. */
+export const imageTypes = { png: "image/png", jpg: "image/jpeg", webp: "image/webp" };
+/** The largest image the page may send: it sends a small one, made from the player's photo. */
+export const sentImageLimit = 1024 * 1024;
+/** The player's own image: its bytes, its type as its first bytes tell it, and a stamp that changes with it; undefined when there is none, or it is no image. */
+export function ownImage(root, id) {
+    const found = ownImageFile(root, id);
+    try {
+        return found === undefined ? undefined : { bytes: readFileSync(found.path), type: found.type, stamp: found.stamp };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The stamp of the player's own image, which the page adds to its address; undefined when there is none. Only its first bytes are read. */
+export function ownImageStamp(root, id) {
+    return ownImageFile(root, id)?.stamp;
+}
+/** Saves an image the page sent as the player's own, in place of any other: a PNG, JPEG or WebP, as its first bytes tell, within the limit. */
+export function saveOwnImage(root, id, bytes) {
+    const type = imageTypeOf(bytes);
+    if (type === undefined) {
+        throw new Error("The picture must be a PNG, JPEG or WebP image.");
+    }
+    if (bytes.length > sentImageLimit) {
+        throw new Error(`The picture is ${Math.ceil(bytes.length / 1024)} KB: send one of ${sentImageLimit / 1024} KB at most.`);
+    }
+    const name = `avatar.${type}`;
+    writeAtomically(join(profileFolder(root, id), name), bytes);
+    removeOwnImage(root, id, name);
+}
+/** Removes the player's own images, but the one kept: a drawn avatar chosen on the page shows in their place. */
+export function removeOwnImage(root, id, kept) {
+    for (const name of fileNames.filter((one) => one !== kept)) {
+        rmSync(join(profileFolder(root, id), name), { force: true });
+    }
+}
+/** An image's type by its first bytes: never by its name, which anything may have. */
+export function imageTypeOf(bytes) {
+    const starts = (signature, at = 0) => signature.every((byte, index) => bytes[at + index] === byte);
+    if (starts([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) {
+        return "png";
+    }
+    if (starts([0xff, 0xd8, 0xff])) {
+        return "jpg";
+    }
+    return starts([0x52, 0x49, 0x46, 0x46]) && starts([0x57, 0x45, 0x42, 0x50], 8) ? "webp" : undefined;
+}
+function ownImageFile(root, id) {
+    for (const name of fileNames) {
+        const path = join(profileFolder(root, id), name);
+        try {
+            const { size, mtimeMs } = statSync(path);
+            const type = size > keptImageLimit ? undefined : imageTypeOf(firstBytes(path));
+            if (type !== undefined) {
+                return { path, type, stamp: `${Math.trunc(mtimeMs)}-${size}` };
+            }
+        }
+        catch {
+            // No such file, or one that cannot be read: the next name.
+        }
+    }
+    return undefined;
+}
+function firstBytes(path) {
+    const bytes = new Uint8Array(12);
+    const file = openSync(path, "r");
+    try {
+        readSync(file, bytes, 0, bytes.length, 0);
+    }
+    finally {
+        closeSync(file);
+    }
+    return bytes;
+}
+// The names the player's image may have in the profile's folder, the first found winning.
+const fileNames = ["avatar.png", "avatar.jpg", "avatar.jpeg", "avatar.webp"];
+// An image the player put in the folder by hand may be a photo as the camera took it, but not a huge file.
+const keptImageLimit = 10 * 1024 * 1024;

package/dist/profiles/front-matter.d.ts

@@ -0,0 +1,9 @@
+/** The fields of a markdown file's front matter, as text, and the text below it. */
+export interface FrontMatter {
+    readonly fields: Readonly<Record<string, string>>;
+    readonly body: string;
+}
+/** Reads a flat front matter: a value in double quotes as JSON writes it, any other as it stands; lines that are not key: value are left out. */
+export declare function readFrontMatter(text: string): FrontMatter;
+/** Writes a flat front matter, its text values in double quotes so that any name reads back as it was, and the text below it. */
+export declare function writeFrontMatter(fields: Readonly<Record<string, string | number | undefined>>, body?: string): string;

package/dist/profiles/front-matter.js

@@ -0,0 +1,33 @@
+// A flat YAML front matter (D-9): one field a line, key: value, between two lines of ---, then the text below it, which stays as it was.
+/** Reads a flat front matter: a value in double quotes as JSON writes it, any other as it stands; lines that are not key: value are left out. */
+export function readFrontMatter(text) {
+    // An editor may begin the file with a byte-order mark.
+    const match = /^?---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
+    if (match === null) {
+        return { fields: {}, body: text };
+    }
+    const fields = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const field = /^([A-Za-z][\w-]*):\s*(.*?)\s*$/.exec(line);
+        if (field !== null && field[2] !== "") {
+            fields[field[1]] = valueOf(field[2]);
+        }
+    }
+    return { fields, body: text.slice(match[0].length) };
+}
+/** Writes a flat front matter, its text values in double quotes so that any name reads back as it was, and the text below it. */
+export function writeFrontMatter(fields, body = "") {
+    const lines = Object.entries(fields).flatMap(([key, value]) => (value === undefined ? [] : [`${key}: ${typeof value === "number" ? value : JSON.stringify(value)}`]));
+    return `---\n${lines.join("\n")}\n---\n${body}`;
+}
+function valueOf(written) {
+    if (written.startsWith('"')) {
+        try {
+            return String(JSON.parse(written));
+        }
+        catch {
+            return written;
+        }
+    }
+    return written.startsWith("'") && written.endsWith("'") && written.length > 1 ? written.slice(1, -1).replaceAll("''", "'") : written;
+}

package/dist/profiles/index.d.ts

@@ -0,0 +1,3 @@
+export { type ImageType, imageTypeOf, imageTypes, ownImage, ownImageStamp, removeOwnImage, saveOwnImage, sentImageLimit } from "./avatar.ts";
+export { type Accounts, activateProfile, activeProfile, createProfile, type DrawnAvatar, drawnAvatars, ensureProfile, gameFolder, gameFolders, type Level, levels, listProfiles, nameLimit, type PlayerProfile, type ProfileFields, profileFolder, type Rating, ratingLimits, type RatingSite, ratingSites, updateProfile, } from "./profiles.ts";
+export { helpsIn, languageIn, type PageSettings, profileSettings, saveProfileSettings, settingsOf } from "./settings.ts";

package/dist/profiles/index.js

@@ -0,0 +1,5 @@
+// The player's profiles (D-23): who plays, their games, their picture and their page settings, each in profiles/<id>/ of the data folder (D-71). Below the
+// commands, beside the games.
+export { imageTypeOf, imageTypes, ownImage, ownImageStamp, removeOwnImage, saveOwnImage, sentImageLimit } from "./avatar.js";
+export { activateProfile, activeProfile, createProfile, drawnAvatars, ensureProfile, gameFolder, gameFolders, levels, listProfiles, nameLimit, profileFolder, ratingLimits, ratingSites, updateProfile, } from "./profiles.js";
+export { helpsIn, languageIn, profileSettings, saveProfileSettings, settingsOf } from "./settings.js";

package/dist/profiles/profiles.d.ts

@@ -0,0 +1,69 @@
+/** How the player says they play, from who has just learned to who plays tournaments. */
+export declare const levels: readonly ["learning", "casual", "regular", "tournament"];
+export type Level = (typeof levels)[number];
+/** Where a rating comes from. */
+export declare const ratingSites: readonly ["lichess", "chess.com", "fide"];
+export type RatingSite = (typeof ratingSites)[number];
+/** The lowest and highest rating a profile takes. */
+export declare const ratingLimits: {
+    readonly lowest: 100;
+    readonly highest: 3500;
+};
+/** The longest name a profile keeps. */
+export declare const nameLimit = 40;
+/** The avatars Zoe drew, for a player without an image of their own (D-45). */
+export declare const drawnAvatars: readonly ["short-hair", "bun", "glasses", "beanie", "beard", "curls", "moustache", "silver-bob", "cat", "owl"];
+export type DrawnAvatar = (typeof drawnAvatars)[number];
+/** A rating and where it comes from. */
+export interface Rating {
+    readonly value: number;
+    readonly site: RatingSite;
+}
+/** What the player tells of themselves: their name, how they play, their rating, the avatar they chose. */
+export interface ProfileFields {
+    readonly name: string;
+    readonly level?: Level;
+    readonly rating?: Rating;
+    readonly avatar?: DrawnAvatar;
+}
+/** The player's names on the sites they play on. */
+export interface Accounts {
+    readonly lichess?: string;
+    readonly chesscom?: string;
+}
+/** A profile: its folder's name, and what profile.md says; a folder without one is named by the folder. */
+export interface PlayerProfile extends ProfileFields {
+    readonly id: string;
+    /** Made by Chesspal at the first start, until the player completes it: the board page's wizard does (D-71). */
+    readonly new?: true;
+    /** The player's names on Lichess and chess.com, written in profile.md by hand or from the page, by which the games they load are theirs (D-93). */
+    readonly accounts?: Accounts;
+}
+/** What may change in a profile: what the player tells of themselves, and their names on the sites, each one written whole. */
+export type ProfileChanges = Partial<ProfileFields> & {
+    readonly accounts?: Accounts;
+};
+/** The profiles in the data folder, by their folders' names. */
+export declare function listProfiles(root: string): PlayerProfile[];
+/**
+ * Makes the first profile when there is none, named after the system's account and new until the player completes it (D-71). Two processes starting
+ * together make one: the second finds its folder taken.
+ */
+export declare function ensureProfile(root: string, account: string): void;
+/** The profile in use: the one active.json names, else the first. */
+export declare function activeProfile(root: string): PlayerProfile;
+/** Where the games are: the folder of the profile in use. */
+export declare function gameFolder(root: string): string;
+/** A profile's folder. */
+export declare function profileFolder(root: string, id: string): string;
+/**
+ * Makes a profile, its folder named from the player's name, and puts it in use unless told not to; the one Chesspal made, while new, becomes it instead,
+ * with its games, and its folder takes the player's name too (D-71).
+ */
+export declare function createProfile(root: string, fields: ProfileFields, use?: boolean): PlayerProfile;
+/** Every profile's folder, where games may be. */
+export declare function gameFolders(root: string): string[];
+/** Puts a profile in use. */
+export declare function activateProfile(root: string, id: string): PlayerProfile;
+/** Changes what a profile says of the player, keeping the rest of profile.md as it was written: its other fields and the text below them. */
+export declare function updateProfile(root: string, id: string, changes: ProfileChanges): PlayerProfile;