@nano133/nanoterra 0.8.0 → 0.9.0

package/dist/player-signin/memory.d.ts

@@ -0,0 +1,15 @@
+import { type PlayerSigninStore, type SessionRecord, type SigninRequest, type Way } from "./types.js";
+type RequestRow = SigninRequest & {
+    way: Way;
+    delivered: boolean;
+};
+export type MemoryPlayerSignin = PlayerSigninStore & {
+    readonly requestRows: Map<string, RequestRow>;
+    readonly sessionRows: Map<string, SessionRecord>;
+    readonly onceRows: Map<string, {
+        address: string;
+        until: number;
+    }>;
+};
+export declare function createMemoryPlayerSignin(): MemoryPlayerSignin;
+export {};

package/dist/player-signin/memory.js

@@ -0,0 +1,101 @@
+// The player sign-in's store in this process's memory: for tests and demos. A game uses a database (./adapters/d1.ts, ./adapters/firestore.ts, or
+// its own store that passes playerSigninStoreConformance).
+import { WAYS } from "./types.js";
+const copy = (v) => structuredClone(v);
+export function createMemoryPlayerSignin() {
+    const requestRows = new Map();
+    const sessionRows = new Map();
+    const onceRows = new Map();
+    const strip = ({ way: _way, delivered: _delivered, ...r }) => copy(r);
+    const stores = new Map();
+    for (const way of WAYS) {
+        stores.set(way, {
+            async create(key, r) {
+                if (requestRows.has(key))
+                    throw new Error("a request with this key exists");
+                requestRows.set(key, { ...copy(r), way, delivered: false });
+            },
+            async get(key) {
+                const r = requestRows.get(key);
+                return r && r.way === way ? strip(r) : null;
+            },
+            async find(id) {
+                for (const [key, r] of requestRows)
+                    if (r.way === way && r.id === id)
+                        return { key, request: strip(r) };
+                return null;
+            },
+            async finish(key, account) {
+                const r = requestRows.get(key);
+                if (!r || r.way !== way || r.status !== "waiting")
+                    return false;
+                r.status = "signedin";
+                r.account = account;
+                return true;
+            },
+        });
+    }
+    return {
+        requestRows,
+        sessionRows,
+        onceRows,
+        requests: (way) => {
+            const s = stores.get(way);
+            if (!s)
+                throw new Error(`no such way: ${String(way)}`);
+            return s;
+        },
+        async deliver(way, key, session) {
+            const r = requestRows.get(key);
+            if (!r || r.way !== way || r.status !== "signedin" || r.delivered)
+                return false;
+            r.delivered = true;
+            sessionRows.set(session.idHash, copy(session));
+            return true;
+        },
+        async createSession(session) {
+            if (sessionRows.has(session.idHash))
+                throw new Error("a session with this id exists");
+            sessionRows.set(session.idHash, copy(session));
+        },
+        async session(idHash, now) {
+            const s = sessionRows.get(idHash);
+            return s && s.expiresAt > now ? copy(s) : null;
+        },
+        async endSession(idHash) {
+            sessionRows.delete(idHash);
+        },
+        async useOnce(key, ttlMs, address) {
+            const now = Date.now();
+            const had = onceRows.get(key);
+            if (had && had.until > now)
+                return false;
+            onceRows.set(key, { address, until: now + ttlMs });
+            return true;
+        },
+        async forget(address) {
+            let n = 0;
+            for (const [k, s] of sessionRows)
+                if (s.address === address && sessionRows.delete(k))
+                    n++;
+            for (const [k, r] of requestRows)
+                if (r.account === address && requestRows.delete(k))
+                    n++;
+            for (const [k, o] of onceRows)
+                if (o.address === address && onceRows.delete(k))
+                    n++;
+            return n;
+        },
+        async clean(now) {
+            for (const [k, r] of requestRows)
+                if (r.expiresAt < now - 2 * 3_600_000)
+                    requestRows.delete(k);
+            for (const [k, s] of sessionRows)
+                if (s.expiresAt <= now)
+                    sessionRows.delete(k);
+            for (const [k, o] of onceRows)
+                if (o.until <= now)
+                    onceRows.delete(k);
+        },
+    };
+}

