Files
place4bees.com/frontend/src/components/SectionCurtain.astro
T
2026-09-17 16:02:51 +02:00

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>