sticky-scroll-trigger 0.9.0 → 0.11.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
/*!
|
|
2
2
|
* @license
|
|
3
|
-
* StickyScrollTrigger v0.
|
|
3
|
+
* StickyScrollTrigger v0.11.0
|
|
4
4
|
* Copyright (c) 2026 Kuninori Ogino
|
|
5
5
|
* Released under the MIT License
|
|
6
6
|
* https://github.com/kuninori-ogino/sticky-scroll-trigger
|
|
@@ -47,10 +47,26 @@ const measureViewportHeight = () => {
|
|
|
47
47
|
probe.remove();
|
|
48
48
|
return height;
|
|
49
49
|
};
|
|
50
|
-
const
|
|
51
|
-
|
|
52
|
-
|
|
50
|
+
const measureDocumentHeight = () => document.documentElement.scrollHeight || document.body.scrollHeight;
|
|
51
|
+
const pinRanges = new Set();
|
|
52
|
+
const measureDocumentHeightWithoutPinRanges = () => {
|
|
53
|
+
pinRanges.forEach((inner) => {
|
|
54
|
+
if (!inner.isConnected) pinRanges.delete(inner);
|
|
55
|
+
});
|
|
56
|
+
const saved = [...pinRanges].map((inner) => ({
|
|
57
|
+
inner,
|
|
58
|
+
height: inner.style.height
|
|
59
|
+
}));
|
|
60
|
+
saved.forEach(({ inner }) => {
|
|
61
|
+
inner.style.height = "";
|
|
62
|
+
});
|
|
63
|
+
const height = measureDocumentHeight();
|
|
64
|
+
saved.forEach(({ inner, height: range }) => {
|
|
65
|
+
inner.style.height = range;
|
|
66
|
+
});
|
|
67
|
+
return height;
|
|
53
68
|
};
|
|
69
|
+
const measureDocumentMaxScroll = (viewportHeight) => Math.max(0, measureDocumentHeight() - viewportHeight);
|
|
54
70
|
const measureBorderWidth = (borderStyle, width) => borderStyle === "none" || borderStyle === "hidden" ? 0 : parseFloat(width);
|
|
55
71
|
const measureUsedHeight = (el) => {
|
|
56
72
|
const rounded = el.offsetHeight;
|
|
@@ -82,7 +98,7 @@ const restoreInlinePosition = (el, saved) => {
|
|
|
82
98
|
el.style.position = saved.position;
|
|
83
99
|
el.style.top = saved.top;
|
|
84
100
|
};
|
|
85
|
-
const wrapScene = (inner) => {
|
|
101
|
+
const wrapScene = (inner, holdTrailingMargin) => {
|
|
86
102
|
if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
|
|
87
103
|
const container = document.createElement("div");
|
|
88
104
|
const wrapper = document.createElement("div");
|
|
@@ -93,6 +109,11 @@ const wrapScene = (inner) => {
|
|
|
93
109
|
container.appendChild(wrapper);
|
|
94
110
|
wrapper.appendChild(inner);
|
|
95
111
|
container.appendChild(padding);
|
|
112
|
+
if (holdTrailingMargin) {
|
|
113
|
+
const sentinel = document.createElement("div");
|
|
114
|
+
sentinel.style.display = "flow-root";
|
|
115
|
+
wrapper.appendChild(sentinel);
|
|
116
|
+
}
|
|
96
117
|
return {
|
|
97
118
|
container,
|
|
98
119
|
wrapper,
|
|
@@ -121,10 +142,11 @@ const wrapPin = (trigger) => {
|
|
|
121
142
|
if (!trigger.parentNode) throw new Error(`createStickyPin: trigger ${describeElement(trigger)} is not attached to the document`);
|
|
122
143
|
const outer = document.createElement("div");
|
|
123
144
|
const inner = document.createElement("div");
|
|
124
|
-
outer.style.
|
|
145
|
+
outer.style.display = "flow-root";
|
|
125
146
|
trigger.parentNode.insertBefore(outer, trigger);
|
|
126
147
|
outer.appendChild(inner);
|
|
127
148
|
inner.appendChild(trigger);
|
|
149
|
+
pinRanges.add(inner);
|
|
128
150
|
return {
|
|
129
151
|
outer,
|
|
130
152
|
inner
|
|
@@ -134,6 +156,7 @@ const unwrapPin = (outer, trigger, saved) => {
|
|
|
134
156
|
const parent = outer.parentNode;
|
|
135
157
|
restoreInlinePosition(trigger, saved);
|
|
136
158
|
if (parent) parent.insertBefore(trigger, outer);
|
|
159
|
+
if (outer.firstElementChild instanceof HTMLElement) pinRanges.delete(outer.firstElementChild);
|
|
137
160
|
outer.remove();
|
|
138
161
|
};
|
|
139
162
|
const LIFT_VALUES = {
|
|
@@ -177,6 +200,584 @@ const liftAboveStickyWrapper = (cover) => {
|
|
|
177
200
|
lifted.length = 0;
|
|
178
201
|
};
|
|
179
202
|
};
|
|
203
|
+
const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
|
|
204
|
+
const KEYWORD_FRACTIONS = {
|
|
205
|
+
top: 0,
|
|
206
|
+
center: .5,
|
|
207
|
+
bottom: 1
|
|
208
|
+
};
|
|
209
|
+
const signedPx = (sign, value, unit, refSize) => {
|
|
210
|
+
const magnitude = unit === "%" ? parseFloat(value) / 100 * refSize : parseFloat(value);
|
|
211
|
+
return sign?.startsWith("-") ? -magnitude : magnitude;
|
|
212
|
+
};
|
|
213
|
+
const CLAUSE_TOKEN_RE = /^(top|center|bottom|[+-]?(?:\d+(?:\.\d*)?|\.\d+))?(%|px)?(?:([+-]=?)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
|
|
214
|
+
const parseClauseToken = (token, refSize) => {
|
|
215
|
+
const match = CLAUSE_TOKEN_RE.exec(token);
|
|
216
|
+
if (!match || !match[1] && !match[3]) {
|
|
217
|
+
if (MAX_TOKEN_RE.test(token)) throw new Error(`StickyScrollTrigger: unsupported position clause "${token}": 'max' is GSAP's end-only keyword for the scroller's maximum scroll position.`);
|
|
218
|
+
throw new Error(`StickyScrollTrigger: unsupported position clause "${token}"`);
|
|
219
|
+
}
|
|
220
|
+
const [, base, baseUnit, sign, offsetValue, offsetUnit] = match;
|
|
221
|
+
if (base !== void 0 && sign && !sign.includes("=")) {
|
|
222
|
+
const suggestion = `${base}${baseUnit ?? ""}${sign}=${offsetValue}${offsetUnit ?? ""}`;
|
|
223
|
+
throw new Error(`StickyScrollTrigger: unsupported position clause "${token}": a signed offset needs an explicit '=' when it follows a keyword or number (GSAP needs it to tell "${base}" from the offset). Did you mean "${suggestion}"?`);
|
|
224
|
+
}
|
|
225
|
+
const isKeyword = base !== void 0 && base in KEYWORD_FRACTIONS;
|
|
226
|
+
const basePercent = baseUnit === "%";
|
|
227
|
+
return {
|
|
228
|
+
fraction: isKeyword ? KEYWORD_FRACTIONS[base] : basePercent ? parseFloat(base) / 100 : 0,
|
|
229
|
+
offsetPx: (!isKeyword && !basePercent && base !== void 0 ? parseFloat(base) : 0) + (sign ? signedPx(sign, offsetValue, offsetUnit, refSize) : 0)
|
|
230
|
+
};
|
|
231
|
+
};
|
|
232
|
+
const isAbsoluteFormat = (resolved) => {
|
|
233
|
+
if (typeof resolved === "number") return true;
|
|
234
|
+
return resolved.trim() !== "" && !Number.isNaN(Number(resolved));
|
|
235
|
+
};
|
|
236
|
+
const resolveAbsolute = (resolved) => typeof resolved === "number" ? resolved : Number(resolved);
|
|
237
|
+
const CLAMP_PREFIX = "clamp(";
|
|
238
|
+
const assertNotClamped = (trimmed) => {
|
|
239
|
+
if (!trimmed.startsWith(CLAMP_PREFIX)) return;
|
|
240
|
+
const inner = trimmed.slice(6).replace(/\)$/, "").trim();
|
|
241
|
+
throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
|
|
242
|
+
};
|
|
243
|
+
const resolveElementAnchor = (position, elementHeight) => {
|
|
244
|
+
const trimmed = position.trim();
|
|
245
|
+
assertNotClamped(trimmed);
|
|
246
|
+
const elementClause = parseClauseToken(trimmed.split(/\s+/)[0], elementHeight);
|
|
247
|
+
return elementHeight * elementClause.fraction + elementClause.offsetPx;
|
|
248
|
+
};
|
|
249
|
+
const resolveElementFraction = (position) => resolveElementAnchor(position, 1) - resolveElementAnchor(position, 0);
|
|
250
|
+
const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
|
|
251
|
+
const trimmed = position.trim();
|
|
252
|
+
assertNotClamped(trimmed);
|
|
253
|
+
const viewportToken = trimmed.split(/\s+/)[1] ?? "top";
|
|
254
|
+
const viewportClause = parseClauseToken(viewportToken, viewportHeight);
|
|
255
|
+
return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - resolveElementAnchor(trimmed, elementHeight);
|
|
256
|
+
};
|
|
257
|
+
const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
|
|
258
|
+
const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
|
|
259
|
+
const prefixSpacedRelativeEnd = (start, endResolved) => {
|
|
260
|
+
if (typeof endResolved !== "string") return endResolved;
|
|
261
|
+
const trimmedEnd = endResolved.trim();
|
|
262
|
+
if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
|
|
263
|
+
const startResolved = resolveMaybeFn(start);
|
|
264
|
+
if (typeof startResolved !== "string") return endResolved;
|
|
265
|
+
const trimmedStart = startResolved.trim();
|
|
266
|
+
assertNotClamped(trimmedStart);
|
|
267
|
+
const [elementToken] = trimmedStart.split(/\s+/);
|
|
268
|
+
try {
|
|
269
|
+
parseClauseToken(elementToken, 0);
|
|
270
|
+
} catch (error) {
|
|
271
|
+
if (!isAbsoluteFormat(startResolved)) throw error;
|
|
272
|
+
return endResolved;
|
|
273
|
+
}
|
|
274
|
+
parseClauseToken(trimmedEnd.split(/\s+/)[0], 0);
|
|
275
|
+
if (elementToken.includes("=")) throw new Error(`StickyScrollTrigger: end "${endResolved}" can't be resolved against start "${startResolved}": GSAP reads an end that starts with '+=' and holds a space by prefixing it with the start clause's element token, and "${elementToken}" carries an offset of its own, which GSAP resolves by discarding the end's. Give end a complete position clause instead, such as 'top+=100 bottom'.`);
|
|
276
|
+
return elementToken + trimmedEnd;
|
|
277
|
+
};
|
|
278
|
+
const resolveDwell = (resolved, viewportHeight) => {
|
|
279
|
+
const match = DWELL_RELATIVE_RE.exec(String(resolved).trim());
|
|
280
|
+
if (!match) throw new Error(`StickyScrollTrigger: unsupported end format "${resolved}"`);
|
|
281
|
+
const [, value, unit] = match;
|
|
282
|
+
return signedPx(void 0, value, unit, viewportHeight);
|
|
283
|
+
};
|
|
284
|
+
const MAX_TOKEN_RE = /^max(?:([+-]=)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
|
|
285
|
+
const isMaxFormat = (resolved) => typeof resolved === "string" && MAX_TOKEN_RE.test(resolved.trim());
|
|
286
|
+
const resolveMaxOffset = (resolved, viewportHeight) => {
|
|
287
|
+
const match = MAX_TOKEN_RE.exec(resolved.trim());
|
|
288
|
+
if (!match) throw new Error(`StickyScrollTrigger: unsupported max-position format "${resolved}"`);
|
|
289
|
+
const [, sign, value, unit] = match;
|
|
290
|
+
return sign ? signedPx(sign, value, unit, viewportHeight) : 0;
|
|
291
|
+
};
|
|
292
|
+
const classifyPosition = (resolved) => {
|
|
293
|
+
if (typeof resolved === "number") return {
|
|
294
|
+
kind: "absolute",
|
|
295
|
+
value: resolved
|
|
296
|
+
};
|
|
297
|
+
if (isDwellFormat(resolved)) return {
|
|
298
|
+
kind: "dwell",
|
|
299
|
+
value: resolved
|
|
300
|
+
};
|
|
301
|
+
if (isMaxFormat(resolved)) return {
|
|
302
|
+
kind: "max",
|
|
303
|
+
value: resolved
|
|
304
|
+
};
|
|
305
|
+
if (isAbsoluteFormat(resolved)) return {
|
|
306
|
+
kind: "absolute",
|
|
307
|
+
value: resolveAbsolute(resolved)
|
|
308
|
+
};
|
|
309
|
+
return {
|
|
310
|
+
kind: "clause",
|
|
311
|
+
value: resolved
|
|
312
|
+
};
|
|
313
|
+
};
|
|
314
|
+
const isHeldIn = (measurements, index, enclosedBy, anchorElement, order) => measurements[index].triggerEnclosedBy.some((m) => m !== index && measurements[m].kind === "scene" && order.isBefore(m, index) && !(enclosedBy.includes(m) && m !== anchorElement));
|
|
315
|
+
const nestedIn = (measurements, index) => measurements.flatMap(({ triggerEnclosedBy }, k) => k !== index && triggerEnclosedBy.includes(index) ? [k] : []);
|
|
316
|
+
const anchorShare = (measurements, world, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex) => {
|
|
317
|
+
const measurement = measurements[index];
|
|
318
|
+
if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? world.unpaddedStart(index, ownIndex, freezeStart) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
|
|
319
|
+
if (order && isHeldIn(measurements, index, enclosedBy, anchorElement, order)) return 0;
|
|
320
|
+
if (box.nests.includes(index)) return box.fraction;
|
|
321
|
+
return measurement.triggerTop + measurement.triggerHeight <= box.top + .05 ? 1 : 0;
|
|
322
|
+
};
|
|
323
|
+
const gapsBeforeEndAnchor = (measurements, world, windows, box, reachedAt, enclosedBy, ownIndex, anchorElement, order, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
|
|
324
|
+
if (index === ownIndex || order && order.isBefore(ownIndex, index)) return total;
|
|
325
|
+
const weight = anchorShare(measurements, world, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex);
|
|
326
|
+
if (weight === 0) return total;
|
|
327
|
+
counted?.add(index);
|
|
328
|
+
return total + weight * (freezeEnd - freezeStart);
|
|
329
|
+
}, 0);
|
|
330
|
+
const clauseFreezeStart = (measurements, index, paddingOf) => {
|
|
331
|
+
const reachOf = (k) => {
|
|
332
|
+
const { start, triggerTop } = measurements[k];
|
|
333
|
+
return start.mode === "clause" ? triggerTop - start.anchorOffset : null;
|
|
334
|
+
};
|
|
335
|
+
const scenes = measurements.flatMap(({ kind }, k) => kind === "scene" ? [k] : []);
|
|
336
|
+
const clauses = scenes.filter((k) => reachOf(k) !== null).sort((a, b) => {
|
|
337
|
+
const gap = reachOf(a) - reachOf(b);
|
|
338
|
+
return Math.abs(gap) <= .05 ? a - b : gap;
|
|
339
|
+
});
|
|
340
|
+
const absolutes = scenes.flatMap((k) => {
|
|
341
|
+
const { start } = measurements[k];
|
|
342
|
+
return start.mode === "absolute" ? [{
|
|
343
|
+
k,
|
|
344
|
+
value: start.value
|
|
345
|
+
}] : [];
|
|
346
|
+
}).sort((a, b) => a.value - b.value);
|
|
347
|
+
let dwell = 0;
|
|
348
|
+
let nextAbsolute = 0;
|
|
349
|
+
for (const k of clauses) {
|
|
350
|
+
const reachedAt = reachOf(k);
|
|
351
|
+
while (nextAbsolute < absolutes.length && absolutes[nextAbsolute].value < reachedAt + dwell + .05) {
|
|
352
|
+
dwell += paddingOf(absolutes[nextAbsolute].k);
|
|
353
|
+
nextAbsolute += 1;
|
|
354
|
+
}
|
|
355
|
+
if (k === index) return reachedAt + dwell;
|
|
356
|
+
dwell += paddingOf(k);
|
|
357
|
+
}
|
|
358
|
+
throw new Error("StickyScrollTrigger: internal error: clauseFreezeStart was given a layer without a clause start.");
|
|
359
|
+
};
|
|
360
|
+
const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, world, record, previousOnly = false) => {
|
|
361
|
+
const fresh = [];
|
|
362
|
+
const knownWindows = () => measurements.flatMap((measurement, k) => {
|
|
363
|
+
if (measurement.kind !== "scene") return [];
|
|
364
|
+
const plan = previousOnly ? null : fresh[k];
|
|
365
|
+
if (plan) return [{
|
|
366
|
+
index: k,
|
|
367
|
+
freezeStart: plan.freezeStart,
|
|
368
|
+
freezeEnd: plan.freezeEnd
|
|
369
|
+
}];
|
|
370
|
+
const freezeStart = previous?.freezeStarts[k] ?? null;
|
|
371
|
+
const paddingHeight = previous?.paddings[k] ?? null;
|
|
372
|
+
return freezeStart === null || paddingHeight === null ? [] : [{
|
|
373
|
+
index: k,
|
|
374
|
+
freezeStart,
|
|
375
|
+
freezeEnd: freezeStart + paddingHeight
|
|
376
|
+
}];
|
|
377
|
+
});
|
|
378
|
+
const paddingOf = (k) => (previousOnly ? null : fresh[k]?.paddingHeight) ?? previous?.paddings[k] ?? 0;
|
|
379
|
+
const recounts = [];
|
|
380
|
+
const plans = measurements.map((measurement, index) => {
|
|
381
|
+
fresh[index] = null;
|
|
382
|
+
if (measurement.kind === "cover") return null;
|
|
383
|
+
const recount = {
|
|
384
|
+
index,
|
|
385
|
+
counted: new Set(),
|
|
386
|
+
runs: []
|
|
387
|
+
};
|
|
388
|
+
recounts.push(recount);
|
|
389
|
+
const { start } = measurement;
|
|
390
|
+
const freezeStart = start.mode === "absolute" ? start.value : previous?.freezeStarts[index] ?? clauseFreezeStart(measurements, index, paddingOf);
|
|
391
|
+
let freezeEnd;
|
|
392
|
+
switch (measurement.end.mode) {
|
|
393
|
+
case "dwell":
|
|
394
|
+
freezeEnd = freezeStart + measurement.end.distancePx;
|
|
395
|
+
break;
|
|
396
|
+
case "absolute": {
|
|
397
|
+
const length = world.absoluteEndLength(index);
|
|
398
|
+
freezeEnd = length === null ? Math.max(freezeStart, measurement.end.value) : freezeStart + length;
|
|
399
|
+
break;
|
|
400
|
+
}
|
|
401
|
+
case "auto":
|
|
402
|
+
case "max": throw new Error(`StickyScrollTrigger: internal error: a Scene layer reached '${measurement.end.mode}' end mode, which only a cover layer can have.`);
|
|
403
|
+
case "clause": {
|
|
404
|
+
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
|
|
405
|
+
if (measurement.endTriggerIsSelf) {
|
|
406
|
+
const nests = nestedIn(measurements, index);
|
|
407
|
+
const weight = resolveElementFraction(measurement.end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
|
|
408
|
+
const dwellInside = measurements.reduce((total, other, k) => {
|
|
409
|
+
if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
|
|
410
|
+
recount.counted.add(k);
|
|
411
|
+
return total + weight * paddingOf(k);
|
|
412
|
+
}, 0);
|
|
413
|
+
if (start.mode === "clause") {
|
|
414
|
+
freezeEnd = freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
|
|
415
|
+
break;
|
|
416
|
+
}
|
|
417
|
+
const dwellAbove = measurements.reduce((total, other, k) => {
|
|
418
|
+
if (k === index || other.kind !== "scene" || nests.includes(k) || other.triggerTop + other.triggerHeight > measurement.triggerTop + .05 || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
|
|
419
|
+
recount.counted.add(k);
|
|
420
|
+
return total + paddingOf(k);
|
|
421
|
+
}, 0);
|
|
422
|
+
freezeEnd = Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
|
|
423
|
+
break;
|
|
424
|
+
}
|
|
425
|
+
let endTop;
|
|
426
|
+
if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
|
|
427
|
+
else {
|
|
428
|
+
const rawTop = measurement.endTriggerIndex === null ? measurement.end.rawTop : measurements[measurement.endTriggerIndex].triggerTop;
|
|
429
|
+
if (rawTop === null) endTop = 0;
|
|
430
|
+
else {
|
|
431
|
+
const box = {
|
|
432
|
+
top: rawTop,
|
|
433
|
+
fraction: resolveElementFraction(measurement.end.clause),
|
|
434
|
+
nests: measurement.endTriggerNests
|
|
435
|
+
};
|
|
436
|
+
const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, world, w, box, rawTop - anchorOffsetEnd, measurement.endTriggerEnclosedBy, index, measurement.endTriggerIndex, order, counted);
|
|
437
|
+
endTop = rawTop + gaps(knownWindows());
|
|
438
|
+
recount.runs.push((w) => gaps(w, recount.counted));
|
|
439
|
+
}
|
|
440
|
+
}
|
|
441
|
+
let layoutStart;
|
|
442
|
+
if (start.mode === "absolute") layoutStart = start.value;
|
|
443
|
+
else {
|
|
444
|
+
const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, world, w, {
|
|
445
|
+
top: measurement.triggerTop,
|
|
446
|
+
fraction: start.elementFraction,
|
|
447
|
+
nests: nestedIn(measurements, index)
|
|
448
|
+
}, measurement.triggerTop - start.anchorOffset, measurement.triggerEnclosedBy, index, index, order, counted);
|
|
449
|
+
layoutStart = measurement.triggerTop - start.anchorOffset + gaps(knownWindows());
|
|
450
|
+
recount.runs.push((w) => gaps(w, recount.counted));
|
|
451
|
+
}
|
|
452
|
+
freezeEnd = freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
|
|
453
|
+
break;
|
|
454
|
+
}
|
|
455
|
+
}
|
|
456
|
+
const plan = {
|
|
457
|
+
freezeStart,
|
|
458
|
+
freezeEnd,
|
|
459
|
+
paddingHeight: Math.max(0, freezeEnd - freezeStart)
|
|
460
|
+
};
|
|
461
|
+
fresh[index] = plan;
|
|
462
|
+
return plan;
|
|
463
|
+
});
|
|
464
|
+
if (record) {
|
|
465
|
+
const windows = knownWindows();
|
|
466
|
+
recounts.forEach(({ index, counted, runs }) => {
|
|
467
|
+
runs.forEach((run) => run(windows));
|
|
468
|
+
record(index, counted);
|
|
469
|
+
});
|
|
470
|
+
}
|
|
471
|
+
return plans;
|
|
472
|
+
};
|
|
473
|
+
const planCover = (measurements, index, windows, { viewportHeight, documentMaxScroll, measureLiveEndTriggerTop }) => {
|
|
474
|
+
const measurement = measurements[index];
|
|
475
|
+
if (measurement.start.mode !== "clause") throw new Error("StickyScrollTrigger: internal error: a cover layer measurement carries an absolute start, which resolveStartSpec should have already rejected.");
|
|
476
|
+
const reached = (reachedAt) => reachedAt + dwellBeforeReach(reachedAt, windows);
|
|
477
|
+
const startReachedAt = measurement.triggerTop - measurement.start.anchorOffset;
|
|
478
|
+
const freezeStart = startReachedAt + dwellBeforeReach(startReachedAt, windows, { countTies: true });
|
|
479
|
+
let freezeEnd;
|
|
480
|
+
switch (measurement.end.mode) {
|
|
481
|
+
case "auto":
|
|
482
|
+
freezeEnd = reached(measurement.coverTop);
|
|
483
|
+
break;
|
|
484
|
+
case "dwell":
|
|
485
|
+
freezeEnd = freezeStart + measurement.end.distancePx;
|
|
486
|
+
break;
|
|
487
|
+
case "absolute":
|
|
488
|
+
freezeEnd = measurement.end.value;
|
|
489
|
+
break;
|
|
490
|
+
case "max":
|
|
491
|
+
freezeEnd = documentMaxScroll + measurement.end.offsetPx;
|
|
492
|
+
break;
|
|
493
|
+
case "clause": {
|
|
494
|
+
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
|
|
495
|
+
if (measurement.end.measureLive) freezeEnd = measureLiveEndTriggerTop(index) - anchorOffsetEnd;
|
|
496
|
+
else freezeEnd = reached((measurement.endTriggerIsSelf ? measurement.triggerTop : measurement.endTriggerIndex === null ? measurement.end.rawTop ?? 0 : measurements[measurement.endTriggerIndex].triggerTop) - anchorOffsetEnd);
|
|
497
|
+
break;
|
|
498
|
+
}
|
|
499
|
+
}
|
|
500
|
+
return {
|
|
501
|
+
freezeStart,
|
|
502
|
+
freezeEnd: Math.max(freezeStart, freezeEnd),
|
|
503
|
+
engagedStart: freezeStart,
|
|
504
|
+
engagedEnd: Math.max(freezeStart, freezeEnd),
|
|
505
|
+
stickyTop: measurement.start.anchorOffset - (measurement.triggerTop - measurement.wrapperTop),
|
|
506
|
+
paddingHeight: null
|
|
507
|
+
};
|
|
508
|
+
};
|
|
509
|
+
const TIE_TOLERANCE_PX = .05;
|
|
510
|
+
const dwellBeforeReach = (reachedAt, windows, { countTies = false } = {}) => {
|
|
511
|
+
const tolerance = countTies ? -.05 : TIE_TOLERANCE_PX;
|
|
512
|
+
let earlierDwell = 0;
|
|
513
|
+
let counted = 0;
|
|
514
|
+
[...windows].sort((a, b) => a.freezeStart - b.freezeStart).forEach(({ freezeStart, freezeEnd }) => {
|
|
515
|
+
if (freezeStart < reachedAt + earlierDwell - tolerance) counted += freezeEnd - freezeStart;
|
|
516
|
+
earlierDwell += freezeEnd - freezeStart;
|
|
517
|
+
});
|
|
518
|
+
return counted;
|
|
519
|
+
};
|
|
520
|
+
const dwellConsumedAt = (scroll, windows) => windows.reduce((consumed, { freezeStart, freezeEnd }) => consumed + Math.min(Math.max(scroll - freezeStart, 0), freezeEnd - freezeStart), 0);
|
|
521
|
+
const componentsOf = (edges) => {
|
|
522
|
+
const visitOrder = edges.map(() => -1);
|
|
523
|
+
const lowLink = edges.map(() => 0);
|
|
524
|
+
const component = edges.map(() => -1);
|
|
525
|
+
const stack = [];
|
|
526
|
+
let visited = 0;
|
|
527
|
+
let components = 0;
|
|
528
|
+
const visit = (v) => {
|
|
529
|
+
visitOrder[v] = visited;
|
|
530
|
+
lowLink[v] = visited;
|
|
531
|
+
visited += 1;
|
|
532
|
+
stack.push(v);
|
|
533
|
+
for (const w of edges[v]) if (visitOrder[w] === -1) {
|
|
534
|
+
visit(w);
|
|
535
|
+
lowLink[v] = Math.min(lowLink[v], lowLink[w]);
|
|
536
|
+
} else if (component[w] === -1) lowLink[v] = Math.min(lowLink[v], visitOrder[w]);
|
|
537
|
+
if (lowLink[v] === visitOrder[v]) {
|
|
538
|
+
let w;
|
|
539
|
+
do {
|
|
540
|
+
w = stack.pop();
|
|
541
|
+
component[w] = components;
|
|
542
|
+
} while (w !== v);
|
|
543
|
+
components += 1;
|
|
544
|
+
}
|
|
545
|
+
};
|
|
546
|
+
edges.forEach((_, v) => {
|
|
547
|
+
if (visitOrder[v] === -1) visit(v);
|
|
548
|
+
});
|
|
549
|
+
return component;
|
|
550
|
+
};
|
|
551
|
+
const fallbackOrder = (measurements, counted) => {
|
|
552
|
+
const component = componentsOf(measurements.map(({ triggerEnclosedBy }, i) => [...counted[i], ...triggerEnclosedBy.filter((m) => m !== i && measurements[m].kind === "scene")]));
|
|
553
|
+
const rank = [];
|
|
554
|
+
measurements.map((_, i) => i).sort((a, b) => component[a] - component[b] || a - b).forEach((layer, position) => {
|
|
555
|
+
rank[layer] = position;
|
|
556
|
+
});
|
|
557
|
+
return { isBefore: (a, b) => rank[a] < rank[b] };
|
|
558
|
+
};
|
|
559
|
+
const hasCycle = (scenes, edges) => {
|
|
560
|
+
const component = componentsOf(edges);
|
|
561
|
+
return new Set(scenes.map((k) => component[k])).size < scenes.length;
|
|
562
|
+
};
|
|
563
|
+
const refreshOrderEdges = (measurements, lengths, edges) => {
|
|
564
|
+
const before = measurements.map(() => []);
|
|
565
|
+
edges.forEach((movers, i) => {
|
|
566
|
+
const measurement = measurements[i];
|
|
567
|
+
const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.endTriggerIsSelf ? measurement.endTriggerEnclosedBy : measurement.triggerEnclosedBy).filter((m) => m !== measurement.endTriggerIndex);
|
|
568
|
+
movers.forEach((k) => {
|
|
569
|
+
if (lengths[k] <= .05) return;
|
|
570
|
+
before[i].push(k);
|
|
571
|
+
measurements[k].triggerEnclosedBy.forEach((m) => {
|
|
572
|
+
if (m !== k && m !== i && measurements[m].kind === "scene" && !enclosingAnchor.includes(m)) before[m].push(k);
|
|
573
|
+
});
|
|
574
|
+
});
|
|
575
|
+
});
|
|
576
|
+
return before;
|
|
577
|
+
};
|
|
578
|
+
const placeWindows = (measurements, scenes, lengths, atWrittenEnd) => {
|
|
579
|
+
const rest = new Set(scenes);
|
|
580
|
+
const reported = [];
|
|
581
|
+
const engaged = [];
|
|
582
|
+
let consumed = 0;
|
|
583
|
+
let frozenUntil = -Infinity;
|
|
584
|
+
while (rest.size) {
|
|
585
|
+
let next = -1;
|
|
586
|
+
let opensAt = 0;
|
|
587
|
+
let nextIsAbsolute = false;
|
|
588
|
+
let nextReach = 0;
|
|
589
|
+
for (const k of rest) {
|
|
590
|
+
const { start, triggerTop } = measurements[k];
|
|
591
|
+
const isAbsolute = start.mode === "absolute";
|
|
592
|
+
const reach = start.mode === "clause" ? triggerTop - start.anchorOffset : 0;
|
|
593
|
+
const at = start.mode === "absolute" ? start.value : reach + consumed;
|
|
594
|
+
const tied = Math.abs(at - opensAt) <= TIE_TOLERANCE_PX;
|
|
595
|
+
if (next === -1 || at < opensAt - .05 || tied && (isAbsolute ? !nextIsAbsolute || at < opensAt : !nextIsAbsolute && reach < nextReach - .05)) {
|
|
596
|
+
next = k;
|
|
597
|
+
opensAt = at;
|
|
598
|
+
nextIsAbsolute = isAbsolute;
|
|
599
|
+
nextReach = reach;
|
|
600
|
+
}
|
|
601
|
+
}
|
|
602
|
+
const { end } = measurements[next];
|
|
603
|
+
const reportedEnd = end.mode === "absolute" && atWrittenEnd(next) ? Math.max(opensAt, end.value) : opensAt + lengths[next];
|
|
604
|
+
const engagedStart = Math.max(opensAt, frozenUntil);
|
|
605
|
+
const engagedEnd = Math.max(engagedStart, reportedEnd);
|
|
606
|
+
rest.delete(next);
|
|
607
|
+
reported[next] = [opensAt, reportedEnd];
|
|
608
|
+
engaged[next] = [engagedStart, engagedEnd];
|
|
609
|
+
consumed += engagedEnd - engagedStart;
|
|
610
|
+
frozenUntil = Math.max(frozenUntil, engagedEnd);
|
|
611
|
+
}
|
|
612
|
+
return {
|
|
613
|
+
reported,
|
|
614
|
+
engaged
|
|
615
|
+
};
|
|
616
|
+
};
|
|
617
|
+
const planLayers = (measurements, deps) => {
|
|
618
|
+
const scenes = measurements.flatMap(({ kind }, k) => kind === "scene" ? [k] : []);
|
|
619
|
+
const needsConvergence = scenes.length > 1;
|
|
620
|
+
const liveTopCache = new Map();
|
|
621
|
+
const passDeps = {
|
|
622
|
+
...deps,
|
|
623
|
+
measureLiveEndTriggerTop: (index) => {
|
|
624
|
+
const cached = liveTopCache.get(index);
|
|
625
|
+
if (cached !== void 0) return cached;
|
|
626
|
+
const value = deps.measureLiveEndTriggerTop(index);
|
|
627
|
+
liveTopCache.set(index, value);
|
|
628
|
+
return value;
|
|
629
|
+
}
|
|
630
|
+
};
|
|
631
|
+
const sameValues = (a, b) => a.every((value, i) => value === b[i] || value !== null && b[i] !== null && Math.abs(value - b[i]) <= .05);
|
|
632
|
+
const sameState = (a, b) => sameValues(a.paddings, b.paddings) && sameValues(a.freezeStarts, b.freezeStarts);
|
|
633
|
+
const lengthsOf = (windows) => windows.map((window) => window ? Math.max(0, window.freezeEnd - window.freezeStart) : 0);
|
|
634
|
+
const stateAt = (lengths, reported) => ({
|
|
635
|
+
paddings: measurements.map(({ kind }, k) => kind === "scene" ? lengths[k] : null),
|
|
636
|
+
freezeStarts: measurements.map(({ kind }, k) => kind === "scene" ? reported[k][0] : null)
|
|
637
|
+
});
|
|
638
|
+
const mix = (states, weights) => {
|
|
639
|
+
const of = (pick) => pick(states[0]).map((value, k) => value === null ? null : states.reduce((sum, state, j) => sum + weights[j] * pick(state)[k], 0));
|
|
640
|
+
return {
|
|
641
|
+
paddings: of((state) => state.paddings),
|
|
642
|
+
freezeStarts: of((state) => state.freezeStarts)
|
|
643
|
+
};
|
|
644
|
+
};
|
|
645
|
+
let world = null;
|
|
646
|
+
const place = (lengths, order, reading) => {
|
|
647
|
+
const placed = placeWindows(measurements, scenes, lengths, () => reading.endsAsRefreshed);
|
|
648
|
+
world = {
|
|
649
|
+
lengths,
|
|
650
|
+
order,
|
|
651
|
+
reported: placed.reported,
|
|
652
|
+
refreshTime: []
|
|
653
|
+
};
|
|
654
|
+
return placed;
|
|
655
|
+
};
|
|
656
|
+
const refreshTimeOf = (own) => {
|
|
657
|
+
if (world === null) return null;
|
|
658
|
+
const { lengths, order, refreshTime } = world;
|
|
659
|
+
const absent = (k) => k === own || order !== null && !order.isBefore(k, own);
|
|
660
|
+
refreshTime[own] ??= placeWindows(measurements, scenes, lengths.map((length, k) => absent(k) ? 0 : length), (k) => !absent(k)).reported;
|
|
661
|
+
return refreshTime[own];
|
|
662
|
+
};
|
|
663
|
+
const passWorld = (order, reading) => ({
|
|
664
|
+
unpaddedStart: (index, ownIndex, freezeStart) => {
|
|
665
|
+
const windows = (reading.startsAsRefreshed ? refreshTimeOf(ownIndex) : null) ?? world?.reported ?? [];
|
|
666
|
+
const spans = scenes.flatMap((k) => {
|
|
667
|
+
if (k === index || k === ownIndex || !windows[k]) return [];
|
|
668
|
+
if (order && !order.isBefore(k, ownIndex)) return [];
|
|
669
|
+
const [from, to] = windows[k];
|
|
670
|
+
return Math.min(to, freezeStart) > from ? [[from, Math.min(to, freezeStart)]] : [];
|
|
671
|
+
}).sort((a, b) => a[0] - b[0]);
|
|
672
|
+
let frozen = 0;
|
|
673
|
+
let frozenUntil = -Infinity;
|
|
674
|
+
for (const [from, to] of spans) {
|
|
675
|
+
const lo = Math.max(from, frozenUntil);
|
|
676
|
+
if (to > lo) frozen += to - lo;
|
|
677
|
+
frozenUntil = Math.max(frozenUntil, to);
|
|
678
|
+
}
|
|
679
|
+
return freezeStart - frozen;
|
|
680
|
+
},
|
|
681
|
+
absoluteEndLength: (index) => {
|
|
682
|
+
const { end } = measurements[index];
|
|
683
|
+
if (!reading.endsAsRefreshed || end.mode !== "absolute" || world === null) return null;
|
|
684
|
+
const windows = world.order === null ? world.reported : refreshTimeOf(index);
|
|
685
|
+
return Math.max(0, end.value - windows[index][0]);
|
|
686
|
+
}
|
|
687
|
+
});
|
|
688
|
+
const solve = (order, reading, cap, record = null, cycle = 2, damping = 1) => {
|
|
689
|
+
const reads = passWorld(order, reading);
|
|
690
|
+
const fed = [];
|
|
691
|
+
let previous = null;
|
|
692
|
+
for (let pass = 0; pass < cap; pass += 1) {
|
|
693
|
+
const lengths = lengthsOf(runPass(measurements, passDeps, previous, order, reads, record));
|
|
694
|
+
const placed = place(lengths, order, reading);
|
|
695
|
+
const next = stateAt(lengths, placed.reported);
|
|
696
|
+
if (!needsConvergence || previous !== null && sameState(next, previous)) return {
|
|
697
|
+
lengths,
|
|
698
|
+
...placed
|
|
699
|
+
};
|
|
700
|
+
let feed = next;
|
|
701
|
+
if (previous !== null) {
|
|
702
|
+
fed.push(previous);
|
|
703
|
+
let back = -1;
|
|
704
|
+
for (let j = 0; j < cycle - 1 && back === -1; j += 1) if (fed.length > j + 1 && sameState(next, fed[fed.length - j - 2])) back = j;
|
|
705
|
+
if (back !== -1) {
|
|
706
|
+
const states = [...fed.slice(fed.length - back - 1), next];
|
|
707
|
+
feed = mix(states, states.map(() => 1 / states.length));
|
|
708
|
+
} else if (damping < 1) feed = mix([next, previous], [damping, 1 - damping]);
|
|
709
|
+
}
|
|
710
|
+
previous = feed;
|
|
711
|
+
}
|
|
712
|
+
return null;
|
|
713
|
+
};
|
|
714
|
+
const activeEdges = (lengths, reading) => {
|
|
715
|
+
const reads = passWorld(null, reading);
|
|
716
|
+
const respond = (from) => {
|
|
717
|
+
const { reported } = place(from, null, reading);
|
|
718
|
+
return lengthsOf(runPass(measurements, passDeps, stateAt(from, reported), null, reads, null, true));
|
|
719
|
+
};
|
|
720
|
+
const base = respond(lengths);
|
|
721
|
+
const edges = measurements.map(() => []);
|
|
722
|
+
scenes.forEach((k) => {
|
|
723
|
+
const nudged = lengths.slice();
|
|
724
|
+
nudged[k] += 2 ** -7;
|
|
725
|
+
respond(nudged).forEach((length, i) => {
|
|
726
|
+
if (i !== k && Math.abs(length - base[i]) > 1e-6) edges[i].push(k);
|
|
727
|
+
});
|
|
728
|
+
});
|
|
729
|
+
return edges;
|
|
730
|
+
};
|
|
731
|
+
const unsettled = (solved) => solved === null || solved.reported.some((window) => window.some((point) => !(Math.abs(point) <= 2 ** 48)));
|
|
732
|
+
const counted = measurements.map(() => new Set());
|
|
733
|
+
const everySpacer = {
|
|
734
|
+
endsAsRefreshed: true,
|
|
735
|
+
startsAsRefreshed: false
|
|
736
|
+
};
|
|
737
|
+
let solved = solve(null, everySpacer, Math.max(64, 2 * measurements.length + 2), (index, layers) => layers.forEach((k) => counted[index].add(k)));
|
|
738
|
+
const fallback = () => {
|
|
739
|
+
if (unsettled(solved)) return fallbackOrder(measurements, counted);
|
|
740
|
+
if (!needsConvergence) return null;
|
|
741
|
+
const edges = activeEdges(solved.lengths, everySpacer);
|
|
742
|
+
if (hasCycle(scenes, edges)) return fallbackOrder(measurements, counted);
|
|
743
|
+
return hasCycle(scenes, refreshOrderEdges(measurements, solved.lengths, edges)) ? { isBefore: (a, b) => a < b } : null;
|
|
744
|
+
};
|
|
745
|
+
const order = fallback();
|
|
746
|
+
if (order) {
|
|
747
|
+
const asReported = {
|
|
748
|
+
endsAsRefreshed: false,
|
|
749
|
+
startsAsRefreshed: false
|
|
750
|
+
};
|
|
751
|
+
solved = solve(order, asReported, 2 * measurements.length + 2);
|
|
752
|
+
if (unsettled(solved)) solved = solve(order, asReported, Math.max(64, 2 * measurements.length + 2), null, 4, .5);
|
|
753
|
+
if (unsettled(solved)) solved = solve(order, {
|
|
754
|
+
endsAsRefreshed: true,
|
|
755
|
+
startsAsRefreshed: true
|
|
756
|
+
}, 2 * measurements.length + 2);
|
|
757
|
+
}
|
|
758
|
+
if (unsettled(solved)) throw new Error("StickyScrollTrigger: could not resolve endTrigger positions: some endTrigger references form a circular structural dependency that never settles. Point each endTrigger at an element that doesn't depend on it.");
|
|
759
|
+
const { reported, engaged } = solved;
|
|
760
|
+
const scenePlans = measurements.map(({ kind }, index) => {
|
|
761
|
+
if (kind !== "scene") return null;
|
|
762
|
+
const [engagedStart, engagedEnd] = engaged[index];
|
|
763
|
+
const outerDwell = scenes.reduce((total, k) => k > index && engaged[k][1] <= engagedStart + .05 ? total + (engaged[k][1] - engaged[k][0]) : total, 0);
|
|
764
|
+
return {
|
|
765
|
+
freezeStart: reported[index][0],
|
|
766
|
+
freezeEnd: reported[index][1],
|
|
767
|
+
engagedStart,
|
|
768
|
+
engagedEnd,
|
|
769
|
+
stickyTop: deps.structureTop - (engagedStart - outerDwell),
|
|
770
|
+
paddingHeight: engagedEnd - engagedStart
|
|
771
|
+
};
|
|
772
|
+
});
|
|
773
|
+
const windows = scenes.map((k) => ({
|
|
774
|
+
freezeStart: engaged[k][0],
|
|
775
|
+
freezeEnd: engaged[k][1]
|
|
776
|
+
}));
|
|
777
|
+
const finalPlans = scenePlans.map((plan, index) => plan ?? planCover(measurements, index, windows, passDeps));
|
|
778
|
+
finalPlans.forEach((plan, index) => deps.onPlanned(index, plan));
|
|
779
|
+
return finalPlans;
|
|
780
|
+
};
|
|
180
781
|
const OFFSET_PROPERTY = "--sst-scroll-margin-top-offset";
|
|
181
782
|
let nextInstanceSuffix = 0;
|
|
182
783
|
const supportsScrollDrivenAnimations = typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("animation-timeline", "scroll()");
|
|
@@ -231,8 +832,8 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
231
832
|
jsHost = null;
|
|
232
833
|
};
|
|
233
834
|
return {
|
|
234
|
-
sync(scenes, host) {
|
|
235
|
-
const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart);
|
|
835
|
+
sync(scenes, host, measureNaturalTops) {
|
|
836
|
+
const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
|
|
236
837
|
if (targetSelector === null || !ramps.length || !host) {
|
|
237
838
|
written.forEach(restoreTarget);
|
|
238
839
|
written = new Set();
|
|
@@ -256,20 +857,22 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
256
857
|
sheet.replaceSync(buildStylesheet(instanceId, ramps));
|
|
257
858
|
}
|
|
258
859
|
const targets = Array.from(rootElement.querySelectorAll(targetSelector));
|
|
860
|
+
const naturalTops = measureNaturalTops(targets);
|
|
259
861
|
targets.forEach((target) => {
|
|
260
862
|
const existing = snapshots.get(target);
|
|
261
863
|
if (!existing) snapshots.set(target, { inline: target.style.scrollMarginTop });
|
|
262
864
|
else if (written.has(target)) target.style.scrollMarginTop = existing.inline;
|
|
263
865
|
});
|
|
264
866
|
const consumed = ramps.map((_, index) => `var(--${instanceId}-c${index}, 0px)`).join(" + ");
|
|
265
|
-
targets.forEach((target) => {
|
|
867
|
+
targets.forEach((target, targetIndex) => {
|
|
266
868
|
const authorPx = parseFloat(getComputedStyle(target).scrollMarginTop) || 0;
|
|
267
|
-
let
|
|
268
|
-
ramps.
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
869
|
+
let earlierDwell = 0;
|
|
870
|
+
const lag = ramps.map(({ freezeStart, freezeEnd }) => {
|
|
871
|
+
const margin = naturalTops[targetIndex] - authorPx + earlierDwell - freezeStart - TIE_TOLERANCE_PX;
|
|
872
|
+
earlierDwell += freezeEnd - freezeStart;
|
|
873
|
+
return `clamp(0px, (${margin}px - var(${OFFSET_PROPERTY}, 0px)) * 1000000, ${freezeEnd - freezeStart}px)`;
|
|
874
|
+
}).join(" + ");
|
|
875
|
+
target.style.scrollMarginTop = `calc(${authorPx}px + var(${OFFSET_PROPERTY}, 0px) + ${consumed} - (${lag}))`;
|
|
273
876
|
});
|
|
274
877
|
const next = new Set(targets);
|
|
275
878
|
written.forEach((target) => {
|
|
@@ -299,7 +902,7 @@ const buildStructure = (rootElement, layers) => {
|
|
|
299
902
|
let outermost = null;
|
|
300
903
|
for (const layer of layers) {
|
|
301
904
|
if (layer.kind !== "scene") continue;
|
|
302
|
-
const wrapped = wrapScene(inner);
|
|
905
|
+
const wrapped = wrapScene(inner, inner === rootElement);
|
|
303
906
|
layer.container = wrapped.container;
|
|
304
907
|
layer.wrapper = wrapped.wrapper;
|
|
305
908
|
layer.padding = wrapped.padding;
|
|
@@ -325,212 +928,6 @@ const unbuildStructure = (rootElement, layers, outermostContainer) => {
|
|
|
325
928
|
}
|
|
326
929
|
});
|
|
327
930
|
};
|
|
328
|
-
const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
|
|
329
|
-
const KEYWORD_FRACTIONS = {
|
|
330
|
-
top: 0,
|
|
331
|
-
center: .5,
|
|
332
|
-
bottom: 1
|
|
333
|
-
};
|
|
334
|
-
const signedPx = (sign, value, unit, refSize) => {
|
|
335
|
-
const magnitude = unit === "%" ? parseFloat(value) / 100 * refSize : parseFloat(value);
|
|
336
|
-
return sign?.startsWith("-") ? -magnitude : magnitude;
|
|
337
|
-
};
|
|
338
|
-
const CLAUSE_TOKEN_RE = /^(top|center|bottom|[+-]?(?:\d+(?:\.\d*)?|\.\d+))?(%|px)?(?:([+-]=?)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
|
|
339
|
-
const parseClauseToken = (token, refSize) => {
|
|
340
|
-
const match = CLAUSE_TOKEN_RE.exec(token);
|
|
341
|
-
if (!match || !match[1] && !match[3]) {
|
|
342
|
-
if (MAX_TOKEN_RE.test(token)) throw new Error(`StickyScrollTrigger: unsupported position clause "${token}": 'max' is GSAP's end-only keyword for the scroller's maximum scroll position.`);
|
|
343
|
-
throw new Error(`StickyScrollTrigger: unsupported position clause "${token}"`);
|
|
344
|
-
}
|
|
345
|
-
const [, base, baseUnit, sign, offsetValue, offsetUnit] = match;
|
|
346
|
-
if (base !== void 0 && sign && !sign.includes("=")) {
|
|
347
|
-
const suggestion = `${base}${baseUnit ?? ""}${sign}=${offsetValue}${offsetUnit ?? ""}`;
|
|
348
|
-
throw new Error(`StickyScrollTrigger: unsupported position clause "${token}": a signed offset needs an explicit '=' when it follows a keyword or number (GSAP needs it to tell "${base}" from the offset). Did you mean "${suggestion}"?`);
|
|
349
|
-
}
|
|
350
|
-
const isKeyword = base !== void 0 && base in KEYWORD_FRACTIONS;
|
|
351
|
-
const basePercent = baseUnit === "%";
|
|
352
|
-
return {
|
|
353
|
-
fraction: isKeyword ? KEYWORD_FRACTIONS[base] : basePercent ? parseFloat(base) / 100 : 0,
|
|
354
|
-
offsetPx: (!isKeyword && !basePercent && base !== void 0 ? parseFloat(base) : 0) + (sign ? signedPx(sign, offsetValue, offsetUnit, refSize) : 0)
|
|
355
|
-
};
|
|
356
|
-
};
|
|
357
|
-
const isAbsoluteFormat = (resolved) => {
|
|
358
|
-
if (typeof resolved === "number") return true;
|
|
359
|
-
return resolved.trim() !== "" && !Number.isNaN(Number(resolved));
|
|
360
|
-
};
|
|
361
|
-
const resolveAbsolute = (resolved) => typeof resolved === "number" ? resolved : Number(resolved);
|
|
362
|
-
const CLAMP_PREFIX = "clamp(";
|
|
363
|
-
const assertNotClamped = (trimmed) => {
|
|
364
|
-
if (!trimmed.startsWith(CLAMP_PREFIX)) return;
|
|
365
|
-
const inner = trimmed.slice(6).replace(/\)$/, "").trim();
|
|
366
|
-
throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
|
|
367
|
-
};
|
|
368
|
-
const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
|
|
369
|
-
const trimmed = position.trim();
|
|
370
|
-
assertNotClamped(trimmed);
|
|
371
|
-
const [elementToken, viewportToken = "top"] = trimmed.split(/\s+/);
|
|
372
|
-
const elementClause = parseClauseToken(elementToken, elementHeight);
|
|
373
|
-
const viewportClause = parseClauseToken(viewportToken, viewportHeight);
|
|
374
|
-
return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - (elementHeight * elementClause.fraction + elementClause.offsetPx);
|
|
375
|
-
};
|
|
376
|
-
const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
|
|
377
|
-
const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
|
|
378
|
-
const prefixSpacedRelativeEnd = (start, endResolved) => {
|
|
379
|
-
if (typeof endResolved !== "string") return endResolved;
|
|
380
|
-
const trimmedEnd = endResolved.trim();
|
|
381
|
-
if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
|
|
382
|
-
const startResolved = resolveMaybeFn(start);
|
|
383
|
-
if (typeof startResolved !== "string") return endResolved;
|
|
384
|
-
const trimmedStart = startResolved.trim();
|
|
385
|
-
assertNotClamped(trimmedStart);
|
|
386
|
-
const [elementToken] = trimmedStart.split(/\s+/);
|
|
387
|
-
try {
|
|
388
|
-
parseClauseToken(elementToken, 0);
|
|
389
|
-
} catch (error) {
|
|
390
|
-
if (!isAbsoluteFormat(startResolved)) throw error;
|
|
391
|
-
return endResolved;
|
|
392
|
-
}
|
|
393
|
-
parseClauseToken(trimmedEnd.split(/\s+/)[0], 0);
|
|
394
|
-
if (elementToken.includes("=")) throw new Error(`StickyScrollTrigger: end "${endResolved}" can't be resolved against start "${startResolved}": GSAP reads an end that starts with '+=' and holds a space by prefixing it with the start clause's element token, and "${elementToken}" carries an offset of its own, which GSAP resolves by discarding the end's. Give end a complete position clause instead, such as 'top+=100 bottom'.`);
|
|
395
|
-
return elementToken + trimmedEnd;
|
|
396
|
-
};
|
|
397
|
-
const resolveDwell = (resolved, viewportHeight) => {
|
|
398
|
-
const match = DWELL_RELATIVE_RE.exec(String(resolved).trim());
|
|
399
|
-
if (!match) throw new Error(`StickyScrollTrigger: unsupported end format "${resolved}"`);
|
|
400
|
-
const [, value, unit] = match;
|
|
401
|
-
return signedPx(void 0, value, unit, viewportHeight);
|
|
402
|
-
};
|
|
403
|
-
const MAX_TOKEN_RE = /^max(?:([+-]=)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
|
|
404
|
-
const isMaxFormat = (resolved) => typeof resolved === "string" && MAX_TOKEN_RE.test(resolved.trim());
|
|
405
|
-
const resolveMaxOffset = (resolved, viewportHeight) => {
|
|
406
|
-
const match = MAX_TOKEN_RE.exec(resolved.trim());
|
|
407
|
-
if (!match) throw new Error(`StickyScrollTrigger: unsupported max-position format "${resolved}"`);
|
|
408
|
-
const [, sign, value, unit] = match;
|
|
409
|
-
return sign ? signedPx(sign, value, unit, viewportHeight) : 0;
|
|
410
|
-
};
|
|
411
|
-
const classifyPosition = (resolved) => {
|
|
412
|
-
if (typeof resolved === "number") return {
|
|
413
|
-
kind: "absolute",
|
|
414
|
-
value: resolved
|
|
415
|
-
};
|
|
416
|
-
if (isDwellFormat(resolved)) return {
|
|
417
|
-
kind: "dwell",
|
|
418
|
-
value: resolved
|
|
419
|
-
};
|
|
420
|
-
if (isMaxFormat(resolved)) return {
|
|
421
|
-
kind: "max",
|
|
422
|
-
value: resolved
|
|
423
|
-
};
|
|
424
|
-
if (isAbsoluteFormat(resolved)) return {
|
|
425
|
-
kind: "absolute",
|
|
426
|
-
value: resolveAbsolute(resolved)
|
|
427
|
-
};
|
|
428
|
-
return {
|
|
429
|
-
kind: "clause",
|
|
430
|
-
value: resolved
|
|
431
|
-
};
|
|
432
|
-
};
|
|
433
|
-
const gapsBeforeRawPosition = (measurements, paddingHeightsSoFar, previous, rawPosition, ownIndex) => {
|
|
434
|
-
let total = 0;
|
|
435
|
-
measurements.forEach((measurement, i) => {
|
|
436
|
-
if (i === ownIndex || measurement.triggerTop >= rawPosition) return;
|
|
437
|
-
const paddingHeight = paddingHeightsSoFar[i] !== void 0 ? paddingHeightsSoFar[i] : previous ? previous.paddings[i] : null;
|
|
438
|
-
if (paddingHeight !== null && paddingHeight !== void 0) total += paddingHeight;
|
|
439
|
-
});
|
|
440
|
-
return total;
|
|
441
|
-
};
|
|
442
|
-
const runPass = (measurements, { viewportHeight, structureTop, documentMaxScroll, measureLiveEndTriggerTop }, previous) => {
|
|
443
|
-
const naturalTops = [];
|
|
444
|
-
const paddingHeightsSoFar = [];
|
|
445
|
-
let precedingGaps = 0;
|
|
446
|
-
return {
|
|
447
|
-
plans: measurements.map((measurement, index) => {
|
|
448
|
-
const naturalAbsoluteTop = measurement.triggerTop + precedingGaps;
|
|
449
|
-
const freezeStart = measurement.start.mode === "absolute" ? measurement.start.value : naturalAbsoluteTop - measurement.start.anchorOffset;
|
|
450
|
-
let freezeEnd;
|
|
451
|
-
switch (measurement.end.mode) {
|
|
452
|
-
case "auto":
|
|
453
|
-
if (measurement.start.mode !== "clause") throw new Error("StickyScrollTrigger: internal error: an absolute start reached 'auto' end mode, which resolveStartSpec should have already rejected.");
|
|
454
|
-
freezeEnd = freezeStart + Math.max(0, measurement.start.anchorOffset + (measurement.coverTop - measurement.triggerTop));
|
|
455
|
-
break;
|
|
456
|
-
case "dwell":
|
|
457
|
-
freezeEnd = freezeStart + measurement.end.distancePx;
|
|
458
|
-
break;
|
|
459
|
-
case "absolute":
|
|
460
|
-
freezeEnd = Math.max(freezeStart, measurement.end.value);
|
|
461
|
-
break;
|
|
462
|
-
case "max":
|
|
463
|
-
freezeEnd = Math.max(freezeStart, documentMaxScroll + measurement.end.offsetPx);
|
|
464
|
-
break;
|
|
465
|
-
case "clause": {
|
|
466
|
-
let endTop;
|
|
467
|
-
if (measurement.endTriggerIsSelf) endTop = naturalAbsoluteTop;
|
|
468
|
-
else {
|
|
469
|
-
const known = measurement.endTriggerIndex === null ? void 0 : naturalTops[measurement.endTriggerIndex] !== void 0 ? naturalTops[measurement.endTriggerIndex] : previous ? previous.naturalTops[measurement.endTriggerIndex] : void 0;
|
|
470
|
-
if (known !== void 0) endTop = known;
|
|
471
|
-
else if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
|
|
472
|
-
else endTop = measurement.end.rawTop === null ? 0 : measurement.end.rawTop + gapsBeforeRawPosition(measurements, paddingHeightsSoFar, previous, measurement.end.rawTop, index);
|
|
473
|
-
}
|
|
474
|
-
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
|
|
475
|
-
freezeEnd = Math.max(freezeStart, endTop - anchorOffsetEnd);
|
|
476
|
-
break;
|
|
477
|
-
}
|
|
478
|
-
}
|
|
479
|
-
let plan;
|
|
480
|
-
if (measurement.kind === "cover") {
|
|
481
|
-
if (measurement.start.mode !== "clause") throw new Error("StickyScrollTrigger: internal error: a cover layer measurement carries an absolute start, which resolveStartSpec should have already rejected.");
|
|
482
|
-
plan = {
|
|
483
|
-
freezeStart,
|
|
484
|
-
freezeEnd,
|
|
485
|
-
stickyTop: measurement.start.anchorOffset - (measurement.triggerTop - measurement.wrapperTop),
|
|
486
|
-
paddingHeight: null
|
|
487
|
-
};
|
|
488
|
-
} else plan = {
|
|
489
|
-
freezeStart,
|
|
490
|
-
freezeEnd,
|
|
491
|
-
stickyTop: structureTop - freezeStart,
|
|
492
|
-
paddingHeight: Math.max(0, freezeEnd - freezeStart)
|
|
493
|
-
};
|
|
494
|
-
if (plan.paddingHeight !== null) precedingGaps += plan.paddingHeight;
|
|
495
|
-
naturalTops[index] = naturalAbsoluteTop;
|
|
496
|
-
paddingHeightsSoFar[index] = plan.paddingHeight;
|
|
497
|
-
return plan;
|
|
498
|
-
}),
|
|
499
|
-
naturalTops
|
|
500
|
-
};
|
|
501
|
-
};
|
|
502
|
-
const planLayers = (measurements, deps) => {
|
|
503
|
-
const needsConvergence = measurements.some((measurement, index) => {
|
|
504
|
-
if (measurement.end.mode !== "clause" || measurement.endTriggerIsSelf) return false;
|
|
505
|
-
return measurement.endTriggerIndex === null ? measurement.end.rawTop !== null : measurement.endTriggerIndex >= index;
|
|
506
|
-
});
|
|
507
|
-
const liveTopCache = new Map();
|
|
508
|
-
const passDeps = {
|
|
509
|
-
...deps,
|
|
510
|
-
measureLiveEndTriggerTop: (index) => {
|
|
511
|
-
const cached = liveTopCache.get(index);
|
|
512
|
-
if (cached !== void 0) return cached;
|
|
513
|
-
const value = deps.measureLiveEndTriggerTop(index);
|
|
514
|
-
liveTopCache.set(index, value);
|
|
515
|
-
return value;
|
|
516
|
-
}
|
|
517
|
-
};
|
|
518
|
-
let { plans, naturalTops } = runPass(measurements, passDeps, null);
|
|
519
|
-
if (needsConvergence) for (let pass = 0; pass < measurements.length; pass += 1) {
|
|
520
|
-
const previous = {
|
|
521
|
-
paddings: plans.map((plan) => plan.paddingHeight),
|
|
522
|
-
naturalTops
|
|
523
|
-
};
|
|
524
|
-
const next = runPass(measurements, passDeps, previous);
|
|
525
|
-
const stable = next.plans.every((plan, i) => plan.paddingHeight === plans[i].paddingHeight);
|
|
526
|
-
plans = next.plans;
|
|
527
|
-
naturalTops = next.naturalTops;
|
|
528
|
-
if (stable) break;
|
|
529
|
-
if (pass === measurements.length - 1) throw new Error("StickyScrollTrigger: could not resolve endTrigger positions: some endTrigger references form a circular structural dependency, each layer's end depending on a layer whose own end depends back on it. Point each endTrigger at a layer that doesn't depend on it.");
|
|
530
|
-
}
|
|
531
|
-
plans.forEach((plan, index) => deps.onPlanned(index, plan));
|
|
532
|
-
return plans;
|
|
533
|
-
};
|
|
534
931
|
const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex) => {
|
|
535
932
|
if (endResolved === null) return { mode: "auto" };
|
|
536
933
|
const classified = classifyPosition(endResolved);
|
|
@@ -550,7 +947,7 @@ const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownInde
|
|
|
550
947
|
offsetPx: resolveMaxOffset(classified.value, viewportHeight)
|
|
551
948
|
};
|
|
552
949
|
case "clause": {
|
|
553
|
-
if (layer.kind !== "cover" && endTriggerIndex !== null && endTriggerIndex > ownIndex) throw new Error(`StickyScrollTrigger: createStickyTrigger's trigger ${describeElement(layer.trigger)}'s endTrigger (${describeElement(layer.endTrigger)}) refers to a layer positioned later in DOM order, which isn't supported
|
|
950
|
+
if (layer.kind !== "cover" && endTriggerIndex !== null && endTriggerIndex > ownIndex) throw new Error(`StickyScrollTrigger: createStickyTrigger's trigger ${describeElement(layer.trigger)}'s endTrigger (${describeElement(layer.endTrigger)}) refers to a layer positioned later in DOM order, which isn't supported for createStickyTrigger. Point endTrigger at a layer earlier in DOM order, use an unregistered element at the same spot, or use a dwell distance such as '+=500'.`);
|
|
554
951
|
const unregistered = endTriggerIndex === null;
|
|
555
952
|
const insideRoot = rootElement.contains(layer.endTrigger);
|
|
556
953
|
if (unregistered && !insideRoot && layer.kind !== "cover") throw new Error(`StickyScrollTrigger: createStickyTrigger's trigger ${describeElement(layer.trigger)} has an endTrigger (${describeElement(layer.endTrigger)}) outside the shared container: the layer's own dwell keeps pushing it away, so the freeze window never settles. Point endTrigger at an element inside the container, or use a dwell distance such as '+=500'.`);
|
|
@@ -576,7 +973,8 @@ const resolveStartSpec = (layer, startResolved, elementHeight, viewportHeight) =
|
|
|
576
973
|
case "dwell":
|
|
577
974
|
case "clause": return {
|
|
578
975
|
mode: "clause",
|
|
579
|
-
anchorOffset: resolveAnchorTop(classified.value, elementHeight, viewportHeight)
|
|
976
|
+
anchorOffset: resolveAnchorTop(classified.value, elementHeight, viewportHeight),
|
|
977
|
+
elementFraction: resolveElementFraction(classified.value)
|
|
580
978
|
};
|
|
581
979
|
}
|
|
582
980
|
};
|
|
@@ -592,12 +990,16 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
|
|
|
592
990
|
kind: layer.kind,
|
|
593
991
|
start,
|
|
594
992
|
triggerTop: documentTop(layer.trigger),
|
|
993
|
+
triggerHeight: elementHeight,
|
|
994
|
+
triggerEnclosedBy: [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.trigger)).map(([, index]) => index),
|
|
595
995
|
wrapperTop: layer.wrapper ? documentTop(layer.wrapper) : 0,
|
|
596
996
|
coverTop: layer.kind === "cover" ? documentTop(layer.cover) : 0,
|
|
597
997
|
end,
|
|
598
998
|
endTriggerIsSelf,
|
|
599
999
|
endTriggerIndex,
|
|
600
|
-
endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0
|
|
1000
|
+
endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
|
|
1001
|
+
endTriggerEnclosedBy: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.endTrigger)).map(([, index]) => index) : [],
|
|
1002
|
+
endTriggerNests: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger !== layer.endTrigger && layer.endTrigger.contains(trigger)).map(([, index]) => index) : []
|
|
601
1003
|
};
|
|
602
1004
|
};
|
|
603
1005
|
const EXCLUDED_VAR_KEYS = [
|
|
@@ -623,11 +1025,11 @@ const topToStartClause = (top) => {
|
|
|
623
1025
|
};
|
|
624
1026
|
return typeof top === "function" ? () => toClause(top()) : toClause(top);
|
|
625
1027
|
};
|
|
626
|
-
const
|
|
1028
|
+
const resolvePinReleaseScroll = (endTrigger, classifiedEnd, engageScroll, viewportHeight, toScroll) => {
|
|
627
1029
|
switch (classifiedEnd.kind) {
|
|
628
|
-
case "dwell": return
|
|
1030
|
+
case "dwell": return engageScroll + resolveDwell(classifiedEnd.value, viewportHeight);
|
|
629
1031
|
case "absolute": return classifiedEnd.value;
|
|
630
|
-
case "clause": return documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight);
|
|
1032
|
+
case "clause": return toScroll(endTrigger, documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight));
|
|
631
1033
|
}
|
|
632
1034
|
};
|
|
633
1035
|
const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
|
|
@@ -742,6 +1144,24 @@ var StickyScrollTrigger = class {
|
|
|
742
1144
|
});
|
|
743
1145
|
};
|
|
744
1146
|
}
|
|
1147
|
+
#resetPinStickyState() {
|
|
1148
|
+
const snapshots = this.#pinLayers.filter((layer) => layer.inner).map(({ trigger }) => ({
|
|
1149
|
+
trigger,
|
|
1150
|
+
position: captureInlinePosition(trigger)
|
|
1151
|
+
}));
|
|
1152
|
+
snapshots.forEach(({ trigger }) => resetStickyPosition(trigger));
|
|
1153
|
+
return () => {
|
|
1154
|
+
snapshots.forEach(({ trigger, position }) => restoreInlinePosition(trigger, position));
|
|
1155
|
+
};
|
|
1156
|
+
}
|
|
1157
|
+
#resetStickyState() {
|
|
1158
|
+
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
1159
|
+
const restorePinStickyState = this.#resetPinStickyState();
|
|
1160
|
+
return () => {
|
|
1161
|
+
restorePinStickyState();
|
|
1162
|
+
restoreSceneCoverStickyState();
|
|
1163
|
+
};
|
|
1164
|
+
}
|
|
745
1165
|
#resetPinState() {
|
|
746
1166
|
const snapshots = this.#pinLayers.map((layer) => ({
|
|
747
1167
|
layer,
|
|
@@ -764,7 +1184,7 @@ var StickyScrollTrigger = class {
|
|
|
764
1184
|
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
765
1185
|
const restorePinState = this.#resetPinState();
|
|
766
1186
|
try {
|
|
767
|
-
this.#refreshPinLayers(viewportHeight);
|
|
1187
|
+
this.#refreshPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
|
|
768
1188
|
} catch (error) {
|
|
769
1189
|
restorePinState();
|
|
770
1190
|
throw error;
|
|
@@ -772,7 +1192,7 @@ var StickyScrollTrigger = class {
|
|
|
772
1192
|
restoreSceneCoverStickyState();
|
|
773
1193
|
}
|
|
774
1194
|
}
|
|
775
|
-
#refreshPinLayers(viewportHeight) {
|
|
1195
|
+
#refreshPinLayers(viewportHeight, documentHeight) {
|
|
776
1196
|
this.#pinLayers.forEach((layer) => {
|
|
777
1197
|
if (!layer.inner) return;
|
|
778
1198
|
const resolvedStart = resolveMaybeFn(layer.start);
|
|
@@ -781,12 +1201,16 @@ var StickyScrollTrigger = class {
|
|
|
781
1201
|
if (classifiedEnd.kind === "max") throw new Error(`StickyScrollTrigger: createStickyPin's end "${resolvedEnd}" uses GSAP's 'max' keyword, which isn't supported here: the pin's own spacer height adds to the document's max scroll position, so it would depend on itself. Use a position clause against endTrigger, such as 'top top'.`);
|
|
782
1202
|
const triggerTop = documentTop(layer.trigger);
|
|
783
1203
|
const triggerHeight = measureUsedHeight(layer.trigger);
|
|
1204
|
+
const triggerMarginBottom = parseFloat(getComputedStyle(layer.trigger).marginBottom) || 0;
|
|
784
1205
|
const classifiedStart = classifyPosition(resolvedStart);
|
|
785
1206
|
if (classifiedStart.kind === "absolute") throw new Error(`StickyScrollTrigger: createStickyPin's start "${resolvedStart}" is an absolute scroll position (GSAP reads any bare number this way). A pin can't act on one: it engages when position:sticky engages, so start says where trigger sits in the viewport while pinned. Use the top option (top: ${resolvedStart}) for a px distance from the viewport's top edge, or a position clause such as 'top top'.`);
|
|
786
1207
|
const topPx = resolveAnchorTop(classifiedStart.value, triggerHeight, viewportHeight);
|
|
787
|
-
const
|
|
1208
|
+
const toScroll = (element, reachedAt) => this.#addDwellBeforeReach(element, reachedAt);
|
|
1209
|
+
const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
|
|
1210
|
+
const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
|
|
1211
|
+
const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
|
|
788
1212
|
applyStickyPosition(layer.trigger, topPx);
|
|
789
|
-
layer.inner.style.height = `${Math.max(0, height)}px`;
|
|
1213
|
+
layer.inner.style.height = `${Math.max(0, Math.min(height, room))}px`;
|
|
790
1214
|
});
|
|
791
1215
|
}
|
|
792
1216
|
#refreshScenesAndCovers(viewportHeight) {
|
|
@@ -794,11 +1218,14 @@ var StickyScrollTrigger = class {
|
|
|
794
1218
|
const active = this.#layers.filter((layer) => layer.wrapper !== null);
|
|
795
1219
|
if (!active.length) return;
|
|
796
1220
|
const restoreStickyState = this.#resetSceneCoverStickyState();
|
|
1221
|
+
const restorePinStickyState = this.#resetPinStickyState();
|
|
797
1222
|
try {
|
|
798
1223
|
this.#planLayerPositions(viewportHeight, active);
|
|
799
1224
|
} catch (error) {
|
|
800
1225
|
restoreStickyState();
|
|
801
1226
|
throw error;
|
|
1227
|
+
} finally {
|
|
1228
|
+
restorePinStickyState();
|
|
802
1229
|
}
|
|
803
1230
|
}
|
|
804
1231
|
#planLayerPositions(viewportHeight, active) {
|
|
@@ -818,6 +1245,8 @@ var StickyScrollTrigger = class {
|
|
|
818
1245
|
const layer = active[index];
|
|
819
1246
|
layer.freezeStart = plan.freezeStart;
|
|
820
1247
|
layer.freezeEnd = plan.freezeEnd;
|
|
1248
|
+
layer.engagedStart = plan.engagedStart;
|
|
1249
|
+
layer.engagedEnd = plan.engagedEnd;
|
|
821
1250
|
if (!layer.wrapper) return;
|
|
822
1251
|
applyStickyPosition(layer.wrapper, plan.stickyTop);
|
|
823
1252
|
if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
|
|
@@ -860,11 +1289,13 @@ var StickyScrollTrigger = class {
|
|
|
860
1289
|
});
|
|
861
1290
|
}
|
|
862
1291
|
#syncScrollMargins() {
|
|
863
|
-
this.#scrollMarginSync.sync(this.#
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
1292
|
+
this.#scrollMarginSync.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
|
|
1293
|
+
if (!targets.length) return [];
|
|
1294
|
+
const restoreStickyState = this.#resetStickyState();
|
|
1295
|
+
const tops = targets.map((target) => documentTop(target));
|
|
1296
|
+
restoreStickyState();
|
|
1297
|
+
return tops;
|
|
1298
|
+
});
|
|
868
1299
|
}
|
|
869
1300
|
#assertNoExcludedVars(rest, context) {
|
|
870
1301
|
const found = EXCLUDED_VAR_KEYS.filter((key) => key in rest);
|
|
@@ -921,7 +1352,9 @@ var StickyScrollTrigger = class {
|
|
|
921
1352
|
start,
|
|
922
1353
|
end,
|
|
923
1354
|
freezeStart: 0,
|
|
924
|
-
freezeEnd: 0
|
|
1355
|
+
freezeEnd: 0,
|
|
1356
|
+
engagedStart: 0,
|
|
1357
|
+
engagedEnd: 0
|
|
925
1358
|
}, onKill, rest);
|
|
926
1359
|
}
|
|
927
1360
|
createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
|
|
@@ -941,7 +1374,9 @@ var StickyScrollTrigger = class {
|
|
|
941
1374
|
start,
|
|
942
1375
|
end,
|
|
943
1376
|
freezeStart: 0,
|
|
944
|
-
freezeEnd: 0
|
|
1377
|
+
freezeEnd: 0,
|
|
1378
|
+
engagedStart: 0,
|
|
1379
|
+
engagedEnd: 0
|
|
945
1380
|
};
|
|
946
1381
|
const vars = this.#registerLayer(layer, (self) => {
|
|
947
1382
|
this.#coverRestoreByLayer.get(layer)?.();
|
|
@@ -995,23 +1430,30 @@ var StickyScrollTrigger = class {
|
|
|
995
1430
|
}
|
|
996
1431
|
}
|
|
997
1432
|
#resolveClauseScrollPosition(element, clause, viewportHeight) {
|
|
998
|
-
let gap = 0;
|
|
999
|
-
this.#layers.forEach((layer) => {
|
|
1000
|
-
if (layer.kind !== "scene") return;
|
|
1001
|
-
if (compareDocumentOrder(layer.trigger, element) >= 0) return;
|
|
1002
|
-
gap += layer.freezeEnd - layer.freezeStart;
|
|
1003
|
-
});
|
|
1004
1433
|
const anchorOffset = resolveAnchorTop(clause, measureUsedHeight(element), viewportHeight);
|
|
1005
|
-
const
|
|
1006
|
-
const
|
|
1007
|
-
|
|
1008
|
-
return
|
|
1434
|
+
const restoreStickyState = this.#resetStickyState();
|
|
1435
|
+
const reachedAt = documentTop(element) - anchorOffset;
|
|
1436
|
+
restoreStickyState();
|
|
1437
|
+
return this.#addDwellBeforeReach(element, reachedAt);
|
|
1438
|
+
}
|
|
1439
|
+
#addDwellBeforeReach(element, reachedAt) {
|
|
1440
|
+
if (!this.#rootElement.contains(element)) return reachedAt;
|
|
1441
|
+
return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
|
|
1442
|
+
}
|
|
1443
|
+
#engagedWindows() {
|
|
1444
|
+
return this.#layers.flatMap((layer) => layer.kind === "scene" ? [{
|
|
1445
|
+
freezeStart: layer.engagedStart,
|
|
1446
|
+
freezeEnd: layer.engagedEnd
|
|
1447
|
+
}] : []);
|
|
1009
1448
|
}
|
|
1010
1449
|
static getScrollTop(elementInput, instances) {
|
|
1011
1450
|
const element = resolveElement(elementInput, "StickyScrollTrigger.getScrollTop");
|
|
1012
1451
|
const owner = instances.find((instance) => instance.#rootElement.contains(element));
|
|
1013
1452
|
if (owner) return owner.resolveScrollPosition(element, "top top");
|
|
1014
|
-
|
|
1453
|
+
const restores = instances.map((instance) => instance.#resetPinStickyState());
|
|
1454
|
+
const top = documentTop(element);
|
|
1455
|
+
restores.forEach((restore) => restore());
|
|
1456
|
+
return top;
|
|
1015
1457
|
}
|
|
1016
1458
|
createResolvedTrigger({ trigger: triggerInput, start = "top bottom", end = "bottom top", endTrigger: endTriggerInput, ...rest }) {
|
|
1017
1459
|
this.#assertNoExcludedVars(rest, "createResolvedTrigger");
|