package/dist/player-signin/panel/index.d.ts

@@ -0,0 +1,9 @@
+export { mountPlayerSignin } from "./mount.js";
+export type { MountedPlayerSignin, PlayerSigninMountOptions } from "./mount.js";
+export { hostFits, passkeyName, signInView } from "./view.js";
+export { PASSKEY_PREVIEW_NOTE, previewHost } from "../host.js";
+export type { PlayerSigninView, PlayerSigninViewOptions, SignedIn } from "./view.js";
+export { faultWords } from "./words.js";
+export type { FaultWords } from "./words.js";
+export { readMemo } from "./memo.js";
+export type { SigninMemo } from "./memo.js";

package/dist/player-signin/panel/index.js

@@ -0,0 +1,7 @@
+// "@nano133/nanoterra/player-signin/panel": the player's sign-in sheet in the browser. `mountPlayerSignin` is the sheet (call `open()`);
+// `signInView` is its content, for a game that has a sheet of its own. Add "@nano133/nanoterra/player-signin/style.css" to the page.
+export { mountPlayerSignin } from "./mount.js";
+export { hostFits, passkeyName, signInView } from "./view.js";
+export { PASSKEY_PREVIEW_NOTE, previewHost } from "../host.js";
+export { faultWords } from "./words.js";
+export { readMemo } from "./memo.js";

package/dist/player-signin/panel/memo.d.ts

@@ -0,0 +1,12 @@
+import type { Way } from "../types.js";
+export type SigninMemo = {
+    ids: string[];
+    unopened: string[];
+    last: Way | "passkey" | null;
+};
+export declare function readMemo(rpId: string): SigninMemo;
+/** A passkey was just MADE and not used yet: remember it at once (a closed sheet or a reload between the two steps must not forget it). */
+export declare function rememberMade(rpId: string, id: string): void;
+/** A passkey signed the player in. Returns true when it was made here and never opened before: a new account. */
+export declare function rememberOpened(rpId: string, id: string): boolean;
+export declare function rememberLast(rpId: string, last: Way | "passkey"): void;

package/dist/player-signin/panel/memo.js

@@ -0,0 +1,41 @@
+// What this browser remembers of the player's sign-in, in localStorage (no secret, no address): the ids of the passkeys it made or used (so the device
+// refuses a second passkey here, and "Use my passkey" is the main key on the next visit), the ids made here and never opened (their first open is a
+// NEW account: the spare key shows then), and the way chosen last. A browser that refuses storage remembers nothing, and nothing depends on it.
+const KEY = (rpId) => `n133.player-signin.v1:${rpId}`;
+const isId = (x) => typeof x === "string" && /^[A-Za-z0-9_-]{8,700}$/.test(x);
+const LAST = new Set(["passkey", "berry", "nanchat", "nautilus"]);
+export function readMemo(rpId) {
+    try {
+        const m = JSON.parse(globalThis.localStorage?.getItem(KEY(rpId)) ?? "null");
+        const ids = Array.isArray(m?.ids) ? m.ids.filter(isId).slice(-8) : [];
+        const unopened = Array.isArray(m?.unopened) ? m.unopened.filter((x) => isId(x) && ids.includes(x)) : [];
+        const last = typeof m?.last === "string" && LAST.has(m.last) ? m.last : null;
+        return { ids, unopened, last };
+    }
+    catch {
+        return { ids: [], unopened: [], last: null };
+    }
+}
+function write(rpId, m) {
+    try {
+        globalThis.localStorage?.setItem(KEY(rpId), JSON.stringify(m));
+    }
+    catch {
+        // Storage refused (a private window): nothing is remembered.
+    }
+}
+/** A passkey was just MADE and not used yet: remember it at once (a closed sheet or a reload between the two steps must not forget it). */
+export function rememberMade(rpId, id) {
+    const m = readMemo(rpId);
+    write(rpId, { ...m, ids: [...m.ids.filter((x) => x !== id), id].slice(-8), unopened: [...m.unopened.filter((x) => x !== id), id] });
+}
+/** A passkey signed the player in. Returns true when it was made here and never opened before: a new account. */
+export function rememberOpened(rpId, id) {
+    const m = readMemo(rpId);
+    const fresh = m.unopened.includes(id);
+    write(rpId, { ids: [...m.ids.filter((x) => x !== id), id].slice(-8), unopened: m.unopened.filter((x) => x !== id), last: "passkey" });
+    return fresh;
+}
+export function rememberLast(rpId, last) {
+    write(rpId, { ...readMemo(rpId), last });
+}

