253 lines
9.7 KiB
Plaintext
253 lines
9.7 KiB
Plaintext
---
|
|
/**
|
|
* Der Weltenwechsel zwischen Privatkunden und Business.
|
|
*
|
|
* Beim Sprung von einem Bereich in den anderen laufen zwei Bahnen über den
|
|
* Schirm: voraus ein schmales Band in der Akzentfarbe, dahinter die Fläche
|
|
* der Zielwelt, die sie beim Namen nennt. Beide ziehen in derselben
|
|
* Richtung weiter, in die man gewechselt ist — so wie im Umschalter oben
|
|
* rechts: Privatkunden liegt links, Business rechts.
|
|
*
|
|
* Die Bahnen hängen an `transition:persist` mit festem Namen, überleben den
|
|
* Swap also als dieselben Knoten mitsamt laufender Animation. Der Name muss
|
|
* gesetzt sein: ohne ihn vergibt Astro einen Schlüssel mit laufender Nummer,
|
|
* die von der Anzahl der Elemente der Seite abhängt — zwischen zwei
|
|
* verschieden großen Seiten passt er dann nicht mehr, der Knoten wird
|
|
* ersetzt und die Bahn läuft ins Leere.
|
|
*
|
|
* Der Seitenwechsel passiert hinter ihnen, während sie decken.
|
|
*
|
|
* Nur bei diesem einen Wechsel. Alles andere bleibt bei der leisen
|
|
* View Transition. Aussehen: siehe #section-curtain in global.css.
|
|
*/
|
|
---
|
|
|
|
<div id="section-curtain" transition:persist="section-curtain" aria-hidden="true">
|
|
<div class="curtain-panel curtain-lead"></div>
|
|
<div class="curtain-panel curtain-main">
|
|
<div class="curtain-inner">
|
|
<p class="curtain-eyebrow">Sie wechseln zu</p>
|
|
<p class="curtain-title" data-curtain-title></p>
|
|
<p class="curtain-tagline" data-curtain-tagline></p>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
<script>
|
|
import { layers, resolveLayer, crossesLayer, type Layer } from "../lib/sections";
|
|
|
|
const root = document.documentElement;
|
|
|
|
/**
|
|
* Die Knoten werden bei jedem Zugriff frisch geholt, nicht einmal beim
|
|
* Laden gemerkt. Sollte `transition:persist` einmal nicht greifen, räumt
|
|
* das Aufziehen dann wenigstens die Bahn ab, die tatsächlich im Dokument
|
|
* steht, statt eine abgehängte zu animieren und den Schirm zu belegen.
|
|
*/
|
|
function parts() {
|
|
const curtain = document.getElementById("section-curtain");
|
|
return {
|
|
curtain,
|
|
lead: curtain?.querySelector<HTMLElement>(".curtain-lead") ?? null,
|
|
main: curtain?.querySelector<HTMLElement>(".curtain-main") ?? null,
|
|
inner: curtain?.querySelector<HTMLElement>(".curtain-inner") ?? null,
|
|
titleEl: curtain?.querySelector<HTMLElement>("[data-curtain-title]") ?? null,
|
|
taglineEl: curtain?.querySelector<HTMLElement>("[data-curtain-tagline]") ?? null,
|
|
};
|
|
}
|
|
|
|
// Kräftiges Ease-in-out: die Bahnen bewegen sich über den Schirm, sie
|
|
// treten nicht auf und nicht ab. Ein Ease-out würde am Ende kleben.
|
|
const EASE = "cubic-bezier(0.77, 0, 0.175, 1)";
|
|
const COVER = 460;
|
|
// Kurzes Halten, damit der Name der Welt tatsächlich zu lesen ist.
|
|
const HOLD = 160;
|
|
const REVEAL = 540;
|
|
|
|
// Alle Wege in vw. Die Bahnen sind 140vw breit und sitzen bei -20vw, sind
|
|
// also ab |120vw| vollständig aus dem Bild.
|
|
/** Startposition beim Decken. */
|
|
const IN = 120;
|
|
/** Zielposition beim Aufziehen — 7vw Reserve für das nachlaufende Band. */
|
|
const OUT = 134;
|
|
/** Breite des Akzentbands an der Kante. */
|
|
const BAND = 7;
|
|
/**
|
|
* Anteil, um den die Schrift gegen die Bahn zurückgeschoben wird. 1 hieße:
|
|
* sie steht bombenfest in der Bildmitte und die Kante deckt sie auf. 0,8
|
|
* lässt ihr einen Rest Nachlauf, damit die Bewegung nicht tot wirkt.
|
|
*/
|
|
const LAG = 0.8;
|
|
|
|
/** 1 = nach rechts (zu Business), -1 = nach links (zu Privatkunden). */
|
|
let direction = 1;
|
|
let crossing = false;
|
|
|
|
const prefersReduced = () =>
|
|
window.matchMedia("(prefers-reduced-motion: reduce)").matches;
|
|
|
|
const shift = (vw: number) => `translateX(${vw * direction}vw)`;
|
|
|
|
/**
|
|
* Wartet auf Animationen, aber nie unbegrenzt.
|
|
*
|
|
* In einem Hintergrund-Tab pausiert der Browser WAAPI: `finished` löst
|
|
* dann nie aus. Weil die Navigation hinter den Bahnen wartet, hinge sie
|
|
* damit für immer. Der Timeout ist der Notausgang.
|
|
*/
|
|
function settle(animations: Animation[], duration: number) {
|
|
return Promise.race([
|
|
Promise.all(animations.map((animation) => animation.finished.catch(() => {}))),
|
|
new Promise((resolve) => setTimeout(resolve, duration + 200)),
|
|
]);
|
|
}
|
|
|
|
/** Deckungsstellung ohne Animation — für Hintergrund-Tab und Fade. */
|
|
function snap() {
|
|
const { lead, main, inner } = parts();
|
|
if (!lead || !main || !inner) return;
|
|
lead.style.transform = shift(-BAND);
|
|
main.style.transform = "translateX(0)";
|
|
inner.style.transform = "none";
|
|
}
|
|
|
|
async function cover(target: Layer) {
|
|
const { curtain, lead, main, inner, titleEl, taglineEl } = parts();
|
|
if (!curtain || !lead || !main || !inner || !titleEl || !taglineEl) return;
|
|
|
|
// Der Hauptauftritt ist dunkel, jede aufgelegte Ebene honiggelb.
|
|
const dark = target === "site";
|
|
curtain.dataset.ground = dark ? "dark" : "honey";
|
|
curtain.dataset.dir = String(direction);
|
|
// Die Wabenstruktur der Zielwelt: Honiglinien auf Dunkel, Tintenlinien
|
|
// auf Honig.
|
|
main.className = `curtain-panel curtain-main ${dark ? "honeycomb-bg-dark" : "honeycomb-bg"}`;
|
|
titleEl.textContent = layers[target].label;
|
|
taglineEl.textContent = layers[target].tagline;
|
|
curtain.style.visibility = "visible";
|
|
inner.style.opacity = "1";
|
|
|
|
// Liegt der Tab im Hintergrund, sieht ohnehin niemand zu — und der
|
|
// Browser hätte die Animation angehalten. Also ohne Umweg decken.
|
|
if (document.hidden) {
|
|
curtain.style.opacity = "1";
|
|
snap();
|
|
return;
|
|
}
|
|
|
|
// Weniger Bewegung, nicht keine: die Welt wechselt weiterhin sichtbar,
|
|
// sie fährt nur nicht mehr quer über den Schirm.
|
|
if (prefersReduced()) {
|
|
snap();
|
|
await settle(
|
|
[curtain.animate([{ opacity: 0 }, { opacity: 1 }], { duration: 160, easing: "ease-out" })],
|
|
160
|
|
);
|
|
curtain.style.opacity = "1";
|
|
return;
|
|
}
|
|
|
|
const timing = { duration: COVER, easing: EASE };
|
|
// Das Band startet gleichauf mit der Fläche und wird von ihr überholt —
|
|
// so öffnet es sich im Lauf, statt als Streifen hereinzuspringen.
|
|
const bandAnim = lead.animate([{ transform: shift(IN) }, { transform: shift(-BAND) }], timing);
|
|
const groundAnim = main.animate([{ transform: shift(IN) }, { transform: "translateX(0)" }], timing);
|
|
// Gegenbewegung: die Schrift steht fast still in der Bildmitte, während
|
|
// die Fläche über sie hinwegläuft und sie aufdeckt.
|
|
const labelAnim = inner.animate(
|
|
[{ transform: shift(-IN * LAG) }, { transform: "translateX(0)" }],
|
|
timing
|
|
);
|
|
|
|
await settle([bandAnim, groundAnim, labelAnim], COVER);
|
|
snap();
|
|
}
|
|
|
|
async function reveal() {
|
|
const { curtain, lead, main, inner } = parts();
|
|
if (!curtain || !lead || !main || !inner) return;
|
|
|
|
if (document.hidden) {
|
|
// nichts abzuwarten, siehe cover()
|
|
} else if (prefersReduced()) {
|
|
await settle(
|
|
[curtain.animate([{ opacity: 1 }, { opacity: 0 }], { duration: 160, easing: "ease-out" })],
|
|
160
|
|
);
|
|
} else {
|
|
const timing = { duration: REVEAL, easing: EASE };
|
|
// Auf dem Rückweg überholt die Fläche das Band wieder: es taucht
|
|
// hinter ihr auf und verlässt den Schirm als Letztes.
|
|
const bandAnim = lead.animate(
|
|
[{ transform: shift(-BAND) }, { transform: shift(-(OUT - BAND)) }],
|
|
timing
|
|
);
|
|
const groundAnim = main.animate(
|
|
[{ transform: "translateX(0)" }, { transform: shift(-OUT) }],
|
|
timing
|
|
);
|
|
// Die Schrift geht früher als die Bahn — sonst liest man sie noch,
|
|
// während die neue Seite schon zur Hälfte dasteht.
|
|
const labelAnim = inner.animate(
|
|
[
|
|
{ transform: "translateX(0)", opacity: 1 },
|
|
{ transform: shift(OUT * LAG * 0.6), opacity: 0, offset: 0.6 },
|
|
{ transform: shift(OUT * LAG), opacity: 0 },
|
|
],
|
|
timing
|
|
);
|
|
await settle([bandAnim, groundAnim, labelAnim], REVEAL);
|
|
}
|
|
|
|
curtain.style.visibility = "hidden";
|
|
curtain.style.opacity = "";
|
|
lead.style.transform = "";
|
|
main.style.transform = "";
|
|
inner.style.transform = "";
|
|
inner.style.opacity = "";
|
|
delete root.dataset.crossing;
|
|
crossing = false;
|
|
}
|
|
|
|
document.addEventListener("astro:before-preparation", (event) => {
|
|
const nav = event as typeof event & {
|
|
to: URL;
|
|
loader: () => Promise<void>;
|
|
};
|
|
const { curtain } = parts();
|
|
if (!curtain || typeof curtain.animate !== "function" || crossing) return;
|
|
|
|
const from = root.dataset.layer as Layer | undefined;
|
|
const to = resolveLayer(nav.to.pathname, nav.to.hostname);
|
|
// Nur beim Sprung über die Grenze zwischen Hauptauftritt und Ebene.
|
|
// Innerhalb einer Ebene wäre die Bahn nur Wartezeit.
|
|
if (!from || !crossesLayer(from, to)) return;
|
|
|
|
crossing = true;
|
|
root.dataset.crossing = "";
|
|
// Die Reiter stehen rechts neben der Hauptnavigation: eine Ebene öffnet
|
|
// sich von rechts, der Rückweg läuft nach links.
|
|
direction = to === "site" ? -1 : 1;
|
|
|
|
// Decken und Laden laufen nebeneinander: die neue Seite ist in aller
|
|
// Regel da, bevor die Bahnen stehen.
|
|
const load = nav.loader;
|
|
nav.loader = async () => {
|
|
await Promise.all([cover(to), load()]);
|
|
await new Promise((resolve) => setTimeout(resolve, HOLD));
|
|
};
|
|
});
|
|
|
|
document.addEventListener("astro:after-swap", () => {
|
|
// Astro ersetzt beim Swap die Attribute am <html> durch die der neuen
|
|
// Seite — data-crossing wäre damit genau in dem Moment weg, in dem
|
|
// Astros eigene Überblendung anläuft. Sie liefe dann im Top-Layer über
|
|
// die Bahnen hinweg, und das ist das Zucken. Also hier erneut setzen.
|
|
if (crossing) root.dataset.crossing = "";
|
|
|
|
// Die neue Ebene greift genau jetzt — verdeckt von den Bahnen.
|
|
root.dataset.layer = resolveLayer(location.pathname, location.hostname);
|
|
if (crossing) void reveal();
|
|
});
|
|
</script>
|