Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-website/components/landing/HoneycombSection.tsx
T

2237 lines
87 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* ──────────────────────────────────────────────────────────────────────────
* HiveGrid — Honeycomb Integrations Element — V6 "Honig A + Sog"
* Wie Honig A, plus: der G-Hover-Effekt (alles driftet weg, Wabe atmet)
* gilt abgestuft für JEDES Hexagon. Hover auf eine Tool-Zelle oder eine
* Deko-Wabe erzeugt einen Mini-Sog um genau dieses Hexagon — Nachbarn
* weichen aus, mit Distanz-Falloff (exp), die Stränge folgen ihren Zellen.
* Stärke: G (Mitte) > Tool-Ring > Deko-Ring — von innen nach außen weniger.
*
* (Basis-Header von V4:)
* Dunkle Basis; Verbindungen sind berechnete Honig-Stränge (Metaball-Pfad):
* gefüllte Pfade, die an beiden Enden aufweiten und mittig eine Taille haben.
* Dehnen (Zelle poppt raus, G wächst) dünnt die Taille aus, Stauchen macht
* sie dicker — Volumenerhaltung. Optionaler Scroll-Reveal: erst die Waben,
* danach die Verbindungen; ohne Prop steht das Grid weiterhin sofort.
* Zell-Hover schiebt die Zelle radial raus, der Strang folgt bündig.
* G-Hover: gesamte Wabe inkl. Hintergrund-Feld atmet mit (kein Licht-Wash).
* Alle äußeren Hexagone einheitlich flach. Cursor-Parallax auf der Wabe.
*
* Flat-top hex "honeycomb": HiveGrid-Hub in der Mitte, 6 Tool-Logos im inneren
* Ring, faint Deko-Ring + ausgedehntes Hintergrund-Feld das radial + von oben
* einfadet. Hover: Zellen "poppen" raus, Linien leuchten, Daten-Pakete laufen
* Tool → Hub. Alles hinter prefers-reduced-motion gegated.
*
* ── Verwendung ──────────────────────────────────────────────────────────────
* import HoneycombSection from "./HoneycombSection";
* <HoneycombSection inline /> // standalone, vertikal einfadendes Feld
* <HoneycombSection bare /> // absolute Full-Bleed-BG (nur lg+)
* <HoneycombSection /> // eigene Section mit Headline/Badge
* theme default = "light" (White-Mode); für Dark-BG theme="dark".
* ────────────────────────────────────────────────────────────────────────── */
"use client";
import { useRef, useState } from "react";
import { useGSAP } from "@gsap/react";
import { gsap } from "gsap";
import { ScrollTrigger } from "gsap/dist/ScrollTrigger";
gsap.registerPlugin(ScrollTrigger, useGSAP);
/* ── Sog physics — one repulsion model for EVERY comb (ring 1, ring 2 and
* the whole background field behave identically). Tunable per variant:
* falloff px — reach of the push (exp kernel); bigger = the whole comb
* moves together and rings don't get squeezed into each other
* hub/cell/outer push strength by which element is hovered
* outerScale how much a hovered background comb grows
* in/out timing + easing of push and settle
* ripple stagger the push by distance → wave running outward */
export type SogPhysics = {
falloff: number;
hub: number;
cell: number;
outer: number;
outerScale: number;
inDur: number;
inEase: string;
outDur: number;
outEase: string;
ripple: boolean;
};
export const PHYSICS_PRESETS: Record<string, SogPhysics> = {
// ruhig & edel: moderater Schub, weiches Settle
soft: { falloff: 280, hub: 22, cell: 14, outer: 10, outerScale: 1.12, inDur: 0.7, inEase: "power2.out", outDur: 0.8, outEase: "power2.out", ripple: false },
// verspielt: kräftiger Schub, federt elastisch zurück
bouncy: { falloff: 260, hub: 26, cell: 18, outer: 14, outerScale: 1.2, inDur: 0.55, inEase: "back.out(2.2)", outDur: 1.15, outEase: "elastic.out(1, 0.5)", ripple: false },
// physisch: kurzer Radius, harter lokaler Abstoß, Hexes wachsen stark
repulsion: { falloff: 170, hub: 30, cell: 22, outer: 18, outerScale: 1.25, inDur: 0.45, inEase: "power3.out", outDur: 0.8, outEase: "power3.out", ripple: false },
// organisch: weiter Radius, Schub läuft als Welle nach außen
welle: { falloff: 340, hub: 24, cell: 16, outer: 12, outerScale: 1.15, inDur: 0.8, inEase: "power2.out", outDur: 0.9, outEase: "power2.out", ripple: true },
};
/* ──────────────────────────────────────────────────────────────────────────
* Honeycomb integrations element.
*
* A flat-top hex honeycomb in HiveGrid's honey/amber: the HiveGrid "G" hub in
* the centre, the tools it connects in the six surrounding cells, and a faint
* outer ring for comb texture. Glowing data packets travel each connection line
* into the hub.
*
* Hovering a cell pops it gently out of the comb (the cells sit on wide seams so
* a hover never overlaps a neighbour) and lights up its connection line.
*
* Built with useGSAP. Hover handlers are wrapped in contextSafe() and removed on
* cleanup; all ambient + entrance motion is gated behind prefers-reduced-motion.
* ────────────────────────────────────────────────────────────────────────── */
// ── hex geometry (flat-top) ────────────────────────────────────────────────
const R = 62; // circumradius — everything derives from this
const W = 2 * R; // hex width (point to point, horizontal)
const H = Math.sqrt(3) * R; // hex height (flat to flat)
const PAD = 24;
// face size factors — < 1 opens a seam between cells so hovers never overlap
const CELL_SIZE = 0.84;
const CENTER_SIZE = 0.88;
const HOVER_SCALE = 1.06;
const DEBUG_CELL_NUMBERS = false;
// axial (q,r) → pixel centre for a flat-top hex grid
const axialToPx = (q: number, r: number) => ({
x: R * 1.5 * q,
y: R * Math.sqrt(3) * (r + q / 2),
});
// the six neighbour directions in axial space
const DIRS = [
[1, 0],
[1, -1],
[0, -1],
[-1, 0],
[-1, 1],
[0, 1],
];
// all hexes exactly `radius` rings out from the centre (redblobgames ring walk)
function hexRing(radius: number) {
if (radius === 0) return [[0, 0]];
const out: number[][] = [];
let q = DIRS[4][0] * radius;
let r = DIRS[4][1] * radius;
for (let side = 0; side < 6; side++) {
for (let step = 0; step < radius; step++) {
out.push([q, r]);
q += DIRS[side][0];
r += DIRS[side][1];
}
}
return out;
}
export type HoneycombLogoPlacements = Partial<Record<number, string>>;
// Final landing-page composition. Cell 1 remains the HiveGrid hub and is
// deliberately not a logo slot; the grid lab can still override this map.
export const HONEYCOMB_DEFAULT_LOGO_PLACEMENTS: Readonly<HoneycombLogoPlacements> = {
9: "DATEV",
10: "PandaDoc",
12: "Outlook",
13: "Google Drive",
15: "Claude",
17: "kwp",
18: "Bauhow",
19: "PDS",
21: "Aircall",
22: "Onepage",
26: "Teams",
28: "Google Calendar",
30: "OpenAI",
36: "Hallo Petra",
};
// real logos keyed by tool label; an unkeyed label renders a blank cell.
// `scale` lets each logo fill the cell to a comparable optical size;
// `cornerRadius` keeps square app tiles soft without changing the source PNG.
// Logos sit flat on the cell — no drop shadows. Production assets live in
// /public (real branded PNGs for kwp/DATEV, brand SVGs for the rest).
export type HoneycombLogoAsset = {
src: string;
scale?: number;
cornerRadius?: string;
};
export const HONEYCOMB_LOGOS: Readonly<Record<string, HoneycombLogoAsset>> = {
kwp: { src: "/kwp.png" },
DATEV: { src: "/datev.png" },
"Google Drive": { src: "/google-drive.svg", scale: 1.05 },
Teams: { src: "/ms-teams.svg", scale: 1.0 },
Outlook: { src: "/ms-outlook.svg", scale: 1.05 },
"Google Calendar": { src: "/google-calendar.svg", scale: 1.0 },
Bauhow: { src: "/bauhow.png", scale: 1.08 },
PDS: { src: "/pds.svg", scale: 1.38 },
Aircall: { src: "/aircall.svg", scale: 1.3 },
"Hallo Petra": { src: "/hallopetra.png", scale: 1.18 },
Claude: { src: "/claude.svg", scale: 1.12 },
OpenAI: { src: "/openai.svg", scale: 1.12 },
PandaDoc: { src: "/pandadoc.png", scale: 1.08, cornerRadius: "18%" },
Onepage: { src: "/onepage.png", scale: 1.12 },
};
export const HONEYCOMB_DEFAULT_ACTIVE_CELL_IDS = Object.freeze([
3,
5,
7,
...Object.keys(HONEYCOMB_DEFAULT_LOGO_PLACEMENTS).map(Number),
].filter((id, index, ids) => ids.indexOf(id) === index));
const HONEYCOMB_DEFAULT_ACTIVE_CELL_ID_SET = new Set<number>(
HONEYCOMB_DEFAULT_ACTIVE_CELL_IDS
);
export type HoneycombAppearance = "solid" | "glass" | "outline" | "frosted";
export type HoneycombLayers = {
hub: boolean;
innerRing: boolean;
outerRing: boolean;
field: boolean;
strands: boolean;
packets: boolean;
glow: boolean;
};
export const HONEYCOMB_DEFAULT_LAYERS: HoneycombLayers = {
hub: true,
innerRing: true,
outerRing: true,
field: true,
strands: true,
packets: true,
glow: true,
};
export type HoneycombPlacementTool = string | "__erase__" | null;
// build cell list: centre hub, inner tool ring (6), outer ring (12)
type Cell = {
x: number;
y: number;
kind: "center" | "tool" | "deco";
i: number;
debugId: number;
label?: string;
};
const rawCells: Cell[] = [
{ ...axialToPx(0, 0), kind: "center", i: 0, debugId: 1 },
...hexRing(1).map(([q, r], i) => ({
...axialToPx(q, r),
kind: "tool" as const,
i,
debugId: i + 2,
})),
...hexRing(2).map(([q, r], i) => ({
...axialToPx(q, r),
kind: "deco" as const,
i,
debugId: i + 8,
})),
];
// the SAME honeycomb, continued outward in further rings — these are the static
// background field that fills the section. 1:1 the same grid as the deco ring,
// just more layers (rings 3..N). Reaches far enough that even a 4K screen is
// covered edge-to-edge once scaled; the radial fade below hides the outer rows.
const FIELD_MAX_RING = 18;
// EVERY background comb (rings 3–18) is an individual, hoverable SVG path —
// same colour, same interaction everywhere. The Sog loops skip hexes outside
// its falloff reach, so the cost per hover stays tiny despite the count.
const fieldRaw: { x: number; y: number; ring: number; debugId: number }[] = [];
for (let k = 3; k <= FIELD_MAX_RING; k++) {
for (const [q, r] of hexRing(k)) {
fieldRaw.push({ ...axialToPx(q, r), ring: k, debugId: rawCells.length + fieldRaw.length + 1 });
}
}
// normalise everything (interactive cells + field) into a positive box (+ padding)
const allRaw = [...rawCells, ...fieldRaw];
const xs = allRaw.map((c) => c.x);
const ys = allRaw.map((c) => c.y);
const minX = Math.min(...xs) - W / 2 - PAD;
const minY = Math.min(...ys) - H / 2 - PAD;
const BOX_W = Math.max(...xs) + W / 2 + PAD - minX;
const BOX_H = Math.max(...ys) + H / 2 + PAD - minY;
const cells = rawCells.map((c) => ({ ...c, x: c.x - minX, y: c.y - minY }));
const fieldCells = fieldRaw.map((c) => ({
x: c.x - minX,
y: c.y - minY,
ring: c.ring,
debugId: c.debugId,
}));
const nearField = fieldCells; // all of them — no static far layer anymore
const center = cells.find((c) => c.kind === "center")!;
const toolCells = cells.filter((c) => c.kind === "tool");
const decoCells = cells.filter((c) => c.kind === "deco");
// Connection lines and packets stop at the outer edge of the G instead of
// running underneath it — the hub logo stands free but stays connected.
// The G is a flat-top hex the size of a cell face; lines approach it through
// the edge midpoints, so the cut distance is its inradius. The ends sit flush
// on the G's edge; while the hub is hovered they track the scaled-up G
// (lineEndsHover) so the line always meets the edge, never gaps or tucks under.
// Math.sqrt, not Math.hypot — see the SSR note at the field render below.
const HUB_HOVER_SCALE = 1.12;
const HUB_EDGE = R * CELL_SIZE * 0.8660254;
const cutTowardHub = (p: { x: number; y: number }, edge: number) => {
const dx = center.x - p.x;
const dy = center.y - p.y;
const len = Math.sqrt(dx * dx + dy * dy) || 1;
return { x: center.x - (dx / len) * edge, y: center.y - (dy / len) * edge };
};
// Where the travelling data packets aim: the G's edge. They still flow the
// whole way in — a clipPath around the central G hex (see the render) hides the
// dot AND its glow the instant they cross into the logo, so nothing shows
// inside the transparent cut-out while the outer flow stays intact.
const lineEnds = toolCells.map((p) => cutTowardHub(p, HUB_EDGE));
/* ── honey strands (V4) ─────────────────────────────────────────────────────
* Each connection is a filled path shaped like a strand of honey: it flares
* where it roots on the tool cell and on the G, and necks down to a waist in
* the middle. The shape is rebuilt from its two endpoints every frame while
* they animate; the waist obeys a volume-conservation rule — stretching the
* strand (longer) thins it, squashing it (shorter) fattens it. */
const STRAND_END_TOOL = 14; // half-width where the strand roots on a tool cell
const STRAND_END_G = 16; // half-width where it roots on the G
const STRAND_WAIST = 4.5; // half-width mid-strand at rest length
// How deep the strand tips sit under the faces. Must be generous: when a
// cell is displaced sideways by the Sog the strand ROTATES around its tip,
// and the tip corners swing out from under the edge — 3px left visible gaps
// at certain positions. 8px keeps the joint buried at every angle (the tip
// is hidden by the opaque cell face resp. the G's band + interior plate).
const STRAND_TUCK = 8;
// point at `dist` from a tool cell's centre toward the hub
const cutFromTool = (p: { x: number; y: number }, dist: number) => {
const dx = center.x - p.x;
const dy = center.y - p.y;
const len = Math.sqrt(dx * dx + dy * dy) || 1;
return { x: p.x + (dx / len) * dist, y: p.y + (dy / len) * dist };
};
const strandRest = toolCells.map((p) => {
const a = cutFromTool(p, HUB_EDGE - STRAND_TUCK); // tool face inradius == HUB_EDGE
const b = cutTowardHub(p, HUB_EDGE - STRAND_TUCK);
const dx = b.x - a.x;
const dy = b.y - a.y;
return { a, b, len: Math.sqrt(dx * dx + dy * dy) || 1 };
});
// strand endpoints while the hub is hovered: cells get pushed 18px outward
// and the G grows — the strand stretches between both
const strandHover = toolCells.map((p, i) => {
const dx = p.x - center.x;
const dy = p.y - center.y;
const len = Math.sqrt(dx * dx + dy * dy) || 1;
const b = cutTowardHub(p, HUB_EDGE * HUB_HOVER_SCALE - STRAND_TUCK);
return {
ax: strandRest[i].a.x + (dx / len) * 18,
ay: strandRest[i].a.y + (dy / len) * 18,
bx: b.x,
by: b.y,
};
});
// flat-top hex path at arbitrary radius
const hexPathR = (cx: number, cy: number, rr: number) => {
const hh = rr * 0.8660254;
const f = (v: number) => v.toFixed(1);
return `M${f(cx + rr)} ${f(cy)} L${f(cx + rr / 2)} ${f(cy + hh)} L${f(cx - rr / 2)} ${f(cy + hh)} L${f(cx - rr)} ${f(cy)} L${f(cx - rr / 2)} ${f(cy - hh)} L${f(cx + rr / 2)} ${f(cy - hh)} Z`;
};
function strandPath(a: { x: number; y: number }, b: { x: number; y: number }, restLen: number) {
const dx = b.x - a.x;
const dy = b.y - a.y;
const len = Math.sqrt(dx * dx + dy * dy) || 1;
const ux = dx / len;
const uy = dy / len;
const nx = -uy;
const ny = ux;
// volume conservation: waist scales with (restLen/len)^1.6, clamped
const squash = Math.min(2.2, Math.max(0.4, Math.pow(restLen / len, 1.6)));
const wa = STRAND_END_TOOL * (0.85 + 0.15 * squash);
const wb = STRAND_END_G * (0.85 + 0.15 * squash);
// never let the waist collapse — the strand must stay visibly connected no
// matter how far the ends are stretched apart
const wm = Math.max(2.5, STRAND_WAIST * squash);
const wc = (8 * wm - wa - wb) / 6; // cubic control offset that yields `wm` mid-strand
const c1x = a.x + ux * len * 0.35;
const c1y = a.y + uy * len * 0.35;
const c2x = a.x + ux * len * 0.65;
const c2y = a.y + uy * len * 0.65;
const f = (v: number) => v.toFixed(2);
return (
`M${f(a.x + nx * wa)} ${f(a.y + ny * wa)} ` +
`C${f(c1x + nx * wc)} ${f(c1y + ny * wc)} ${f(c2x + nx * wc)} ${f(c2y + ny * wc)} ${f(b.x + nx * wb)} ${f(b.y + ny * wb)} ` +
`L${f(b.x - nx * wb)} ${f(b.y - ny * wb)} ` +
`C${f(c2x - nx * wc)} ${f(c2y - ny * wc)} ${f(c1x - nx * wc)} ${f(c1y - ny * wc)} ${f(a.x - nx * wa)} ${f(a.y - ny * wa)} Z`
);
}
// flat-top hex outline path (same radius as a deco cell's face) for the static
// background field — drawn as light SVG paths instead of hundreds of DOM nodes.
const FIELD_RR = R * CELL_SIZE; // matches the deco face circumradius
const FIELD_HH = FIELD_RR * 0.8660254;
const FIELD_LOGO_BOX = W * 0.48;
const fieldHexPath = (cx: number, cy: number) => {
const f = (x: number, y: number) => `${x.toFixed(1)} ${y.toFixed(1)}`;
return `M${f(cx + FIELD_RR, cy)} L${f(cx + FIELD_RR / 2, cy + FIELD_HH)} L${f(cx - FIELD_RR / 2, cy + FIELD_HH)} L${f(cx - FIELD_RR, cy)} L${f(cx - FIELD_RR / 2, cy - FIELD_HH)} L${f(cx + FIELD_RR / 2, cy - FIELD_HH)} Z`;
};
const HEX_CLIP = "polygon(25% 0%, 75% 0%, 100% 50%, 75% 100%, 25% 100%, 0% 50%)";
// honey/amber brand fill for the tool cells — flat, no gradient
const CELL_BG = "var(--accent-yellow)";
type HoneycombVisual = {
activeFill: string;
inactiveFill: string;
hoverFill: string;
activeOutline?: string;
inactiveOutline?: string;
outlineWidth?: number;
backdropFilter?: string;
activeShadow?: string;
inactiveShadow?: string;
fieldFill: string;
fieldActiveOpacity: number;
fieldInactiveOpacity: number;
fieldHoverOpacity: number;
fieldActiveStroke?: string;
fieldInactiveStroke?: string;
fieldStrokeWidth?: number;
strand: string;
packet: string;
glow: string;
flare: string;
};
const HONEYCOMB_VISUALS: Record<HoneycombAppearance, HoneycombVisual> = {
solid: {
activeFill: CELL_BG,
inactiveFill: "rgba(241,183,41,0.08)",
hoverFill: "rgba(241,183,41,0.16)",
activeShadow: "0 0 26px -8px rgba(241,183,41,0.3)",
fieldFill: "#F1B729",
fieldActiveOpacity: 1,
fieldInactiveOpacity: 0.08,
fieldHoverOpacity: 0.16,
strand: "#F1B729",
packet: "#F1B729",
glow: "radial-gradient(closest-side, rgba(241,183,41,0.6), rgba(241,183,41,0.12) 58%, transparent 72%)",
flare: "radial-gradient(closest-side, rgba(241,183,41,0.65), rgba(241,183,41,0.15) 55%, transparent 70%)",
},
glass: {
activeFill: "rgba(241,183,41,0.25)",
inactiveFill: "rgba(241,183,41,0.055)",
hoverFill: "rgba(241,183,41,0.13)",
activeOutline: "rgba(255,239,184,0.72)",
inactiveOutline: "rgba(255,228,139,0.22)",
outlineWidth: 1.5,
backdropFilter: "blur(16px) saturate(1.35)",
activeShadow: "inset 0 1px 0 rgba(255,255,255,0.55), 0 18px 38px -22px rgba(105,70,0,0.68), 0 0 28px -14px rgba(241,183,41,0.72)",
inactiveShadow: "inset 0 1px 0 rgba(255,255,255,0.2)",
fieldFill: "#F1B729",
fieldActiveOpacity: 0.26,
fieldInactiveOpacity: 0.045,
fieldHoverOpacity: 0.13,
fieldActiveStroke: "rgba(255,232,155,0.62)",
fieldInactiveStroke: "rgba(241,183,41,0.16)",
fieldStrokeWidth: 1.2,
strand: "rgba(241,183,41,0.58)",
packet: "#FFE7A3",
glow: "radial-gradient(closest-side, rgba(241,183,41,0.38), rgba(241,183,41,0.08) 58%, transparent 72%)",
flare: "radial-gradient(closest-side, rgba(255,221,124,0.45), rgba(241,183,41,0.1) 55%, transparent 70%)",
},
outline: {
activeFill: "rgba(241,183,41,0.11)",
inactiveFill: "rgba(241,183,41,0.018)",
hoverFill: "rgba(241,183,41,0.075)",
activeOutline: "rgba(241,183,41,0.96)",
inactiveOutline: "rgba(241,183,41,0.19)",
outlineWidth: 1.7,
activeShadow: "0 0 28px -15px rgba(241,183,41,0.88)",
fieldFill: "#F1B729",
fieldActiveOpacity: 0.1,
fieldInactiveOpacity: 0.012,
fieldHoverOpacity: 0.07,
fieldActiveStroke: "rgba(241,183,41,0.9)",
fieldInactiveStroke: "rgba(241,183,41,0.16)",
fieldStrokeWidth: 1.5,
strand: "rgba(241,183,41,0.78)",
packet: "#F1B729",
glow: "radial-gradient(closest-side, rgba(241,183,41,0.3), rgba(241,183,41,0.045) 58%, transparent 72%)",
flare: "radial-gradient(closest-side, rgba(241,183,41,0.38), rgba(241,183,41,0.07) 55%, transparent 70%)",
},
frosted: {
activeFill: "rgba(255,218,112,0.48)",
inactiveFill: "rgba(255,246,214,0.1)",
hoverFill: "rgba(255,225,139,0.22)",
activeOutline: "rgba(255,251,236,0.82)",
inactiveOutline: "rgba(255,240,190,0.28)",
outlineWidth: 1.2,
backdropFilter: "blur(9px) saturate(1.18)",
activeShadow: "inset 0 1px 0 rgba(255,255,255,0.72), 0 18px 44px -26px rgba(77,48,0,0.72)",
inactiveShadow: "inset 0 1px 0 rgba(255,255,255,0.3)",
fieldFill: "#FFD96F",
fieldActiveOpacity: 0.46,
fieldInactiveOpacity: 0.075,
fieldHoverOpacity: 0.19,
fieldActiveStroke: "rgba(255,250,229,0.66)",
fieldInactiveStroke: "rgba(255,226,139,0.22)",
fieldStrokeWidth: 1,
strand: "rgba(255,210,86,0.66)",
packet: "#FFF4D0",
glow: "radial-gradient(closest-side, rgba(255,215,102,0.42), rgba(255,229,151,0.09) 58%, transparent 72%)",
flare: "radial-gradient(closest-side, rgba(255,242,197,0.52), rgba(241,183,41,0.1) 55%, transparent 70%)",
},
};
function HexShell({
x,
y,
children,
bg,
border,
outline,
outlineWidth = 2,
dataAttr,
z = 1,
faceShadow,
faceBackdropFilter,
size = 1,
debugNumber,
active,
}: {
x: number;
y: number;
children?: React.ReactNode;
bg: string;
border?: string;
outline?: string; // a true hex-shaped outline (a CSS border gets clipped on the slants)
outlineWidth?: number;
dataAttr?: Record<string, string | number>;
z?: number;
faceShadow?: string;
faceBackdropFilter?: string;
size?: number; // shrink the face to open a honeycomb seam between cells
debugNumber?: number;
active?: boolean;
}) {
const interactive = dataAttr?.["data-hex"] === "cell" || dataAttr?.["data-hex"] === "center";
return (
<div
{...dataAttr}
className={`absolute flex items-center justify-center ${interactive ? "pointer-events-auto" : ""}`}
style={{
left: x,
top: y,
width: W,
height: H,
marginLeft: -W / 2,
marginTop: -H / 2,
zIndex: z,
willChange: "transform",
}}
>
{/* the hexagon face — a separate node so it can scale/lift without moving
the wrapper's hit-area origin. When `outline` is set, the face becomes
the outline-coloured hex and an inset inner hex carries the fill, so
the outline follows the hex shape (a CSS border would be clipped). */}
<div
data-active={active ? "1" : undefined}
className="hex-face absolute flex items-center justify-center overflow-hidden"
style={{
inset: `${(H * (1 - size)) / 2}px ${(W * (1 - size)) / 2}px`,
clipPath: HEX_CLIP,
background: outline ?? bg,
border: outline ? undefined : border,
boxShadow: faceShadow,
backdropFilter: faceBackdropFilter,
WebkitBackdropFilter: faceBackdropFilter,
willChange: "transform, box-shadow",
}}
>
{outline ? (
<div
data-hex-fill=""
className="absolute flex items-center justify-center overflow-hidden"
style={{
inset: outlineWidth,
clipPath: HEX_CLIP,
background: bg,
backdropFilter: faceBackdropFilter,
WebkitBackdropFilter: faceBackdropFilter,
}}
>
{children}
</div>
) : (
children
)}
{debugNumber !== undefined && (
<span
data-cell-number={debugNumber}
aria-hidden="true"
className="pointer-events-none absolute z-50 grid place-items-center rounded-full text-[10px] font-extrabold leading-none"
style={{
top: 7,
left: "50%",
minWidth: 22,
height: 22,
paddingInline: 5,
transform: "translateX(-50%)",
color: "#3E2C0A",
background: "rgba(255,255,255,0.94)",
boxShadow: "0 2px 8px rgba(15,23,42,0.22)",
fontVariantNumeric: "tabular-nums",
}}
>
{debugNumber}
</span>
)}
</div>
</div>
);
}
export type HoneycombSectionProps = {
bare?: boolean;
inline?: boolean;
theme?: "dark" | "light";
physics?: SogPhysics;
appearance?: HoneycombAppearance;
layers?: Partial<HoneycombLayers>;
showCellNumbers?: boolean;
showInlineFade?: boolean;
logoPlacements?: Readonly<HoneycombLogoPlacements>;
onLogoPlacementsChange?: (placements: HoneycombLogoPlacements) => void;
activeCellIds?: readonly number[];
onActiveCellIdsChange?: (cellIds: number[]) => void;
editorMode?: boolean;
placementTool?: HoneycombPlacementTool;
revealOnScroll?: boolean;
};
export default function HoneycombSection({
bare = false,
inline = false,
theme = "light",
physics = PHYSICS_PRESETS.soft,
appearance = "solid",
layers: layerOverrides,
showCellNumbers = DEBUG_CELL_NUMBERS,
showInlineFade = true,
logoPlacements: controlledLogoPlacements,
onLogoPlacementsChange,
activeCellIds,
onActiveCellIdsChange,
editorMode = false,
placementTool = null,
revealOnScroll = false,
}: HoneycombSectionProps = {}) {
const root = useRef<HTMLElement>(null);
const [internalLogoPlacements, setInternalLogoPlacements] = useState<HoneycombLogoPlacements>(() => ({
...HONEYCOMB_DEFAULT_LOGO_PLACEMENTS,
}));
const logoPlacements = controlledLogoPlacements ?? internalLogoPlacements;
const activeCellIdSet = activeCellIds === undefined ? null : new Set(activeCellIds);
const commitLogoPlacements = (
update: (current: Readonly<HoneycombLogoPlacements>) => HoneycombLogoPlacements
) => {
const next = update(logoPlacements);
if (controlledLogoPlacements === undefined) setInternalLogoPlacements(next);
onLogoPlacementsChange?.(next);
};
const commitCellActive = (cellId: number, active: boolean) => {
const current = activeCellIdSet;
if (!current) return;
const next = new Set(current);
if (active) next.add(cellId);
else next.delete(cellId);
onActiveCellIdsChange?.([...next].sort((a, b) => a - b));
};
const isCellActive = (cellId: number, defaultActive: boolean) =>
activeCellIdSet?.has(cellId) ?? defaultActive;
const layers: HoneycombLayers = {
...HONEYCOMB_DEFAULT_LAYERS,
...layerOverrides,
};
const visual = HONEYCOMB_VISUALS[appearance];
const activeStateKey = activeCellIds === undefined ? "internal" : [...activeCellIds].sort((a, b) => a - b).join(",");
const layerStateKey = Object.values(layers).map((enabled) => (enabled ? "1" : "0")).join("");
const dark = theme !== "light";
// edge-fade gradient in the current background colour
const fadeBg = dark
? "linear-gradient(to right, #171106 0%, rgba(23,17,6,0) 24%, rgba(23,17,6,0) 76%, #171106 100%), linear-gradient(to bottom, rgba(23,17,6,0.85) 0%, rgba(23,17,6,0) 18%, rgba(23,17,6,0) 80%, #171106 100%)"
: "linear-gradient(to right, #FFFFFF 0%, rgba(255,255,255,0) 24%, rgba(255,255,255,0) 76%, #FFFFFF 100%), linear-gradient(to bottom, rgba(255,255,255,0.85) 0%, rgba(255,255,255,0) 18%, rgba(255,255,255,0) 80%, #FFFFFF 100%)";
// Inline (pain-point) usage is full-bleed on the section's own bg (#FAFAFA =
// var(--bg-primary)); fade EVERY edge to that colour so clipped "half" hexes
// dissolve into whitespace instead of being hard-cut. Percent-based, so it
// holds on every viewport height.
const inlineFade =
"linear-gradient(to bottom, #FAFAFA 0%, rgba(250,250,250,0) 15%, rgba(250,250,250,0) 85%, #FAFAFA 100%), " +
"linear-gradient(to right, #FAFAFA 0%, rgba(250,250,250,0) 13%, rgba(250,250,250,0) 87%, #FAFAFA 100%)";
useGSAP(
(_context, contextSafe) => {
const q = gsap.utils.selector(root);
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
const centerEl = q("[data-hex='center']");
const cellEls = q("[data-hex='cell']");
const decoEls = q("[data-hex='deco']");
const baseLines = q("[data-line='base']");
const packets = q("[data-packet]");
const glow = q("[data-glow]");
const toolCellIsActive = (index: number) =>
isCellActive(
toolCells[index].debugId,
HONEYCOMB_DEFAULT_ACTIVE_CELL_ID_SET.has(toolCells[index].debugId)
);
const activeBaseLines = baseLines.filter((_line, index) => toolCellIsActive(index));
// live strand endpoints — tweened; every update rebuilds the honey paths
const sState = strandRest.map((s) => ({ ax: s.a.x, ay: s.a.y, bx: s.b.x, by: s.b.y }));
const redrawStrands = () =>
sState.forEach((st, i) =>
baseLines[i]?.setAttribute(
"d",
strandPath({ x: st.ax, y: st.ay }, { x: st.bx, y: st.by }, strandRest[i].len)
)
);
const cleanups: Array<() => void> = [];
// ── graded "Sog": the G-hover effect, scaled down, for EVERY hex ─────
// Hovering any hexagon pushes its neighbours away from it with an
// exponential distance falloff; the strands follow their cells so the
// honey never detaches. Strength: G 16 > tool 13 > deco 8 > field 6.
// Long durations + power2 (no overshoot) keep it soft, never choppy.
const nearEls = q("[data-nearhex]");
const nearMoveEls = q("[data-nearcell]");
const PHY = physics;
const SOG_IN = { duration: PHY.inDur, ease: PHY.inEase, overwrite: "auto" as const };
const SOG_OUT = { duration: PHY.outDur, ease: PHY.outEase, overwrite: "auto" as const };
// ripple mode: the push starts later the further out a comb sits —
// the displacement runs outward as a wave
const rippleDelay = (d: number) => (PHY.ripple ? d * 0.0009 : 0);
// with ALL field combs animatable (1000+), only touch the ones inside
// the falloff reach and only reset the ones that actually moved
const displacedNear = new Set<Element>();
const sogNear = (ox: number, oy: number, strength: number) => {
nearMoveEls.forEach((el, j) => {
const dx = nearField[j].x - ox;
const dy = nearField[j].y - oy;
const d = Math.sqrt(dx * dx + dy * dy) || 1;
const amt = strength * Math.exp(-d / PHY.falloff);
if (amt < 0.3) return; // beyond reach — skip the tween entirely
displacedNear.add(el);
gsap.to(el, { x: (dx / d) * amt, y: (dy / d) * amt, delay: rippleDelay(d), ...SOG_IN });
});
};
const releaseNear = () => {
if (!displacedNear.size) return;
gsap.to(Array.from(displacedNear), { x: 0, y: 0, ...SOG_OUT });
displacedNear.clear();
};
const applySog = (ox: number, oy: number, strength: number, skipCell = -1) => {
cellEls.forEach((el, j) => {
if (j === skipCell) return;
const dx = toolCells[j].x - ox;
const dy = toolCells[j].y - oy;
const d = Math.sqrt(dx * dx + dy * dy) || 1;
const amt = strength * Math.exp(-d / PHY.falloff);
gsap.to(el, { x: (dx / d) * amt, y: (dy / d) * amt, delay: rippleDelay(d), ...SOG_IN });
gsap.to(sState[j], {
ax: strandRest[j].a.x + (dx / d) * amt,
ay: strandRest[j].a.y + (dy / d) * amt,
delay: rippleDelay(d),
...SOG_IN,
onUpdate: redrawStrands,
});
});
decoEls.forEach((el, j) => {
const dx = decoCells[j].x - ox;
const dy = decoCells[j].y - oy;
const d = Math.sqrt(dx * dx + dy * dy) || 1;
const amt = strength * Math.exp(-d / PHY.falloff);
gsap.to(el, { x: (dx / d) * amt, y: (dy / d) * amt, delay: rippleDelay(d), ...SOG_IN });
});
sogNear(ox, oy, strength);
};
const releaseSog = (skipCell = -1) => {
cellEls.forEach((el, j) => {
if (j === skipCell) return;
gsap.to(el, { x: 0, y: 0, ...SOG_OUT });
gsap.to(sState[j], {
ax: strandRest[j].a.x,
ay: strandRest[j].a.y,
...SOG_OUT,
onUpdate: redrawStrands,
});
});
gsap.to(decoEls, { x: 0, y: 0, ...SOG_OUT });
releaseNear();
};
// ── near-field hover: even the outer honeycomb rings interact ────────
nearEls.forEach((hex, k) => {
const moveEl = nearMoveEls[k] ?? hex;
const enter = contextSafe!(() => {
gsap.to(moveEl, {
scale: PHY.outerScale,
transformOrigin: "50% 50%",
duration: PHY.inDur * 0.6,
ease: "back.out(2)",
overwrite: "auto",
});
gsap.to(hex, {
// click-activated combs are solid — hover must not dim them
attr: {
"fill-opacity": (hex as HTMLElement).dataset.active
? visual.fieldActiveOpacity
: visual.fieldHoverOpacity,
},
duration: PHY.inDur * 0.6,
ease: "power2.out",
overwrite: "auto",
});
if (!reduce) applySog(nearField[k].x, nearField[k].y, PHY.outer);
});
const leave = contextSafe!(() => {
gsap.to(moveEl, {
scale: 1,
duration: PHY.outDur,
ease: PHY.outEase,
overwrite: "auto",
});
gsap.to(hex, {
attr: {
"fill-opacity": (hex as HTMLElement).dataset.active
? visual.fieldActiveOpacity
: visual.fieldInactiveOpacity,
},
duration: PHY.outDur,
ease: PHY.outEase,
overwrite: "auto",
});
if (!reduce) releaseSog();
});
hex.addEventListener("mouseenter", enter);
hex.addEventListener("mouseleave", leave);
cleanups.push(() => {
hex.removeEventListener("mouseenter", enter);
hex.removeEventListener("mouseleave", leave);
});
});
// ── hover: a gentle pop, line highlight, packet boost ────────────────
cellEls.forEach((cell) => {
const face = cell.querySelector(".hex-face") as HTMLElement;
const i = Number((cell as HTMLElement).dataset.index);
const base = baseLines[i];
const packet = packets[i];
// radial outward direction of this cell — hover pops the cell away
// from the G and the honey strand stretches after it
const dxo = toolCells[i].x - center.x;
const dyo = toolCells[i].y - center.y;
const dlen = Math.sqrt(dxo * dxo + dyo * dyo) || 1;
const ox = (dxo / dlen) * 10;
const oy = (dyo / dlen) * 10;
const enter = contextSafe!(() => {
(cell as HTMLElement).style.zIndex = "30";
gsap.to(cell, { x: reduce ? 0 : ox, y: reduce ? 0 : oy, duration: 0.4, ease: "back.out(2)", overwrite: "auto" });
gsap.to(face, {
scale: reduce ? 1.03 : HOVER_SCALE,
duration: 0.4,
ease: "back.out(2)",
boxShadow: visual.activeShadow ?? "0 0 42px -6px rgba(241,183,41,0.75)",
overwrite: "auto",
});
if (!reduce)
gsap.to(sState[i], {
ax: strandRest[i].a.x + ox,
ay: strandRest[i].a.y + oy,
duration: 0.4,
ease: "back.out(2)",
overwrite: "auto",
onUpdate: redrawStrands,
});
if (base) gsap.to(base, { attr: { "fill-opacity": toolCellIsActive(i) ? 0.95 : 0 }, duration: 0.3, overwrite: "auto" });
if (packet) gsap.to(packet, { scale: 1.8, transformOrigin: "50% 50%", duration: 0.3, overwrite: "auto" });
// mini-Sog around this cell — neighbours give way, graded by distance
if (!reduce) applySog(toolCells[i].x, toolCells[i].y, PHY.cell, i);
});
const leave = contextSafe!(() => {
gsap.to(cell, { x: 0, y: 0, duration: 0.5, ease: "power3.out", overwrite: "auto" });
gsap.to(face, {
scale: 1,
duration: 0.5,
ease: "power3.out",
boxShadow: toolCellIsActive(i) ? visual.activeShadow ?? "none" : visual.inactiveShadow ?? "none",
overwrite: "auto",
onComplete: () => {
(cell as HTMLElement).style.zIndex = "2";
},
});
gsap.to(sState[i], {
ax: strandRest[i].a.x,
ay: strandRest[i].a.y,
duration: 0.5,
ease: "power3.out",
overwrite: "auto",
onUpdate: redrawStrands,
});
if (base) gsap.to(base, { attr: { "fill-opacity": toolCellIsActive(i) ? 0.7 : 0 }, duration: 0.45, overwrite: "auto" });
if (packet) gsap.to(packet, { scale: 1, transformOrigin: "50% 50%", duration: 0.45, overwrite: "auto" });
if (!reduce) releaseSog(i);
});
// tap on touch devices pops the cell then settles it again — touch only,
// a mouse click while hovering must not schedule a delayed collapse
const tap = contextSafe!((e: Event) => {
if ((e as PointerEvent).pointerType !== "touch") return;
enter();
gsap.delayedCall(1, leave);
});
cell.addEventListener("mouseenter", enter);
cell.addEventListener("mouseleave", leave);
cell.addEventListener("pointerdown", tap);
cleanups.push(() => {
cell.removeEventListener("mouseenter", enter);
cell.removeEventListener("mouseleave", leave);
cell.removeEventListener("pointerdown", tap);
});
});
// ── deco hover (ring 2): behaves EXACTLY like the background combs —
// same brighten, same grow, same Sog tier. The hit area is the
// clip-path'd hex face (not the rectangular wrapper), so ring 2 feels
// identical to the SVG hexes around it; the wrapper lets events
// through to whatever sits beneath its corners.
decoEls.forEach((deco, k) => {
const face = deco.querySelector(".hex-face") as HTMLElement;
const paint = (face.querySelector("[data-hex-fill]") as HTMLElement | null) ?? face;
if (isCellActive(decoCells[k].debugId, Boolean(logoPlacements[decoCells[k].debugId]))) {
face.dataset.active = "1";
}
const isActive = () => Boolean(face.dataset.active);
(deco as HTMLElement).style.pointerEvents = "none";
face.style.pointerEvents = "auto";
const enter = contextSafe!(() => {
gsap.to(face, {
scale: PHY.outerScale,
duration: PHY.inDur * 0.6,
ease: "back.out(2)",
overwrite: "auto",
});
gsap.to(paint, {
backgroundColor: isActive() ? visual.activeFill : visual.hoverFill,
duration: PHY.inDur * 0.6,
ease: "power2.out",
overwrite: "auto",
});
if (!reduce) applySog(decoCells[k].x, decoCells[k].y, PHY.outer);
});
const leave = contextSafe!(() => {
gsap.to(face, {
scale: 1,
duration: PHY.outDur,
ease: PHY.outEase,
overwrite: "auto",
});
gsap.to(paint, {
backgroundColor: isActive() ? visual.activeFill : visual.inactiveFill,
duration: PHY.outDur,
ease: PHY.outEase,
overwrite: "auto",
});
if (!reduce) releaseSog();
});
face.addEventListener("mouseenter", enter);
face.addEventListener("mouseleave", leave);
cleanups.push(() => {
face.removeEventListener("mouseenter", enter);
face.removeEventListener("mouseleave", leave);
});
});
// failsafe: leaving the section always brings every comb back to its
// exact home position, whatever hover races happened before
const sectionEl = root.current;
const resetAllSog = contextSafe!(() => releaseSog());
sectionEl?.addEventListener("pointerleave", resetAllSog);
cleanups.push(() => sectionEl?.removeEventListener("pointerleave", resetAllSog));
// ── click-to-connect ─────────────────────────────────────────────────
// Klick auf eine äußere Wabe (Ring 2 oder Feld) aktiviert sie: volle
// Amber-Füllung + Honig-Stränge zu allen direkt benachbarten
// "besetzten" Waben (Tool-Zellen und andere aktivierte). Nochmal
// klicken löst sie. Die Stränge lesen jede Frame die Live-Transforms
// BEIDER Enden (gsap.ticker) — sie bleiben also auch unter Sog,
// Hover-Pop und Elastik-Nachschwingen bündig verbunden.
type CombNode = {
x: number;
y: number;
debugId: number;
moveEl: Element; // carries the x/y transform (wrapper resp. path)
visEl: HTMLElement | SVGElement; // carries fill + click + cursor
paintEl: HTMLElement | SVGElement; // carries the active/inactive fill
logoLabel?: string;
logoEl?: Element | null;
kind: "tool" | "partner" | "deco" | "fieldPartner" | "near";
solid: boolean;
};
const NEIGHBOR_DIST = R * 1.8; // direct hex neighbours sit at sqrt(3)·R
const combNodes: CombNode[] = [];
cellEls.forEach((el, i) => {
const debugId = toolCells[i].debugId;
const logoLabel = logoPlacements[debugId];
combNodes.push({
x: toolCells[i].x,
y: toolCells[i].y,
debugId,
moveEl: el,
visEl: el as HTMLElement,
paintEl: (el.querySelector("[data-hex-fill]") as HTMLElement | null) ?? (el.querySelector(".hex-face") as HTMLElement),
logoLabel,
logoEl: el.querySelector("[data-cell-logo]"),
kind: "tool",
solid: isCellActive(
debugId,
HONEYCOMB_DEFAULT_ACTIVE_CELL_ID_SET.has(debugId)
),
});
});
decoEls.forEach((el, i) => {
const debugId = decoCells[i].debugId;
const logoLabel = logoPlacements[debugId];
combNodes.push({
x: decoCells[i].x,
y: decoCells[i].y,
debugId,
moveEl: el,
visEl: el.querySelector(".hex-face") as HTMLElement,
paintEl: (el.querySelector("[data-hex-fill]") as HTMLElement | null) ?? (el.querySelector(".hex-face") as HTMLElement),
logoLabel,
logoEl: el.querySelector("[data-cell-logo]"),
kind: logoLabel ? "partner" : "deco",
solid: isCellActive(debugId, Boolean(logoLabel)),
});
});
nearEls.forEach((el, i) => {
const debugId = nearField[i].debugId;
const logoLabel = logoPlacements[debugId];
const moveEl = nearMoveEls[i] ?? el;
combNodes.push({
x: nearField[i].x,
y: nearField[i].y,
debugId,
moveEl,
visEl: el as unknown as SVGElement,
paintEl: el as unknown as SVGElement,
logoLabel,
logoEl: moveEl.querySelector("[data-cell-logo]"),
kind: logoLabel ? "fieldPartner" : "near",
solid: isCellActive(debugId, Boolean(logoLabel)),
});
});
combNodes.forEach((node) => {
if (!node.solid && node.logoEl) {
gsap.set(node.logoEl, { autoAlpha: 0, scale: 0.72, transformOrigin: "50% 50%" });
}
});
const dynGroup = q("[data-dyn]")[0];
type DynStrand = {
el: SVGPathElement;
a: CombNode;
b: CombNode;
aBase: { x: number; y: number };
bBase: { x: number; y: number };
rest: number;
grow: number;
};
const dynStrands: DynStrand[] = [];
const updateDynStrands = () => {
if (!dynStrands.length) return;
dynStrands.forEach((s) => {
const ax = s.aBase.x + Number(gsap.getProperty(s.a.moveEl, "x")) || s.aBase.x;
const ay = s.aBase.y + Number(gsap.getProperty(s.a.moveEl, "y")) || s.aBase.y;
const bxF = s.bBase.x + Number(gsap.getProperty(s.b.moveEl, "x")) || s.bBase.x;
const byF = s.bBase.y + Number(gsap.getProperty(s.b.moveEl, "y")) || s.bBase.y;
// grow: the strand pours from the clicked comb toward its neighbour
const bx = ax + (bxF - ax) * s.grow;
const by = ay + (byF - ay) * s.grow;
s.el.setAttribute("d", strandPath({ x: ax, y: ay }, { x: bx, y: by }, s.rest));
});
};
gsap.ticker.add(updateDynStrands);
cleanups.push(() => {
gsap.ticker.remove(updateDynStrands);
dynStrands.forEach((strand) => strand.el.remove());
dynStrands.length = 0;
});
const connectNodes = contextSafe!((a: CombNode, b: CombNode, animate = true) => {
const alreadyConnected = dynStrands.some(
(strand) =>
(strand.a === a && strand.b === b) ||
(strand.a === b && strand.b === a)
);
if (alreadyConnected) return;
const dx = b.x - a.x;
const dy = b.y - a.y;
const len = Math.sqrt(dx * dx + dy * dy) || 1;
const ux = dx / len;
const uy = dy / len;
const cut = HUB_EDGE - STRAND_TUCK;
const aBase = { x: a.x + ux * cut, y: a.y + uy * cut };
const bBase = { x: b.x - ux * cut, y: b.y - uy * cut };
const rdx = bBase.x - aBase.x;
const rdy = bBase.y - aBase.y;
const el = document.createElementNS("http://www.w3.org/2000/svg", "path");
el.setAttribute("fill", visual.strand);
el.setAttribute("fill-opacity", animate ? "0" : "0.7");
dynGroup?.appendChild(el);
const s: DynStrand = {
el,
a,
b,
aBase,
bBase,
rest: Math.sqrt(rdx * rdx + rdy * rdy) || 1,
grow: animate ? 0 : 1,
};
dynStrands.push(s);
if (animate) {
gsap.to(s, { grow: 1, duration: 0.55, ease: "power2.out" });
gsap.to(el, { attr: { "fill-opacity": 0.7 }, duration: 0.4 });
} else {
updateDynStrands();
}
});
const disconnectNode = contextSafe!((n: CombNode) => {
for (let i = dynStrands.length - 1; i >= 0; i--) {
const s = dynStrands[i];
if (s.a !== n && s.b !== n) continue;
dynStrands.splice(i, 1);
gsap.to(s.el, { attr: { "fill-opacity": 0 }, duration: 0.3, onComplete: () => s.el.remove() });
}
});
// Logo cells are already active on first paint. Build their links without
// an activation animation, and only for pairs that involve an outer logo
// (the six inner tools should not connect into an extra hexagon ring).
const initiallySolid = combNodes.filter((node) => node.solid);
initiallySolid.forEach((a, i) => {
initiallySolid.slice(i + 1).forEach((b) => {
if (a.kind === "tool" && b.kind === "tool") return;
const dx = b.x - a.x;
const dy = b.y - a.y;
if (Math.sqrt(dx * dx + dy * dy) < NEIGHBOR_DIST) {
connectNodes(a, b, false);
}
});
});
const setNodeSolid = contextSafe!((n: CombNode, active: boolean) => {
if (n.solid === active) return;
const isSvgCell = n.kind === "near" || n.kind === "fieldPartner";
const cellLogo = n.logoEl;
const face = n.kind === "tool"
? n.visEl.querySelector(".hex-face") as HTMLElement | null
: n.visEl;
if (!active) {
n.solid = false;
delete (face as HTMLElement).dataset.active;
if (isSvgCell) {
gsap.to(n.paintEl, { attr: { "fill-opacity": visual.fieldInactiveOpacity }, duration: 0.35, overwrite: "auto" });
} else {
gsap.to(n.paintEl, { backgroundColor: visual.inactiveFill, duration: 0.35, overwrite: "auto" });
}
if (cellLogo) {
gsap.to(cellLogo, {
autoAlpha: 0,
scale: 0.72,
transformOrigin: "50% 50%",
duration: 0.22,
ease: "power2.in",
overwrite: "auto",
});
}
disconnectNode(n);
} else {
n.solid = true;
(face as HTMLElement).dataset.active = "1";
if (isSvgCell) {
gsap.to(n.paintEl, { attr: { "fill-opacity": visual.fieldActiveOpacity }, duration: 0.35, overwrite: "auto" });
} else {
gsap.to(n.paintEl, { backgroundColor: visual.activeFill, duration: 0.35, overwrite: "auto" });
}
if (cellLogo) {
gsap.to(cellLogo, {
autoAlpha: 1,
scale: 1,
transformOrigin: "50% 50%",
duration: 0.34,
ease: "back.out(2)",
overwrite: "auto",
});
}
combNodes.forEach((m) => {
if (m === n || !m.solid) return;
const ndx = m.x - n.x;
const ndy = m.y - n.y;
if (Math.sqrt(ndx * ndx + ndy * ndy) < NEIGHBOR_DIST) connectNodes(n, m);
});
}
commitCellActive(n.debugId, active);
});
const toggleNode = contextSafe!((n: CombNode) => {
if (n.kind === "tool" && !editorMode) return;
setNodeSolid(n, !n.solid);
});
// ── temporary logo layout editor ────────────────────────────────────
// A short move starts a drag; a normal click still toggles outer cells.
// Dropping on an occupied slot swaps both logos, dropping on an empty
// slot moves the logo. The centre hub deliberately has no logo-slot ID.
type LogoDragState = {
source: CombNode;
pointerId: number;
startX: number;
startY: number;
dragging: boolean;
ghost: HTMLDivElement | null;
targetSlot: Element | null;
previousCursor: string;
previousUserSelect: string;
moveHandler: (event: PointerEvent) => void;
endHandler: (event: PointerEvent) => void;
cancelHandler: (event: PointerEvent) => void;
};
let logoDrag: LogoDragState | null = null;
let suppressClickEl: Element | null = null;
let suppressClickUntil = 0;
const dragGhosts = new Set<HTMLDivElement>();
const findLogoSlot = (clientX: number, clientY: number) => {
for (const element of document.elementsFromPoint(clientX, clientY)) {
const slot = element.closest("[data-logo-slot]");
if (slot && root.current?.contains(slot)) return slot;
}
return null;
};
const setDropTarget = (slot: Element | null) => {
if (!logoDrag || logoDrag.targetSlot === slot) return;
logoDrag.targetSlot?.removeAttribute("data-logo-drop-target");
logoDrag.targetSlot = slot;
slot?.setAttribute("data-logo-drop-target", "1");
};
const createLogoGhost = (label: string) => {
const logo = HONEYCOMB_LOGOS[label];
const ghost = document.createElement("div");
const image = document.createElement("img");
ghost.setAttribute("aria-hidden", "true");
Object.assign(ghost.style, {
position: "fixed",
left: "0px",
top: "0px",
width: `${W * CELL_SIZE}px`,
height: `${H * CELL_SIZE}px`,
display: "grid",
placeItems: "center",
clipPath: HEX_CLIP,
background: visual.activeFill,
backdropFilter: visual.backdropFilter ?? "none",
WebkitBackdropFilter: visual.backdropFilter ?? "none",
boxShadow: "0 14px 36px rgba(62,44,10,0.26), 0 0 0 2px rgba(255,255,255,0.9)",
pointerEvents: "none",
userSelect: "none",
zIndex: "2147483647",
willChange: "transform, opacity",
});
image.src = logo.src;
image.alt = "";
image.draggable = false;
Object.assign(image.style, {
width: `${48 * (logo.scale ?? 1)}%`,
maxHeight: "64%",
objectFit: "contain",
borderRadius: logo.cornerRadius ?? "0",
pointerEvents: "none",
userSelect: "none",
});
ghost.appendChild(image);
document.body.appendChild(ghost);
dragGhosts.add(ghost);
return ghost;
};
const updateLogoDrag = (event: PointerEvent) => {
const state = logoDrag;
if (!state || event.pointerId !== state.pointerId) return;
const distance = Math.hypot(event.clientX - state.startX, event.clientY - state.startY);
if (!state.dragging && distance < 7) return;
event.preventDefault();
if (!state.dragging) {
state.dragging = true;
state.ghost = createLogoGhost(state.source.logoLabel!);
document.body.style.cursor = "grabbing";
document.body.style.userSelect = "none";
releaseSog();
gsap.set(state.ghost, {
x: event.clientX,
y: event.clientY,
xPercent: -50,
yPercent: -50,
scale: reduce ? 1 : 0.88,
autoAlpha: reduce ? 1 : 0,
});
if (!reduce) {
gsap.to(state.ghost, {
scale: 1.04,
autoAlpha: 1,
duration: 0.18,
ease: "back.out(2)",
overwrite: "auto",
});
}
if (state.source.logoEl) {
gsap.to(state.source.logoEl, {
autoAlpha: 0.28,
scale: 0.86,
duration: reduce ? 0 : 0.14,
ease: "power2.out",
overwrite: "auto",
});
}
}
if (state.ghost) gsap.set(state.ghost, { x: event.clientX, y: event.clientY });
const candidate = findLogoSlot(event.clientX, event.clientY);
const candidateId = Number(candidate?.getAttribute("data-logo-slot"));
setDropTarget(candidateId && candidateId !== state.source.debugId ? candidate : null);
};
const finishLogoDrag = (event: PointerEvent, cancelled: boolean) => {
const state = logoDrag;
if (!state || event.pointerId !== state.pointerId) return;
window.removeEventListener("pointermove", state.moveHandler);
window.removeEventListener("pointerup", state.endHandler);
window.removeEventListener("pointercancel", state.cancelHandler);
const targetId = Number(state.targetSlot?.getAttribute("data-logo-slot"));
state.targetSlot?.removeAttribute("data-logo-drop-target");
document.body.style.cursor = state.previousCursor;
document.body.style.userSelect = state.previousUserSelect;
logoDrag = null;
if (!state.dragging) return;
event.preventDefault();
suppressClickEl = state.source.visEl;
suppressClickUntil = performance.now() + 400;
if (state.source.logoEl) {
gsap.to(state.source.logoEl, {
autoAlpha: 1,
scale: 1,
duration: reduce ? 0 : 0.2,
ease: "power2.out",
overwrite: "auto",
});
}
const commitDrop = () => {
state.ghost?.remove();
if (state.ghost) dragGhosts.delete(state.ghost);
if (cancelled || !targetId || targetId === state.source.debugId) return;
commitLogoPlacements((current) => {
const sourceLogo = current[state.source.debugId];
if (!sourceLogo) return { ...current };
const targetLogo = current[targetId];
const next = { ...current };
if (targetLogo) next[state.source.debugId] = targetLogo;
else delete next[state.source.debugId];
next[targetId] = sourceLogo;
return next;
});
const targetNode = combNodes.find((node) => node.debugId === targetId);
if (targetNode && !targetNode.solid) setNodeSolid(targetNode, true);
};
if (state.ghost && !reduce) {
gsap.to(state.ghost, {
scale: 0.86,
autoAlpha: 0,
duration: 0.12,
ease: "power2.in",
overwrite: "auto",
onComplete: commitDrop,
});
} else {
commitDrop();
}
};
combNodes.forEach((n) => {
// The landing-page comb is a fixed composition. Dragging, placing and
// click-to-toggle are reserved for the explicit grid-lab editor.
if (!editorMode) {
n.visEl.style.cursor = "default";
return;
}
const selectedTool = placementTool;
n.visEl.style.cursor = selectedTool === "__erase__"
? "not-allowed"
: selectedTool && HONEYCOMB_LOGOS[selectedTool]
? "copy"
: n.logoLabel && n.solid
? "grab"
: editorMode || n.kind !== "tool"
? "pointer"
: "default";
if (n.logoLabel && n.logoEl) {
n.visEl.style.touchAction = "none";
const onPointerDown = contextSafe!((event: PointerEvent) => {
if (logoDrag || placementTool || !n.solid || !event.isPrimary || event.button !== 0) return;
const moveHandler = contextSafe!((moveEvent: PointerEvent) => updateLogoDrag(moveEvent));
const endHandler = contextSafe!((endEvent: PointerEvent) => finishLogoDrag(endEvent, false));
const cancelHandler = contextSafe!((cancelEvent: PointerEvent) => finishLogoDrag(cancelEvent, true));
logoDrag = {
source: n,
pointerId: event.pointerId,
startX: event.clientX,
startY: event.clientY,
dragging: false,
ghost: null,
targetSlot: null,
previousCursor: document.body.style.cursor,
previousUserSelect: document.body.style.userSelect,
moveHandler,
endHandler,
cancelHandler,
};
window.addEventListener("pointermove", moveHandler, { passive: false });
window.addEventListener("pointerup", endHandler);
window.addEventListener("pointercancel", cancelHandler);
});
n.visEl.addEventListener("pointerdown", onPointerDown as EventListener);
cleanups.push(() => n.visEl.removeEventListener("pointerdown", onPointerDown as EventListener));
}
const onClick = (event: Event) => {
if (suppressClickEl === n.visEl && performance.now() < suppressClickUntil) {
event.preventDefault();
event.stopPropagation();
return;
}
const tool = placementTool;
if (editorMode && tool === "__erase__") {
commitLogoPlacements((current) => {
const next = { ...current };
delete next[n.debugId];
return next;
});
return;
}
if (editorMode && tool && HONEYCOMB_LOGOS[tool]) {
commitLogoPlacements((current) => {
const next = { ...current };
Object.entries(next).forEach(([cellId, label]) => {
if (label === tool) delete next[Number(cellId)];
});
next[n.debugId] = tool;
return next;
});
if (!n.solid) setNodeSolid(n, true);
return;
}
toggleNode(n);
};
n.visEl.addEventListener("click", onClick);
cleanups.push(() => n.visEl.removeEventListener("click", onClick));
});
cleanups.push(() => {
if (logoDrag) {
window.removeEventListener("pointermove", logoDrag.moveHandler);
window.removeEventListener("pointerup", logoDrag.endHandler);
window.removeEventListener("pointercancel", logoDrag.cancelHandler);
logoDrag.targetSlot?.removeAttribute("data-logo-drop-target");
document.body.style.cursor = logoDrag.previousCursor;
document.body.style.userSelect = logoDrag.previousUserSelect;
logoDrag = null;
}
dragGhosts.forEach((ghost) => ghost.remove());
dragGhosts.clear();
});
// ── hub hover: the whole network "powers on" ─────────────────────────
const hub = centerEl[0] as HTMLElement | undefined;
if (hub) {
const hubFace = hub.querySelector(".hex-face") as HTMLElement;
const toolFaces = cellEls.map((c) => c.querySelector(".hex-face") as HTMLElement);
const flare = q("[data-glow-flare]");
const hubEnter = contextSafe!(() => {
hub.style.zIndex = "40";
// logo pop
gsap.to(hubFace, { scale: reduce ? 1.05 : HUB_HOVER_SCALE, duration: 0.5, ease: "back.out(3)", overwrite: "auto" });
// the dark interior plate grows in lockstep with the G
gsap.to(q("[data-gcover]"), {
scale: reduce ? 1.05 : HUB_HOVER_SCALE,
svgOrigin: `${center.x} ${center.y}`,
duration: 0.5,
ease: "back.out(3)",
overwrite: "auto",
});
if (reduce) return;
// EVERY comb — ring 1, ring 2, whole field — drifts outward with
// the exact same physics (strongest tier). Strand roots follow
// their cells automatically via applySog.
applySog(center.x, center.y, PHY.hub);
// glow flares out
gsap.to(flare, { scale: 1.5, opacity: 1, duration: 0.5, ease: "power2.out", overwrite: "auto" });
// strands brighten; their tips ride the growing G separately
gsap.to(activeBaseLines, { attr: { "fill-opacity": 0.9 }, duration: 0.3, overwrite: "auto" });
gsap.to(sState, {
bx: (i: number) => strandHover[i].bx,
by: (i: number) => strandHover[i].by,
duration: 0.5,
ease: "back.out(3)",
overwrite: "auto",
onUpdate: redrawStrands,
});
// a wave ripples outward through the tool cells
gsap.to(toolFaces, {
scale: 1.07,
duration: 0.26,
ease: "power2.out",
stagger: { each: 0.05, from: "start" },
yoyo: true,
repeat: 1,
overwrite: "auto",
});
});
const hubLeave = contextSafe!(() => {
gsap.to(hubFace, { scale: 1, duration: 0.5, ease: "power3.out", overwrite: "auto", onComplete: () => { hub.style.zIndex = "20"; } });
gsap.to(q("[data-gcover]"), { scale: 1, duration: 0.5, ease: "power3.out", overwrite: "auto" });
releaseSog();
gsap.to(flare, { scale: 1, opacity: 0, duration: 0.6, ease: "power2.out", overwrite: "auto" });
gsap.to(activeBaseLines, { attr: { "fill-opacity": 0.7 }, duration: 0.5, overwrite: "auto" });
gsap.to(sState, {
bx: (i: number) => strandRest[i].b.x,
by: (i: number) => strandRest[i].b.y,
duration: 0.5,
ease: "power3.out",
overwrite: "auto",
onUpdate: redrawStrands,
});
});
const hubTap = contextSafe!((e: Event) => {
if ((e as PointerEvent).pointerType !== "touch") return;
hubEnter();
gsap.delayedCall(1.1, hubLeave);
});
hub.addEventListener("mouseenter", hubEnter);
hub.addEventListener("mouseleave", hubLeave);
hub.addEventListener("pointerdown", hubTap);
cleanups.push(() => {
hub.removeEventListener("mouseenter", hubEnter);
hub.removeEventListener("mouseleave", hubLeave);
hub.removeEventListener("pointerdown", hubTap);
});
}
const rootEl = root.current;
const activeRevealNodes = [
...centerEl.map((el) => ({ el, distance: 0 })),
...combNodes
.filter((node) => node.solid)
.map((node) => ({
el: node.moveEl,
distance: Math.hypot(node.x - center.x, node.y - center.y),
})),
]
.sort((a, b) => a.distance - b.distance)
.map(({ el }) => el);
const dynamicPaths = dynStrands.map((strand) => strand.el);
const setConnectionsFinal = () => {
sState.forEach((state, index) => {
state.ax = strandRest[index].a.x;
state.ay = strandRest[index].a.y;
state.bx = strandRest[index].b.x;
state.by = strandRest[index].b.y;
});
dynStrands.forEach((strand) => {
strand.grow = 1;
});
redrawStrands();
updateDynStrands();
baseLines.forEach((line, index) => {
gsap.set(line, { attr: { "fill-opacity": toolCellIsActive(index) ? 0.7 : 0 } });
});
if (dynamicPaths.length) {
gsap.set(dynamicPaths, { attr: { "fill-opacity": 0.7 } });
}
};
const collapseConnections = () => {
sState.forEach((state) => {
state.bx = state.ax;
state.by = state.ay;
});
dynStrands.forEach((strand) => {
strand.grow = 0;
});
redrawStrands();
updateDynStrands();
if (baseLines.length) {
gsap.set(baseLines, { attr: { "fill-opacity": 0 } });
}
if (dynamicPaths.length) {
gsap.set(dynamicPaths, { attr: { "fill-opacity": 0 } });
}
};
// ── animated bits, gated behind prefers-reduced-motion ───────────────
const mm = gsap.matchMedia();
mm.add("(prefers-reduced-motion: reduce)", () => {
if (packets.length) gsap.set(packets, { autoAlpha: 0 });
if (activeRevealNodes.length) {
gsap.set(activeRevealNodes, {
scale: 1,
autoAlpha: 1,
transformOrigin: "50% 50%",
});
}
if (glow.length) gsap.set(glow, { scale: 1, opacity: 0.7 });
setConnectionsFinal();
});
mm.add("(prefers-reduced-motion: no-preference)", () => {
if (packets.length) gsap.set(packets, { autoAlpha: 0 });
// parallax (from V5) — the whole comb drifts gently with the pointer
const par = q("[data-parallax]")[0];
let cleanupParallax: (() => void) | undefined;
if (par && rootEl) {
const px = gsap.quickTo(par, "x", { duration: 0.9, ease: "power3.out" });
const py = gsap.quickTo(par, "y", { duration: 0.9, ease: "power3.out" });
const move = (e: PointerEvent) => {
const b = rootEl.getBoundingClientRect();
px(((e.clientX - b.left) / b.width - 0.5) * 16);
py(((e.clientY - b.top) / b.height - 0.5) * 10);
};
const settle = () => {
px(0);
py(0);
};
rootEl.addEventListener("pointermove", move);
rootEl.addEventListener("pointerleave", settle);
cleanupParallax = () => {
rootEl.removeEventListener("pointermove", move);
rootEl.removeEventListener("pointerleave", settle);
};
}
const glowTween = glow.length
? gsap.fromTo(
glow,
{ scale: 1, opacity: 0.65 },
{
scale: 1.12,
opacity: 0.8,
duration: 3.2,
ease: "sine.inOut",
repeat: -1,
yoyo: true,
paused: true,
}
)
: null;
// ambient — a glowing data packet travels each line from tool → hub.
// The packet group is clipPath'd to exclude the central G hex, so the
// dot + glow vanish at the G's edge instead of bleeding into its
// transparent cut-out.
const packetTimelines: gsap.core.Timeline[] = [];
packets.forEach((dot, i) => {
if (!toolCellIsActive(i)) {
gsap.set(dot, { autoAlpha: 0 });
return;
}
const from = toolCells[i];
const packetTimeline = gsap.timeline({ repeat: -1, paused: true, delay: i * 0.45 })
.set(dot, { attr: { cx: from.x, cy: from.y } })
.to(dot, { autoAlpha: 1, duration: 0.25 })
.to(dot, { attr: { cx: lineEnds[i].x, cy: lineEnds[i].y }, duration: 1.8, ease: "power1.in" }, 0)
.to(dot, { autoAlpha: 0, duration: 0.2 }, "-=0.05");
packetTimelines.push(packetTimeline);
});
const startAmbientMotion = () => {
glowTween?.play(0);
packetTimelines.forEach((timeline) => timeline.restart(true));
};
if (revealOnScroll && rootEl) {
if (activeRevealNodes.length) {
gsap.set(activeRevealNodes, {
scale: 0.16,
autoAlpha: 0,
transformOrigin: "50% 50%",
});
}
if (glow.length) gsap.set(glow, { scale: 0.8, autoAlpha: 0 });
collapseConnections();
const introTimeline = gsap.timeline({
scrollTrigger: {
trigger: rootEl,
start: "top 72%",
once: true,
},
});
if (activeRevealNodes.length) {
introTimeline.to(activeRevealNodes, {
scale: 1,
autoAlpha: 1,
duration: 0.48,
stagger: 0.045,
ease: "back.out(1.75)",
});
}
introTimeline.addLabel("connections");
if (activeBaseLines.length) {
introTimeline
.to(sState, {
bx: (index: number) => strandRest[index].b.x,
by: (index: number) => strandRest[index].b.y,
duration: 0.58,
stagger: 0.045,
ease: "power2.out",
onUpdate: redrawStrands,
}, "connections")
.to(activeBaseLines, {
attr: { "fill-opacity": 0.7 },
duration: 0.42,
stagger: 0.045,
ease: "power2.out",
}, "connections");
}
if (glow.length) {
introTimeline.to(
glow,
{ scale: 1, autoAlpha: 0.65, duration: 0.45, ease: "power2.out" },
0
);
}
if (dynStrands.length) {
introTimeline
.to(dynStrands, {
grow: 1,
duration: 0.55,
stagger: 0.025,
ease: "power2.out",
onUpdate: updateDynStrands,
}, "connections+=0.04")
.to(dynamicPaths, {
attr: { "fill-opacity": 0.7 },
duration: 0.38,
stagger: 0.025,
ease: "power2.out",
}, "connections+=0.04");
}
introTimeline.call(startAmbientMotion);
} else {
if (activeRevealNodes.length) {
gsap.set(activeRevealNodes, {
scale: 1,
autoAlpha: 1,
transformOrigin: "50% 50%",
});
}
if (glow.length) gsap.set(glow, { scale: 1, opacity: 0.65 });
setConnectionsFinal();
startAmbientMotion();
}
// NOTE: no ambient drift on ring 2 anymore — it kept the deco combs
// permanently a few px off their true position, which read as "not
// returning home" and made ring 2 behave differently from the field.
return () => {
cleanupParallax?.();
if (activeRevealNodes.length) {
gsap.set(activeRevealNodes, { clearProps: "transform,opacity,visibility" });
}
};
});
return () => {
mm.revert();
cleanups.forEach((fn) => fn());
};
},
{
scope: root,
dependencies: [logoPlacements, activeStateKey, layerStateKey, appearance, placementTool, editorMode, physics, revealOnScroll],
revertOnUpdate: true,
}
);
return (
<section
ref={root}
data-honeycomb-logo-editor=""
data-honeycomb-appearance={appearance}
data-honeycomb-reveal={revealOnScroll ? "scroll" : "static"}
className={
bare
? "absolute inset-0 overflow-hidden pointer-events-none hidden lg:block"
: inline
? "relative w-full overflow-hidden flex justify-center items-center h-[560px] sm:h-[680px] md:h-[860px] lg:h-[1020px]"
: "section-full"
}
style={
bare
? undefined
: inline
? undefined
: { background: dark ? "#171106" : "#FFFFFF", paddingBlock: 88 }
}
>
<style>{`
[data-honeycomb-logo-editor] [data-logo-drop-target="1"] .hex-face,
[data-honeycomb-logo-editor] [data-logo-drop-target="1"] [data-nearhex] {
filter: drop-shadow(0 0 4px rgba(255, 255, 255, 0.95)) drop-shadow(0 0 14px rgba(241, 183, 41, 0.9));
}
[data-honeycomb-logo-editor] [data-nearcell][data-logo-drop-target="1"] [data-nearhex] {
stroke: rgba(255, 255, 255, 0.95);
stroke-width: 3px;
vector-effect: non-scaling-stroke;
}
`}</style>
{!bare && !inline && (
<div className="mx-auto flex flex-col items-center gap-4 text-center" style={{ maxWidth: "var(--content-width)" }}>
<span
className="text-[12px] font-semibold tracking-widest rounded-[var(--radius-badge)] px-2 py-0.5"
style={
dark
? { background: "rgba(241,183,41,0.14)", color: "var(--accent-yellow)" }
: { background: "var(--accent-yellow-light)", color: "var(--accent-yellow-dark)" }
}
>
INTEGRATIONEN
</span>
<h2
className="text-[32px] md:text-[42px] font-bold leading-[1.15]"
style={{ color: dark ? "#F7F1E1" : "var(--text-primary)" }}
>
Deine Werkzeuge. <span style={{ color: "var(--accent-yellow)" }}>Eine Wabe.</span>
</h2>
<p className="text-[16px] max-w-xl" style={{ color: dark ? "#B8AC94" : "var(--text-secondary)" }}>
HiveGrid verbindet die Software, mit der dein Betrieb schon arbeitet — alles fließt in einem
System zusammen.
</p>
</div>
)}
{/* honeycomb — the comb box is far larger than any viewport (the field
rings fade out radially), so every variant shows it through a clipped
window centred on the hub instead of letting it size the layout. */}
<div
className={
bare || inline
? undefined
: "relative mt-14 w-full overflow-hidden h-[440px] sm:h-[540px] md:h-[660px] lg:h-[740px]"
}
>
<div
className={
bare
? "absolute top-1/2 left-[70%] -translate-x-1/2 -translate-y-1/2"
: "absolute left-1/2 top-1/2"
}
style={bare ? undefined : { transform: `translate(-${center.x}px, -${center.y}px)` }}
>
<div data-parallax>
<div
className={
bare
? "relative origin-center scale-[0.85]"
: inline
? "relative scale-[0.62] sm:scale-[0.8] md:scale-[1] lg:scale-[1.18]"
: "relative scale-[0.62] sm:scale-75 md:scale-90 lg:scale-100"
}
style={{
width: BOX_W,
height: BOX_H,
...(!bare && { transformOrigin: `${center.x}px ${center.y}px` }),
}}
>
{/* static background field — the same honeycomb continued outward.
Each hex fades by horizontal position: faint on the left (behind the
text), stronger toward the cluster on the right → soft transition. */}
{/* background field (rings 3–18): every comb identical, every comb
hoverable — uniform colour, uniform interaction */}
{layers.field && <svg className="absolute inset-0" width={BOX_W} height={BOX_H} viewBox={`0 0 ${BOX_W} ${BOX_H}`}>
{nearField.map((c) => {
const label = logoPlacements[c.debugId];
const logo = label ? HONEYCOMB_LOGOS[label] : undefined;
const active = isCellActive(c.debugId, Boolean(label));
const logoSize = FIELD_LOGO_BOX * (logo?.scale ?? 1);
return (
<g
key={c.debugId}
data-nearcell
data-cell-number={c.debugId}
data-logo-slot={c.debugId}
>
<path
data-nearhex
data-active={active ? "1" : undefined}
d={fieldHexPath(c.x, c.y)}
fill={visual.fieldFill}
fillOpacity={active ? visual.fieldActiveOpacity : visual.fieldInactiveOpacity}
stroke={active ? visual.fieldActiveStroke : visual.fieldInactiveStroke}
strokeWidth={visual.fieldStrokeWidth}
vectorEffect="non-scaling-stroke"
/>
{label && logo && (
<image
data-cell-logo=""
href={logo.src}
aria-label={label}
x={c.x - logoSize / 2}
y={c.y - logoSize / 2}
width={logoSize}
height={logoSize}
preserveAspectRatio="xMidYMid meet"
pointerEvents="none"
opacity={active ? 1 : 0}
style={{
userSelect: "none",
clipPath: logo.cornerRadius
? `inset(0 round ${logo.cornerRadius})`
: undefined,
}}
/>
)}
{showCellNumbers && (
<text
x={c.x}
y={label ? c.y - FIELD_HH + 14 : c.y}
dy="0.35em"
textAnchor="middle"
aria-hidden="true"
pointerEvents="none"
fontSize={14}
fontWeight={800}
fill={dark ? "#F7F1E1" : "#3E2C0A"}
stroke={dark ? "#171106" : "#FAFAFA"}
strokeWidth={4}
strokeLinejoin="round"
paintOrder="stroke"
style={{ fontFamily: "var(--font-sans)", fontVariantNumeric: "tabular-nums" }}
>
{c.debugId}
</text>
)}
</g>
);
})}
</svg>}
{/* hub glow */}
{layers.glow && (
<div
data-glow
aria-hidden
className="absolute rounded-full -z-10"
style={{
left: center.x,
top: center.y,
width: W * 2,
height: W * 2,
marginLeft: -W,
marginTop: -W,
background: visual.glow,
filter: "blur(28px)",
opacity: 0.65,
}}
/>
)}
{/* extra glow that flares only while the hub is hovered */}
{layers.glow && (
<div
data-glow-flare
aria-hidden
className="absolute rounded-full -z-10"
style={{
left: center.x,
top: center.y,
width: W * 2.4,
height: W * 2.4,
marginLeft: -W * 1.2,
marginTop: -W * 1.2,
background: visual.flare,
filter: "blur(30px)",
opacity: 0,
}}
/>
)}
{/* connection lines + travelling data packets */}
{(layers.strands || layers.packets) && <svg
className="absolute inset-0 pointer-events-none"
viewBox={`0 0 ${BOX_W} ${BOX_H}`}
width={BOX_W}
height={BOX_H}
>
{layers.strands && toolCells.map((p, i) => (
<path
key={`b${i}`}
data-line="base"
d={strandPath(strandRest[i].a, strandRest[i].b, strandRest[i].len)}
fill={visual.strand}
fillOpacity={isCellActive(
p.debugId,
HONEYCOMB_DEFAULT_ACTIVE_CELL_ID_SET.has(p.debugId)
) ? 0.7 : 0}
/>
))}
{/* Dynamic strands connect every active outer cell with its active
direct neighbours; populated imperatively. */}
{layers.strands && <g data-dyn />}
{/* the G's interior. In dark mode an opaque plate (matching the bg)
sits under the logo band to block glow + strands. In light mode
we keep it transparent so the G's cut-out negative space shows
the honeycomb field + amber hub-glow through it, instead of a
flat white plate — matching the source's dark-mode seamlessness. */}
{layers.hub && (
<path
data-gcover
d={hexPathR(center.x, center.y, R * CELL_SIZE * 0.92)}
fill={dark ? "#171106" : "transparent"}
style={{ transition: "fill 0.4s ease" }}
/>
)}
{/* Travelling data packets. The whole group is clipped to EXCLUDE
the central G hexagon (outer box minus a centre hex, evenodd), so
a packet and its glow are cut off exactly at the G's edge — the
flow along the strands stays visible, but nothing renders inside
the transparent G cut-out. */}
<defs>
<clipPath id="hub-exclude" clipPathUnits="userSpaceOnUse">
<path
clipRule="evenodd"
d={`M0 0H${BOX_W}V${BOX_H}H0Z ${hexPathR(center.x, center.y, R * CELL_SIZE)}`}
/>
</clipPath>
</defs>
{layers.packets && <g clipPath="url(#hub-exclude)">
{toolCells.map((p, i) => (
<circle
key={`p${i}`}
data-packet
cx={p.x}
cy={p.y}
r={4}
fill={visual.packet}
style={{ filter: "drop-shadow(0 0 5px rgba(241,183,41,0.95))" }}
/>
))}
</g>}
</svg>}
{/* Outer ring: every numbered cell is a draggable logo slot. */}
{layers.outerRing && decoCells.map((c, i) => {
const label = logoPlacements[c.debugId];
const logo = label ? HONEYCOMB_LOGOS[label] : undefined;
const active = isCellActive(c.debugId, Boolean(label));
return (
<HexShell
key={`deco${i}`}
x={c.x}
y={c.y}
z={label ? 2 : 1}
dataAttr={{
"data-hex": "deco",
"data-cell-number": c.debugId,
"data-logo-slot": c.debugId,
}}
size={CELL_SIZE}
bg={active ? visual.activeFill : visual.inactiveFill}
outline={active ? visual.activeOutline : visual.inactiveOutline}
outlineWidth={visual.outlineWidth}
faceShadow={active ? visual.activeShadow : visual.inactiveShadow}
faceBackdropFilter={visual.backdropFilter}
active={active}
debugNumber={showCellNumbers ? c.debugId : undefined}
>
{label && logo ? (
<img
src={logo.src}
alt={label}
data-cell-logo=""
className="pointer-events-none select-none"
style={{
width: `${48 * (logo.scale ?? 1)}%`,
objectFit: "contain",
opacity: active ? 1 : 0,
borderRadius: logo.cornerRadius,
}}
draggable={false}
/>
) : null}
</HexShell>
);
})}
{/* tool cells — key by position (c.i), NOT label: a stable key keeps the
DOM node alive when a logo is swapped, so the hover listeners that
useGSAP attached on mount stay bound to it. */}
{layers.innerRing && toolCells.map((c) => {
const label = logoPlacements[c.debugId];
const logo = label ? HONEYCOMB_LOGOS[label] : undefined;
const active = isCellActive(
c.debugId,
HONEYCOMB_DEFAULT_ACTIVE_CELL_ID_SET.has(c.debugId)
);
return (
<HexShell
key={c.i}
x={c.x}
y={c.y}
z={2}
dataAttr={{
"data-hex": "cell",
"data-index": c.i,
"data-cell-number": c.debugId,
"data-logo-slot": c.debugId,
}}
size={CELL_SIZE}
bg={active ? visual.activeFill : visual.inactiveFill}
outline={active ? visual.activeOutline : visual.inactiveOutline}
outlineWidth={visual.outlineWidth}
faceShadow={active ? visual.activeShadow : visual.inactiveShadow}
faceBackdropFilter={visual.backdropFilter}
active={active}
debugNumber={showCellNumbers ? c.debugId : undefined}
>
{label && logo ? (
<img
src={logo.src}
alt={label}
data-cell-logo=""
className="pointer-events-none select-none"
style={{
width: `${48 * (logo.scale ?? 1)}%`,
objectFit: "contain",
opacity: active ? 1 : 0,
borderRadius: logo.cornerRadius,
}}
draggable={false}
/>
) : null}
</HexShell>
);
})}
{/* centre hub — the HiveGrid "G" filling the cell, dark G on amber */}
{layers.hub && <HexShell
x={center.x}
y={center.y}
z={20}
dataAttr={{ "data-hex": "center", "data-cell-number": center.debugId }}
size={CENTER_SIZE}
bg="transparent"
debugNumber={showCellNumbers ? center.debugId : undefined}
>
{/* the logo asset is a flat-top hex spanning its full width — sizing
the square img to the cell-face width makes the G exactly as
large as the surrounding comb faces */}
<img
src="/hivegrid-logo.png"
alt="HiveGrid"
className="cursor-pointer select-none"
style={{ width: W * CELL_SIZE, height: W * CELL_SIZE, objectFit: "contain" }}
/>
</HexShell>}
</div>
</div>
</div>
{/* Full-canvas edge fade — the hex field dissolves into the section's
background colour: strong on the left/right (esp. fullscreen),
softer top, full at the bottom so no hard clip line remains */}
{!bare && !inline && (
<div
aria-hidden
className="absolute inset-0 pointer-events-none"
style={{ zIndex: 50, background: fadeBg }}
/>
)}
</div>
{/* inline edge fade — dissolves clipped hexes on every edge into the
section bg so only whole hexagons read, on all viewports */}
{inline && showInlineFade && (
<div
aria-hidden
className="absolute inset-0 pointer-events-none"
style={{ zIndex: 50, background: inlineFade }}
/>
)}
</section>
);
}