// Runs inside the HyperFrames composition. The slideshow player seeks // window.__timelines.deck to a scene's hold-point; this script turns that playhead into // "which scene is up, and which fragment step it is on", then plays that scene's // entrance, its fragment reveals and its looping flow on GSAP's own ticker. ;(function () { 'use strict' var params = new URLSearchParams(location.search) // ?still: every flow shows one finished frame (screenshots, print). var STILL = params.has('still') // Reduced motion softens: fades in place instead of travel, slower loops. It never stops motion. var SOFT = params.has('soft') || window.matchMedia('(prefers-reduced-motion: reduce)').matches document.documentElement.toggleAttribute('data-soft', SOFT) var island = JSON.parse(document.querySelector('script[type="application/hyperframes-slideshow+json"]').textContent) var fragmentsById = {} island.slides.forEach(function (s) { fragmentsById[s.sceneId] = s.fragments || [] }) var scenes = Array.prototype.map.call(document.querySelectorAll('.scene-frame'), function (el) { var start = Number(el.getAttribute('data-start')) var id = el.getAttribute('data-composition-id') return { id: id, el: el, start: start, end: start + Number(el.getAttribute('data-duration')), fragments: fragmentsById[id] || [], initialHTML: el.innerHTML } }) var total = scenes[scenes.length - 1].end function resetScene(scene) { gsap.killTweensOf(scene.el.querySelectorAll('*')) scene.el.innerHTML = scene.initialHTML } var EASE = 'power3.out' var LIFT = SOFT ? 0 : 28 function sceneAt(t) { for (var i = 0; i < scenes.length; i++) if (t >= scenes[i].start && t < scenes[i].end) return scenes[i] return scenes[scenes.length - 1] } function stepAt(scene, t) { var n = 0 scene.fragments.forEach(function (f) { if (t + 1e-4 >= f) n++ }) return Math.max(0, n - 1) } // ---------- Flow engine ---------- // A stage holds absolutely positioned .node[data-node] elements (left/top are their // centers) and an of . Wires are // routed edge to edge from the nodes' layout boxes, so transforms never skew them. function box(node) { var w = node.offsetWidth var h = node.offsetHeight var cx = node.offsetLeft var cy = node.offsetTop return { cx: cx, cy: cy, l: cx - w / 2, r: cx + w / 2, t: cy - h / 2, b: cy + h / 2 } } function route(a, b, kind, lane, out) { lane = lane || 0 var pts if (kind === 'v') { var x = (Math.max(a.l, b.l) + Math.min(a.r, b.r)) / 2 + lane pts = b.cy > a.cy ? [[x, a.b], [x, b.t]] : [[x, a.t], [x, b.b]] } else if (kind === 'vh') { var sx = a.cx + lane var ty = b.cy pts = [[sx, b.cy > a.cy ? a.b : a.t], [sx, ty], [b.cx > sx ? b.l : b.r, ty]] } else if (kind === 'hv') { var sy = a.cy + lane var tx = b.cx + lane pts = [[b.cx > a.cx ? a.r : a.l, sy], [tx, sy], [tx, b.cy > sy ? b.t : b.b]] } else if (kind === 'hvh') { var x1 = b.cx > a.cx ? a.r : a.l var x2 = b.cx > a.cx ? b.l : b.r var mx = (x1 + x2) / 2 pts = [[x1, a.cy], [mx, a.cy], [mx, b.cy + lane], [x2, b.cy + lane]] } else if (kind === 'loop-left') { var lx = Math.min(a.l, b.l) - (out || 90) pts = [[a.l, a.cy + lane], [lx, a.cy + lane], [lx, b.cy + lane], [b.l, b.cy + lane]] } else { var y = (Math.max(a.t, b.t) + Math.min(a.b, b.b)) / 2 + lane pts = b.cx > a.cx ? [[a.r, y], [b.l, y]] : [[a.l, y], [b.r, y]] } return pts } function pathD(pts) { var radius = 26 var d = 'M' + pts[0][0] + ' ' + pts[0][1] for (var i = 1; i < pts.length; i++) { var p = pts[i] if (i < pts.length - 1) { var prev = pts[i - 1] var next = pts[i + 1] var r1 = Math.min(radius, Math.hypot(p[0] - prev[0], p[1] - prev[1]) / 2) var r2 = Math.min(radius, Math.hypot(next[0] - p[0], next[1] - p[1]) / 2) var ax = p[0] - Math.sign(p[0] - prev[0]) * r1 var ay = p[1] - Math.sign(p[1] - prev[1]) * r1 var bx = p[0] + Math.sign(next[0] - p[0]) * r2 var by = p[1] + Math.sign(next[1] - p[1]) * r2 d += ' L' + ax + ' ' + ay + ' Q' + p[0] + ' ' + p[1] + ' ' + bx + ' ' + by } else { d += ' L' + p[0] + ' ' + p[1] } } return d } function Flow(stage) { this.stage = stage this.packets = [] this.tl = gsap.timeline({ paused: true, repeat: 200, repeatDelay: SOFT ? 2 : 1.4 }) var nodes = stage.querySelectorAll('.node') this.tl.set(nodes, { '--glow': 0 }, 0) this.layout() } Flow.prototype.layout = function () { var stage = this.stage stage.querySelectorAll('.wire[data-from]').forEach(function (w) { var a = stage.querySelector('[data-node="' + w.getAttribute('data-from') + '"]') var b = stage.querySelector('[data-node="' + w.getAttribute('data-to') + '"]') if (!a || !b) return var pts = route(box(a), box(b), w.getAttribute('data-route'), Number(w.getAttribute('data-lane') || 0), Number(w.getAttribute('data-out') || 0)) w.setAttribute('d', pathD(pts)) }) } Flow.prototype.node = function (name) { return this.stage.querySelector('[data-node="' + name + '"]') } Flow.prototype.wire = function (name) { return this.stage.querySelector('.wire[data-name="' + name + '"]') } // Light a node at `at`, and let it settle back `hold` seconds later. Flow.prototype.lit = function (name, at, hold) { var n = this.node(name) this.tl.to(n, { '--glow': 1, duration: SOFT ? 0.5 : 0.3, ease: 'power2.out' }, at) if (!SOFT) this.tl.fromTo(n, { scale: 1 }, { scale: 1.04, duration: 0.18, yoyo: true, repeat: 1, ease: 'power1.inOut' }, at) if (hold != null) this.tl.to(n, { '--glow': 0, duration: 0.6, ease: 'power2.inOut' }, at + hold) return this } Flow.prototype.dim = function (name, at) { this.tl.to(this.node(name), { '--glow': 0, duration: 0.5 }, at) return this } // A labelled packet travels the wire. Returns the arrival time. Flow.prototype.send = function (wireName, label, at, opts) { opts = opts || {} var w = this.wire(wireName) var dur = opts.dur || 1 var pk = document.createElement('span') pk.className = 'packet' + (opts.cls ? ' ' + opts.cls : '') pk.innerHTML = label w.ownerSVGElement.parentNode.appendChild(pk) this.packets.push(pk) var len = w.getTotalLength() var reverse = !!opts.reverse var hot = opts.cls === 'err' ? '#ff7a6b' : opts.cls === 'back' ? '#7cc7ff' : opts.cls === 'key' ? '#f2c77a' : opts.cls === 'cf' ? '#ff8a45' : '#4fd27a' var place = function (v) { var p = w.getPointAtLength((reverse ? 1 - v : v) * len) gsap.set(pk, { x: p.x, y: p.y }) } this.tl.set(pk, { opacity: 0 }, 0) this.tl.to(w, { stroke: hot, duration: 0.25 }, at) this.tl.to(w, { stroke: getComputedStyle(w).stroke, duration: 0.6 }, at + dur + 0.3) if (SOFT) { this.tl.call(place, [0.5], at) this.tl.fromTo(pk, { opacity: 0 }, { opacity: 1, duration: 0.5 }, at) this.tl.to(pk, { opacity: 0, duration: 0.5 }, at + dur + 0.2) } else { var prog = { v: 0 } this.tl.fromTo(prog, { v: 0 }, { v: 1, duration: dur, ease: 'power1.inOut', onUpdate: function () { place(prog.v) } }, at) this.tl.fromTo(pk, { opacity: 0, scale: 0.7 }, { opacity: 1, scale: 1, duration: 0.2 }, at) this.tl.to(pk, { opacity: 0, scale: 0.8, duration: 0.25 }, at + dur) } return at + dur } // Swap an element's text at a time in the loop (reset at the loop start). Flow.prototype.text = function (el, value, at, initial) { if (typeof el === 'string') el = this.stage.querySelector(el) if (initial != null) this.tl.call(function () { el.innerHTML = initial }, null, 0.001) this.tl.call(function () { el.innerHTML = value }, null, at) return this } Flow.prototype.attr = function (el, name, value, at, initial) { if (typeof el === 'string') el = this.stage.querySelector(el) if (initial != null) this.tl.call(function () { el.setAttribute(name, initial) }, null, 0.001) this.tl.call(function () { el.setAttribute(name, value) }, null, at) return this } Flow.prototype.still = function (at) { this.tl.addLabel('still', at) return this } Flow.prototype.start = function (delay) { if (SOFT) this.tl.timeScale(0.8) if (STILL) { this.tl.seek(this.tl.labels.still != null ? this.tl.labels.still : this.tl.duration() * 0.6, false) return } this.tl.delay(delay || 0).play(0) } Flow.prototype.kill = function () { this.tl.kill() this.packets.forEach(function (p) { p.remove() }) this.stage.querySelectorAll('.wire').forEach(function (w) { w.style.stroke = '' }) this.stage.querySelectorAll('.node').forEach(function (n) { gsap.set(n, { '--glow': 0, scale: 1 }) }) } // ---------- Per-slide flows and step hooks ---------- var FLOWS = window.__deckFlows || {} var STEPS = window.__deckSteps || {} // ---------- Scene controller ---------- var active = null var activeStep = -1 var flow = null function stepEls(scene) { return scene.el.querySelectorAll('[data-step], [data-until]') } function shownAt(el, step) { var from = el.hasAttribute('data-step') ? Number(el.getAttribute('data-step')) : 0 var until = el.hasAttribute('data-until') ? Number(el.getAttribute('data-until')) : Infinity return step >= from && step <= until } function enter(scene, prev) { if (prev) { gsap.killTweensOf(prev.el) gsap.to(prev.el, { opacity: 0, duration: 0.25, onComplete: function () { prev.el.style.visibility = 'hidden' }, }) prev.el.style.pointerEvents = 'none' } gsap.killTweensOf(scene.el) scene.el.style.visibility = 'visible' scene.el.style.pointerEvents = 'auto' gsap.fromTo(scene.el, { opacity: prev ? 0 : 1 }, { opacity: 1, duration: SOFT ? 0.6 : 0.35, ease: 'power1.out' }) } function applyStep(scene, step, entering) { // The last visit leaves inline positions and text in place. Restore the // markup so entrance, fragments, and flows start from the first frame. if (entering) resetScene(scene) var revealed = [] stepEls(scene).forEach(function (el) { var show = shownAt(el, step) var wasShown = el.getAttribute('data-shown') === '1' el.setAttribute('data-shown', show ? '1' : '0') if (show && (entering || !wasShown)) { gsap.killTweensOf(el) gsap.set(el, { opacity: 0, y: LIFT * 0.7 }) revealed.push(el) } else if (!show) { gsap.killTweensOf(el) if (entering || !wasShown) gsap.set(el, { opacity: 0, y: 0 }) else gsap.to(el, { opacity: 0, duration: 0.25 }) } el.style.pointerEvents = show ? '' : 'none' }) if (entering) { var enterEls = scene.el.querySelectorAll('[data-enter]') gsap.fromTo(enterEls, { opacity: 0, y: LIFT }, { opacity: 1, y: 0, duration: SOFT ? 0.8 : 0.6, stagger: 0.08, ease: EASE, overwrite: 'auto' }) } // One tween per element, so a quick step change can cancel each reveal on its own. revealed.forEach(function (el, i) { gsap.to(el, { opacity: 1, y: 0, duration: SOFT ? 0.8 : 0.5, ease: EASE, delay: (entering ? 0.25 : 0) + i * 0.1 }) }) var hook = STEPS[scene.id] if (hook) hook(scene.el, step, { entering: entering, soft: SOFT, still: STILL }) if (flow) flow.kill() flow = null var build = FLOWS[scene.id] if (build) { var stage = scene.el.querySelector('.stage') flow = new Flow(stage) build(flow, step, { soft: SOFT }) flow.start(entering ? 0.5 : 0.2) } } function update(t) { var scene = sceneAt(t) var step = stepAt(scene, t) if (scene !== active) { var prev = active if (flow) flow.kill() flow = null active = scene activeStep = -1 enter(scene, prev) } if (step !== activeStep) { var entering = activeStep === -1 activeStep = step applyStep(scene, step, entering) } } var root = gsap.timeline({ paused: true }) root.to({}, { duration: total }) root.eventCallback('onUpdate', function () { update(root.time()) }) window.__timelines = window.__timelines || {} window.__timelines.deck = root window.__deck = { get scene() { return active && active.id }, get step() { return activeStep }, get soft() { return SOFT }, get flowActive() { return !!(flow && flow.tl.isActive()) }, scenes: scenes.map(function (s) { return { id: s.id, start: s.start, end: s.end, fragments: s.fragments } }), } function boot() { update(root.time()) } if (document.fonts && document.fonts.ready) document.fonts.ready.then(boot) else boot() // The player learns the scene list from the runtime's "timeline" message; without the // engine, the composition posts it itself. function postTimeline() { if (window.parent === window) return window.parent.postMessage( { source: 'hf-preview', type: 'timeline', durationInFrames: Math.round(total * 30), durationSeconds: total, compositionWidth: 1920, compositionHeight: 1080, scenes: scenes.map(function (s) { return { id: s.id, start: s.start, duration: s.end - s.start } }), }, '*', ) } if (document.readyState === 'complete') postTimeline() else window.addEventListener('load', postTimeline) })()