mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 04:45:33 -08:00
118 lines
5.3 KiB
JavaScript
118 lines
5.3 KiB
JavaScript
// Planny's wake-up on a freshly opened dashboard: he sits powered down centre
|
|
// stage until the first click or key, gets nudged awake (he rocks side to side
|
|
// for one snore), then about five seconds of him powering on, then a glide
|
|
// into the rail as the menu comes in.
|
|
//
|
|
// The beats before the glide are pure CSS (keyframes on delays under
|
|
// `.wake.booting`, see app.css). The glide is the one part CSS cannot know on
|
|
// its own, because it ends wherever the rail's Planny sits right now, so this
|
|
// measures it once and hands CSS a single transform through --wake-glide.
|
|
//
|
|
// No DOM access at module scope, so `node --test` can import it.
|
|
|
|
// When the glide starts, and when the run is over at the latest. The CSS
|
|
// delays are the beats before GLIDE_AT_MS; the glide itself is 0.6 s.
|
|
export const GLIDE_AT_MS = 4300;
|
|
export const DONE_AT_MS = 5000;
|
|
|
|
// Plays the wake-up and resolves `{ skipped }` once the dashboard is fully
|
|
// awake. He waits powered down until the first click or key anywhere, which
|
|
// nudges him (`.stirring`) and calls `stir()` -- the page's cue to play one
|
|
// full snore, since a browser only lets a page make noise after a real click
|
|
// or keypress. The boot starts once the promise `stir()` returns settles (at
|
|
// once without one), and calls `onStart()`, the page's cue for the boot-up
|
|
// sound. `onGlide({ instant })` is the page's cue to bring the menu in: called
|
|
// at the glide, or with `instant: true` if the run ends before one (a skip).
|
|
// From the nudge on, clicks and keys are swallowed, so the run always plays
|
|
// out to the end with its sound; only `signal` aborting (the page leaving the
|
|
// dashboard, dormant or mid-run) cuts it short, as a skip. Under reduced
|
|
// motion nothing is shown and it resolves at once.
|
|
export function playWake({ stage, bot, target, stir, onStart, onGlide, signal }) {
|
|
return new Promise((resolve) => {
|
|
if (matchMedia("(prefers-reduced-motion: reduce)").matches || signal?.aborted) {
|
|
resolve({ skipped: false });
|
|
return;
|
|
}
|
|
const timers = [];
|
|
let glided = false;
|
|
let over = false;
|
|
|
|
const onGlideEnd = (e) => {
|
|
if (e.target === bot && e.propertyName === "transform") end(false);
|
|
};
|
|
const skip = () => end(true);
|
|
// Browser and OS shortcuts (reload, tab switch, devtools) still go through.
|
|
const swallow = (e) => {
|
|
if (e.ctrlKey || e.metaKey || e.altKey) return;
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
};
|
|
|
|
function glide() {
|
|
glided = true;
|
|
// Measured untransformed, as the sketch's glideToSlot() does: the
|
|
// transform-origin is the drawing's top-left, so the move is the gap
|
|
// between the two top-left corners and the scale is the width ratio.
|
|
// The target's own box, not its bounding rect: the rail's Planny is
|
|
// usually tilted mid-flight, and a tilted box measures wider than he
|
|
// is. Centred on the rect, which the tilt barely moves.
|
|
const from = bot.getBoundingClientRect();
|
|
const rect = target.getBoundingClientRect();
|
|
const w = target.clientWidth || rect.width;
|
|
const h = target.clientHeight || rect.height;
|
|
const left = rect.left + (rect.width - w) / 2;
|
|
const top = rect.top + (rect.height - h) / 2;
|
|
const scale = from.width ? w / from.width : 1;
|
|
bot.style.setProperty("--wake-glide", `translate(${left - from.left}px, ${top - from.top}px) scale(${scale})`);
|
|
bot.addEventListener("transitionend", onGlideEnd);
|
|
stage.classList.add("gliding");
|
|
onGlide({ instant: false });
|
|
}
|
|
|
|
function end(skipped) {
|
|
if (over) return;
|
|
over = true;
|
|
for (const t of timers) clearTimeout(t);
|
|
document.removeEventListener("pointerdown", start, true);
|
|
document.removeEventListener("keydown", start, true);
|
|
document.removeEventListener("pointerdown", swallow, true);
|
|
document.removeEventListener("keydown", swallow, true);
|
|
bot.removeEventListener("transitionend", onGlideEnd);
|
|
signal?.removeEventListener("abort", skip);
|
|
stage.hidden = true;
|
|
stage.classList.remove("dormant", "stirring", "booting", "gliding");
|
|
bot.style.removeProperty("--wake-glide");
|
|
if (!glided) onGlide({ instant: true });
|
|
resolve({ skipped });
|
|
}
|
|
|
|
// The waking click is the only input the run takes: from here on every
|
|
// click and key is swallowed until it ends.
|
|
function start(e) {
|
|
e.preventDefault();
|
|
document.removeEventListener("pointerdown", start, true);
|
|
document.removeEventListener("keydown", start, true);
|
|
stage.classList.replace("dormant", "stirring");
|
|
document.addEventListener("pointerdown", swallow, true);
|
|
document.addEventListener("keydown", swallow, true);
|
|
Promise.resolve(stir?.()).then(boot);
|
|
}
|
|
|
|
function boot() {
|
|
if (over) return;
|
|
stage.classList.replace("stirring", "booting");
|
|
onStart?.();
|
|
timers.push(setTimeout(glide, GLIDE_AT_MS));
|
|
// The glide's transitionend normally ends the run a touch earlier; this
|
|
// is the fallback for a transition that never fires (a hidden tab).
|
|
timers.push(setTimeout(() => end(false), DONE_AT_MS));
|
|
}
|
|
|
|
document.addEventListener("pointerdown", start, true);
|
|
document.addEventListener("keydown", start, true);
|
|
signal?.addEventListener("abort", skip);
|
|
stage.hidden = false;
|
|
stage.classList.add("dormant");
|
|
});
|
|
}
|