The camera now behaves as the page to the left of the first one: a swipe right pushes the home screen (wallpaper included) to the right while the camera follows the finger in from the left edge, and finishes the slide when the finger lets go. Before, the home screen rubber-banded and the camera was revealed by a clip from the edge. Same in the scroll story, the playground gesture and its demo button; in the playground a short swipe springs back, and a swipe left slides the camera out again. The white flash at the end of the camera chapter was a shutter flash over the whole screen; it read as a glitch while scrolling into the next chapter. The shutter button now presses in instead. Checked in Chrome: the camera chapters stepped through in 0.02 steps show no brightness spike; the playground swipe in, swipe back, short swipe and demo button; no console errors or sideways scrolling at 1440 x 900 and 390 x 844. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1285 lines
51 KiB
JavaScript
1285 lines
51 KiB
JavaScript
/* Flexera Launcher landing page. Plain JavaScript, no libraries, nothing loaded from elsewhere.
|
|
*
|
|
* The phone is built here, three times: a looping teaser in the hero, one that the page's scroll
|
|
* position drives through seven chapters, and one people can play with. All three draw from the
|
|
* same state object (see blank()), so a picture of the phone is a pure function of that state:
|
|
* the story computes it from the scroll position, the playground animates it from gestures. */
|
|
(() => {
|
|
'use strict';
|
|
|
|
/** The version shown on the page. Change it here after a release. */
|
|
const VERSION = '0.13.0';
|
|
|
|
const motion = window.matchMedia('(prefers-reduced-motion: reduce)');
|
|
let reduced = motion.matches;
|
|
|
|
/* ------------------------------------------------------------------ math */
|
|
const clamp = (v, a = 0, b = 1) => (v < a ? a : v > b ? b : v);
|
|
const lerp = (a, b, t) => a + (b - a) * t;
|
|
const seg = (t, a, b) => clamp((t - a) / (b - a));
|
|
const inOut = (t) => (t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2);
|
|
const outCubic = (t) => 1 - Math.pow(1 - t, 3);
|
|
const linear = (t) => t;
|
|
const smooth = (t) => t * t * (3 - 2 * t);
|
|
const E = (t, a, b) => inOut(seg(t, a, b));
|
|
/** Eased value along key points [[t, value], ...]. */
|
|
function keys(t, pts) {
|
|
if (t <= pts[0][0]) return pts[0][1];
|
|
for (let i = 1; i < pts.length; i++) {
|
|
if (t <= pts[i][0]) return lerp(pts[i - 1][1], pts[i][1], inOut(seg(t, pts[i - 1][0], pts[i][0])));
|
|
}
|
|
return pts[pts.length - 1][1];
|
|
}
|
|
/** Eased position along key points [[t, x, y], ...]. */
|
|
const route = (t, pts) => ({ x: keys(t, pts.map((p) => [p[0], p[1]])), y: keys(t, pts.map((p) => [p[0], p[2]])) });
|
|
const near = (t, list, eps) => list.some((v) => t > v - eps && t < v + eps * 2);
|
|
/** A pull against a wall: follows the finger at first, then gives less and less. */
|
|
const rubber = (x) => Math.sign(x) * 96 * (1 - Math.exp(-Math.abs(x) / 140));
|
|
|
|
/* ------------------------------------------------------------------ data */
|
|
const GRADS = {
|
|
cyan: ['#1ddbfd', '#3d6ff2'],
|
|
blue: ['#4a7cf6', '#653df0'],
|
|
violet: ['#8a4dff', '#f04ff0'],
|
|
sunset: ['#fc59fb', '#ff8a5b'],
|
|
mint: ['#2ee6a8', '#0f9fb8'],
|
|
gold: ['#ffd34e', '#ff9440'],
|
|
rose: ['#ff5c7a', '#cf2470'],
|
|
slate: ['#8e96bd', '#4a4f78'],
|
|
};
|
|
const APPS = [
|
|
['Authenticator', 'shield', 'slate'],
|
|
['Banking', 'bank', 'mint'],
|
|
['Books', 'book', 'gold'],
|
|
['Browser', 'globe', 'cyan'],
|
|
['Calculator', 'calc', 'slate'],
|
|
['Calendar', 'cal', 'blue'],
|
|
['Camera', 'camera', 'violet'],
|
|
['Clock', 'clock', 'blue'],
|
|
['Contacts', 'person', 'cyan'],
|
|
['Files', 'files', 'gold'],
|
|
['Fitness', 'pulse', 'rose'],
|
|
['Gallery', 'image', 'sunset'],
|
|
['Mail', 'mail', 'rose'],
|
|
['Maps', 'map', 'mint'],
|
|
['Messages', 'msg', 'cyan', 'Sam: Dinner at 8? I booked a table'],
|
|
['Music', 'music', 'violet'],
|
|
['News', 'news', 'slate'],
|
|
['Notes', 'notes', 'gold'],
|
|
['Phone', 'phone', 'mint'],
|
|
['Podcasts', 'mic', 'violet'],
|
|
['Recorder', 'wave', 'rose'],
|
|
['Settings', 'sliders', 'slate'],
|
|
['Shop', 'bag', 'sunset'],
|
|
['Translate', 'translate', 'blue'],
|
|
['Travel', 'plane', 'cyan'],
|
|
['Video', 'play', 'rose'],
|
|
['Wallet', 'wallet', 'mint'],
|
|
['Weather', 'sun', 'gold'],
|
|
['Zen', 'moon', 'blue'],
|
|
].map(([n, g, c, note]) => ({ n, g, c, note }));
|
|
const APP = Object.fromEntries(APPS.map((a) => [a.n, a]));
|
|
const LETTERS = [...new Set(APPS.map((a) => a.n[0]))];
|
|
const L = (letter) => LETTERS.indexOf(letter);
|
|
const FOLDERS = {
|
|
media: { title: 'Media', apps: ['Video', 'Podcasts', 'Gallery', 'Books', 'News'] },
|
|
tools: { title: 'Tools', apps: ['Calculator', 'Files', 'Recorder', 'Translate', 'Notes', 'Authenticator'] },
|
|
};
|
|
const HOME = [
|
|
[
|
|
{ k: 'clock', c: 0, r: 0, w: 4, h: 2 },
|
|
{ k: 'pics', c: 2, r: 2, w: 2, h: 2 },
|
|
{ app: 'Maps', c: 0, r: 2 }, { app: 'Music', c: 1, r: 2 },
|
|
{ app: 'Mail', c: 0, r: 3 }, { app: 'Calendar', c: 1, r: 3 },
|
|
{ folder: 'media', c: 0, r: 4 }, { app: 'Weather', c: 1, r: 4 }, { app: 'Wallet', c: 2, r: 4 }, { folder: 'tools', c: 3, r: 4 },
|
|
{ app: 'Phone', c: 0, r: 5 }, { app: 'Messages', c: 1, r: 5, dot: true }, { app: 'Browser', c: 2, r: 5 }, { app: 'Camera', c: 3, r: 5 },
|
|
],
|
|
[
|
|
{ app: 'Fitness', c: 0, r: 0 }, { app: 'Zen', c: 1, r: 0 }, { app: 'Travel', c: 2, r: 0 }, { app: 'Shop', c: 3, r: 0 },
|
|
{ app: 'Banking', c: 0, r: 1 }, { app: 'Contacts', c: 1, r: 1 }, { app: 'Clock', c: 2, r: 1 }, { app: 'Settings', c: 3, r: 1 },
|
|
{ app: 'Translate', c: 0, r: 2 }, { app: 'Recorder', c: 1, r: 2 },
|
|
],
|
|
];
|
|
|
|
/* ------------------------------------------------------------------ the phone */
|
|
const W = 390;
|
|
const H = 844;
|
|
const SIDE = 14;
|
|
const CW = (W - 2 * SIDE) / 4;
|
|
const RH = 104;
|
|
const GRID_TOP = 56;
|
|
const LIST_TOP = 46;
|
|
const MENU_X = 120;
|
|
const CLOCK_W = 4 * CW - 36;
|
|
const DEFAULT_WEIGHT = 300;
|
|
|
|
const gl = (id, cls = 'gl') => `<svg class="${cls}" aria-hidden="true"><use href="#g-${id}"/></svg>`;
|
|
function icon(app, cls = '') {
|
|
const [a, b] = GRADS[app.c];
|
|
return `<span class="ic${cls}" style="--a:${a};--b:${b}">${gl(app.g, '')}</span>`;
|
|
}
|
|
|
|
function cellMarkup(it) {
|
|
const box = `left:${SIDE + it.c * CW}px;top:${GRID_TOP + it.r * RH}px;width:${(it.w || 1) * CW}px;height:${(it.h || 1) * RH}px`;
|
|
if (it.k === 'clock') {
|
|
return `<div class="w-clock" data-key="clock" style="${box}">
|
|
<div class="clk__line clk__time"><span data-time>9:41</span></div>
|
|
<div class="clk__line clk__date"><span data-date>Thursday, November 12</span></div>
|
|
<div class="clk__line clk__wx"><span>18° · Clear</span></div></div>`;
|
|
}
|
|
if (it.k === 'pics') {
|
|
return `<div class="w-pics" data-key="pics" style="${box}"><div class="pics">
|
|
<i class="pic pic--a on"></i><i class="pic pic--b"></i><i class="pic pic--c"></i></div></div>`;
|
|
}
|
|
if (it.folder) {
|
|
const f = FOLDERS[it.folder];
|
|
return `<div class="cell" data-key="${it.folder}" data-folder="${it.folder}" style="${box}">
|
|
<span class="fic">${f.apps.slice(0, 4).map((n) => icon(APP[n], ' ic--mini')).join('')}</span>
|
|
<span class="lbl">${f.title}</span></div>`;
|
|
}
|
|
const app = APP[it.app];
|
|
return `<div class="cell" data-key="${app.n}" data-app="${app.n}" style="${box}">${icon(app)}${it.dot ? '<i class="ndot"></i>' : ''}<span class="lbl">${app.n}</span></div>`;
|
|
}
|
|
|
|
function listMarkup() {
|
|
let html = `<div class="search">${gl('search')}<span>Search apps</span></div>`;
|
|
for (const letter of LETTERS) {
|
|
html += `<div class="grp" data-letter="${letter}"><div class="hdr">${letter}</div>`;
|
|
for (const a of APPS.filter((x) => x.n[0] === letter)) {
|
|
html += `<div class="row${a.note ? ' row--note' : ''}" data-row="${a.n}">${icon(a)}
|
|
<span class="row__t"><span class="row__n">${a.n}</span>${a.note ? `<span class="row__p">${a.note}</span>` : ''}</span></div>`;
|
|
}
|
|
html += '</div>';
|
|
}
|
|
return html;
|
|
}
|
|
|
|
function phoneMarkup() {
|
|
const pages = HOME.map((items, pi) => `<div class="page" style="left:${pi * W}px">${items.map(cellMarkup).join('')}</div>`).join('');
|
|
const dots = HOME.map((_, i) => `<i${i ? '' : ' class="on"'}></i>`).join('');
|
|
return `<div class="phone"><div class="screen">
|
|
<div class="world"><div class="wall"></div>
|
|
<div class="home"><div class="pages">${pages}</div><div class="pagedots">${dots}</div></div>
|
|
</div>
|
|
<div class="fscrim"></div>
|
|
<div class="fcard"><div class="fcard__grid"></div><div class="fcard__title"></div></div>
|
|
<div class="drawer"><div class="drawer__in">
|
|
<div class="list">${listMarkup()}</div>
|
|
<div class="alpha"><span class="alpha__s">${gl('search', 'gl')}</span>${LETTERS.map((l) => `<span class="alpha__l">${l}</span>`).join('')}</div>
|
|
<div class="bubble"></div>
|
|
</div></div>
|
|
<div class="menu">
|
|
<div class="mi">${gl('info')}App info</div>
|
|
<div class="mi">${gl('widgets')}Widgets</div>
|
|
<div class="mi">${gl('edit')}Customize</div>
|
|
<div class="mi mi--hide">${gl('eyeoff')}Hide app</div>
|
|
</div>
|
|
<div class="snack"><span class="snack__t">Podcasts is hidden</span><button type="button" class="snack__undo" tabindex="-1">Undo</button></div>
|
|
<div class="sheet"><i class="sheet__grab"></i><h4>Clock</h4>
|
|
<p class="sheet__h">Alignment</p>
|
|
<div class="seg" data-seg="align"><span data-v="0" data-k="align-0">Left</span><span data-v="0.5" data-k="align-0.5">Center</span><span data-v="1" data-k="align-1">Right</span></div>
|
|
<p class="sheet__h">Size</p>
|
|
<div class="seg"><span data-k="size-s">Small</span><span class="on" data-k="size-m">Medium</span><span data-k="size-l">Large</span></div>
|
|
<p class="sheet__h">Weight</p>
|
|
<div class="seg" data-seg="weight"><span data-v="100" data-k="weight-100">Thin</span><span data-v="300" data-k="weight-300">Light</span><span data-v="400" data-k="weight-400">Regular</span><span data-v="700" data-k="weight-700">Bold</span></div>
|
|
</div>
|
|
<div class="cam">
|
|
<div class="cam__view"><i class="cam__hill cam__hill--1"></i><i class="cam__hill cam__hill--2"></i><i class="cam__grid"></i><i class="cam__focus"></i></div>
|
|
<div class="cam__modes"><span>Video</span><span class="on">Photo</span><span>Portrait</span></div>
|
|
<div class="cam__bar"><i class="cam__thumb"></i><i class="cam__shutter"></i><i class="cam__flip">${gl('flip')}</i></div>
|
|
<button type="button" class="cam__close" tabindex="-1" aria-label="Close camera">×</button>
|
|
</div>
|
|
<div class="sbar"><span class="sbar__time">9:41</span><span class="sbar__icons"><span class="sbar__sig"><i></i><i></i><i></i><i></i></span><span class="sbar__bat"></span></span></div>
|
|
<i class="notch"></i>
|
|
<i class="gbar"></i>
|
|
<div class="finger"><i class="finger__ring"></i></div>
|
|
</div></div>`;
|
|
}
|
|
|
|
/** Everything the phone can show. Numbers are 0..1 unless noted. */
|
|
function blank() {
|
|
return {
|
|
drawer: 0,
|
|
list: 0, // px the app list is scrolled
|
|
scrub: 0, // letter index, fractional
|
|
scrubShow: 0,
|
|
folder: 0,
|
|
folderId: 'media',
|
|
pull: 0, // px the pages are dragged sideways
|
|
page: 0,
|
|
camera: 0, // the camera is the page left of the first one: 0 home, 1 camera fully in
|
|
shutter: 0,
|
|
sheet: 0,
|
|
align: 0, // 0 left, .5 center, 1 right
|
|
weight: DEFAULT_WEIGHT,
|
|
menu: 0,
|
|
menuY: 420,
|
|
menuPick: 0,
|
|
held: null,
|
|
hidden: {},
|
|
snack: 0,
|
|
snackText: 'Podcasts is hidden',
|
|
finger: { x: 195, y: 600, o: 0, press: 0, ring: 0 },
|
|
};
|
|
}
|
|
|
|
/** Offset of el inside ancestor, summed along the offsetParent chain (ignores transforms). */
|
|
function offsetIn(el, ancestor) {
|
|
let x = 0;
|
|
let y = 0;
|
|
while (el && el !== ancestor) {
|
|
x += el.offsetLeft;
|
|
y += el.offsetTop;
|
|
el = el.offsetParent;
|
|
}
|
|
return { x, y };
|
|
}
|
|
|
|
class Phone {
|
|
constructor(host) {
|
|
this.host = host;
|
|
host.innerHTML = phoneMarkup();
|
|
const q = (sel) => host.querySelector(sel);
|
|
const qa = (sel) => [...host.querySelectorAll(sel)];
|
|
this.el = q('.phone');
|
|
this.screen = q('.screen');
|
|
this.r = {
|
|
world: q('.world'), home: q('.home'), pages: q('.pages'), dots: qa('.pagedots i'),
|
|
fscrim: q('.fscrim'), fcard: q('.fcard'), fgrid: q('.fcard__grid'), ftitle: q('.fcard__title'),
|
|
drawer: q('.drawer'), drawerIn: q('.drawer__in'), list: q('.list'), alpha: q('.alpha'), letters: qa('.alpha__l'), bubble: q('.bubble'),
|
|
menu: q('.menu'), menuHide: q('.mi--hide'), snack: q('.snack'), snackT: q('.snack__t'),
|
|
sheet: q('.sheet'), segAlign: qa('[data-seg="align"] span'), segWeight: qa('[data-seg="weight"] span'),
|
|
cam: q('.cam'), shutter: q('.cam__shutter'), finger: q('.finger'), ring: q('.finger__ring'),
|
|
clockLines: qa('.clk__line > span'), clockTime: q('.clk__time'), time: q('[data-time]'), date: q('[data-date]'), stime: q('.sbar__time'),
|
|
pics: qa('.pic'),
|
|
rows: new Map(qa('.row').map((el) => [el.dataset.row, el])),
|
|
};
|
|
this.scale = 0.5;
|
|
this.picIndex = 0;
|
|
this.folderId = null;
|
|
this.fillFolder('media');
|
|
this.fit();
|
|
if ('ResizeObserver' in window) new ResizeObserver(() => this.fit()).observe(host);
|
|
this.measure();
|
|
}
|
|
|
|
fit() {
|
|
const w = this.host.clientWidth;
|
|
if (!w) return;
|
|
this.scale = w / 414;
|
|
this.el.style.setProperty('--s', this.scale.toFixed(5));
|
|
}
|
|
|
|
/** Reads the layout once, so that animating never has to. Call again when rows change height. */
|
|
measure() {
|
|
const r = this.r;
|
|
const g = {};
|
|
g.groupTop = {};
|
|
for (const grp of r.list.querySelectorAll('.grp')) g.groupTop[grp.dataset.letter] = grp.offsetTop;
|
|
g.rowTop = {};
|
|
g.rowH = {};
|
|
for (const [name, el] of r.rows) {
|
|
g.rowTop[name] = el.offsetTop;
|
|
g.rowH[name] = el.offsetHeight || 54;
|
|
}
|
|
g.maxScroll = Math.max(0, LIST_TOP + r.list.offsetHeight + 150 - H);
|
|
const a = offsetIn(r.alpha, this.screen);
|
|
g.alphaX = a.x + r.alpha.offsetWidth / 2;
|
|
g.letterY = r.letters.map((l) => a.y + l.offsetTop + l.offsetHeight / 2);
|
|
g.home = {};
|
|
for (const el of this.host.querySelectorAll('.page:first-child [data-key]')) {
|
|
const target = el.querySelector('.ic, .fic') || el;
|
|
const p = offsetIn(target, this.screen);
|
|
g.home[el.dataset.key] = { x: p.x + target.offsetWidth / 2, y: p.y + target.offsetHeight / 2 };
|
|
}
|
|
g.fcx = r.fcard.offsetLeft + r.fcard.offsetWidth / 2;
|
|
g.fcy = r.fcard.offsetTop + r.fcard.offsetHeight / 2;
|
|
const sheetTop = H - r.sheet.offsetHeight;
|
|
g.seg = {};
|
|
for (const sp of this.host.querySelectorAll('.seg span')) {
|
|
const p = offsetIn(sp, r.sheet);
|
|
g.seg[sp.dataset.k] = { x: p.x + sp.offsetWidth / 2, y: sheetTop + p.y + sp.offsetHeight / 2 };
|
|
}
|
|
const m = offsetIn(r.menuHide, r.menu);
|
|
g.menuHide = { x: m.x + r.menuHide.offsetWidth / 2, y: m.y + r.menuHide.offsetHeight / 2 };
|
|
g.menuH = r.menu.offsetHeight || 212;
|
|
this.g = g;
|
|
}
|
|
|
|
fillFolder(id) {
|
|
this.folderId = id;
|
|
const f = FOLDERS[id];
|
|
this.r.fgrid.innerHTML = f.apps.map((n) => `<div class="fcard__app">${icon(APP[n])}<span>${n}</span></div>`).join('');
|
|
this.r.ftitle.textContent = f.title;
|
|
if (this.g) this.g.fcy = this.r.fcard.offsetTop + this.r.fcard.offsetHeight / 2;
|
|
}
|
|
|
|
/** Where the list rests when a letter is chosen: its header a little above the middle. */
|
|
scrollFor(i) {
|
|
const letter = LETTERS[clamp(Math.round(i), 0, LETTERS.length - 1)];
|
|
return clamp(LIST_TOP + this.g.groupTop[letter] - H * 0.42, 0, this.g.maxScroll);
|
|
}
|
|
/** scrollFor between letters, snapping near each one, for scroll-driven scrubbing. */
|
|
scrollAt(f) {
|
|
const a = Math.floor(f);
|
|
const b = Math.ceil(f);
|
|
if (a === b) return this.scrollFor(a);
|
|
return lerp(this.scrollFor(a), this.scrollFor(b), smooth(seg(f - a, 0.3, 0.7)));
|
|
}
|
|
letterYAt(f) {
|
|
const ys = this.g.letterY;
|
|
const a = clamp(Math.floor(f), 0, ys.length - 1);
|
|
const b = clamp(a + 1, 0, ys.length - 1);
|
|
return lerp(ys[a], ys[b], clamp(f - a));
|
|
}
|
|
letterAtY(y) {
|
|
const ys = this.g.letterY;
|
|
if (y <= ys[0]) return 0;
|
|
for (let i = 1; i < ys.length; i++) if (y <= ys[i]) return i - 1 + (y - ys[i - 1]) / (ys[i] - ys[i - 1]);
|
|
return ys.length - 1;
|
|
}
|
|
rowY(name, scroll) {
|
|
return LIST_TOP + this.g.rowTop[name] + this.g.rowH[name] / 2 - scroll;
|
|
}
|
|
|
|
tick(now, date) {
|
|
if (this.r.time.textContent !== now) {
|
|
this.r.time.textContent = now;
|
|
this.r.stime.textContent = now;
|
|
}
|
|
if (this.r.date.textContent !== date) this.r.date.textContent = date;
|
|
}
|
|
|
|
nextPicture() {
|
|
this.r.pics[this.picIndex].classList.remove('on');
|
|
this.picIndex = (this.picIndex + 1) % this.r.pics.length;
|
|
this.r.pics[this.picIndex].classList.add('on');
|
|
}
|
|
|
|
render(s) {
|
|
const r = this.r;
|
|
const g = this.g;
|
|
const css = (el, prop, val) => {
|
|
const k = '_' + prop;
|
|
if (el[k] !== val) {
|
|
el[k] = val;
|
|
el.style[prop] = val;
|
|
}
|
|
};
|
|
const d = s.drawer;
|
|
const f = s.folder;
|
|
|
|
// Wallpaper and home share one layer, so a folder blurs both, and the camera, the page to
|
|
// the left of the first one, pushes both to the right as it slides in.
|
|
const cam = s.camera;
|
|
const slide = cam > 0.0005 ? `translateX(${(cam * W).toFixed(1)}px)` : '';
|
|
const shrink = f > 0.001 ? `scale(${(1 - 0.035 * f).toFixed(4)})` : '';
|
|
css(r.world, 'transform', `${slide} ${shrink}`.trim());
|
|
css(r.world, 'filter', f > 0.001 ? `blur(${(f * 16).toFixed(2)}px)` : '');
|
|
css(r.home, 'opacity', (1 - d).toFixed(3));
|
|
css(r.home, 'transform', d > 0.001 ? `translateY(${(-26 * d).toFixed(1)}px) scale(${(1 - 0.05 * d).toFixed(4)})` : '');
|
|
css(r.pages, 'transform', `translateX(${(-s.page * W + s.pull).toFixed(1)}px)`);
|
|
const page = Math.round(clamp(s.page - s.pull / W, 0, HOME.length - 1));
|
|
r.dots.forEach((dot, i) => dot.classList.toggle('on', i === page));
|
|
|
|
// Folder: grows out of its icon.
|
|
css(r.fscrim, 'opacity', (0.34 * f).toFixed(3));
|
|
if (s.folderId !== this.folderId) this.fillFolder(s.folderId);
|
|
if (f > 0.001) {
|
|
const from = g.home[s.folderId] || { x: g.fcx, y: g.fcy };
|
|
css(r.fcard, 'visibility', 'visible');
|
|
css(r.fcard, 'opacity', clamp(f * 2.2).toFixed(3));
|
|
css(r.fcard, 'transform', `translate(${lerp(from.x - g.fcx, 0, f).toFixed(1)}px, ${lerp(from.y - g.fcy, 0, f).toFixed(1)}px) scale(${lerp(0.2, 1, f).toFixed(4)})`);
|
|
} else {
|
|
css(r.fcard, 'visibility', 'hidden');
|
|
}
|
|
|
|
// App list.
|
|
css(r.drawer, 'visibility', d > 0.002 ? 'visible' : 'hidden');
|
|
css(r.drawer, 'opacity', d.toFixed(3));
|
|
css(r.drawerIn, 'transform', d < 0.999 ? `translateY(${((1 - d) * 56).toFixed(1)}px)` : '');
|
|
css(r.list, 'transform', `translateY(${(-s.list).toFixed(1)}px)`);
|
|
|
|
// The wave: letters near the thumb swell and lean out; the chosen one rides in a bubble.
|
|
const show = s.scrubShow;
|
|
const sel = clamp(Math.round(s.scrub), 0, LETTERS.length - 1);
|
|
r.letters.forEach((el, i) => {
|
|
const k = show * Math.exp(-((i - s.scrub) ** 2) / 4.2);
|
|
css(el, 'transform', k > 0.002 ? `translateX(${(-46 * k).toFixed(1)}px) scale(${(1 + 0.6 * k).toFixed(3)})` : '');
|
|
el.classList.toggle('on', show > 0.4 && i === sel);
|
|
});
|
|
css(r.bubble, 'opacity', show.toFixed(3));
|
|
if (show > 0.001) {
|
|
css(r.bubble, 'transform', `translate(${(g.alphaX - 140).toFixed(1)}px, ${(this.letterYAt(s.scrub) - 33).toFixed(1)}px) scale(${(0.5 + 0.5 * show).toFixed(3)})`);
|
|
if (r.bubble.textContent !== LETTERS[sel]) r.bubble.textContent = LETTERS[sel];
|
|
}
|
|
|
|
// Hidden apps fold away.
|
|
for (const [name, el] of r.rows) {
|
|
const x = s.hidden[name] || 0;
|
|
if (el._hx !== x) {
|
|
if (!el._h) el._h = el.offsetHeight;
|
|
el._hx = x;
|
|
el.style.height = x ? `${((1 - x) * el._h).toFixed(1)}px` : '';
|
|
el.style.opacity = x ? (1 - x).toFixed(3) : '';
|
|
}
|
|
el.classList.toggle('held', s.held === name);
|
|
}
|
|
|
|
// Long-press menu and the message after hiding.
|
|
css(r.menu, 'visibility', s.menu > 0.002 ? 'visible' : 'hidden');
|
|
css(r.menu, 'opacity', s.menu.toFixed(3));
|
|
css(r.menu, 'transform', `translate(${MENU_X}px, ${s.menuY.toFixed(1)}px) scale(${(0.9 + 0.1 * s.menu).toFixed(3)})`);
|
|
r.menuHide.classList.toggle('pick', s.menuPick > 0.5);
|
|
css(r.snack, 'visibility', s.snack > 0.002 ? 'visible' : 'hidden');
|
|
css(r.snack, 'opacity', s.snack.toFixed(3));
|
|
css(r.snack, 'transform', `translateY(${((1 - s.snack) * 26).toFixed(1)}px)`);
|
|
if (r.snackT.textContent !== s.snackText) r.snackT.textContent = s.snackText;
|
|
|
|
// Camera, sliding in from the left with the home screen.
|
|
css(r.cam, 'visibility', cam > 0.0005 ? 'visible' : 'hidden');
|
|
css(r.cam, 'transform', `translateX(${((cam - 1) * W).toFixed(1)}px)`);
|
|
css(r.shutter, 'transform', s.shutter > 0.5 ? 'scale(.86)' : '');
|
|
|
|
// Clock options sheet and the clock itself.
|
|
css(r.sheet, 'transform', `translateY(${((1 - s.sheet) * 105).toFixed(2)}%)`);
|
|
const pick = (els, v) => {
|
|
let best = null;
|
|
let bd = Infinity;
|
|
for (const e of els) {
|
|
const dd = Math.abs(+e.dataset.v - v);
|
|
if (dd < bd) {
|
|
bd = dd;
|
|
best = e;
|
|
}
|
|
}
|
|
els.forEach((e) => e.classList.toggle('on', e === best));
|
|
};
|
|
pick(r.segAlign, s.align);
|
|
pick(r.segWeight, s.weight);
|
|
css(r.clockTime, 'fontWeight', String(Math.round(s.weight)));
|
|
for (const sp of r.clockLines) {
|
|
css(sp, 'transform', s.align > 0.001 ? `translateX(${(s.align * (CLOCK_W - sp.offsetWidth)).toFixed(1)}px)` : '');
|
|
}
|
|
|
|
// The finger that shows each gesture.
|
|
const fg = s.finger;
|
|
css(r.finger, 'opacity', fg.o.toFixed(3));
|
|
if (fg.o > 0.001) {
|
|
css(r.finger, 'transform', `translate(${fg.x.toFixed(1)}px, ${fg.y.toFixed(1)}px) scale(${(1 - 0.16 * fg.press).toFixed(3)})`);
|
|
}
|
|
const ring = fg.ring.toFixed(3);
|
|
if (r.ring._ring !== ring) {
|
|
r.ring._ring = ring;
|
|
r.ring.style.setProperty('--ring', ring);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ the story */
|
|
/**
|
|
* The phone at story position P, from 0 to 7: one unit per chapter, each chapter's end matching
|
|
* the next one's start, so scrolling either way plays the same film.
|
|
*/
|
|
function storyState(ph, P) {
|
|
const s = blank();
|
|
P = clamp(P, 0, 7);
|
|
const ch = Math.min(6, Math.floor(P));
|
|
const t = P - ch;
|
|
const F = s.finger;
|
|
const g = ph.g;
|
|
|
|
switch (ch) {
|
|
case 0: { // home; a finger gets ready at the bottom
|
|
const a = seg(t, 0.62, 0.82);
|
|
F.o = a;
|
|
F.x = 195;
|
|
F.y = 790 - 8 * a;
|
|
break;
|
|
}
|
|
case 1: { // swipe up, the list fades in, flicks to M
|
|
const up = E(t, 0.05, 0.36);
|
|
F.x = 195;
|
|
F.y = lerp(782, 470, up);
|
|
F.o = 1 - seg(t, 0.36, 0.46);
|
|
F.press = t < 0.36 ? 1 : 0;
|
|
s.drawer = E(t, 0.1, 0.4);
|
|
s.list = E(t, 0.5, 0.92) * ph.scrollFor(L('M'));
|
|
break;
|
|
}
|
|
case 2: { // scrub M → Z → C
|
|
s.drawer = 1;
|
|
const idx = keys(t, [[0.15, L('M')], [0.48, LETTERS.length - 1], [0.53, LETTERS.length - 1], [0.86, L('C')]]);
|
|
s.scrub = idx;
|
|
s.scrubShow = seg(t, 0.06, 0.15) * (1 - seg(t, 0.88, 0.97));
|
|
s.list = ph.scrollAt(idx);
|
|
F.x = lerp(g.alphaX - 60, g.alphaX, E(t, 0, 0.1));
|
|
F.y = ph.letterYAt(idx);
|
|
F.o = seg(t, 0, 0.08) * (1 - seg(t, 0.88, 0.97));
|
|
F.press = s.scrubShow > 0.5 ? 1 : 0;
|
|
break;
|
|
}
|
|
case 3: { // back home, tap the folder, blur
|
|
s.drawer = 1 - E(t, 0, 0.18);
|
|
s.list = ph.scrollFor(L('C'));
|
|
const fp = g.home.media;
|
|
F.x = fp.x;
|
|
F.y = fp.y;
|
|
F.o = seg(t, 0.2, 0.27) * (1 - seg(t, 0.42, 0.5));
|
|
F.press = t > 0.29 && t < 0.36 ? 1 : 0;
|
|
s.folder = E(t, 0.33, 0.62);
|
|
break;
|
|
}
|
|
case 4: { // close the folder, swipe right: the camera slides in as the page to the left
|
|
s.folder = 1 - E(t, 0, 0.15);
|
|
const drag = E(t, 0.26, 0.55);
|
|
const reach = 230 / W; // how far the finger drags the screen before letting go
|
|
F.x = lerp(70, 70 + 230, drag);
|
|
F.y = 420;
|
|
F.o = seg(t, 0.18, 0.25) * (1 - seg(t, 0.55, 0.62));
|
|
F.press = t > 0.25 && t < 0.56 ? 1 : 0;
|
|
// The screen follows the finger, then finishes the slide on its own once it lets go.
|
|
s.camera = reach * drag + (1 - reach) * E(t, 0.55, 0.74);
|
|
s.shutter = t > 0.86 && t < 0.92 ? 1 : 0;
|
|
break;
|
|
}
|
|
case 5: { // close the camera, hold the clock, restyle it
|
|
s.camera = 1 - E(t, 0, 0.14);
|
|
const ck = g.home.clock;
|
|
const sg = g.seg;
|
|
const taps = [0.42, 0.52, 0.62, 0.72, 0.81, 0.88, 0.95];
|
|
const fp = route(t, [
|
|
[0.16, ck.x, ck.y], [0.32, ck.x, ck.y],
|
|
[taps[0], sg['align-0.5'].x, sg['align-0.5'].y],
|
|
[taps[1], sg['align-1'].x, sg['align-1'].y],
|
|
[taps[2], sg['align-0'].x, sg['align-0'].y],
|
|
[taps[3], sg['weight-100'].x, sg['weight-100'].y],
|
|
[taps[4], sg['weight-400'].x, sg['weight-400'].y],
|
|
[taps[5], sg['weight-700'].x, sg['weight-700'].y],
|
|
[taps[6], sg['weight-300'].x, sg['weight-300'].y],
|
|
]);
|
|
F.x = fp.x;
|
|
F.y = fp.y;
|
|
F.o = seg(t, 0.14, 0.2) * (1 - seg(t, 0.96, 1));
|
|
F.ring = seg(t, 0.2, 0.3) * (1 - seg(t, 0.3, 0.33));
|
|
F.press = (t > 0.2 && t < 0.31) || near(t, taps, 0.012) ? 1 : 0;
|
|
s.sheet = E(t, 0.3, 0.42);
|
|
s.align = keys(t, [[0.42, 0], [0.45, 0.5], [0.52, 0.5], [0.55, 1], [0.62, 1], [0.65, 0]]);
|
|
s.weight = keys(t, [[0.72, 300], [0.75, 100], [0.81, 100], [0.84, 400], [0.88, 400], [0.91, 700], [0.95, 700], [0.98, 300]]);
|
|
break;
|
|
}
|
|
case 6: { // the list again, hold Podcasts, Hide app, Undo message
|
|
s.sheet = 1 - E(t, 0, 0.12);
|
|
s.drawer = E(t, 0.12, 0.28);
|
|
s.list = ph.scrollFor(L('P'));
|
|
const ry = ph.rowY('Podcasts', s.list);
|
|
s.menuY = ry + 34;
|
|
const hide = { x: MENU_X + g.menuHide.x, y: s.menuY + g.menuHide.y };
|
|
const fp = route(t, [[0.3, 150, ry], [0.56, 150, ry], [0.64, hide.x, hide.y]]);
|
|
F.x = fp.x;
|
|
F.y = fp.y;
|
|
F.o = seg(t, 0.28, 0.33) * (1 - seg(t, 0.72, 0.8));
|
|
F.ring = seg(t, 0.34, 0.5) * (1 - seg(t, 0.5, 0.53));
|
|
F.press = (t > 0.33 && t < 0.52) || (t > 0.65 && t < 0.69) ? 1 : 0;
|
|
s.held = t > 0.34 && t < 0.72 ? 'Podcasts' : null;
|
|
s.menu = E(t, 0.5, 0.56) * (1 - E(t, 0.69, 0.74));
|
|
s.menuPick = t > 0.65 && t < 0.72 ? 1 : 0;
|
|
s.hidden = { Podcasts: E(t, 0.72, 0.82) };
|
|
s.snack = E(t, 0.76, 0.84);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
function setupStory(ph) {
|
|
const box = document.querySelector('.story__steps');
|
|
const steps = [...document.querySelectorAll('[data-step]')];
|
|
const num = document.querySelector('[data-story-num]');
|
|
const rail = [...document.querySelectorAll('[data-story-rail] li')];
|
|
let lastChapter = -1;
|
|
let lastP = -1;
|
|
return function update() {
|
|
const vh = window.innerHeight;
|
|
const P = clamp(-box.getBoundingClientRect().top / vh + 0.5, 0, 7);
|
|
const ch = Math.min(6, Math.floor(P));
|
|
// Without motion, each chapter shows its finished picture.
|
|
const shown = reduced ? ch + 0.985 : P;
|
|
if (Math.abs(shown - lastP) > 0.0002) {
|
|
lastP = shown;
|
|
ph.render(storyState(ph, shown));
|
|
}
|
|
if (ch !== lastChapter) {
|
|
lastChapter = ch;
|
|
steps.forEach((el, i) => el.classList.toggle('is-active', i === ch));
|
|
num.textContent = String(ch + 1).padStart(2, '0');
|
|
rail.forEach((li, i) => {
|
|
li.classList.toggle('on', i === ch);
|
|
li.classList.toggle('done', i < ch);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ the hero teaser */
|
|
/** Story positions 0.55 to 3.19 on a loop: home, swipe up, scrub, back home. */
|
|
function heroP(ms) {
|
|
const cycle = 12500;
|
|
const t = (ms % cycle) / cycle;
|
|
return t < 0.1 ? 0.55 : lerp(0.55, 3.19, (t - 0.1) / 0.9);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ the playground */
|
|
function setupPlay(ph) {
|
|
const s = blank();
|
|
const caption = document.querySelector('[data-caption]');
|
|
const HELLO = 'Swipe up on the home screen to open your apps.';
|
|
const say = (text) => {
|
|
if (caption && caption.textContent !== text) caption.textContent = text;
|
|
};
|
|
|
|
// A tiny tween engine over paths into the state ("drawer", "finger.x", "hidden.Podcasts").
|
|
let anims = [];
|
|
let raf = 0;
|
|
let token = 0;
|
|
let scrubbing = false;
|
|
let listTarget = null;
|
|
let snackTimer = 0;
|
|
let lastHidden = null;
|
|
const getp = (p) => p.split('.').reduce((o, k) => (o == null ? undefined : o[k]), s);
|
|
const setp = (p, v) => {
|
|
const ks = p.split('.');
|
|
let o = s;
|
|
for (let i = 0; i < ks.length - 1; i++) o = o[ks[i]];
|
|
o[ks[ks.length - 1]] = v;
|
|
};
|
|
function derive() {
|
|
let more = false;
|
|
if (scrubbing) {
|
|
s.finger.x = ph.g.alphaX;
|
|
s.finger.y = ph.letterYAt(s.scrub);
|
|
listTarget = ph.scrollFor(s.scrub);
|
|
}
|
|
if (listTarget != null) {
|
|
const d = listTarget - s.list;
|
|
if (Math.abs(d) < 0.5) {
|
|
s.list = listTarget;
|
|
listTarget = null;
|
|
} else {
|
|
s.list += d * 0.32;
|
|
more = true;
|
|
}
|
|
}
|
|
return more;
|
|
}
|
|
function frame(now) {
|
|
raf = 0;
|
|
anims = anims.filter((a) => {
|
|
const k = a.dur ? clamp((now - a.start) / a.dur) : 1;
|
|
setp(a.key, lerp(a.from, a.to, a.ease(k)));
|
|
if (k >= 1) {
|
|
a.done();
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
const more = derive();
|
|
ph.render(s);
|
|
if (anims.length || more) raf = requestAnimationFrame(frame);
|
|
}
|
|
const kick = () => {
|
|
if (!raf) raf = requestAnimationFrame(frame);
|
|
};
|
|
const drop = (key) => {
|
|
anims = anims.filter((a) => {
|
|
if (a.key !== key) return true;
|
|
a.done();
|
|
return false;
|
|
});
|
|
};
|
|
function to(patch, dur = 320, ease = inOut) {
|
|
const start = performance.now();
|
|
const all = Object.entries(patch).map(([key, v]) => new Promise((done) => {
|
|
drop(key);
|
|
anims.push({ key, from: +getp(key) || 0, to: v, start, dur: reduced ? 0 : dur, ease, done });
|
|
}));
|
|
kick();
|
|
return Promise.all(all);
|
|
}
|
|
function set(patch) {
|
|
for (const [key, v] of Object.entries(patch)) {
|
|
drop(key);
|
|
setp(key, v);
|
|
}
|
|
kick();
|
|
}
|
|
const wait = (ms) => new Promise((r) => setTimeout(r, reduced ? 0 : ms));
|
|
const stopAll = () => {
|
|
token++;
|
|
anims.forEach((a) => a.done());
|
|
anims = [];
|
|
scrubbing = false;
|
|
};
|
|
|
|
// Building blocks shared by gestures and the demo buttons.
|
|
const fingerAt = (x, y) => set({ 'finger.x': x, 'finger.y': y });
|
|
const fingerOff = () => to({ 'finger.o': 0, 'finger.press': 0, 'finger.ring': 0 }, 220);
|
|
async function closeAll() {
|
|
s.held = null;
|
|
scrubbing = false;
|
|
await to({ drawer: 0, folder: 0, camera: 0, menu: 0, sheet: 0, scrubShow: 0, pull: 0, page: 0, snack: 0, menuPick: 0 }, 280);
|
|
}
|
|
const openDrawer = () => to({ drawer: 1 }, 300).then(() => say('Every app, A to Z. Now drag along the letters on the right.'));
|
|
const closeDrawer = () => to({ drawer: 0, menu: 0, scrubShow: 0 }, 260).then(() => { s.held = null; });
|
|
function openFolder(id) {
|
|
s.folderId = id;
|
|
say('Blur behind folders. Tap outside the folder to close it.');
|
|
return to({ folder: 1 }, 480, outCubic);
|
|
}
|
|
const closeFolder = () => to({ folder: 0 }, 300);
|
|
function launchCamera() {
|
|
say('Quick launch. Swipe past the first page and your camera is right there. Swipe left to go back.');
|
|
return to({ pull: 0, page: 0, camera: 1 }, 420, outCubic);
|
|
}
|
|
const closeCamera = () => to({ camera: 0 }, 400).then(() => say('Back home. Try the playground buttons, or just play.'));
|
|
function openMenu(name) {
|
|
s.held = name;
|
|
const ry = ph.rowY(name, s.list);
|
|
const below = ry + 34;
|
|
s.menuY = below + ph.g.menuH > H - 70 ? ry - 34 - ph.g.menuH : below;
|
|
say(`Tap Hide app to hide ${name}.`);
|
|
return to({ menu: 1, 'finger.ring': 0 }, 200, outCubic);
|
|
}
|
|
async function hideApp(name) {
|
|
if (!name) return;
|
|
set({ menuPick: 1 });
|
|
await wait(120);
|
|
await to({ menu: 0 }, 180);
|
|
s.held = null;
|
|
s.menuPick = 0;
|
|
s.snackText = `${name} is hidden`;
|
|
lastHidden = name;
|
|
await to({ [`hidden.${name}`]: 1, snack: 1 }, 380);
|
|
ph.measure();
|
|
say(`${name} is hidden from the list and from search. Tap Undo to bring it back.`);
|
|
clearTimeout(snackTimer);
|
|
snackTimer = setTimeout(() => to({ snack: 0 }, 260), 4200);
|
|
}
|
|
async function unhide(name) {
|
|
if (!name) return;
|
|
clearTimeout(snackTimer);
|
|
await to({ [`hidden.${name}`]: 0, snack: 0 }, 320);
|
|
ph.measure();
|
|
say(`${name} is back. In the app, hidden apps also live under Settings, App drawer, Hidden apps.`);
|
|
}
|
|
async function sweep(from, target, dur) {
|
|
scrubbing = true;
|
|
s.scrub = from;
|
|
await to({ scrub: target }, dur, inOut);
|
|
scrubbing = false;
|
|
}
|
|
|
|
// The demo buttons.
|
|
const demos = {
|
|
async drawer(alive) {
|
|
await closeAll();
|
|
if (!alive()) return;
|
|
fingerAt(195, 790);
|
|
await to({ 'finger.o': 1 }, 160);
|
|
set({ 'finger.press': 1 });
|
|
await to({ 'finger.y': 470, drawer: 1 }, 650);
|
|
set({ 'finger.press': 0 });
|
|
await fingerOff();
|
|
if (alive()) say('Every app, A to Z. Now drag along the letters on the right.');
|
|
},
|
|
async scrub(alive) {
|
|
if (s.drawer < 0.99 || s.folder > 0.01 || s.camera > 0.01) {
|
|
await demos.drawer(alive);
|
|
if (!alive()) return;
|
|
}
|
|
const start = L('B');
|
|
fingerAt(ph.g.alphaX, ph.letterYAt(start));
|
|
s.scrub = start;
|
|
await to({ 'finger.o': 1, scrubShow: 1 }, 220);
|
|
set({ 'finger.press': 1 });
|
|
if (!alive()) return;
|
|
await sweep(start, LETTERS.length - 1, 1500);
|
|
if (!alive()) return;
|
|
await sweep(LETTERS.length - 1, L('M'), 900);
|
|
set({ 'finger.press': 0 });
|
|
await to({ scrubShow: 0, 'finger.o': 0 }, 280);
|
|
if (alive()) say('The wave alphabet. Your thumb never has to leave the edge.');
|
|
},
|
|
async folder(alive) {
|
|
await closeAll();
|
|
if (!alive()) return;
|
|
const fp = ph.g.home.media;
|
|
fingerAt(fp.x + 30, fp.y + 60);
|
|
await to({ 'finger.o': 1, 'finger.x': fp.x, 'finger.y': fp.y }, 320);
|
|
set({ 'finger.press': 1 });
|
|
await wait(110);
|
|
set({ 'finger.press': 0 });
|
|
if (!alive()) return;
|
|
fingerOff();
|
|
await openFolder('media');
|
|
},
|
|
async hide(alive) {
|
|
await closeAll();
|
|
if (!alive()) return;
|
|
if ((s.hidden.Podcasts || 0) > 0) {
|
|
set({ 'hidden.Podcasts': 0 });
|
|
ph.render(s);
|
|
ph.measure();
|
|
}
|
|
await to({ drawer: 1, list: ph.scrollFor(L('P')) }, 520);
|
|
if (!alive()) return;
|
|
const ry = ph.rowY('Podcasts', s.list);
|
|
fingerAt(150, ry);
|
|
await to({ 'finger.o': 1 }, 160);
|
|
set({ 'finger.press': 1 });
|
|
s.held = 'Podcasts';
|
|
await to({ 'finger.ring': 1 }, 520, linear);
|
|
if (!alive()) return;
|
|
await openMenu('Podcasts');
|
|
set({ 'finger.press': 0 });
|
|
const hp = { x: MENU_X + ph.g.menuHide.x, y: s.menuY + ph.g.menuHide.y };
|
|
await to({ 'finger.x': hp.x, 'finger.y': hp.y }, 380);
|
|
if (!alive()) return;
|
|
set({ 'finger.press': 1 });
|
|
await wait(110);
|
|
set({ 'finger.press': 0 });
|
|
fingerOff();
|
|
await hideApp('Podcasts');
|
|
},
|
|
async quick(alive) {
|
|
await closeAll();
|
|
if (!alive()) return;
|
|
fingerAt(70, 420);
|
|
await to({ 'finger.o': 1 }, 160);
|
|
set({ 'finger.press': 1 });
|
|
await to({ 'finger.x': 300, camera: 230 / W }, 560);
|
|
set({ 'finger.press': 0 });
|
|
fingerOff();
|
|
if (!alive()) return;
|
|
await launchCamera();
|
|
},
|
|
async reset() {
|
|
await closeAll();
|
|
for (const name of Object.keys(s.hidden)) s.hidden[name] = 0;
|
|
set({ align: 0, weight: DEFAULT_WEIGHT, list: 0 });
|
|
ph.render(s);
|
|
ph.measure();
|
|
say(HELLO);
|
|
},
|
|
};
|
|
for (const btn of document.querySelectorAll('[data-demo]')) {
|
|
btn.addEventListener('click', () => {
|
|
stopAll();
|
|
const mine = token;
|
|
const run = demos[btn.dataset.demo];
|
|
if (run) run(() => mine === token);
|
|
});
|
|
}
|
|
|
|
// Gestures on the phone itself.
|
|
const scr = ph.screen;
|
|
let gest = null;
|
|
let lpTimer = 0;
|
|
const pt = (e) => {
|
|
const rc = scr.getBoundingClientRect();
|
|
return { x: (e.clientX - rc.left) / ph.scale, y: (e.clientY - rc.top) / ph.scale };
|
|
};
|
|
const cancelHold = () => {
|
|
clearTimeout(lpTimer);
|
|
lpTimer = 0;
|
|
if (gest && !gest.held) {
|
|
drop('finger.ring');
|
|
s.finger.ring = 0;
|
|
if (s.menu < 0.5) s.held = null;
|
|
}
|
|
};
|
|
function bounce(el) {
|
|
el.classList.remove('tap');
|
|
void el.offsetWidth;
|
|
el.classList.add('tap');
|
|
}
|
|
|
|
scr.addEventListener('pointerdown', (e) => {
|
|
if (e.button > 0) return;
|
|
stopAll();
|
|
const p = pt(e);
|
|
try {
|
|
scr.setPointerCapture(e.pointerId);
|
|
} catch (_) { /* not every pointer can be captured */ }
|
|
gest = { x0: p.x, y0: p.y, x: p.x, y: p.y, t0: performance.now(), mode: 'home', target: e.target, moved: false, dir: null, held: false };
|
|
set({ 'finger.x': p.x, 'finger.y': p.y, 'finger.o': 0.9, 'finger.press': 1, 'finger.ring': 0 });
|
|
const g = ph.g;
|
|
if (e.target.closest('.snack__undo') && s.snack > 0.5) gest.mode = 'undo';
|
|
else if (p.y > H - 44) gest.mode = 'edge';
|
|
else if (s.camera > 0.5) gest.mode = 'camera';
|
|
else if (s.menu > 0.5) gest.mode = 'menu';
|
|
else if (s.sheet > 0.5) gest.mode = 'sheet';
|
|
else if (s.folder > 0.5) gest.mode = 'folder';
|
|
else if (s.drawer > 0.5) {
|
|
const inAlpha = p.x > W - 56 && p.y > g.letterY[0] - 44 && p.y < g.letterY[g.letterY.length - 1] + 30;
|
|
if (inAlpha) {
|
|
gest.mode = 'scrub';
|
|
scrubbing = true;
|
|
s.scrub = ph.letterAtY(p.y);
|
|
to({ scrubShow: 1 }, 160, outCubic);
|
|
} else {
|
|
gest.mode = 'list';
|
|
gest.list0 = s.list;
|
|
const row = e.target.closest('.row');
|
|
gest.row = row ? row.dataset.row : null;
|
|
if (gest.row) {
|
|
to({ 'finger.ring': 1 }, 450, linear);
|
|
lpTimer = setTimeout(() => {
|
|
if (!gest || gest.moved) return;
|
|
gest.held = true;
|
|
openMenu(gest.row);
|
|
}, 450);
|
|
}
|
|
}
|
|
} else {
|
|
const cell = e.target.closest('[data-key]');
|
|
if (cell && cell.dataset.key === 'clock') {
|
|
to({ 'finger.ring': 1 }, 450, linear);
|
|
lpTimer = setTimeout(() => {
|
|
if (!gest || gest.moved) return;
|
|
gest.held = true;
|
|
set({ 'finger.ring': 0 });
|
|
say('Restyle the clock: alignment and weight. Tap above the sheet to close it.');
|
|
to({ sheet: 1 }, 360, outCubic);
|
|
}, 450);
|
|
}
|
|
}
|
|
});
|
|
|
|
scr.addEventListener('pointermove', (e) => {
|
|
if (!gest) return;
|
|
const p = pt(e);
|
|
gest.x = p.x;
|
|
gest.y = p.y;
|
|
const dx = p.x - gest.x0;
|
|
const dy = p.y - gest.y0;
|
|
if (!gest.moved && Math.hypot(dx, dy) > 9) {
|
|
gest.moved = true;
|
|
if (!gest.held) cancelHold();
|
|
}
|
|
s.finger.x = p.x;
|
|
s.finger.y = p.y;
|
|
switch (gest.mode) {
|
|
case 'scrub':
|
|
s.scrub = ph.letterAtY(p.y);
|
|
break;
|
|
case 'list':
|
|
if (gest.moved && !gest.held) {
|
|
if (gest.list0 <= 1 && dy > 0) s.drawer = clamp(1 - dy / 320);
|
|
else s.list = clamp(gest.list0 - dy, 0, ph.g.maxScroll);
|
|
}
|
|
break;
|
|
case 'home':
|
|
if (gest.held) break;
|
|
if (!gest.dir && gest.moved) gest.dir = Math.abs(dy) > Math.abs(dx) ? 'v' : 'h';
|
|
if (gest.dir === 'v') s.drawer = clamp(-dy / 280);
|
|
if (gest.dir === 'h') {
|
|
if (s.page < 0.5 && dx > 0) {
|
|
// Past the first page: the camera follows the finger in from the left.
|
|
s.camera = clamp(dx / W);
|
|
s.pull = 0;
|
|
} else {
|
|
const atEnd = s.page > HOME.length - 1.5 && dx < 0;
|
|
s.pull = atEnd ? rubber(dx) : dx;
|
|
s.camera = 0;
|
|
}
|
|
}
|
|
break;
|
|
case 'camera':
|
|
if (!gest.dir && gest.moved) gest.dir = Math.abs(dy) > Math.abs(dx) ? 'v' : 'h';
|
|
if (gest.dir === 'h') s.camera = clamp(1 + Math.min(0, dx) / W);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
kick();
|
|
});
|
|
|
|
const end = (e) => {
|
|
if (!gest) return;
|
|
clearTimeout(lpTimer);
|
|
const g = gest;
|
|
gest = null;
|
|
const dx = g.x - g.x0;
|
|
const dy = g.y - g.y0;
|
|
const tap = !g.moved && performance.now() - g.t0 < 450;
|
|
if (!(g.mode === 'list' && g.held)) to({ 'finger.ring': 0 }, 120);
|
|
to({ 'finger.o': 0, 'finger.press': 0 }, 240);
|
|
if (e.type === 'pointercancel') {
|
|
if (g.mode === 'scrub') {
|
|
scrubbing = false;
|
|
to({ scrubShow: 0 }, 200);
|
|
}
|
|
to({ pull: 0, drawer: Math.round(s.drawer) }, 200);
|
|
return;
|
|
}
|
|
switch (g.mode) {
|
|
case 'undo':
|
|
unhide(lastHidden);
|
|
break;
|
|
case 'edge':
|
|
if (dy < -36) closeAll().then(() => say('Home. Swipe up from the bottom edge works from anywhere.'));
|
|
break;
|
|
case 'camera':
|
|
if (g.dir === 'h') {
|
|
if (s.camera < 0.8) closeCamera();
|
|
else to({ camera: 1 }, 220, outCubic);
|
|
} else if ((tap && g.target.closest('.cam__close')) || dy < -60) closeCamera();
|
|
else if (tap) {
|
|
set({ shutter: 1 });
|
|
setTimeout(() => set({ shutter: 0 }), 140);
|
|
}
|
|
break;
|
|
case 'menu':
|
|
if (tap && g.target.closest('.mi--hide')) hideApp(s.held);
|
|
else {
|
|
s.held = null;
|
|
to({ menu: 0 }, 180);
|
|
}
|
|
break;
|
|
case 'sheet': {
|
|
const spanEl = g.target.closest('.seg span');
|
|
if (tap && spanEl && spanEl.dataset.v !== undefined) {
|
|
const v = +spanEl.dataset.v;
|
|
if (spanEl.parentElement.dataset.seg === 'align') to({ align: v }, 380);
|
|
else to({ weight: v }, 420);
|
|
} else if (tap && !g.target.closest('.sheet')) to({ sheet: 0 }, 300);
|
|
else if (dy > 60) to({ sheet: 0 }, 300);
|
|
break;
|
|
}
|
|
case 'folder':
|
|
if (tap && !g.target.closest('.fcard')) closeFolder();
|
|
else if (tap) {
|
|
const app = g.target.closest('.fcard__app');
|
|
if (app) bounce(app);
|
|
}
|
|
break;
|
|
case 'scrub':
|
|
scrubbing = false;
|
|
to({ scrubShow: 0 }, 280);
|
|
say(`Landed on ${LETTERS[clamp(Math.round(s.scrub), 0, LETTERS.length - 1)]}. That's the wave alphabet.`);
|
|
break;
|
|
case 'list':
|
|
if (g.held) break; // the menu stays open
|
|
if (s.drawer < 1) {
|
|
if (s.drawer < 0.75) closeDrawer().then(() => say('Closed. Swipe up to open it again.'));
|
|
else to({ drawer: 1 }, 200);
|
|
} else if (tap && g.row) {
|
|
const row = ph.r.rows.get(g.row);
|
|
row.classList.add('flash');
|
|
setTimeout(() => row.classList.remove('flash'), 220);
|
|
say(`Hold ${g.row} to see what else you can do with it.`);
|
|
}
|
|
break;
|
|
case 'home':
|
|
if (g.held) break;
|
|
if (g.dir === 'v') {
|
|
if (s.drawer > 0.3) openDrawer();
|
|
else to({ drawer: 0 }, 220);
|
|
} else if (g.dir === 'h') {
|
|
if (s.page < 0.5 && dx > 0) {
|
|
if (s.camera > 0.2) launchCamera();
|
|
else to({ camera: 0 }, 240, outCubic);
|
|
} else if (s.page < 0.5 && dx < -70) to({ page: 1, pull: 0 }, 380).then(() => say('Page two. Swipe back, or past the last page.'));
|
|
else if (s.page > 0.5 && dx > 70) to({ page: 0, pull: 0 }, 380).then(() => say(HELLO));
|
|
else to({ pull: 0 }, 260, outCubic);
|
|
} else if (tap) {
|
|
const cell = g.target.closest('[data-key]');
|
|
if (cell && cell.dataset.folder) openFolder(cell.dataset.folder);
|
|
else if (cell && cell.dataset.app === 'Camera') launchCamera();
|
|
else if (cell && cell.classList.contains('cell')) {
|
|
bounce(cell);
|
|
say('Swipe up from anywhere on the home screen to see every app.');
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
kick();
|
|
};
|
|
scr.addEventListener('pointerup', end);
|
|
scr.addEventListener('pointercancel', end);
|
|
scr.addEventListener('contextmenu', (e) => e.preventDefault());
|
|
|
|
ph.render(s);
|
|
return { render: () => ph.render(s) };
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ page */
|
|
function setupReveal() {
|
|
const els = document.querySelectorAll('.rv');
|
|
if (reduced || !('IntersectionObserver' in window)) {
|
|
els.forEach((el) => el.classList.add('in'));
|
|
return;
|
|
}
|
|
const io = new IntersectionObserver((entries) => {
|
|
for (const en of entries) {
|
|
if (en.isIntersecting) {
|
|
en.target.classList.add('in');
|
|
io.unobserve(en.target);
|
|
}
|
|
}
|
|
}, { rootMargin: '0px 0px -6% 0px', threshold: 0.1 });
|
|
els.forEach((el) => io.observe(el));
|
|
}
|
|
|
|
function setupMarquees() {
|
|
const tracks = [...document.querySelectorAll('[data-marquee]')].map((el) => {
|
|
const base = el.innerHTML;
|
|
let guard = 0;
|
|
while (el.scrollWidth < window.innerWidth * 1.6 && guard++ < 8) el.innerHTML += base;
|
|
el.innerHTML += el.innerHTML; // two identical halves, so the loop is seamless
|
|
return { el, speed: +el.dataset.marquee, x: 0, half: el.scrollWidth / 2 };
|
|
});
|
|
window.addEventListener('resize', () => tracks.forEach((t) => { t.half = t.el.scrollWidth / 2; }));
|
|
return (dt, boost) => {
|
|
for (const t of tracks) {
|
|
t.x -= (t.speed / 1000) * dt * (1 + boost);
|
|
if (t.x <= -t.half) t.x += t.half;
|
|
if (t.x > 0) t.x -= t.half;
|
|
t.el.style.transform = `translate3d(${t.x.toFixed(1)}px,0,0)`;
|
|
}
|
|
};
|
|
}
|
|
|
|
function boot() {
|
|
document.querySelectorAll('[data-version]').forEach((el) => { el.textContent = VERSION; });
|
|
|
|
const phones = {};
|
|
for (const host of document.querySelectorAll('[data-phone]')) phones[host.dataset.phone] = new Phone(host);
|
|
|
|
// Live time and date in every phone.
|
|
const cycle = new Intl.DateTimeFormat(undefined, { hour: 'numeric' }).resolvedOptions().hourCycle || 'h23';
|
|
const h24 = !/h1[12]/.test(cycle);
|
|
function tick() {
|
|
const d = new Date();
|
|
const hh = d.getHours();
|
|
const mm = String(d.getMinutes()).padStart(2, '0');
|
|
const now = h24 ? `${String(hh).padStart(2, '0')}:${mm}` : `${((hh + 11) % 12) + 1}:${mm}`;
|
|
const date = d.toLocaleDateString('en-US', { weekday: 'long', month: 'long', day: 'numeric' });
|
|
Object.values(phones).forEach((p) => p.tick(now, date));
|
|
}
|
|
tick();
|
|
setInterval(tick, 10000);
|
|
|
|
const story = phones.story ? setupStory(phones.story) : null;
|
|
const play = phones.play ? setupPlay(phones.play) : null;
|
|
if (phones.hero) phones.hero.render(storyState(phones.hero, 0.55));
|
|
|
|
// Picture widgets turn to the next picture now and then.
|
|
if (!reduced) setInterval(() => Object.values(phones).forEach((p) => p.nextPicture()), 3800);
|
|
|
|
// Fonts change nothing that is measured, but measure again once they are in, to be sure.
|
|
if (document.fonts && document.fonts.ready) {
|
|
document.fonts.ready.then(() => {
|
|
Object.values(phones).forEach((p) => p.measure());
|
|
if (story) story();
|
|
if (play) play.render();
|
|
});
|
|
}
|
|
|
|
// Is the hero phone on screen?
|
|
let heroVisible = true;
|
|
const heroHost = document.querySelector('[data-phone="hero"]');
|
|
if (heroHost && 'IntersectionObserver' in window) {
|
|
new IntersectionObserver((en) => { heroVisible = en[0].isIntersecting; }).observe(heroHost);
|
|
}
|
|
|
|
const nav = document.querySelector('.nav');
|
|
const bar = document.querySelector('.nav__progress i');
|
|
const tilt = document.querySelector('[data-tilt]');
|
|
const hero = document.querySelector('.hero');
|
|
const parallax = [...document.querySelectorAll('[data-parallax]')];
|
|
let mouse = { x: 0, y: 0 };
|
|
if (hero && window.matchMedia('(hover: hover)').matches) {
|
|
hero.addEventListener('pointermove', (e) => {
|
|
const rc = hero.getBoundingClientRect();
|
|
mouse = { x: (e.clientX - rc.left) / rc.width * 2 - 1, y: (e.clientY - rc.top) / rc.height * 2 - 1 };
|
|
});
|
|
hero.addEventListener('pointerleave', () => { mouse = { x: 0, y: 0 }; });
|
|
}
|
|
|
|
function onScroll() {
|
|
const y = window.scrollY;
|
|
const vh = window.innerHeight;
|
|
nav.classList.toggle('is-scrolled', y > 24);
|
|
const max = document.documentElement.scrollHeight - vh;
|
|
bar.style.transform = `scaleX(${max > 0 ? (y / max).toFixed(4) : 0})`;
|
|
if (!reduced) {
|
|
for (const el of parallax) {
|
|
const rc = el.getBoundingClientRect();
|
|
el.style.transform = `translate3d(0, ${((rc.top + rc.height / 2 - vh / 2) * +el.dataset.parallax).toFixed(1)}px, 0)`;
|
|
}
|
|
}
|
|
if (story) story();
|
|
}
|
|
|
|
const marquee = setupMarquees();
|
|
let lastT = performance.now();
|
|
let lastY = window.scrollY;
|
|
let boost = 0;
|
|
let tiltNow = { x: 0, y: 0 };
|
|
function loop(now) {
|
|
const dt = Math.min(64, now - lastT);
|
|
lastT = now;
|
|
const y = window.scrollY;
|
|
const v = Math.abs(y - lastY) / Math.max(dt, 1);
|
|
lastY = y;
|
|
boost = lerp(boost, Math.min(7, v * 3), 0.12);
|
|
if (!reduced) {
|
|
marquee(dt, boost);
|
|
if (tilt) {
|
|
const hp = clamp(y / (window.innerHeight * 0.9));
|
|
tiltNow.x = lerp(tiltNow.x, mouse.x, 0.08);
|
|
tiltNow.y = lerp(tiltNow.y, mouse.y, 0.08);
|
|
tilt.style.setProperty('--ry', `${(lerp(-16, 0, hp) + tiltNow.x * 7).toFixed(2)}deg`);
|
|
tilt.style.setProperty('--rx', `${(lerp(8, 0, hp) - tiltNow.y * 6).toFixed(2)}deg`);
|
|
tilt.style.setProperty('--rz', `${lerp(3, 0, hp).toFixed(2)}deg`);
|
|
}
|
|
if (phones.hero && heroVisible) phones.hero.render(storyState(phones.hero, heroP(now)));
|
|
}
|
|
requestAnimationFrame(loop);
|
|
}
|
|
|
|
let ticking = false;
|
|
window.addEventListener('scroll', () => {
|
|
if (ticking) return;
|
|
ticking = true;
|
|
requestAnimationFrame(() => {
|
|
ticking = false;
|
|
onScroll();
|
|
});
|
|
}, { passive: true });
|
|
window.addEventListener('resize', onScroll);
|
|
motion.addEventListener?.('change', (e) => {
|
|
reduced = e.matches;
|
|
onScroll();
|
|
});
|
|
|
|
if (reduced && tilt) {
|
|
tilt.style.setProperty('--ry', '0deg');
|
|
tilt.style.setProperty('--rx', '0deg');
|
|
tilt.style.setProperty('--rz', '0deg');
|
|
}
|
|
setupReveal();
|
|
onScroll();
|
|
requestAnimationFrame(loop);
|
|
}
|
|
|
|
if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', boot);
|
|
else boot();
|
|
})();
|