sticky-scroll-trigger 0.9.0 → 0.10.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.10.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;
|
|
@@ -121,10 +137,11 @@ const wrapPin = (trigger) => {
|
|
|
121
137
|
if (!trigger.parentNode) throw new Error(`createStickyPin: trigger ${describeElement(trigger)} is not attached to the document`);
|
|
122
138
|
const outer = document.createElement("div");
|
|
123
139
|
const inner = document.createElement("div");
|
|
124
|
-
outer.style.
|
|
140
|
+
outer.style.display = "flow-root";
|
|
125
141
|
trigger.parentNode.insertBefore(outer, trigger);
|
|
126
142
|
outer.appendChild(inner);
|
|
127
143
|
inner.appendChild(trigger);
|
|
144
|
+
pinRanges.add(inner);
|
|
128
145
|
return {
|
|
129
146
|
outer,
|
|
130
147
|
inner
|
|
@@ -134,6 +151,7 @@ const unwrapPin = (outer, trigger, saved) => {
|
|
|
134
151
|
const parent = outer.parentNode;
|
|
135
152
|
restoreInlinePosition(trigger, saved);
|
|
136
153
|
if (parent) parent.insertBefore(trigger, outer);
|
|
154
|
+
if (outer.firstElementChild instanceof HTMLElement) pinRanges.delete(outer.firstElementChild);
|
|
137
155
|
outer.remove();
|
|
138
156
|
};
|
|
139
157
|
const LIFT_VALUES = {
|
|
@@ -177,6 +195,417 @@ const liftAboveStickyWrapper = (cover) => {
|
|
|
177
195
|
lifted.length = 0;
|
|
178
196
|
};
|
|
179
197
|
};
|
|
198
|
+
const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
|
|
199
|
+
const KEYWORD_FRACTIONS = {
|
|
200
|
+
top: 0,
|
|
201
|
+
center: .5,
|
|
202
|
+
bottom: 1
|
|
203
|
+
};
|
|
204
|
+
const signedPx = (sign, value, unit, refSize) => {
|
|
205
|
+
const magnitude = unit === "%" ? parseFloat(value) / 100 * refSize : parseFloat(value);
|
|
206
|
+
return sign?.startsWith("-") ? -magnitude : magnitude;
|
|
207
|
+
};
|
|
208
|
+
const CLAUSE_TOKEN_RE = /^(top|center|bottom|[+-]?(?:\d+(?:\.\d*)?|\.\d+))?(%|px)?(?:([+-]=?)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
|
|
209
|
+
const parseClauseToken = (token, refSize) => {
|
|
210
|
+
const match = CLAUSE_TOKEN_RE.exec(token);
|
|
211
|
+
if (!match || !match[1] && !match[3]) {
|
|
212
|
+
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.`);
|
|
213
|
+
throw new Error(`StickyScrollTrigger: unsupported position clause "${token}"`);
|
|
214
|
+
}
|
|
215
|
+
const [, base, baseUnit, sign, offsetValue, offsetUnit] = match;
|
|
216
|
+
if (base !== void 0 && sign && !sign.includes("=")) {
|
|
217
|
+
const suggestion = `${base}${baseUnit ?? ""}${sign}=${offsetValue}${offsetUnit ?? ""}`;
|
|
218
|
+
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}"?`);
|
|
219
|
+
}
|
|
220
|
+
const isKeyword = base !== void 0 && base in KEYWORD_FRACTIONS;
|
|
221
|
+
const basePercent = baseUnit === "%";
|
|
222
|
+
return {
|
|
223
|
+
fraction: isKeyword ? KEYWORD_FRACTIONS[base] : basePercent ? parseFloat(base) / 100 : 0,
|
|
224
|
+
offsetPx: (!isKeyword && !basePercent && base !== void 0 ? parseFloat(base) : 0) + (sign ? signedPx(sign, offsetValue, offsetUnit, refSize) : 0)
|
|
225
|
+
};
|
|
226
|
+
};
|
|
227
|
+
const isAbsoluteFormat = (resolved) => {
|
|
228
|
+
if (typeof resolved === "number") return true;
|
|
229
|
+
return resolved.trim() !== "" && !Number.isNaN(Number(resolved));
|
|
230
|
+
};
|
|
231
|
+
const resolveAbsolute = (resolved) => typeof resolved === "number" ? resolved : Number(resolved);
|
|
232
|
+
const CLAMP_PREFIX = "clamp(";
|
|
233
|
+
const assertNotClamped = (trimmed) => {
|
|
234
|
+
if (!trimmed.startsWith(CLAMP_PREFIX)) return;
|
|
235
|
+
const inner = trimmed.slice(6).replace(/\)$/, "").trim();
|
|
236
|
+
throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
|
|
237
|
+
};
|
|
238
|
+
const resolveElementAnchor = (position, elementHeight) => {
|
|
239
|
+
const trimmed = position.trim();
|
|
240
|
+
assertNotClamped(trimmed);
|
|
241
|
+
const elementClause = parseClauseToken(trimmed.split(/\s+/)[0], elementHeight);
|
|
242
|
+
return elementHeight * elementClause.fraction + elementClause.offsetPx;
|
|
243
|
+
};
|
|
244
|
+
const resolveElementFraction = (position) => resolveElementAnchor(position, 1) - resolveElementAnchor(position, 0);
|
|
245
|
+
const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
|
|
246
|
+
const trimmed = position.trim();
|
|
247
|
+
assertNotClamped(trimmed);
|
|
248
|
+
const viewportToken = trimmed.split(/\s+/)[1] ?? "top";
|
|
249
|
+
const viewportClause = parseClauseToken(viewportToken, viewportHeight);
|
|
250
|
+
return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - resolveElementAnchor(trimmed, elementHeight);
|
|
251
|
+
};
|
|
252
|
+
const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
|
|
253
|
+
const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
|
|
254
|
+
const prefixSpacedRelativeEnd = (start, endResolved) => {
|
|
255
|
+
if (typeof endResolved !== "string") return endResolved;
|
|
256
|
+
const trimmedEnd = endResolved.trim();
|
|
257
|
+
if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
|
|
258
|
+
const startResolved = resolveMaybeFn(start);
|
|
259
|
+
if (typeof startResolved !== "string") return endResolved;
|
|
260
|
+
const trimmedStart = startResolved.trim();
|
|
261
|
+
assertNotClamped(trimmedStart);
|
|
262
|
+
const [elementToken] = trimmedStart.split(/\s+/);
|
|
263
|
+
try {
|
|
264
|
+
parseClauseToken(elementToken, 0);
|
|
265
|
+
} catch (error) {
|
|
266
|
+
if (!isAbsoluteFormat(startResolved)) throw error;
|
|
267
|
+
return endResolved;
|
|
268
|
+
}
|
|
269
|
+
parseClauseToken(trimmedEnd.split(/\s+/)[0], 0);
|
|
270
|
+
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'.`);
|
|
271
|
+
return elementToken + trimmedEnd;
|
|
272
|
+
};
|
|
273
|
+
const resolveDwell = (resolved, viewportHeight) => {
|
|
274
|
+
const match = DWELL_RELATIVE_RE.exec(String(resolved).trim());
|
|
275
|
+
if (!match) throw new Error(`StickyScrollTrigger: unsupported end format "${resolved}"`);
|
|
276
|
+
const [, value, unit] = match;
|
|
277
|
+
return signedPx(void 0, value, unit, viewportHeight);
|
|
278
|
+
};
|
|
279
|
+
const MAX_TOKEN_RE = /^max(?:([+-]=)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
|
|
280
|
+
const isMaxFormat = (resolved) => typeof resolved === "string" && MAX_TOKEN_RE.test(resolved.trim());
|
|
281
|
+
const resolveMaxOffset = (resolved, viewportHeight) => {
|
|
282
|
+
const match = MAX_TOKEN_RE.exec(resolved.trim());
|
|
283
|
+
if (!match) throw new Error(`StickyScrollTrigger: unsupported max-position format "${resolved}"`);
|
|
284
|
+
const [, sign, value, unit] = match;
|
|
285
|
+
return sign ? signedPx(sign, value, unit, viewportHeight) : 0;
|
|
286
|
+
};
|
|
287
|
+
const classifyPosition = (resolved) => {
|
|
288
|
+
if (typeof resolved === "number") return {
|
|
289
|
+
kind: "absolute",
|
|
290
|
+
value: resolved
|
|
291
|
+
};
|
|
292
|
+
if (isDwellFormat(resolved)) return {
|
|
293
|
+
kind: "dwell",
|
|
294
|
+
value: resolved
|
|
295
|
+
};
|
|
296
|
+
if (isMaxFormat(resolved)) return {
|
|
297
|
+
kind: "max",
|
|
298
|
+
value: resolved
|
|
299
|
+
};
|
|
300
|
+
if (isAbsoluteFormat(resolved)) return {
|
|
301
|
+
kind: "absolute",
|
|
302
|
+
value: resolveAbsolute(resolved)
|
|
303
|
+
};
|
|
304
|
+
return {
|
|
305
|
+
kind: "clause",
|
|
306
|
+
value: resolved
|
|
307
|
+
};
|
|
308
|
+
};
|
|
309
|
+
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));
|
|
310
|
+
const nestedIn = (measurements, index) => measurements.flatMap(({ triggerEnclosedBy }, k) => k !== index && triggerEnclosedBy.includes(index) ? [k] : []);
|
|
311
|
+
const anchorShare = (measurements, windows, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex) => {
|
|
312
|
+
const measurement = measurements[index];
|
|
313
|
+
if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? freezeStart - windows.reduce((earlier, other) => other.index !== index && other.index !== ownIndex && !(order && order.isBefore(ownIndex, other.index)) && other.freezeEnd <= freezeStart + .05 ? earlier + other.freezeEnd - other.freezeStart : earlier, 0) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
|
|
314
|
+
if (order && isHeldIn(measurements, index, enclosedBy, anchorElement, order)) return 0;
|
|
315
|
+
if (box.nests.includes(index)) return box.fraction;
|
|
316
|
+
return measurement.triggerTop + measurement.triggerHeight <= box.top + .05 ? 1 : 0;
|
|
317
|
+
};
|
|
318
|
+
const gapsBeforeEndAnchor = (measurements, windows, box, reachedAt, enclosedBy, ownIndex, anchorElement, order, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
|
|
319
|
+
if (index === ownIndex || order && order.isBefore(ownIndex, index)) return total;
|
|
320
|
+
const weight = anchorShare(measurements, windows, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex);
|
|
321
|
+
if (weight === 0) return total;
|
|
322
|
+
counted?.add(index);
|
|
323
|
+
return total + weight * (freezeEnd - freezeStart);
|
|
324
|
+
}, 0);
|
|
325
|
+
const clauseFreezeStart = (measurements, index, paddingOf) => {
|
|
326
|
+
const reachOf = (k) => {
|
|
327
|
+
const { start, triggerTop } = measurements[k];
|
|
328
|
+
return start.mode === "clause" ? triggerTop - start.anchorOffset : null;
|
|
329
|
+
};
|
|
330
|
+
const scenes = measurements.flatMap(({ kind }, k) => kind === "scene" ? [k] : []);
|
|
331
|
+
const clauses = scenes.filter((k) => reachOf(k) !== null).sort((a, b) => {
|
|
332
|
+
const gap = reachOf(a) - reachOf(b);
|
|
333
|
+
return Math.abs(gap) <= .05 ? a - b : gap;
|
|
334
|
+
});
|
|
335
|
+
const absolutes = scenes.flatMap((k) => {
|
|
336
|
+
const { start } = measurements[k];
|
|
337
|
+
return start.mode === "absolute" ? [{
|
|
338
|
+
k,
|
|
339
|
+
value: start.value
|
|
340
|
+
}] : [];
|
|
341
|
+
}).sort((a, b) => a.value - b.value);
|
|
342
|
+
let dwell = 0;
|
|
343
|
+
let nextAbsolute = 0;
|
|
344
|
+
for (const k of clauses) {
|
|
345
|
+
const reachedAt = reachOf(k);
|
|
346
|
+
while (nextAbsolute < absolutes.length && absolutes[nextAbsolute].value < reachedAt + dwell + .05) {
|
|
347
|
+
dwell += paddingOf(absolutes[nextAbsolute].k);
|
|
348
|
+
nextAbsolute += 1;
|
|
349
|
+
}
|
|
350
|
+
if (k === index) return reachedAt + dwell;
|
|
351
|
+
dwell += paddingOf(k);
|
|
352
|
+
}
|
|
353
|
+
throw new Error("StickyScrollTrigger: internal error: clauseFreezeStart was given a layer without a clause start.");
|
|
354
|
+
};
|
|
355
|
+
const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, record) => {
|
|
356
|
+
const fresh = [];
|
|
357
|
+
const knownWindows = () => measurements.flatMap((measurement, k) => {
|
|
358
|
+
if (measurement.kind !== "scene") return [];
|
|
359
|
+
const plan = fresh[k];
|
|
360
|
+
if (plan) return [{
|
|
361
|
+
index: k,
|
|
362
|
+
freezeStart: plan.freezeStart,
|
|
363
|
+
freezeEnd: plan.freezeEnd
|
|
364
|
+
}];
|
|
365
|
+
const freezeStart = previous?.freezeStarts[k] ?? null;
|
|
366
|
+
const paddingHeight = previous?.paddings[k] ?? null;
|
|
367
|
+
return freezeStart === null || paddingHeight === null ? [] : [{
|
|
368
|
+
index: k,
|
|
369
|
+
freezeStart,
|
|
370
|
+
freezeEnd: freezeStart + paddingHeight
|
|
371
|
+
}];
|
|
372
|
+
});
|
|
373
|
+
const paddingOf = (k) => fresh[k]?.paddingHeight ?? previous?.paddings[k] ?? 0;
|
|
374
|
+
const recounts = [];
|
|
375
|
+
const plans = measurements.map((measurement, index) => {
|
|
376
|
+
fresh[index] = null;
|
|
377
|
+
if (measurement.kind === "cover") return null;
|
|
378
|
+
const recount = {
|
|
379
|
+
index,
|
|
380
|
+
counted: new Set(),
|
|
381
|
+
runs: []
|
|
382
|
+
};
|
|
383
|
+
recounts.push(recount);
|
|
384
|
+
const { start } = measurement;
|
|
385
|
+
const freezeStart = start.mode === "absolute" ? start.value : clauseFreezeStart(measurements, index, paddingOf);
|
|
386
|
+
let freezeEnd;
|
|
387
|
+
switch (measurement.end.mode) {
|
|
388
|
+
case "dwell":
|
|
389
|
+
freezeEnd = freezeStart + measurement.end.distancePx;
|
|
390
|
+
break;
|
|
391
|
+
case "absolute":
|
|
392
|
+
freezeEnd = Math.max(freezeStart, measurement.end.value);
|
|
393
|
+
break;
|
|
394
|
+
case "auto":
|
|
395
|
+
case "max": throw new Error(`StickyScrollTrigger: internal error: a Scene layer reached '${measurement.end.mode}' end mode, which only a cover layer can have.`);
|
|
396
|
+
case "clause": {
|
|
397
|
+
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
|
|
398
|
+
if (measurement.endTriggerIsSelf) {
|
|
399
|
+
const nests = nestedIn(measurements, index);
|
|
400
|
+
const weight = resolveElementFraction(measurement.end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
|
|
401
|
+
const dwellInside = measurements.reduce((total, other, k) => {
|
|
402
|
+
if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
|
|
403
|
+
recount.counted.add(k);
|
|
404
|
+
return total + weight * paddingOf(k);
|
|
405
|
+
}, 0);
|
|
406
|
+
if (start.mode === "clause") {
|
|
407
|
+
freezeEnd = freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
|
|
408
|
+
break;
|
|
409
|
+
}
|
|
410
|
+
const dwellAbove = measurements.reduce((total, other, k) => {
|
|
411
|
+
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;
|
|
412
|
+
recount.counted.add(k);
|
|
413
|
+
return total + paddingOf(k);
|
|
414
|
+
}, 0);
|
|
415
|
+
freezeEnd = Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
|
|
416
|
+
break;
|
|
417
|
+
}
|
|
418
|
+
let endTop;
|
|
419
|
+
if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
|
|
420
|
+
else {
|
|
421
|
+
const rawTop = measurement.endTriggerIndex === null ? measurement.end.rawTop : measurements[measurement.endTriggerIndex].triggerTop;
|
|
422
|
+
if (rawTop === null) endTop = 0;
|
|
423
|
+
else {
|
|
424
|
+
const box = {
|
|
425
|
+
top: rawTop,
|
|
426
|
+
fraction: resolveElementFraction(measurement.end.clause),
|
|
427
|
+
nests: measurement.endTriggerNests
|
|
428
|
+
};
|
|
429
|
+
const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, w, box, rawTop - anchorOffsetEnd, measurement.endTriggerEnclosedBy, index, measurement.endTriggerIndex, order, counted);
|
|
430
|
+
endTop = rawTop + gaps(knownWindows());
|
|
431
|
+
recount.runs.push((w) => gaps(w, recount.counted));
|
|
432
|
+
}
|
|
433
|
+
}
|
|
434
|
+
let layoutStart;
|
|
435
|
+
if (start.mode === "absolute") layoutStart = start.value;
|
|
436
|
+
else {
|
|
437
|
+
const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, w, {
|
|
438
|
+
top: measurement.triggerTop,
|
|
439
|
+
fraction: start.elementFraction,
|
|
440
|
+
nests: nestedIn(measurements, index)
|
|
441
|
+
}, measurement.triggerTop - start.anchorOffset, measurement.triggerEnclosedBy, index, index, order, counted);
|
|
442
|
+
layoutStart = measurement.triggerTop - start.anchorOffset + gaps(knownWindows());
|
|
443
|
+
recount.runs.push((w) => gaps(w, recount.counted));
|
|
444
|
+
}
|
|
445
|
+
freezeEnd = freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
|
|
446
|
+
break;
|
|
447
|
+
}
|
|
448
|
+
}
|
|
449
|
+
const paddingHeight = Math.max(0, freezeEnd - freezeStart);
|
|
450
|
+
const plan = {
|
|
451
|
+
freezeStart,
|
|
452
|
+
freezeEnd,
|
|
453
|
+
stickyTop: 0,
|
|
454
|
+
paddingHeight
|
|
455
|
+
};
|
|
456
|
+
fresh[index] = plan;
|
|
457
|
+
return plan;
|
|
458
|
+
});
|
|
459
|
+
if (record) {
|
|
460
|
+
const windows = knownWindows();
|
|
461
|
+
recounts.forEach(({ index, counted, runs }) => {
|
|
462
|
+
runs.forEach((run) => run(windows));
|
|
463
|
+
record(index, counted);
|
|
464
|
+
});
|
|
465
|
+
}
|
|
466
|
+
return plans;
|
|
467
|
+
};
|
|
468
|
+
const planCover = (measurements, index, windows, { viewportHeight, documentMaxScroll, measureLiveEndTriggerTop }) => {
|
|
469
|
+
const measurement = measurements[index];
|
|
470
|
+
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.");
|
|
471
|
+
const reached = (reachedAt) => reachedAt + dwellBeforeReach(reachedAt, windows);
|
|
472
|
+
const startReachedAt = measurement.triggerTop - measurement.start.anchorOffset;
|
|
473
|
+
const freezeStart = startReachedAt + dwellBeforeReach(startReachedAt, windows, { countTies: true });
|
|
474
|
+
let freezeEnd;
|
|
475
|
+
switch (measurement.end.mode) {
|
|
476
|
+
case "auto":
|
|
477
|
+
freezeEnd = reached(measurement.coverTop);
|
|
478
|
+
break;
|
|
479
|
+
case "dwell":
|
|
480
|
+
freezeEnd = freezeStart + measurement.end.distancePx;
|
|
481
|
+
break;
|
|
482
|
+
case "absolute":
|
|
483
|
+
freezeEnd = measurement.end.value;
|
|
484
|
+
break;
|
|
485
|
+
case "max":
|
|
486
|
+
freezeEnd = documentMaxScroll + measurement.end.offsetPx;
|
|
487
|
+
break;
|
|
488
|
+
case "clause": {
|
|
489
|
+
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
|
|
490
|
+
if (measurement.end.measureLive) freezeEnd = measureLiveEndTriggerTop(index) - anchorOffsetEnd;
|
|
491
|
+
else freezeEnd = reached((measurement.endTriggerIsSelf ? measurement.triggerTop : measurement.endTriggerIndex === null ? measurement.end.rawTop ?? 0 : measurements[measurement.endTriggerIndex].triggerTop) - anchorOffsetEnd);
|
|
492
|
+
break;
|
|
493
|
+
}
|
|
494
|
+
}
|
|
495
|
+
return {
|
|
496
|
+
freezeStart,
|
|
497
|
+
freezeEnd: Math.max(freezeStart, freezeEnd),
|
|
498
|
+
stickyTop: measurement.start.anchorOffset - (measurement.triggerTop - measurement.wrapperTop),
|
|
499
|
+
paddingHeight: null
|
|
500
|
+
};
|
|
501
|
+
};
|
|
502
|
+
const TIE_TOLERANCE_PX = .05;
|
|
503
|
+
const dwellBeforeReach = (reachedAt, windows, { countTies = false } = {}) => {
|
|
504
|
+
const tolerance = countTies ? -.05 : TIE_TOLERANCE_PX;
|
|
505
|
+
let earlierDwell = 0;
|
|
506
|
+
let counted = 0;
|
|
507
|
+
[...windows].sort((a, b) => a.freezeStart - b.freezeStart).forEach(({ freezeStart, freezeEnd }) => {
|
|
508
|
+
if (freezeStart < reachedAt + earlierDwell - tolerance) counted += freezeEnd - freezeStart;
|
|
509
|
+
earlierDwell += freezeEnd - freezeStart;
|
|
510
|
+
});
|
|
511
|
+
return counted;
|
|
512
|
+
};
|
|
513
|
+
const dwellConsumedAt = (scroll, windows) => windows.reduce((consumed, { freezeStart, freezeEnd }) => consumed + Math.min(Math.max(scroll - freezeStart, 0), freezeEnd - freezeStart), 0);
|
|
514
|
+
const componentsOf = (edges) => {
|
|
515
|
+
const visitOrder = edges.map(() => -1);
|
|
516
|
+
const lowLink = edges.map(() => 0);
|
|
517
|
+
const component = edges.map(() => -1);
|
|
518
|
+
const stack = [];
|
|
519
|
+
let visited = 0;
|
|
520
|
+
let components = 0;
|
|
521
|
+
const visit = (v) => {
|
|
522
|
+
visitOrder[v] = visited;
|
|
523
|
+
lowLink[v] = visited;
|
|
524
|
+
visited += 1;
|
|
525
|
+
stack.push(v);
|
|
526
|
+
for (const w of edges[v]) if (visitOrder[w] === -1) {
|
|
527
|
+
visit(w);
|
|
528
|
+
lowLink[v] = Math.min(lowLink[v], lowLink[w]);
|
|
529
|
+
} else if (component[w] === -1) lowLink[v] = Math.min(lowLink[v], visitOrder[w]);
|
|
530
|
+
if (lowLink[v] === visitOrder[v]) {
|
|
531
|
+
let w;
|
|
532
|
+
do {
|
|
533
|
+
w = stack.pop();
|
|
534
|
+
component[w] = components;
|
|
535
|
+
} while (w !== v);
|
|
536
|
+
components += 1;
|
|
537
|
+
}
|
|
538
|
+
};
|
|
539
|
+
edges.forEach((_, v) => {
|
|
540
|
+
if (visitOrder[v] === -1) visit(v);
|
|
541
|
+
});
|
|
542
|
+
return component;
|
|
543
|
+
};
|
|
544
|
+
const fallbackOrder = (measurements, counted) => {
|
|
545
|
+
const component = componentsOf(measurements.map(({ triggerEnclosedBy }, i) => [...counted[i], ...triggerEnclosedBy.filter((m) => m !== i && measurements[m].kind === "scene")]));
|
|
546
|
+
const rank = [];
|
|
547
|
+
measurements.map((_, i) => i).sort((a, b) => component[a] - component[b] || a - b).forEach((layer, position) => {
|
|
548
|
+
rank[layer] = position;
|
|
549
|
+
});
|
|
550
|
+
return { isBefore: (a, b) => rank[a] < rank[b] };
|
|
551
|
+
};
|
|
552
|
+
const planLayers = (measurements, deps) => {
|
|
553
|
+
const needsConvergence = measurements.filter(({ kind }) => kind === "scene").length > 1;
|
|
554
|
+
const liveTopCache = new Map();
|
|
555
|
+
const passDeps = {
|
|
556
|
+
...deps,
|
|
557
|
+
measureLiveEndTriggerTop: (index) => {
|
|
558
|
+
const cached = liveTopCache.get(index);
|
|
559
|
+
if (cached !== void 0) return cached;
|
|
560
|
+
const value = deps.measureLiveEndTriggerTop(index);
|
|
561
|
+
liveTopCache.set(index, value);
|
|
562
|
+
return value;
|
|
563
|
+
}
|
|
564
|
+
};
|
|
565
|
+
const stateOf = (passPlans) => ({
|
|
566
|
+
paddings: passPlans.map((plan) => plan?.paddingHeight ?? null),
|
|
567
|
+
freezeStarts: passPlans.map((plan) => plan?.freezeStart ?? null)
|
|
568
|
+
});
|
|
569
|
+
const sameValues = (a, b) => a.every((value, i) => value === b[i] || value !== null && b[i] !== null && Math.abs(value - b[i]) <= .05);
|
|
570
|
+
const sameState = (a, b) => sameValues(a.paddings, b.paddings) && sameValues(a.freezeStarts, b.freezeStarts);
|
|
571
|
+
const average = (a, b) => a.map((value, i) => value === null ? null : (value + b[i]) / 2);
|
|
572
|
+
const settle = (order, record) => {
|
|
573
|
+
let plans = runPass(measurements, passDeps, null, order, record);
|
|
574
|
+
if (!needsConvergence) return plans;
|
|
575
|
+
const budget = order === null ? Math.max(64, 2 * measurements.length + 2) : 2 * measurements.length + 2;
|
|
576
|
+
let fed = stateOf(plans);
|
|
577
|
+
let fedBefore = null;
|
|
578
|
+
for (let pass = 0; pass < budget; pass += 1) {
|
|
579
|
+
plans = runPass(measurements, passDeps, fed, order, record);
|
|
580
|
+
const out = stateOf(plans);
|
|
581
|
+
if (sameState(out, fed)) return plans;
|
|
582
|
+
const flipped = fedBefore !== null && sameState(out, fedBefore);
|
|
583
|
+
fedBefore = fed;
|
|
584
|
+
fed = flipped ? {
|
|
585
|
+
paddings: average(out.paddings, fed.paddings),
|
|
586
|
+
freezeStarts: average(out.freezeStarts, fed.freezeStarts)
|
|
587
|
+
} : out;
|
|
588
|
+
}
|
|
589
|
+
return null;
|
|
590
|
+
};
|
|
591
|
+
const counted = measurements.map(() => new Set());
|
|
592
|
+
let settled = settle(null, (index, layers) => layers.forEach((k) => counted[index].add(k)));
|
|
593
|
+
if (settled === null) settled = settle(fallbackOrder(measurements, counted), null);
|
|
594
|
+
if (settled === null) 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.");
|
|
595
|
+
const plans = settled;
|
|
596
|
+
const withTops = plans.map((plan, index) => {
|
|
597
|
+
if (plan === null) return null;
|
|
598
|
+
const outerDwell = plans.reduce((total, outer, k) => k > index && outer !== null && outer.freezeEnd <= plan.freezeStart + .05 ? total + outer.paddingHeight : total, 0);
|
|
599
|
+
return {
|
|
600
|
+
...plan,
|
|
601
|
+
stickyTop: deps.structureTop - (plan.freezeStart - outerDwell)
|
|
602
|
+
};
|
|
603
|
+
});
|
|
604
|
+
const windows = withTops.filter((plan) => plan !== null);
|
|
605
|
+
const finalPlans = withTops.map((plan, index) => plan ?? planCover(measurements, index, windows, passDeps));
|
|
606
|
+
finalPlans.forEach((plan, index) => deps.onPlanned(index, plan));
|
|
607
|
+
return finalPlans;
|
|
608
|
+
};
|
|
180
609
|
const OFFSET_PROPERTY = "--sst-scroll-margin-top-offset";
|
|
181
610
|
let nextInstanceSuffix = 0;
|
|
182
611
|
const supportsScrollDrivenAnimations = typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("animation-timeline", "scroll()");
|
|
@@ -231,8 +660,8 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
231
660
|
jsHost = null;
|
|
232
661
|
};
|
|
233
662
|
return {
|
|
234
|
-
sync(scenes, host) {
|
|
235
|
-
const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart);
|
|
663
|
+
sync(scenes, host, measureNaturalTops) {
|
|
664
|
+
const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
|
|
236
665
|
if (targetSelector === null || !ramps.length || !host) {
|
|
237
666
|
written.forEach(restoreTarget);
|
|
238
667
|
written = new Set();
|
|
@@ -256,20 +685,22 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
256
685
|
sheet.replaceSync(buildStylesheet(instanceId, ramps));
|
|
257
686
|
}
|
|
258
687
|
const targets = Array.from(rootElement.querySelectorAll(targetSelector));
|
|
688
|
+
const naturalTops = measureNaturalTops(targets);
|
|
259
689
|
targets.forEach((target) => {
|
|
260
690
|
const existing = snapshots.get(target);
|
|
261
691
|
if (!existing) snapshots.set(target, { inline: target.style.scrollMarginTop });
|
|
262
692
|
else if (written.has(target)) target.style.scrollMarginTop = existing.inline;
|
|
263
693
|
});
|
|
264
694
|
const consumed = ramps.map((_, index) => `var(--${instanceId}-c${index}, 0px)`).join(" + ");
|
|
265
|
-
targets.forEach((target) => {
|
|
695
|
+
targets.forEach((target, targetIndex) => {
|
|
266
696
|
const authorPx = parseFloat(getComputedStyle(target).scrollMarginTop) || 0;
|
|
267
|
-
let
|
|
268
|
-
ramps.
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
697
|
+
let earlierDwell = 0;
|
|
698
|
+
const lag = ramps.map(({ freezeStart, freezeEnd }) => {
|
|
699
|
+
const margin = naturalTops[targetIndex] - authorPx + earlierDwell - freezeStart - TIE_TOLERANCE_PX;
|
|
700
|
+
earlierDwell += freezeEnd - freezeStart;
|
|
701
|
+
return `clamp(0px, (${margin}px - var(${OFFSET_PROPERTY}, 0px)) * 1000000, ${freezeEnd - freezeStart}px)`;
|
|
702
|
+
}).join(" + ");
|
|
703
|
+
target.style.scrollMarginTop = `calc(${authorPx}px + var(${OFFSET_PROPERTY}, 0px) + ${consumed} - (${lag}))`;
|
|
273
704
|
});
|
|
274
705
|
const next = new Set(targets);
|
|
275
706
|
written.forEach((target) => {
|
|
@@ -325,212 +756,6 @@ const unbuildStructure = (rootElement, layers, outermostContainer) => {
|
|
|
325
756
|
}
|
|
326
757
|
});
|
|
327
758
|
};
|
|
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
759
|
const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex) => {
|
|
535
760
|
if (endResolved === null) return { mode: "auto" };
|
|
536
761
|
const classified = classifyPosition(endResolved);
|
|
@@ -550,7 +775,7 @@ const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownInde
|
|
|
550
775
|
offsetPx: resolveMaxOffset(classified.value, viewportHeight)
|
|
551
776
|
};
|
|
552
777
|
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
|
|
778
|
+
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
779
|
const unregistered = endTriggerIndex === null;
|
|
555
780
|
const insideRoot = rootElement.contains(layer.endTrigger);
|
|
556
781
|
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 +801,8 @@ const resolveStartSpec = (layer, startResolved, elementHeight, viewportHeight) =
|
|
|
576
801
|
case "dwell":
|
|
577
802
|
case "clause": return {
|
|
578
803
|
mode: "clause",
|
|
579
|
-
anchorOffset: resolveAnchorTop(classified.value, elementHeight, viewportHeight)
|
|
804
|
+
anchorOffset: resolveAnchorTop(classified.value, elementHeight, viewportHeight),
|
|
805
|
+
elementFraction: resolveElementFraction(classified.value)
|
|
580
806
|
};
|
|
581
807
|
}
|
|
582
808
|
};
|
|
@@ -592,12 +818,16 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
|
|
|
592
818
|
kind: layer.kind,
|
|
593
819
|
start,
|
|
594
820
|
triggerTop: documentTop(layer.trigger),
|
|
821
|
+
triggerHeight: elementHeight,
|
|
822
|
+
triggerEnclosedBy: [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.trigger)).map(([, index]) => index),
|
|
595
823
|
wrapperTop: layer.wrapper ? documentTop(layer.wrapper) : 0,
|
|
596
824
|
coverTop: layer.kind === "cover" ? documentTop(layer.cover) : 0,
|
|
597
825
|
end,
|
|
598
826
|
endTriggerIsSelf,
|
|
599
827
|
endTriggerIndex,
|
|
600
|
-
endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0
|
|
828
|
+
endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
|
|
829
|
+
endTriggerEnclosedBy: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.endTrigger)).map(([, index]) => index) : [],
|
|
830
|
+
endTriggerNests: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger !== layer.endTrigger && layer.endTrigger.contains(trigger)).map(([, index]) => index) : []
|
|
601
831
|
};
|
|
602
832
|
};
|
|
603
833
|
const EXCLUDED_VAR_KEYS = [
|
|
@@ -623,11 +853,11 @@ const topToStartClause = (top) => {
|
|
|
623
853
|
};
|
|
624
854
|
return typeof top === "function" ? () => toClause(top()) : toClause(top);
|
|
625
855
|
};
|
|
626
|
-
const
|
|
856
|
+
const resolvePinReleaseScroll = (endTrigger, classifiedEnd, engageScroll, viewportHeight, toScroll) => {
|
|
627
857
|
switch (classifiedEnd.kind) {
|
|
628
|
-
case "dwell": return
|
|
858
|
+
case "dwell": return engageScroll + resolveDwell(classifiedEnd.value, viewportHeight);
|
|
629
859
|
case "absolute": return classifiedEnd.value;
|
|
630
|
-
case "clause": return documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight);
|
|
860
|
+
case "clause": return toScroll(endTrigger, documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight));
|
|
631
861
|
}
|
|
632
862
|
};
|
|
633
863
|
const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
|
|
@@ -742,6 +972,24 @@ var StickyScrollTrigger = class {
|
|
|
742
972
|
});
|
|
743
973
|
};
|
|
744
974
|
}
|
|
975
|
+
#resetPinStickyState() {
|
|
976
|
+
const snapshots = this.#pinLayers.filter((layer) => layer.inner).map(({ trigger }) => ({
|
|
977
|
+
trigger,
|
|
978
|
+
position: captureInlinePosition(trigger)
|
|
979
|
+
}));
|
|
980
|
+
snapshots.forEach(({ trigger }) => resetStickyPosition(trigger));
|
|
981
|
+
return () => {
|
|
982
|
+
snapshots.forEach(({ trigger, position }) => restoreInlinePosition(trigger, position));
|
|
983
|
+
};
|
|
984
|
+
}
|
|
985
|
+
#resetStickyState() {
|
|
986
|
+
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
987
|
+
const restorePinStickyState = this.#resetPinStickyState();
|
|
988
|
+
return () => {
|
|
989
|
+
restorePinStickyState();
|
|
990
|
+
restoreSceneCoverStickyState();
|
|
991
|
+
};
|
|
992
|
+
}
|
|
745
993
|
#resetPinState() {
|
|
746
994
|
const snapshots = this.#pinLayers.map((layer) => ({
|
|
747
995
|
layer,
|
|
@@ -764,7 +1012,7 @@ var StickyScrollTrigger = class {
|
|
|
764
1012
|
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
765
1013
|
const restorePinState = this.#resetPinState();
|
|
766
1014
|
try {
|
|
767
|
-
this.#refreshPinLayers(viewportHeight);
|
|
1015
|
+
this.#refreshPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
|
|
768
1016
|
} catch (error) {
|
|
769
1017
|
restorePinState();
|
|
770
1018
|
throw error;
|
|
@@ -772,7 +1020,7 @@ var StickyScrollTrigger = class {
|
|
|
772
1020
|
restoreSceneCoverStickyState();
|
|
773
1021
|
}
|
|
774
1022
|
}
|
|
775
|
-
#refreshPinLayers(viewportHeight) {
|
|
1023
|
+
#refreshPinLayers(viewportHeight, documentHeight) {
|
|
776
1024
|
this.#pinLayers.forEach((layer) => {
|
|
777
1025
|
if (!layer.inner) return;
|
|
778
1026
|
const resolvedStart = resolveMaybeFn(layer.start);
|
|
@@ -781,12 +1029,16 @@ var StickyScrollTrigger = class {
|
|
|
781
1029
|
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
1030
|
const triggerTop = documentTop(layer.trigger);
|
|
783
1031
|
const triggerHeight = measureUsedHeight(layer.trigger);
|
|
1032
|
+
const triggerMarginBottom = parseFloat(getComputedStyle(layer.trigger).marginBottom) || 0;
|
|
784
1033
|
const classifiedStart = classifyPosition(resolvedStart);
|
|
785
1034
|
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
1035
|
const topPx = resolveAnchorTop(classifiedStart.value, triggerHeight, viewportHeight);
|
|
787
|
-
const
|
|
1036
|
+
const toScroll = (element, reachedAt) => this.#addDwellBeforeReach(element, reachedAt);
|
|
1037
|
+
const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
|
|
1038
|
+
const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#sceneLayers()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
|
|
1039
|
+
const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
|
|
788
1040
|
applyStickyPosition(layer.trigger, topPx);
|
|
789
|
-
layer.inner.style.height = `${Math.max(0, height)}px`;
|
|
1041
|
+
layer.inner.style.height = `${Math.max(0, Math.min(height, room))}px`;
|
|
790
1042
|
});
|
|
791
1043
|
}
|
|
792
1044
|
#refreshScenesAndCovers(viewportHeight) {
|
|
@@ -794,11 +1046,14 @@ var StickyScrollTrigger = class {
|
|
|
794
1046
|
const active = this.#layers.filter((layer) => layer.wrapper !== null);
|
|
795
1047
|
if (!active.length) return;
|
|
796
1048
|
const restoreStickyState = this.#resetSceneCoverStickyState();
|
|
1049
|
+
const restorePinStickyState = this.#resetPinStickyState();
|
|
797
1050
|
try {
|
|
798
1051
|
this.#planLayerPositions(viewportHeight, active);
|
|
799
1052
|
} catch (error) {
|
|
800
1053
|
restoreStickyState();
|
|
801
1054
|
throw error;
|
|
1055
|
+
} finally {
|
|
1056
|
+
restorePinStickyState();
|
|
802
1057
|
}
|
|
803
1058
|
}
|
|
804
1059
|
#planLayerPositions(viewportHeight, active) {
|
|
@@ -860,11 +1115,16 @@ var StickyScrollTrigger = class {
|
|
|
860
1115
|
});
|
|
861
1116
|
}
|
|
862
1117
|
#syncScrollMargins() {
|
|
863
|
-
this.#scrollMarginSync.sync(this.#
|
|
864
|
-
trigger,
|
|
1118
|
+
this.#scrollMarginSync.sync(this.#sceneLayers().map(({ freezeStart, freezeEnd }) => ({
|
|
865
1119
|
freezeStart,
|
|
866
1120
|
freezeEnd
|
|
867
|
-
})), this.#outermostContainer)
|
|
1121
|
+
})), this.#outermostContainer, (targets) => {
|
|
1122
|
+
if (!targets.length) return [];
|
|
1123
|
+
const restoreStickyState = this.#resetStickyState();
|
|
1124
|
+
const tops = targets.map((target) => documentTop(target));
|
|
1125
|
+
restoreStickyState();
|
|
1126
|
+
return tops;
|
|
1127
|
+
});
|
|
868
1128
|
}
|
|
869
1129
|
#assertNoExcludedVars(rest, context) {
|
|
870
1130
|
const found = EXCLUDED_VAR_KEYS.filter((key) => key in rest);
|
|
@@ -995,23 +1255,27 @@ var StickyScrollTrigger = class {
|
|
|
995
1255
|
}
|
|
996
1256
|
}
|
|
997
1257
|
#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
1258
|
const anchorOffset = resolveAnchorTop(clause, measureUsedHeight(element), viewportHeight);
|
|
1005
|
-
const
|
|
1006
|
-
const
|
|
1007
|
-
|
|
1008
|
-
return
|
|
1259
|
+
const restoreStickyState = this.#resetStickyState();
|
|
1260
|
+
const reachedAt = documentTop(element) - anchorOffset;
|
|
1261
|
+
restoreStickyState();
|
|
1262
|
+
return this.#addDwellBeforeReach(element, reachedAt);
|
|
1263
|
+
}
|
|
1264
|
+
#addDwellBeforeReach(element, reachedAt) {
|
|
1265
|
+
if (!this.#rootElement.contains(element)) return reachedAt;
|
|
1266
|
+
return reachedAt + dwellBeforeReach(reachedAt, this.#sceneLayers());
|
|
1267
|
+
}
|
|
1268
|
+
#sceneLayers() {
|
|
1269
|
+
return this.#layers.filter((layer) => layer.kind === "scene");
|
|
1009
1270
|
}
|
|
1010
1271
|
static getScrollTop(elementInput, instances) {
|
|
1011
1272
|
const element = resolveElement(elementInput, "StickyScrollTrigger.getScrollTop");
|
|
1012
1273
|
const owner = instances.find((instance) => instance.#rootElement.contains(element));
|
|
1013
1274
|
if (owner) return owner.resolveScrollPosition(element, "top top");
|
|
1014
|
-
|
|
1275
|
+
const restores = instances.map((instance) => instance.#resetPinStickyState());
|
|
1276
|
+
const top = documentTop(element);
|
|
1277
|
+
restores.forEach((restore) => restore());
|
|
1278
|
+
return top;
|
|
1015
1279
|
}
|
|
1016
1280
|
createResolvedTrigger({ trigger: triggerInput, start = "top bottom", end = "bottom top", endTrigger: endTriggerInput, ...rest }) {
|
|
1017
1281
|
this.#assertNoExcludedVars(rest, "createResolvedTrigger");
|