package/dist/player-signin/panel/mount.d.ts

@@ -0,0 +1,21 @@
+import { type PlayerSigninViewOptions, type SignedIn } from "./view.js";
+export type PlayerSigninMountOptions = PlayerSigninViewOptions & {
+    /** The sheet's title. Default "Sign in". */
+    title?: string;
+    /** How long "Signed in as …" shows before the sheet closes, in ms. Default 900. */
+    closeAfterMs?: number;
+    /**
+     * Where the keyboard focus goes when the sheet closes. "game" (the default): out of the sheet, to the page, so the game's keys reach the game. "back":
+     * to the element that had it when the sheet opened (a page with keys of its own).
+     */
+    focusAfterClose?: "game" | "back";
+};
+export type MountedPlayerSignin = {
+    /** Opens the sheet. Resolves with the player when they sign in, or null when the sheet closes first. A second call while it is open gets the same promise. */
+    open(): Promise<SignedIn | null>;
+    close(): void;
+    readonly isOpen: boolean;
+    /** Removes the sheet and stops every wait. */
+    destroy(): void;
+};
+export declare function mountPlayerSignin(root: HTMLElement, options: PlayerSigninMountOptions): MountedPlayerSignin;

package/dist/player-signin/panel/mount.js

@@ -0,0 +1,105 @@
+// The sign-in sheet of a game: `mountPlayerSignin(element, options)`. It draws no key of its own: the game's account key, the shop's "sign in
+// first" and anything else call `open()`, which resolves with the player once they are signed in, or null when the sheet closes. Plain DOM; a
+// modal sheet with a scrim: from the bottom on a phone held upright, in the middle on a wide or sideways screen. Escape, the close key and a press
+// on the scrim close it. Every key is 44 px or more.
+import { h, releaseFocus } from "../../admin/panel/dom.js";
+import { icon } from "../../admin/panel/icons.js";
+import { signInView } from "./view.js";
+let mounts = 0;
+export function mountPlayerSignin(root, options) {
+    const n = ++mounts;
+    let isOpen = false;
+    let pending = null;
+    let before = null;
+    let closing;
+    const settle = (p) => {
+        const was = pending;
+        pending = null;
+        was?.resolve(p);
+    };
+    const view = signInView({
+        ...options,
+        onSignedIn(player) {
+            options.onSignedIn?.(player);
+            settle(player);
+            closing = setTimeout(close, Math.max(0, options.closeAfterMs ?? 900));
+        },
+    });
+    const titleEl = h("h2", { class: "n133s-title", id: `n133s-title-${n}` }, options.title ?? "Sign in");
+    const closeKey = h("button", { class: "n133s-close", type: "button", "aria-label": "Close" }, icon("close", 20));
+    const scrim = h("div", { class: "n133s-scrim" });
+    const panel = h("section", { class: "n133s-panel", role: "dialog", "aria-modal": "true", "aria-labelledby": `n133s-title-${n}` }, h("header", { class: "n133s-head" }, titleEl, closeKey), h("div", { class: "n133s-body" }, view.node));
+    const wrap = h("div", { class: "n133-signin n133s-sheet", "data-open": "false" }, scrim, panel);
+    wrap.hidden = true;
+    root.append(wrap);
+    function close() {
+        if (closing)
+            clearTimeout(closing);
+        closing = undefined;
+        if (!isOpen)
+            return;
+        isOpen = false;
+        view.stop();
+        wrap.dataset.open = "false";
+        wrap.hidden = true;
+        settle(null);
+        if (options.focusAfterClose === "back" && before instanceof HTMLElement)
+            before.focus();
+        else
+            releaseFocus(wrap);
+    }
+    function open() {
+        if (isOpen && pending)
+            return pending.promise;
+        if (closing)
+            clearTimeout(closing);
+        let resolve;
+        const promise = new Promise((r) => (resolve = r));
+        pending = { promise, resolve };
+        before = document.activeElement;
+        isOpen = true;
+        view.reset();
+        wrap.hidden = false;
+        wrap.dataset.open = "true";
+        (panel.querySelector(".n133s-area button") ?? closeKey).focus({ preventScroll: true });
+        return promise;
+    }
+    closeKey.addEventListener("click", close);
+    scrim.addEventListener("click", close);
+    wrap.addEventListener("keydown", (e) => {
+        if (e.key === "Escape") {
+            e.preventDefault();
+            e.stopPropagation();
+            close();
+            return;
+        }
+        if (e.key !== "Tab")
+            return;
+        // The focus stays in the sheet while it is open.
+        const keys = Array.from(panel.querySelectorAll("button:not([disabled]), a[href], [tabindex]:not([tabindex='-1'])")).filter((el) => !el.closest("[hidden]"));
+        if (!keys.length)
+            return;
+        const first = keys[0];
+        const last = keys[keys.length - 1];
+        if (e.shiftKey && document.activeElement === first) {
+            e.preventDefault();
+            last.focus();
+        }
+        else if (!e.shiftKey && document.activeElement === last) {
+            e.preventDefault();
+            first.focus();
+        }
+    });
+    return {
+        open,
+        close,
+        get isOpen() {
+            return isOpen;
+        },
+        destroy() {
+            close();
+            view.stop();
+            wrap.remove();
+        },
+    };
+}

