@diffenderfer-games/hub 2.0.0-next.6 → 2.0.0-next.8

package/dist/shared/src.js

@@ -5097,6 +5097,50 @@ function isSavedEntry(candidate) {
 	return typeof readField(candidate, "path") === "string" && typeof readField(candidate, "progress") === "object";
 }
 //#endregion
+//#region src/core/turns/your-turn-buzz.ts
+/** The pattern: two short pulses, ms. */
+const YOUR_TURN_BUZZ = [
+	60,
+	40,
+	60
+];
+/** Where this device keeps the player's choice (`off` turns it off). */
+const YOUR_TURN_BUZZ_KEY = "dg:your-turn-buzz";
+/** Whether going from `previous` to `next` makes this player newly due (the moment to buzz). */
+function isNewlyDue(previous, next) {
+	const wasDue = previous.phase === "playing" && previous.isMyTurn;
+	return next.phase === "playing" && next.isMyTurn && !wasDue && !next.isMuted;
+}
+/** The player's own switch on this device (on unless they turned it off). */
+function readYourTurnBuzz() {
+	try {
+		return localStorage.getItem(YOUR_TURN_BUZZ_KEY) !== "off";
+	} catch {
+		return true;
+	}
+}
+/** Save the player's switch on this device. */
+function saveYourTurnBuzz(isOn) {
+	try {
+		localStorage.setItem(YOUR_TURN_BUZZ_KEY, isOn ? "on" : "off");
+	} catch {}
+}
+/** Whether the page asks for less motion (the hub's setting, else the system's). */
+function prefersLessMotion() {
+	if (typeof document !== "undefined" && document.documentElement.dataset.hubMotion === "reduce") return true;
+	return typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+/** Buzz now, when this page is visible and nothing says not to; fails silently. Answers whether it buzzed. */
+function buzzYourTurn() {
+	if (typeof document === "undefined" || document.visibilityState !== "visible" || !readYourTurnBuzz() || prefersLessMotion()) return false;
+	if (typeof navigator === "undefined" || typeof navigator.vibrate !== "function") return false;
+	try {
+		return navigator.vibrate([...YOUR_TURN_BUZZ]);
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/core/turns/turn-game.ts
 /** The window event the social runtime fires for each `ev:turn`. */
 const TURN_EVENT = "hub:turn";
@@ -5106,9 +5150,13 @@ const TURN_RESYNC_EVENT = "hub:turn-resync";
 const TURN_CHAT_EVENT = "hub:turn-chat";
 /** How often a page without the live runtime looks for moves, ms. */
 const TURN_POLL_MS = 2e4;
+/** How long a visible page waiting on another player's move may hear nothing before it fetches the game again, ms. */
+const TURN_QUIET_MS = 15e3;
+/** How often the page checks whether it should fetch, ms. */
+const TURN_CHECK_MS = 5e3;
 /** One online game. `View`, `Move` and `Ev` (its events) are the game's own JSON types from its rules. */
 var TurnGame = class TurnGame {
-	constructor(host, initial) {
+	constructor(host, initial, options = {}) {
 		_defineProperty(this, "id", void 0);
 		_defineProperty(this, "state", void 0);
 		_defineProperty(this, "host", void 0);
@@ -5122,7 +5170,11 @@ var TurnGame = class TurnGame {
 		_defineProperty(this, "isClosed", false);
 		_defineProperty(this, "catchingUp", null);
 		_defineProperty(this, "ownSeq", null);
+		_defineProperty(this, "heardAt", Date.now());
+		_defineProperty(this, "options", void 0);
+		_defineProperty(this, "isBuzzOn", true);
 		this.host = host;
+		this.options = options;
 		this.id = initial.id;
 		this.state = initial;
 		host.opened(this);
@@ -5156,20 +5208,44 @@ var TurnGame = class TurnGame {
 	get link() {
 		return this.state.link === null ? null : new URL(this.state.link, location.origin).href;
 	}
+	/** Whether this player may move now without it being their turn (the rules' `mayAct`: a jump-in, calling or catching "UNO"): offer that action. */
+	get mayActNow() {
+		const { mySeat } = this.state;
+		return mySeat !== null && this.state.summary.phase === "playing" && (this.state.summary.mayAct ?? []).includes(mySeat);
+	}
+	/** The tournament match this game is, or `null` (show it if you like: "Saturday Cup: your match"). */
+	get tournament() {
+		return this.state.tournament ?? null;
+	}
+	/**
+	* The "your turn" buzz for this game: a short vibration when this player
+	* becomes due on a live update while the page is visible (never for the
+	* next step of their own turn, a move out of turn, a game just opened or a
+	* catch-up; never when the player turned it off or asks for less motion;
+	* silently nothing where the device can't vibrate). On by default.
+	*/
+	setYourTurnBuzz(isOn) {
+		this.isBuzzOn = isOn;
+	}
 	/** Creator: start the game (empty seats go to the computer when the game allows). */
 	async start() {
 		this.update(await this.host.start(this.id));
 	}
 	/**
-	* Make a move. Rejects with a `HubError`: 403 `not_your_turn`, 409
-	* `stale` (the game moved on: the view is refreshed first), 422 `illegal`
-	* with the rules' own code in `rule`.
+	* Make a move: when it is your turn (`summary.isMyTurn`), or out of turn
+	* when the rules allow it (`mayActNow`). Rejects with a `HubError`: 403
+	* `not_your_turn`, 409 `stale` (the game moved on, or another player's
+	* move got there first: the view is refreshed first), 422 `illegal` with
+	* the rules' own code in `rule`, 500 `rules_error` or 503 `rules_busy`
+	* (the move was not made; the game is fetched again). The answer's `view` is the newest this
+	* page has: moves that arrived live while the answer was on its way (the
+	* computer's, another player's) are never rolled back.
 	*/
 	async move(move) {
 		this.ownSeq = this.state.summary.seq + 1;
 		try {
 			const answer = await this.host.move(this.id, this.state.summary.seq, toPayload(move));
-			this.update(answer.game);
+			if (answer.game.summary.seq >= this.state.summary.seq) this.update(answer.game);
 			return {
 				seq: answer.game.summary.seq,
 				view: this.view,
@@ -5177,6 +5253,7 @@ var TurnGame = class TurnGame {
 			};
 		} catch (failure) {
 			if (failure instanceof HubError && failure.code === "stale") await this.refresh();
+			else if (failure instanceof HubError && (failure.code === "rules_error" || failure.code === "rules_busy")) await this.catchUp();
 			throw failure;
 		} finally {
 			this.ownSeq = null;
@@ -5205,7 +5282,7 @@ var TurnGame = class TurnGame {
 	}
 	/** A finished game: a new one with the same friends (they get an invite). */
 	async rematch() {
-		return new TurnGame(this.host, await this.host.rematch(this.id));
+		return new TurnGame(this.host, await this.host.rematch(this.id), this.options);
 	}
 	/** Creator, before the start: add an invite link (`link: true`, then read `link`) or list the open seats for anyone (`public`). */
 	async share(share) {
@@ -5215,7 +5292,33 @@ var TurnGame = class TurnGame {
 	async invite(userIds) {
 		this.update(await this.host.invite(this.id, userIds));
 	}
-	/** The turn's deadline passed (or its player is suspended): let the computer play it. */
+	/**
+	* Whether "Let the computer play for <name>" may work now: another
+	* player is due, the hub's hand-over wait (`summary.handOverAt`) has
+	* passed and a due player isn't connected (`TurnSeat.connected` false
+	* or unknown), or the turn's `deadline` passed. `false` in a
+	* tournament match, and from a hub too old to say. Re-check it on each
+	* `turn` event (a player coming or going fires one) and when
+	* `handOverAt` comes.
+	*/
+	canLetComputerPlay(now = Date.now()) {
+		const { summary, mySeat } = this.state;
+		if (summary.phase !== "playing" || mySeat === null || this.state.tournament !== void 0) return false;
+		const due = summary.seats.filter((seat) => summary.toAct.includes(seat.seat) && seat.seat !== mySeat && seat.status === "joined");
+		if (due.length === 0) return false;
+		if (summary.deadline !== null && summary.deadline <= now) return true;
+		const { handOverAt } = summary;
+		return handOverAt !== void 0 && handOverAt !== null && handOverAt <= now && due.some((seat) => seat.connected !== true);
+	}
+	/**
+	* Let the computer play for whoever is due: a turn whose deadline passed
+	* (or whose player is suspended) is played once; otherwise, when that
+	* player has been due a while (2 minutes) and isn't connected at all, the
+	* computer plays their seat for the rest of the game (it shows as `bot`,
+	* named with who chose it) until they open the game again. Rejects with
+	* 409 `deadline_not_passed` when neither (it never says whether they are
+	* online), and 409 `not_supported` in a tournament match.
+	*/
 	async letComputerPlay() {
 		this.update(await this.host.autoPlay(this.id));
 	}
@@ -5223,20 +5326,28 @@ var TurnGame = class TurnGame {
 	say(send) {
 		return this.host.chat(this.id, send);
 	}
-	/** Fetch the game again, and replay moves missed since the last one this page saw. */
+	/**
+	* Fetch the game again, and replay moves missed since the last one this
+	* page saw. An answer older than what the page has by then (live moves
+	* arrived while it was on its way) is dropped, never rolled back to, and
+	* a move that arrived live is never replayed twice.
+	*/
 	async refresh() {
-		const before = this.state.summary.seq;
 		const fresh = await this.host.get(this.id);
-		if (fresh.summary.seq > before) {
-			const missed = await this.host.history(this.id, before);
+		const seen = this.state.summary.seq;
+		if (fresh.summary.seq <= seen) {
 			this.update(fresh);
-			for (const move of missed) this.emit("move", {
-				seq: move.seq,
-				seat: move.seat,
-				view: this.view,
-				events: move.events.map((event) => toGameData(event))
-			});
-		} else this.update(fresh);
+			return;
+		}
+		const missed = await this.host.history(this.id, seen);
+		const since = this.state.summary.seq;
+		this.update(fresh);
+		for (const move of missed) if (move.seq > since && move.seq <= fresh.summary.seq) this.emit("move", {
+			seq: move.seq,
+			seat: move.seat,
+			view: this.view,
+			events: move.events.map((event) => toGameData(event))
+		});
 	}
 	/** Hear moves, turn changes, the end and chat; returns a function that stops listening. */
 	on(eventName, listener) {
@@ -5253,11 +5364,13 @@ var TurnGame = class TurnGame {
 		for (const stop of this.stopListening) stop();
 		this.host.closed(this);
 	}
-	/** Take a fresh answer from the hub; fire `turn` and `ended` when they changed. */
+	/** Take a fresh answer from the hub (one older than what the page has is dropped: no rollback); fire `turn` and `ended` when they changed. */
 	update(next) {
+		this.heardAt = Date.now();
 		const previous = this.state;
+		if (next.summary.seq < previous.summary.seq) return;
 		this.state = next;
-		if (previous.summary.seq !== next.summary.seq || previous.summary.phase !== next.summary.phase || !sameSeats(previous.summary, next.summary) || previous.chatMode !== next.chatMode || previous.link !== next.link) this.emit("turn", next.summary);
+		if (previous.summary.seq !== next.summary.seq || previous.summary.phase !== next.summary.phase || !sameSeats(previous.summary, next.summary) || previous.summary.handOverAt !== next.summary.handOverAt || previous.chatMode !== next.chatMode || previous.link !== next.link) this.emit("turn", next.summary);
 		if (previous.summary.phase !== "ended" && next.summary.phase === "ended") this.emit("ended", {
 			outcome: next.outcome,
 			view: this.view
@@ -5267,8 +5380,14 @@ var TurnGame = class TurnGame {
 		const set = this.listeners[eventName];
 		for (const listener of set) listener(payload);
 	}
+	/** Whether it is another player's move now (the page is waiting on someone). */
+	isWaitingOnOthers() {
+		const { summary } = this.state;
+		return summary.phase === "playing" && !summary.isMyTurn;
+	}
 	/** A live `hub:turn` for this game: a move (or a missed run of them), or another change. */
 	onLive(detail) {
+		this.heardAt = Date.now();
 		const seq = readField(detail, "seq");
 		const view = readField(detail, "view");
 		const summary = readField(detail, "summary");
@@ -5277,17 +5396,20 @@ var TurnGame = class TurnGame {
 			this.catchUp();
 			return;
 		}
+		if (seq < this.state.summary.seq) return;
 		const seat = readField(detail, "seat");
 		const events = readField(detail, "events");
 		const outcome = readField(detail, "outcome");
 		const isMove = typeof seat === "number" && seq === this.state.summary.seq + 1 && seq !== this.ownSeq;
 		if (summary.phase !== this.state.summary.phase || !sameSeating(this.state.summary, summary)) this.catchUp();
+		const before = this.state.summary;
 		this.update({
 			...this.state,
 			summary,
 			view: toPayloadJson(view),
 			outcome: isOutcome(outcome) ? outcome : this.state.outcome
 		});
+		if (this.isBuzzOn && (this.options.isBuzzOn?.() ?? true) && isNewlyDue(before, this.state.summary)) buzzYourTurn();
 		if (isMove) this.emit("move", {
 			seq,
 			seat,
@@ -5332,8 +5454,13 @@ var TurnGame = class TurnGame {
 		window.addEventListener(TURN_RESYNC_EVENT, onResync);
 		document.addEventListener("visibilitychange", onVisible);
 		const poll = setInterval(() => {
-			if (!this.host.isLive() && document.visibilityState === "visible") this.catchUp();
-		}, TURN_POLL_MS);
+			if (document.visibilityState !== "visible" || this.catchingUp !== null) return;
+			const quietMs = Date.now() - this.heardAt;
+			if (this.host.isLive() ? this.isWaitingOnOthers() && quietMs >= 15e3 : quietMs >= 2e4) {
+				this.heardAt = Date.now();
+				this.catchUp();
+			}
+		}, TURN_CHECK_MS);
 		this.stopListening.push(() => {
 			window.removeEventListener(TURN_EVENT, onTurn);
 		}, () => {
@@ -5358,9 +5485,9 @@ function eachSeat(a, b, same) {
 function sameSeating(a, b) {
 	return eachSeat(a, b, (seat, other) => seat.status === other.status && seat.userId === other.userId);
 }
-/** The same seating, and the same looks (a player's new avatar is a change: `turn` fires). */
+/** The same seating, looks and who is connected (a player's new avatar, or a player coming or going, is a change: `turn` fires). */
 function sameSeats(a, b) {
-	return sameSeating(a, b) && eachSeat(a, b, (seat, other) => seat.look === other.look);
+	return sameSeating(a, b) && eachSeat(a, b, (seat, other) => seat.look === other.look && seat.connected === other.connected);
 }
 /** A game's move as the JSON the hub takes. */
 function toPayload(move) {
@@ -5414,8 +5541,25 @@ function isGameId(idOrKey) {
 var HubTurns = class {
 	constructor(host) {
 		_defineProperty(this, "host", void 0);
+		_defineProperty(this, "isBuzzOn", true);
+		_defineProperty(this, "gameOptions", { isBuzzOn: () => this.isBuzzOn });
 		this.host = host;
 	}
+	/**
+	* This page's "your turn" buzz (a short vibration when the player becomes
+	* due in an open game, see `TurnGame.setYourTurnBuzz`): pass `false` if
+	* your game gives its own signal. On by default.
+	*/
+	setYourTurnBuzz(isOn) {
+		this.isBuzzOn = isOn;
+	}
+	/** The player's own "Buzz when it's my turn" switch on this device (the menu's Settings show it too). */
+	get playerYourTurnBuzz() {
+		return readYourTurnBuzz();
+	}
+	set playerYourTurnBuzz(isOn) {
+		saveYourTurnBuzz(isOn);
+	}
 	/** The invite link key this page was opened with (`?hub_turn_link=`), taken out of the address bar; `null` when none. Synchronous. */
 	get link() {
 		return linkOnPage();
@@ -5434,16 +5578,16 @@ var HubTurns = class {
 			...options.deadline === void 0 ? {} : { deadline: options.deadline },
 			...options.autoStart === void 0 ? {} : { autoStart: options.autoStart }
 		};
-		return new TurnGame(this.host, await this.host.create(body));
+		return new TurnGame(this.host, await this.host.create(body), this.gameOptions);
 	}
 	/** Take a seat: by the game's id (an invite, an open seat) or by an invite link's key. */
 	async join(idOrLinkKey) {
 		const joined = isGameId(idOrLinkKey) ? await this.host.join(idOrLinkKey) : await this.host.joinByLink(idOrLinkKey);
-		return new TurnGame(this.host, joined);
+		return new TurnGame(this.host, joined, this.gameOptions);
 	}
 	/** Open a game the player sits in (from `hub.saved.opened`, the Continue list, an invite). */
 	async open(id) {
-		return new TurnGame(this.host, await this.host.get(id));
+		return new TurnGame(this.host, await this.host.get(id), this.gameOptions);
 	}
 	/** This game's online games the player sits in (the same rows as `hub.saved.list({ kinds: ['turns'] })`). */
 	list() {
@@ -5900,6 +6044,6 @@ function createHub(options = {}) {
 	return new Hub(options);
 }
 //#endregion
-export { UNSUPPORTED_BY_HUB as A, OUTBOX_MAX_CHARS as C, HubError as D, ContentRejectedError as E, OfflineError as O, OUTBOX_FULL_CODE as S, OfflineApi as T, savedGameUrl as _, TURN_LINK_PARAM as a, RESUME_MAX_STATE_BYTES as b, TURN_POLL_MS as c, HubSaved as d, SAVED_CHANGE_QUIET_MS as f, SAVED_OPEN_PARAM as g, SAVED_OPEN_EVENT as h, HubTurns as i, HubAvatar as j, SAVE_UNKNOWN_CODE as k, TURN_RESYNC_EVENT as l, SAVED_KIND_PARAM as m, createHub as n, TURN_CHAT_EVENT as o, SAVED_CHANGE_EVENT as p, hub as r, TURN_EVENT as s, Hub as t, TurnGame as u, HubResume as v, OUTBOX_MAX_ENTRIES as w, CLIENT_VERSION_HEADER as x, RESUME_DEBOUNCE_MS as y };
+export { OUTBOX_MAX_ENTRIES as A, savedGameUrl as C, CLIENT_VERSION_HEADER as D, RESUME_MAX_STATE_BYTES as E, SAVE_UNKNOWN_CODE as F, UNSUPPORTED_BY_HUB as I, HubAvatar as L, ContentRejectedError as M, HubError as N, OUTBOX_FULL_CODE as O, OfflineError as P, SAVED_OPEN_PARAM as S, RESUME_DEBOUNCE_MS as T, HubSaved as _, TURN_LINK_PARAM as a, SAVED_KIND_PARAM as b, TURN_POLL_MS as c, TurnGame as d, YOUR_TURN_BUZZ as f, saveYourTurnBuzz as g, readYourTurnBuzz as h, HubTurns as i, OfflineApi as j, OUTBOX_MAX_CHARS as k, TURN_QUIET_MS as l, isNewlyDue as m, createHub as n, TURN_CHAT_EVENT as o, YOUR_TURN_BUZZ_KEY as p, hub as r, TURN_EVENT as s, Hub as t, TURN_RESYNC_EVENT as u, SAVED_CHANGE_QUIET_MS as v, HubResume as w, SAVED_OPEN_EVENT as x, SAVED_CHANGE_EVENT as y };
 
 //# sourceMappingURL=src.js.map