package/dist/player-signin/panel/view.d.ts

@@ -0,0 +1,45 @@
+import { type PasskeyScheme } from "@nano133/signin/passkey";
+import { type Way } from "../types.js";
+export type SignedIn = {
+    address: string;
+    via: "wallet" | "passkey";
+};
+export type PlayerSigninViewOptions = {
+    /** The game's name: the device shows it next to the passkey ("Coin Bees · 1 Nov 2026"). */
+    name: string;
+    /** The game's FROZEN passkey scheme (see "/player-signin": checkScheme, schemeVector). Needed while the passkey is offered. */
+    scheme?: PasskeyScheme;
+    /** Offer the passkey. Default: on, except on a preview address (`*.workers.dev`, see `previewHost`): a passkey made there is lost when the game
+     *  moves to its own domain. `true` offers it there too. */
+    passkey?: boolean;
+    /** The passkeys' relying party id: the game's domain. Default: the page's host name. The passkey is offered on this host and its subdomains only. */
+    rpId?: string;
+    /** The wallet apps, in the sheet's order. Default: Berry Wallet, NanChat, Nautilus. */
+    ways?: readonly Way[];
+    /** Where the handler's routes are. Default "/api/signin". */
+    base?: string;
+    /** Show "Keep a spare key" after a new passkey. Default true. */
+    spareKey?: boolean;
+    /** The person check (Turnstile): fills `box` and gives its token, before a wallet start and a passkey sign-in. No hook: no check. */
+    personCheck?: (box: HTMLElement) => Promise<string | null | undefined>;
+    /** Draws a QR code of `text` (a wallet's link), for a screen with a mouse. No hook: the link is shown as a link. */
+    qr?: (text: string) => HTMLElement;
+    /** The player signed in. */
+    onSignedIn?: (player: SignedIn) => void;
+    /** The `fetch` to use (default: the page's). */
+    fetch?: typeof fetch;
+    /** A touch screen (one key that opens the app) or not (a QR code). Default: `(pointer: coarse)`. */
+    touch?: boolean;
+};
+export type PlayerSigninView = {
+    node: HTMLElement;
+    /** Ends the waiting and any device prompt (the sheet closed). */
+    stop(): void;
+    /** Starts again at the ways (the sheet opens again). */
+    reset(): void;
+};
+/** True when the page's host may ask for a passkey of `rpId`: the same host, or a subdomain of it. An IP address never may. */
+export declare function hostFits(hostname: string, rpId: string): boolean;
+/** The passkey's name in the device's list: the game and the day it was made (the account does not exist yet). */
+export declare const passkeyName: (game: string, now?: Date) => string;
+export declare function signInView(options: PlayerSigninViewOptions): PlayerSigninView;