sticky-scroll-trigger 0.10.0 → 0.12.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.
- package/README.md +35 -9
- package/dist/StickyScrollTrigger.d.ts +4 -1
- package/dist/StickyScrollTrigger.global.js +836 -175
- package/dist/StickyScrollTrigger.global.min.js +2 -2
- package/dist/StickyScrollTrigger.js +836 -175
- package/dist/StickyScrollTrigger.min.js +2 -2
- package/package.json +12 -12
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
/*!
|
|
2
2
|
* @license
|
|
3
|
-
* StickyScrollTrigger v0.
|
|
3
|
+
* StickyScrollTrigger v0.12.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
|
|
@@ -98,7 +98,12 @@ const restoreInlinePosition = (el, saved) => {
|
|
|
98
98
|
el.style.position = saved.position;
|
|
99
99
|
el.style.top = saved.top;
|
|
100
100
|
};
|
|
101
|
-
const
|
|
101
|
+
const stripStickyPositions = (elements) => {
|
|
102
|
+
const saved = elements.map(captureInlinePosition);
|
|
103
|
+
elements.forEach(resetStickyPosition);
|
|
104
|
+
return () => elements.forEach((el, i) => restoreInlinePosition(el, saved[i]));
|
|
105
|
+
};
|
|
106
|
+
const wrapScene = (inner, holdTrailingMargin) => {
|
|
102
107
|
if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
|
|
103
108
|
const container = document.createElement("div");
|
|
104
109
|
const wrapper = document.createElement("div");
|
|
@@ -109,6 +114,11 @@ const wrapScene = (inner) => {
|
|
|
109
114
|
container.appendChild(wrapper);
|
|
110
115
|
wrapper.appendChild(inner);
|
|
111
116
|
container.appendChild(padding);
|
|
117
|
+
if (holdTrailingMargin) {
|
|
118
|
+
const sentinel = document.createElement("div");
|
|
119
|
+
sentinel.style.display = "flow-root";
|
|
120
|
+
wrapper.appendChild(sentinel);
|
|
121
|
+
}
|
|
112
122
|
return {
|
|
113
123
|
container,
|
|
114
124
|
wrapper,
|
|
@@ -195,6 +205,438 @@ const liftAboveStickyWrapper = (cover) => {
|
|
|
195
205
|
lifted.length = 0;
|
|
196
206
|
};
|
|
197
207
|
};
|
|
208
|
+
const AUTO_MIN_DEPTH = 7;
|
|
209
|
+
const MAX_CHAIN_IN_BAND = 4;
|
|
210
|
+
const BUFFER_FLOOR_PX = 325;
|
|
211
|
+
const BUFFER_STEP_PX = 25;
|
|
212
|
+
const isWebKit = () => typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("font", "-apple-system-body") || typeof navigator !== "undefined" && navigator.vendor === "Apple Computer, Inc." && !/\bjsdom\//.test(navigator.userAgent);
|
|
213
|
+
const mergeIntervals = (intervals) => {
|
|
214
|
+
const sorted = intervals.filter(([a, b]) => b > a).sort((x, y) => x[0] - y[0]);
|
|
215
|
+
const merged = [];
|
|
216
|
+
sorted.forEach(([a, b]) => {
|
|
217
|
+
const last = merged.at(-1);
|
|
218
|
+
if (last && a <= last[1]) last[1] = Math.max(last[1], b);
|
|
219
|
+
else merged.push([a, b]);
|
|
220
|
+
});
|
|
221
|
+
return merged;
|
|
222
|
+
};
|
|
223
|
+
const invertStuckUnion = (union, y, inclusive) => {
|
|
224
|
+
let scroll = y;
|
|
225
|
+
for (const [a, b] of union) if (inclusive ? a <= scroll : a < scroll) scroll += b - a;
|
|
226
|
+
else break;
|
|
227
|
+
return scroll;
|
|
228
|
+
};
|
|
229
|
+
const isTransformed = (style) => [
|
|
230
|
+
style.transform,
|
|
231
|
+
style.translate,
|
|
232
|
+
style.scale,
|
|
233
|
+
style.rotate
|
|
234
|
+
].some((value) => value !== void 0 && value !== "" && value !== "none");
|
|
235
|
+
const hasTransform = (el, memo) => {
|
|
236
|
+
if (!el) return false;
|
|
237
|
+
const known = memo.get(el);
|
|
238
|
+
if (known !== void 0) return known;
|
|
239
|
+
const result = isTransformed(getComputedStyle(el)) || hasTransform(el.parentElement, memo);
|
|
240
|
+
memo.set(el, result);
|
|
241
|
+
return result;
|
|
242
|
+
};
|
|
243
|
+
const scrolls = (style) => ![style.overflowX, style.overflowY].every((v) => v === "visible" || v === "clip");
|
|
244
|
+
const bodyScrolls = () => scrolls(getComputedStyle(document.documentElement)) && scrolls(getComputedStyle(document.body));
|
|
245
|
+
const isInsideScroller = (el, memo) => {
|
|
246
|
+
const node = el.parentElement;
|
|
247
|
+
if (!node || node === document.body || node === document.documentElement) return false;
|
|
248
|
+
const known = memo.get(node);
|
|
249
|
+
if (known !== void 0) return known;
|
|
250
|
+
const style = getComputedStyle(node);
|
|
251
|
+
const result = style.position === "fixed" || scrolls(style) || isInsideScroller(node, memo);
|
|
252
|
+
memo.set(node, result);
|
|
253
|
+
return result;
|
|
254
|
+
};
|
|
255
|
+
const ownedDepth = (owned, demoted) => {
|
|
256
|
+
const levels = new Map();
|
|
257
|
+
const levelsUpFrom = (node) => {
|
|
258
|
+
if (!node) return 0;
|
|
259
|
+
const known = levels.get(node);
|
|
260
|
+
if (known !== void 0) return known;
|
|
261
|
+
const level = (demoted.has(node) || getComputedStyle(node).position === "sticky" ? 1 : 0) + levelsUpFrom(node.parentElement);
|
|
262
|
+
levels.set(node, level);
|
|
263
|
+
return level;
|
|
264
|
+
};
|
|
265
|
+
const scrollerMemo = new Map();
|
|
266
|
+
let depth = 0;
|
|
267
|
+
for (const el of owned) {
|
|
268
|
+
if (!el.isConnected || isInsideScroller(el, scrollerMemo)) continue;
|
|
269
|
+
depth = Math.max(depth, 1 + levelsUpFrom(el.parentElement));
|
|
270
|
+
}
|
|
271
|
+
return depth;
|
|
272
|
+
};
|
|
273
|
+
const SIMPLE_TOP = /^-?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?(px|%)$/i;
|
|
274
|
+
const clients = new Set();
|
|
275
|
+
let records = [];
|
|
276
|
+
let buffer = 0;
|
|
277
|
+
let listening = false;
|
|
278
|
+
let scrollBeforeGsapRefresh = null;
|
|
279
|
+
let gsapPhase = "idle";
|
|
280
|
+
let adoptedMidRefresh = false;
|
|
281
|
+
let scannedThisTask = null;
|
|
282
|
+
const gsapClasses = new Set();
|
|
283
|
+
const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => cls.isRefreshing === true);
|
|
284
|
+
const stateAt = (record, scroll) => {
|
|
285
|
+
if (!record.demotable) return "in";
|
|
286
|
+
if (scroll < record.lo - buffer) return "before";
|
|
287
|
+
return scroll > record.hi + buffer && !record.holdsAfter ? "after" : "in";
|
|
288
|
+
};
|
|
289
|
+
const promote = (record, afterMeasure = false) => {
|
|
290
|
+
const { style } = record.el;
|
|
291
|
+
const demoted = record.state !== "in";
|
|
292
|
+
const positionOurs = afterMeasure && style.position === "static" || demoted && style.position === "relative";
|
|
293
|
+
if (positionOurs) style.position = record.position;
|
|
294
|
+
if (demoted && positionOurs && style.top === record.demotedTop) style.top = record.top;
|
|
295
|
+
if (demoted && record.zIndexAuto && style.zIndex === "0") style.zIndex = record.zIndex;
|
|
296
|
+
if (demoted && record.willChangeAuto && style.willChange === "opacity") style.willChange = record.willChange;
|
|
297
|
+
record.state = "in";
|
|
298
|
+
};
|
|
299
|
+
const applyState = (record, state) => {
|
|
300
|
+
if (record.state === state) return;
|
|
301
|
+
if (state === "in") {
|
|
302
|
+
promote(record);
|
|
303
|
+
return;
|
|
304
|
+
}
|
|
305
|
+
const { style } = record.el;
|
|
306
|
+
style.position = "relative";
|
|
307
|
+
style.top = `${state === "before" ? 0 : record.travel}px`;
|
|
308
|
+
record.demotedTop = style.top;
|
|
309
|
+
if (record.zIndexAuto) style.zIndex = "0";
|
|
310
|
+
if (record.willChangeAuto) style.willChange = "opacity";
|
|
311
|
+
record.state = state;
|
|
312
|
+
};
|
|
313
|
+
const update = (scroll) => {
|
|
314
|
+
records.forEach((record) => applyState(record, stateAt(record, scroll)));
|
|
315
|
+
};
|
|
316
|
+
const onScroll = () => update(window.scrollY);
|
|
317
|
+
const listen = (on) => {
|
|
318
|
+
if (on === listening) return;
|
|
319
|
+
listening = on;
|
|
320
|
+
if (on) window.addEventListener("scroll", onScroll, { passive: true });
|
|
321
|
+
else window.removeEventListener("scroll", onScroll);
|
|
322
|
+
};
|
|
323
|
+
const clearTable = () => {
|
|
324
|
+
records.forEach((record) => promote(record));
|
|
325
|
+
records = [];
|
|
326
|
+
listen(false);
|
|
327
|
+
};
|
|
328
|
+
const restoreAfterGsapMeasure = () => {
|
|
329
|
+
const scroll = scrollBeforeGsapRefresh;
|
|
330
|
+
if (gsapPhase !== "measuring" || scroll === null) return;
|
|
331
|
+
gsapPhase = "restored";
|
|
332
|
+
if (records.length) update(scroll);
|
|
333
|
+
};
|
|
334
|
+
const endGsapRefresh = () => {
|
|
335
|
+
gsapPhase = "idle";
|
|
336
|
+
scrollBeforeGsapRefresh = null;
|
|
337
|
+
adoptedMidRefresh = false;
|
|
338
|
+
};
|
|
339
|
+
const rebuildSafely = () => {
|
|
340
|
+
try {
|
|
341
|
+
rebuildDormancy(null);
|
|
342
|
+
} catch (error) {
|
|
343
|
+
clearTable();
|
|
344
|
+
queueMicrotask(() => {
|
|
345
|
+
throw error;
|
|
346
|
+
});
|
|
347
|
+
}
|
|
348
|
+
};
|
|
349
|
+
const onGsapRefreshDone = () => {
|
|
350
|
+
const wasRefreshing = gsapPhase !== "idle";
|
|
351
|
+
endGsapRefresh();
|
|
352
|
+
if (wasRefreshing && liveClients().length) rebuildSafely();
|
|
353
|
+
};
|
|
354
|
+
const onGsapRefreshInit = () => {
|
|
355
|
+
if (gsapPhase === "idle") {
|
|
356
|
+
gsapPhase = "measuring";
|
|
357
|
+
scrollBeforeGsapRefresh = window.scrollY;
|
|
358
|
+
queueMicrotask(onGsapRefreshDone);
|
|
359
|
+
if (records.length) update(0);
|
|
360
|
+
}
|
|
361
|
+
return { render: restoreAfterGsapMeasure };
|
|
362
|
+
};
|
|
363
|
+
const adoptGsapClass = (cls) => {
|
|
364
|
+
if (gsapClasses.has(cls)) return;
|
|
365
|
+
if (cls.isRefreshing === true) adoptedMidRefresh = true;
|
|
366
|
+
gsapClasses.add(cls);
|
|
367
|
+
cls.addEventListener?.("refresh", onGsapRefreshDone);
|
|
368
|
+
cls.addEventListener?.("refreshInit", onGsapRefreshInit);
|
|
369
|
+
};
|
|
370
|
+
const dropGsapClassesLater = () => {
|
|
371
|
+
if (!gsapClasses.size) return;
|
|
372
|
+
queueMicrotask(() => {
|
|
373
|
+
if (liveClients().length) return;
|
|
374
|
+
gsapClasses.forEach((cls) => {
|
|
375
|
+
cls.removeEventListener?.("refresh", onGsapRefreshDone);
|
|
376
|
+
cls.removeEventListener?.("refreshInit", onGsapRefreshInit);
|
|
377
|
+
});
|
|
378
|
+
gsapClasses.clear();
|
|
379
|
+
});
|
|
380
|
+
};
|
|
381
|
+
const scanStickyElements = (owned) => {
|
|
382
|
+
const scrollerMemo = new Map();
|
|
383
|
+
const isWindowSticky = (el) => el.isConnected && getComputedStyle(el).position === "sticky" && !isInsideScroller(el, scrollerMemo);
|
|
384
|
+
if (scannedThisTask) return Array.from(new Set([
|
|
385
|
+
...scannedThisTask,
|
|
386
|
+
...records.map((r) => r.el),
|
|
387
|
+
...owned
|
|
388
|
+
])).filter(isWindowSticky);
|
|
389
|
+
const found = Array.from(document.querySelectorAll("*")).filter(isWindowSticky);
|
|
390
|
+
scannedThisTask = found;
|
|
391
|
+
queueMicrotask(() => {
|
|
392
|
+
scannedThisTask = null;
|
|
393
|
+
});
|
|
394
|
+
return found;
|
|
395
|
+
};
|
|
396
|
+
const maxChainInBand = (b, maxScroll) => {
|
|
397
|
+
const bands = records.flatMap((r) => {
|
|
398
|
+
const band = r.demotable ? [Math.max(0, r.lo - b), Math.min(maxScroll, r.hi + (r.holdsAfter ? Infinity : b))] : [0, maxScroll];
|
|
399
|
+
return band[1] >= band[0] ? [{
|
|
400
|
+
record: r,
|
|
401
|
+
start: band[0],
|
|
402
|
+
end: band[1]
|
|
403
|
+
}] : [];
|
|
404
|
+
});
|
|
405
|
+
let max = 0;
|
|
406
|
+
new Set([0, ...bands.filter(({ record }) => record.demotable).map(({ start }) => start)]).forEach((scroll) => {
|
|
407
|
+
const inBand = new Set(bands.filter(({ start, end }) => start <= scroll && scroll <= end).map(({ record }) => record));
|
|
408
|
+
inBand.forEach((r) => {
|
|
409
|
+
max = Math.max(max, 1 + r.ancestors.filter((a) => inBand.has(a)).length);
|
|
410
|
+
});
|
|
411
|
+
});
|
|
412
|
+
return max;
|
|
413
|
+
};
|
|
414
|
+
const chooseBuffer = (viewportHeight, maxScroll) => {
|
|
415
|
+
let low = Math.ceil(BUFFER_FLOOR_PX / BUFFER_STEP_PX);
|
|
416
|
+
let high = Math.floor(viewportHeight / BUFFER_STEP_PX);
|
|
417
|
+
if (high < low || maxChainInBand(low * BUFFER_STEP_PX, maxScroll) > MAX_CHAIN_IN_BAND) return BUFFER_FLOOR_PX;
|
|
418
|
+
while (low < high) {
|
|
419
|
+
const mid = Math.ceil((low + high) / 2);
|
|
420
|
+
if (maxChainInBand(mid * BUFFER_STEP_PX, maxScroll) <= MAX_CHAIN_IN_BAND) low = mid;
|
|
421
|
+
else high = mid - 1;
|
|
422
|
+
}
|
|
423
|
+
return low * BUFFER_STEP_PX;
|
|
424
|
+
};
|
|
425
|
+
const liveClients = () => {
|
|
426
|
+
const live = [];
|
|
427
|
+
clients.forEach((ref) => {
|
|
428
|
+
const client = ref.deref();
|
|
429
|
+
if (!client) {
|
|
430
|
+
clients.delete(ref);
|
|
431
|
+
return;
|
|
432
|
+
}
|
|
433
|
+
const owned = client.ownedElements();
|
|
434
|
+
if (owned.some((el) => el.isConnected)) live.push({
|
|
435
|
+
client,
|
|
436
|
+
owned
|
|
437
|
+
});
|
|
438
|
+
});
|
|
439
|
+
return live;
|
|
440
|
+
};
|
|
441
|
+
const measureStatic = (all, owned, unmodeled) => {
|
|
442
|
+
const scroll = window.scrollY;
|
|
443
|
+
const viewportHeight = document.documentElement.clientHeight || window.innerHeight;
|
|
444
|
+
const transformMemo = new Map();
|
|
445
|
+
const documentHeight = measureDocumentHeight();
|
|
446
|
+
all.forEach((record) => {
|
|
447
|
+
const { el } = record;
|
|
448
|
+
const rect = el.getBoundingClientRect();
|
|
449
|
+
const computed = getComputedStyle(el);
|
|
450
|
+
const parent = el.parentElement;
|
|
451
|
+
let containerBottom = rect.bottom + scroll;
|
|
452
|
+
if (parent) {
|
|
453
|
+
const parentStyle = getComputedStyle(parent);
|
|
454
|
+
containerBottom = parent.getBoundingClientRect().bottom + scroll - parseFloat(parentStyle.borderBottomWidth) - parseFloat(parentStyle.paddingBottom);
|
|
455
|
+
if (parentStyle.display === "contents" || parentStyle.display === "inline") unmodeled.add(record);
|
|
456
|
+
}
|
|
457
|
+
record.naturalTop = rect.top + scroll;
|
|
458
|
+
record.travel = Math.max(0, containerBottom - (record.naturalTop + rect.height + parseFloat(computed.marginBottom)));
|
|
459
|
+
record.overflowBottom = record.naturalTop + el.clientTop + el.scrollHeight;
|
|
460
|
+
if (computed.position !== "static" || hasTransform(el, transformMemo)) unmodeled.add(record);
|
|
461
|
+
if (computed.bottom !== "auto" || computed.left !== "auto" || computed.right !== "auto") unmodeled.add(record);
|
|
462
|
+
if (owned.has(el) && (!computed.top.endsWith("px") || Math.abs(parseFloat(computed.top) - parseFloat(el.style.top)) > .01)) unmodeled.add(record);
|
|
463
|
+
if (!owned.has(el) && computed.top === "auto") {
|
|
464
|
+
record.stickyTop = 0;
|
|
465
|
+
record.travel = 0;
|
|
466
|
+
} else if (!owned.has(el)) {
|
|
467
|
+
const unit = SIMPLE_TOP.exec(computed.top)?.[1];
|
|
468
|
+
if (!unit) unmodeled.add(record);
|
|
469
|
+
else if (unit === "%") record.stickyTop = parseFloat(computed.top) * viewportHeight / 100;
|
|
470
|
+
else record.stickyTop = parseFloat(computed.top);
|
|
471
|
+
}
|
|
472
|
+
});
|
|
473
|
+
return {
|
|
474
|
+
scroll,
|
|
475
|
+
viewportHeight,
|
|
476
|
+
documentHeight
|
|
477
|
+
};
|
|
478
|
+
};
|
|
479
|
+
const teardown = () => {
|
|
480
|
+
clearTable();
|
|
481
|
+
endGsapRefresh();
|
|
482
|
+
dropGsapClassesLater();
|
|
483
|
+
};
|
|
484
|
+
const rebuildDormancy = (scrollTriggerClass) => {
|
|
485
|
+
const live = liveClients();
|
|
486
|
+
if (!live.length) {
|
|
487
|
+
teardown();
|
|
488
|
+
return;
|
|
489
|
+
}
|
|
490
|
+
if (scrollTriggerClass) adoptGsapClass(scrollTriggerClass);
|
|
491
|
+
if (!gsapRefreshing()) endGsapRefresh();
|
|
492
|
+
if (!gsapClasses.size || bodyScrolls()) {
|
|
493
|
+
clearTable();
|
|
494
|
+
return;
|
|
495
|
+
}
|
|
496
|
+
const owned = new Map();
|
|
497
|
+
live.forEach(({ client, owned: elements }) => {
|
|
498
|
+
elements.forEach((el) => owned.set(el, client));
|
|
499
|
+
});
|
|
500
|
+
const autoOnly = live.every(({ client }) => client.mode === "auto");
|
|
501
|
+
const demoted = new Set(records.filter((r) => r.state !== "in").map((r) => r.el));
|
|
502
|
+
if (autoOnly && ownedDepth(owned.keys(), demoted) < AUTO_MIN_DEPTH) {
|
|
503
|
+
clearTable();
|
|
504
|
+
return;
|
|
505
|
+
}
|
|
506
|
+
const sticky = scanStickyElements(owned.keys());
|
|
507
|
+
const stickySet = new Set(sticky);
|
|
508
|
+
const leftover = records.filter((r) => r.state !== "in" && !stickySet.has(r.el));
|
|
509
|
+
leftover.filter((r) => !r.el.isConnected).forEach((r) => promote(r));
|
|
510
|
+
const kept = leftover.filter((r) => r.el.isConnected);
|
|
511
|
+
const previous = new Map(records.map((r) => [r.el, r]));
|
|
512
|
+
const found = [...sticky.map((el) => {
|
|
513
|
+
const computed = getComputedStyle(el);
|
|
514
|
+
const before = previous.get(el);
|
|
515
|
+
if (before && before.state !== "in") return {
|
|
516
|
+
...before,
|
|
517
|
+
demotable: false,
|
|
518
|
+
position: el.style.position,
|
|
519
|
+
top: el.style.top,
|
|
520
|
+
stickyTop: parseFloat(el.style.top) || 0,
|
|
521
|
+
ancestors: [],
|
|
522
|
+
state: "before"
|
|
523
|
+
};
|
|
524
|
+
return {
|
|
525
|
+
el,
|
|
526
|
+
demotable: false,
|
|
527
|
+
position: el.style.position,
|
|
528
|
+
top: el.style.top,
|
|
529
|
+
zIndex: el.style.zIndex,
|
|
530
|
+
willChange: el.style.willChange,
|
|
531
|
+
zIndexAuto: computed.zIndex === "auto",
|
|
532
|
+
willChangeAuto: computed.willChange === "auto",
|
|
533
|
+
stickyTop: parseFloat(el.style.top) || 0,
|
|
534
|
+
naturalTop: 0,
|
|
535
|
+
travel: 0,
|
|
536
|
+
ancestors: [],
|
|
537
|
+
lo: 0,
|
|
538
|
+
hi: 0,
|
|
539
|
+
overflowBottom: 0,
|
|
540
|
+
holdsAfter: false,
|
|
541
|
+
state: "in",
|
|
542
|
+
demotedTop: ""
|
|
543
|
+
};
|
|
544
|
+
}), ...kept];
|
|
545
|
+
found.sort((a, b) => compareDocumentOrder(a.el, b.el));
|
|
546
|
+
found.forEach((record, index) => {
|
|
547
|
+
record.ancestors = found.slice(0, index).filter((a) => a.el.contains(record.el));
|
|
548
|
+
});
|
|
549
|
+
const holdsOwned = new Set();
|
|
550
|
+
found.forEach((record) => {
|
|
551
|
+
if (owned.has(record.el)) record.ancestors.forEach((a) => holdsOwned.add(a));
|
|
552
|
+
});
|
|
553
|
+
const all = found.filter((r) => owned.has(r.el) || holdsOwned.has(r) || r.state !== "in" || r.ancestors.some((a) => owned.has(a.el)));
|
|
554
|
+
const inTable = new Set(all);
|
|
555
|
+
all.forEach((record) => {
|
|
556
|
+
record.ancestors = record.ancestors.filter((a) => inTable.has(a));
|
|
557
|
+
});
|
|
558
|
+
const depths = new Map();
|
|
559
|
+
all.forEach((record) => {
|
|
560
|
+
const client = owned.get(record.el);
|
|
561
|
+
if (client) depths.set(client, Math.max(depths.get(client) ?? 0, record.ancestors.length + 1));
|
|
562
|
+
});
|
|
563
|
+
const active = new Set(live.map(({ client }) => client).filter((client) => client.mode === "always" || (depths.get(client) ?? 0) >= AUTO_MIN_DEPTH));
|
|
564
|
+
all.forEach((record) => {
|
|
565
|
+
const client = owned.get(record.el);
|
|
566
|
+
record.demotable = client !== void 0 && active.has(client);
|
|
567
|
+
});
|
|
568
|
+
records = all;
|
|
569
|
+
if (!all.some((r) => r.demotable)) {
|
|
570
|
+
clearTable();
|
|
571
|
+
return;
|
|
572
|
+
}
|
|
573
|
+
const toMeasure = all.filter((r) => owned.has(r.el) || holdsOwned.has(r) || r.state !== "in");
|
|
574
|
+
const authorStyle = new Map(toMeasure.filter((r) => !owned.has(r.el) && r.state === "in").map(({ el }) => [el, el.getAttribute("style")]));
|
|
575
|
+
const restorePositions = () => toMeasure.forEach((record) => {
|
|
576
|
+
if (!authorStyle.has(record.el)) {
|
|
577
|
+
promote(record, true);
|
|
578
|
+
return;
|
|
579
|
+
}
|
|
580
|
+
const saved = authorStyle.get(record.el);
|
|
581
|
+
if (saved === null || saved === void 0) record.el.removeAttribute("style");
|
|
582
|
+
else record.el.setAttribute("style", saved);
|
|
583
|
+
});
|
|
584
|
+
toMeasure.forEach(({ el }) => {
|
|
585
|
+
el.style.position = "static";
|
|
586
|
+
});
|
|
587
|
+
const unmodeled = new Set();
|
|
588
|
+
let measured;
|
|
589
|
+
try {
|
|
590
|
+
measured = measureStatic(toMeasure, owned, unmodeled);
|
|
591
|
+
} finally {
|
|
592
|
+
restorePositions();
|
|
593
|
+
}
|
|
594
|
+
const { scroll, viewportHeight, documentHeight } = measured;
|
|
595
|
+
const maxScroll = Math.max(0, documentHeight - viewportHeight);
|
|
596
|
+
all.forEach((record) => {
|
|
597
|
+
const union = mergeIntervals(record.ancestors.map((a) => [a.lo, a.hi]));
|
|
598
|
+
const reach = record.naturalTop - record.stickyTop;
|
|
599
|
+
record.lo = invertStuckUnion(union, reach, true);
|
|
600
|
+
record.hi = invertStuckUnion(union, reach + record.travel, false);
|
|
601
|
+
if (unmodeled.has(record) || record.ancestors.some((a) => unmodeled.has(a))) record.demotable = false;
|
|
602
|
+
const carried = record.ancestors.filter((a) => a.demotable && !a.holdsAfter).reduce((sum, a) => sum + a.travel, 0);
|
|
603
|
+
record.holdsAfter = record.overflowBottom + record.travel + carried > documentHeight + 1;
|
|
604
|
+
});
|
|
605
|
+
buffer = chooseBuffer(viewportHeight, maxScroll);
|
|
606
|
+
update(gsapPhase === "measuring" ? 0 : (gsapPhase === "restored" ? scrollBeforeGsapRefresh : null) ?? scroll);
|
|
607
|
+
listen(true);
|
|
608
|
+
};
|
|
609
|
+
const takeGsapRefreshRestore = () => adoptedMidRefresh && gsapRefreshing() ? onGsapRefreshInit().render : null;
|
|
610
|
+
const clearDormancy = clearTable;
|
|
611
|
+
const releaseDormant = (elements) => {
|
|
612
|
+
const released = new Set(elements);
|
|
613
|
+
records = records.filter((record) => {
|
|
614
|
+
if (!released.has(record.el)) return true;
|
|
615
|
+
promote(record);
|
|
616
|
+
return false;
|
|
617
|
+
});
|
|
618
|
+
};
|
|
619
|
+
const registerDormancyClient = (client) => {
|
|
620
|
+
clients.add(new WeakRef(client));
|
|
621
|
+
};
|
|
622
|
+
let rebuildQueued = false;
|
|
623
|
+
const queueRebuild = () => {
|
|
624
|
+
if (rebuildQueued) return;
|
|
625
|
+
rebuildQueued = true;
|
|
626
|
+
queueMicrotask(() => {
|
|
627
|
+
rebuildQueued = false;
|
|
628
|
+
rebuildSafely();
|
|
629
|
+
});
|
|
630
|
+
};
|
|
631
|
+
const unregisterDormancyClient = (client) => {
|
|
632
|
+
clients.forEach((ref) => {
|
|
633
|
+
if (ref.deref() !== client) return;
|
|
634
|
+
clients.delete(ref);
|
|
635
|
+
releaseDormant(client.ownedElements());
|
|
636
|
+
});
|
|
637
|
+
if (liveClients().length) queueRebuild();
|
|
638
|
+
else teardown();
|
|
639
|
+
};
|
|
198
640
|
const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
|
|
199
641
|
const KEYWORD_FRACTIONS = {
|
|
200
642
|
top: 0,
|
|
@@ -235,19 +677,20 @@ const assertNotClamped = (trimmed) => {
|
|
|
235
677
|
const inner = trimmed.slice(6).replace(/\)$/, "").trim();
|
|
236
678
|
throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
|
|
237
679
|
};
|
|
238
|
-
const
|
|
680
|
+
const splitClause = (position) => {
|
|
239
681
|
const trimmed = position.trim();
|
|
240
682
|
assertNotClamped(trimmed);
|
|
241
|
-
|
|
242
|
-
return elementHeight * elementClause.fraction + elementClause.offsetPx;
|
|
683
|
+
return trimmed.split(/\s+/);
|
|
243
684
|
};
|
|
685
|
+
const anchorWithin = (token, size) => {
|
|
686
|
+
const { fraction, offsetPx } = parseClauseToken(token, size);
|
|
687
|
+
return size * fraction + offsetPx;
|
|
688
|
+
};
|
|
689
|
+
const resolveElementAnchor = (position, elementHeight) => anchorWithin(splitClause(position)[0], elementHeight);
|
|
244
690
|
const resolveElementFraction = (position) => resolveElementAnchor(position, 1) - resolveElementAnchor(position, 0);
|
|
245
691
|
const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
|
|
246
|
-
const
|
|
247
|
-
|
|
248
|
-
const viewportToken = trimmed.split(/\s+/)[1] ?? "top";
|
|
249
|
-
const viewportClause = parseClauseToken(viewportToken, viewportHeight);
|
|
250
|
-
return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - resolveElementAnchor(trimmed, elementHeight);
|
|
692
|
+
const [elementToken, viewportToken = "top"] = splitClause(position);
|
|
693
|
+
return anchorWithin(viewportToken, viewportHeight) - anchorWithin(elementToken, elementHeight);
|
|
251
694
|
};
|
|
252
695
|
const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
|
|
253
696
|
const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
|
|
@@ -257,9 +700,7 @@ const prefixSpacedRelativeEnd = (start, endResolved) => {
|
|
|
257
700
|
if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
|
|
258
701
|
const startResolved = resolveMaybeFn(start);
|
|
259
702
|
if (typeof startResolved !== "string") return endResolved;
|
|
260
|
-
const
|
|
261
|
-
assertNotClamped(trimmedStart);
|
|
262
|
-
const [elementToken] = trimmedStart.split(/\s+/);
|
|
703
|
+
const [elementToken] = splitClause(startResolved);
|
|
263
704
|
try {
|
|
264
705
|
parseClauseToken(elementToken, 0);
|
|
265
706
|
} catch (error) {
|
|
@@ -308,16 +749,18 @@ const classifyPosition = (resolved) => {
|
|
|
308
749
|
};
|
|
309
750
|
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
751
|
const nestedIn = (measurements, index) => measurements.flatMap(({ triggerEnclosedBy }, k) => k !== index && triggerEnclosedBy.includes(index) ? [k] : []);
|
|
311
|
-
const anchorShare = (measurements,
|
|
752
|
+
const anchorShare = ({ measurements, world, order, ownIndex }, index, freezeStart, box, reachedAt) => {
|
|
753
|
+
const { enclosedBy, anchorElement } = box;
|
|
312
754
|
const measurement = measurements[index];
|
|
313
|
-
if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ?
|
|
755
|
+
if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? world.unpaddedStart(index, ownIndex, freezeStart) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
|
|
314
756
|
if (order && isHeldIn(measurements, index, enclosedBy, anchorElement, order)) return 0;
|
|
315
757
|
if (box.nests.includes(index)) return box.fraction;
|
|
316
758
|
return measurement.triggerTop + measurement.triggerHeight <= box.top + .05 ? 1 : 0;
|
|
317
759
|
};
|
|
318
|
-
const gapsBeforeEndAnchor = (
|
|
760
|
+
const gapsBeforeEndAnchor = (context, windows, box, reachedAt, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
|
|
761
|
+
const { ownIndex, order } = context;
|
|
319
762
|
if (index === ownIndex || order && order.isBefore(ownIndex, index)) return total;
|
|
320
|
-
const weight = anchorShare(
|
|
763
|
+
const weight = anchorShare(context, index, freezeStart, box, reachedAt);
|
|
321
764
|
if (weight === 0) return total;
|
|
322
765
|
counted?.add(index);
|
|
323
766
|
return total + weight * (freezeEnd - freezeStart);
|
|
@@ -352,11 +795,11 @@ const clauseFreezeStart = (measurements, index, paddingOf) => {
|
|
|
352
795
|
}
|
|
353
796
|
throw new Error("StickyScrollTrigger: internal error: clauseFreezeStart was given a layer without a clause start.");
|
|
354
797
|
};
|
|
355
|
-
const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, record) => {
|
|
798
|
+
const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, world, record, previousOnly = false) => {
|
|
356
799
|
const fresh = [];
|
|
357
800
|
const knownWindows = () => measurements.flatMap((measurement, k) => {
|
|
358
801
|
if (measurement.kind !== "scene") return [];
|
|
359
|
-
const plan = fresh[k];
|
|
802
|
+
const plan = previousOnly ? null : fresh[k];
|
|
360
803
|
if (plan) return [{
|
|
361
804
|
index: k,
|
|
362
805
|
freezeStart: plan.freezeStart,
|
|
@@ -370,7 +813,7 @@ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, pre
|
|
|
370
813
|
freezeEnd: freezeStart + paddingHeight
|
|
371
814
|
}];
|
|
372
815
|
});
|
|
373
|
-
const paddingOf = (k) => fresh[k]?.paddingHeight ?? previous?.paddings[k] ?? 0;
|
|
816
|
+
const paddingOf = (k) => (previousOnly ? null : fresh[k]?.paddingHeight) ?? previous?.paddings[k] ?? 0;
|
|
374
817
|
const recounts = [];
|
|
375
818
|
const plans = measurements.map((measurement, index) => {
|
|
376
819
|
fresh[index] = null;
|
|
@@ -381,77 +824,86 @@ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, pre
|
|
|
381
824
|
runs: []
|
|
382
825
|
};
|
|
383
826
|
recounts.push(recount);
|
|
827
|
+
const context = {
|
|
828
|
+
measurements,
|
|
829
|
+
world,
|
|
830
|
+
order,
|
|
831
|
+
ownIndex: index
|
|
832
|
+
};
|
|
833
|
+
const gapsOf = (box, reachedAt) => {
|
|
834
|
+
const gaps = (w, counted) => gapsBeforeEndAnchor(context, w, box, reachedAt, counted);
|
|
835
|
+
recount.runs.push((w) => gaps(w, recount.counted));
|
|
836
|
+
return gaps(knownWindows());
|
|
837
|
+
};
|
|
384
838
|
const { start } = measurement;
|
|
385
|
-
const freezeStart = start.mode === "absolute" ? start.value : clauseFreezeStart(measurements, index, paddingOf);
|
|
839
|
+
const freezeStart = start.mode === "absolute" ? start.value : previous?.freezeStarts[index] ?? clauseFreezeStart(measurements, index, paddingOf);
|
|
840
|
+
const heldBack = (k) => order !== null && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order));
|
|
841
|
+
const selfClauseEnd = (end, anchorOffsetEnd) => {
|
|
842
|
+
const nests = nestedIn(measurements, index);
|
|
843
|
+
const weight = resolveElementFraction(end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
|
|
844
|
+
const dwellInside = measurements.reduce((total, other, k) => {
|
|
845
|
+
if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || heldBack(k)) return total;
|
|
846
|
+
recount.counted.add(k);
|
|
847
|
+
return total + weight * paddingOf(k);
|
|
848
|
+
}, 0);
|
|
849
|
+
if (start.mode === "clause") return freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
|
|
850
|
+
const dwellAbove = measurements.reduce((total, other, k) => {
|
|
851
|
+
if (k === index || other.kind !== "scene" || nests.includes(k) || other.triggerTop + other.triggerHeight > measurement.triggerTop + .05 || heldBack(k)) return total;
|
|
852
|
+
recount.counted.add(k);
|
|
853
|
+
return total + paddingOf(k);
|
|
854
|
+
}, 0);
|
|
855
|
+
return Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
|
|
856
|
+
};
|
|
857
|
+
const elementClauseEnd = (end, anchorOffsetEnd) => {
|
|
858
|
+
let endTop;
|
|
859
|
+
if (end.measureLive) endTop = measureLiveEndTriggerTop(index);
|
|
860
|
+
else {
|
|
861
|
+
const rawTop = measurement.endTrigger.index === null ? end.rawTop : measurements[measurement.endTrigger.index].triggerTop;
|
|
862
|
+
if (rawTop === null) endTop = 0;
|
|
863
|
+
else {
|
|
864
|
+
const box = {
|
|
865
|
+
top: rawTop,
|
|
866
|
+
fraction: resolveElementFraction(end.clause),
|
|
867
|
+
nests: measurement.endTrigger.nests,
|
|
868
|
+
enclosedBy: measurement.endTrigger.enclosedBy,
|
|
869
|
+
anchorElement: measurement.endTrigger.index
|
|
870
|
+
};
|
|
871
|
+
endTop = rawTop + gapsOf(box, rawTop - anchorOffsetEnd);
|
|
872
|
+
}
|
|
873
|
+
}
|
|
874
|
+
let layoutStart;
|
|
875
|
+
if (start.mode === "absolute") layoutStart = start.value;
|
|
876
|
+
else layoutStart = measurement.triggerTop - start.anchorOffset + gapsOf({
|
|
877
|
+
top: measurement.triggerTop,
|
|
878
|
+
fraction: start.elementFraction,
|
|
879
|
+
nests: nestedIn(measurements, index),
|
|
880
|
+
enclosedBy: measurement.triggerEnclosedBy,
|
|
881
|
+
anchorElement: index
|
|
882
|
+
}, measurement.triggerTop - start.anchorOffset);
|
|
883
|
+
return freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
|
|
884
|
+
};
|
|
386
885
|
let freezeEnd;
|
|
387
886
|
switch (measurement.end.mode) {
|
|
388
887
|
case "dwell":
|
|
389
888
|
freezeEnd = freezeStart + measurement.end.distancePx;
|
|
390
889
|
break;
|
|
391
|
-
case "absolute":
|
|
392
|
-
|
|
890
|
+
case "absolute": {
|
|
891
|
+
const length = world.absoluteEndLength(index);
|
|
892
|
+
freezeEnd = length === null ? Math.max(freezeStart, measurement.end.value) : freezeStart + length;
|
|
393
893
|
break;
|
|
894
|
+
}
|
|
394
895
|
case "auto":
|
|
395
896
|
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
897
|
case "clause": {
|
|
397
|
-
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.
|
|
398
|
-
|
|
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);
|
|
898
|
+
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
|
|
899
|
+
freezeEnd = measurement.endTrigger.isSelf ? selfClauseEnd(measurement.end, anchorOffsetEnd) : elementClauseEnd(measurement.end, anchorOffsetEnd);
|
|
446
900
|
break;
|
|
447
901
|
}
|
|
448
902
|
}
|
|
449
|
-
const paddingHeight = Math.max(0, freezeEnd - freezeStart);
|
|
450
903
|
const plan = {
|
|
451
904
|
freezeStart,
|
|
452
905
|
freezeEnd,
|
|
453
|
-
|
|
454
|
-
paddingHeight
|
|
906
|
+
paddingHeight: Math.max(0, freezeEnd - freezeStart)
|
|
455
907
|
};
|
|
456
908
|
fresh[index] = plan;
|
|
457
909
|
return plan;
|
|
@@ -486,15 +938,17 @@ const planCover = (measurements, index, windows, { viewportHeight, documentMaxSc
|
|
|
486
938
|
freezeEnd = documentMaxScroll + measurement.end.offsetPx;
|
|
487
939
|
break;
|
|
488
940
|
case "clause": {
|
|
489
|
-
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.
|
|
941
|
+
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
|
|
490
942
|
if (measurement.end.measureLive) freezeEnd = measureLiveEndTriggerTop(index) - anchorOffsetEnd;
|
|
491
|
-
else freezeEnd = reached((measurement.
|
|
943
|
+
else freezeEnd = reached((measurement.endTrigger.isSelf ? measurement.triggerTop : measurement.endTrigger.index === null ? measurement.end.rawTop ?? 0 : measurements[measurement.endTrigger.index].triggerTop) - anchorOffsetEnd);
|
|
492
944
|
break;
|
|
493
945
|
}
|
|
494
946
|
}
|
|
495
947
|
return {
|
|
496
948
|
freezeStart,
|
|
497
949
|
freezeEnd: Math.max(freezeStart, freezeEnd),
|
|
950
|
+
engagedStart: freezeStart,
|
|
951
|
+
engagedEnd: Math.max(freezeStart, freezeEnd),
|
|
498
952
|
stickyTop: measurement.start.anchorOffset - (measurement.triggerTop - measurement.wrapperTop),
|
|
499
953
|
paddingHeight: null
|
|
500
954
|
};
|
|
@@ -549,8 +1003,67 @@ const fallbackOrder = (measurements, counted) => {
|
|
|
549
1003
|
});
|
|
550
1004
|
return { isBefore: (a, b) => rank[a] < rank[b] };
|
|
551
1005
|
};
|
|
1006
|
+
const hasCycle = (scenes, edges) => {
|
|
1007
|
+
const component = componentsOf(edges);
|
|
1008
|
+
return new Set(scenes.map((k) => component[k])).size < scenes.length;
|
|
1009
|
+
};
|
|
1010
|
+
const refreshOrderEdges = (measurements, lengths, edges) => {
|
|
1011
|
+
const before = measurements.map(() => []);
|
|
1012
|
+
edges.forEach((movers, i) => {
|
|
1013
|
+
const measurement = measurements[i];
|
|
1014
|
+
const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.endTrigger.isSelf ? measurement.endTrigger.enclosedBy : measurement.triggerEnclosedBy).filter((m) => m !== measurement.endTrigger.index);
|
|
1015
|
+
movers.forEach((k) => {
|
|
1016
|
+
if (lengths[k] <= .05) return;
|
|
1017
|
+
before[i].push(k);
|
|
1018
|
+
measurements[k].triggerEnclosedBy.forEach((m) => {
|
|
1019
|
+
if (m !== k && m !== i && measurements[m].kind === "scene" && !enclosingAnchor.includes(m)) before[m].push(k);
|
|
1020
|
+
});
|
|
1021
|
+
});
|
|
1022
|
+
});
|
|
1023
|
+
return before;
|
|
1024
|
+
};
|
|
1025
|
+
const placeWindows = (measurements, scenes, lengths, atWrittenEnd) => {
|
|
1026
|
+
const rest = new Set(scenes);
|
|
1027
|
+
const reported = [];
|
|
1028
|
+
const engaged = [];
|
|
1029
|
+
let consumed = 0;
|
|
1030
|
+
let frozenUntil = -Infinity;
|
|
1031
|
+
while (rest.size) {
|
|
1032
|
+
let next = -1;
|
|
1033
|
+
let opensAt = 0;
|
|
1034
|
+
let nextIsAbsolute = false;
|
|
1035
|
+
let nextReach = 0;
|
|
1036
|
+
for (const k of rest) {
|
|
1037
|
+
const { start, triggerTop } = measurements[k];
|
|
1038
|
+
const isAbsolute = start.mode === "absolute";
|
|
1039
|
+
const reach = start.mode === "clause" ? triggerTop - start.anchorOffset : 0;
|
|
1040
|
+
const at = start.mode === "absolute" ? start.value : reach + consumed;
|
|
1041
|
+
const tied = Math.abs(at - opensAt) <= TIE_TOLERANCE_PX;
|
|
1042
|
+
if (next === -1 || at < opensAt - .05 || tied && (isAbsolute ? !nextIsAbsolute || at < opensAt : !nextIsAbsolute && reach < nextReach - .05)) {
|
|
1043
|
+
next = k;
|
|
1044
|
+
opensAt = at;
|
|
1045
|
+
nextIsAbsolute = isAbsolute;
|
|
1046
|
+
nextReach = reach;
|
|
1047
|
+
}
|
|
1048
|
+
}
|
|
1049
|
+
const { end } = measurements[next];
|
|
1050
|
+
const reportedEnd = end.mode === "absolute" && atWrittenEnd(next) ? Math.max(opensAt, end.value) : opensAt + lengths[next];
|
|
1051
|
+
const engagedStart = Math.max(opensAt, frozenUntil);
|
|
1052
|
+
const engagedEnd = Math.max(engagedStart, reportedEnd);
|
|
1053
|
+
rest.delete(next);
|
|
1054
|
+
reported[next] = [opensAt, reportedEnd];
|
|
1055
|
+
engaged[next] = [engagedStart, engagedEnd];
|
|
1056
|
+
consumed += engagedEnd - engagedStart;
|
|
1057
|
+
frozenUntil = Math.max(frozenUntil, engagedEnd);
|
|
1058
|
+
}
|
|
1059
|
+
return {
|
|
1060
|
+
reported,
|
|
1061
|
+
engaged
|
|
1062
|
+
};
|
|
1063
|
+
};
|
|
552
1064
|
const planLayers = (measurements, deps) => {
|
|
553
|
-
const
|
|
1065
|
+
const scenes = measurements.flatMap(({ kind }, k) => kind === "scene" ? [k] : []);
|
|
1066
|
+
const needsConvergence = scenes.length > 1;
|
|
554
1067
|
const liveTopCache = new Map();
|
|
555
1068
|
const passDeps = {
|
|
556
1069
|
...deps,
|
|
@@ -562,47 +1075,153 @@ const planLayers = (measurements, deps) => {
|
|
|
562
1075
|
return value;
|
|
563
1076
|
}
|
|
564
1077
|
};
|
|
565
|
-
const stateOf = (passPlans) => ({
|
|
566
|
-
paddings: passPlans.map((plan) => plan?.paddingHeight ?? null),
|
|
567
|
-
freezeStarts: passPlans.map((plan) => plan?.freezeStart ?? null)
|
|
568
|
-
});
|
|
569
1078
|
const sameValues = (a, b) => a.every((value, i) => value === b[i] || value !== null && b[i] !== null && Math.abs(value - b[i]) <= .05);
|
|
570
1079
|
const sameState = (a, b) => sameValues(a.paddings, b.paddings) && sameValues(a.freezeStarts, b.freezeStarts);
|
|
571
|
-
const
|
|
572
|
-
const
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
1080
|
+
const lengthsOf = (windows) => windows.map((window) => window ? Math.max(0, window.freezeEnd - window.freezeStart) : 0);
|
|
1081
|
+
const stateAt = (lengths, reported) => ({
|
|
1082
|
+
paddings: measurements.map(({ kind }, k) => kind === "scene" ? lengths[k] : null),
|
|
1083
|
+
freezeStarts: measurements.map(({ kind }, k) => kind === "scene" ? reported[k][0] : null)
|
|
1084
|
+
});
|
|
1085
|
+
const mix = (states, weights) => {
|
|
1086
|
+
const of = (pick) => pick(states[0]).map((value, k) => value === null ? null : states.reduce((sum, state, j) => sum + weights[j] * pick(state)[k], 0));
|
|
1087
|
+
return {
|
|
1088
|
+
paddings: of((state) => state.paddings),
|
|
1089
|
+
freezeStarts: of((state) => state.freezeStarts)
|
|
1090
|
+
};
|
|
1091
|
+
};
|
|
1092
|
+
let world = null;
|
|
1093
|
+
const place = (lengths, order, reading) => {
|
|
1094
|
+
const placed = placeWindows(measurements, scenes, lengths, () => reading.endsAsRefreshed);
|
|
1095
|
+
world = {
|
|
1096
|
+
lengths,
|
|
1097
|
+
order,
|
|
1098
|
+
reported: placed.reported,
|
|
1099
|
+
refreshTime: []
|
|
1100
|
+
};
|
|
1101
|
+
return placed;
|
|
1102
|
+
};
|
|
1103
|
+
const refreshTimeOf = (own) => {
|
|
1104
|
+
if (world === null) return null;
|
|
1105
|
+
const { lengths, order, refreshTime } = world;
|
|
1106
|
+
const absent = (k) => k === own || order !== null && !order.isBefore(k, own);
|
|
1107
|
+
refreshTime[own] ??= placeWindows(measurements, scenes, lengths.map((length, k) => absent(k) ? 0 : length), (k) => !absent(k)).reported;
|
|
1108
|
+
return refreshTime[own];
|
|
1109
|
+
};
|
|
1110
|
+
const passWorld = (order, reading) => ({
|
|
1111
|
+
unpaddedStart: (index, ownIndex, freezeStart) => {
|
|
1112
|
+
const windows = (reading.startsAsRefreshed ? refreshTimeOf(ownIndex) : null) ?? world?.reported ?? [];
|
|
1113
|
+
const spans = scenes.flatMap((k) => {
|
|
1114
|
+
if (k === index || k === ownIndex || !windows[k]) return [];
|
|
1115
|
+
if (order && !order.isBefore(k, ownIndex)) return [];
|
|
1116
|
+
const [from, to] = windows[k];
|
|
1117
|
+
return Math.min(to, freezeStart) > from ? [[from, Math.min(to, freezeStart)]] : [];
|
|
1118
|
+
}).sort((a, b) => a[0] - b[0]);
|
|
1119
|
+
let frozen = 0;
|
|
1120
|
+
let frozenUntil = -Infinity;
|
|
1121
|
+
for (const [from, to] of spans) {
|
|
1122
|
+
const lo = Math.max(from, frozenUntil);
|
|
1123
|
+
if (to > lo) frozen += to - lo;
|
|
1124
|
+
frozenUntil = Math.max(frozenUntil, to);
|
|
1125
|
+
}
|
|
1126
|
+
return freezeStart - frozen;
|
|
1127
|
+
},
|
|
1128
|
+
absoluteEndLength: (index) => {
|
|
1129
|
+
const { end } = measurements[index];
|
|
1130
|
+
if (!reading.endsAsRefreshed || end.mode !== "absolute" || world === null) return null;
|
|
1131
|
+
const windows = world.order === null ? world.reported : refreshTimeOf(index);
|
|
1132
|
+
return Math.max(0, end.value - windows[index][0]);
|
|
1133
|
+
}
|
|
1134
|
+
});
|
|
1135
|
+
const solve = (order, reading, cap, record = null, cycle = 2, damping = 1) => {
|
|
1136
|
+
const reads = passWorld(order, reading);
|
|
1137
|
+
const fed = [];
|
|
1138
|
+
let previous = null;
|
|
1139
|
+
for (let pass = 0; pass < cap; pass += 1) {
|
|
1140
|
+
const lengths = lengthsOf(runPass(measurements, passDeps, previous, order, reads, record));
|
|
1141
|
+
const placed = place(lengths, order, reading);
|
|
1142
|
+
const next = stateAt(lengths, placed.reported);
|
|
1143
|
+
if (!needsConvergence || previous !== null && sameState(next, previous)) return {
|
|
1144
|
+
lengths,
|
|
1145
|
+
...placed
|
|
1146
|
+
};
|
|
1147
|
+
let feed = next;
|
|
1148
|
+
if (previous !== null) {
|
|
1149
|
+
fed.push(previous);
|
|
1150
|
+
let back = -1;
|
|
1151
|
+
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;
|
|
1152
|
+
if (back !== -1) {
|
|
1153
|
+
const states = [...fed.slice(fed.length - back - 1), next];
|
|
1154
|
+
feed = mix(states, states.map(() => 1 / states.length));
|
|
1155
|
+
} else if (damping < 1) feed = mix([next, previous], [damping, 1 - damping]);
|
|
1156
|
+
}
|
|
1157
|
+
previous = feed;
|
|
588
1158
|
}
|
|
589
1159
|
return null;
|
|
590
1160
|
};
|
|
1161
|
+
const activeEdges = (lengths, reading) => {
|
|
1162
|
+
const reads = passWorld(null, reading);
|
|
1163
|
+
const respond = (from) => {
|
|
1164
|
+
const { reported } = place(from, null, reading);
|
|
1165
|
+
return lengthsOf(runPass(measurements, passDeps, stateAt(from, reported), null, reads, null, true));
|
|
1166
|
+
};
|
|
1167
|
+
const base = respond(lengths);
|
|
1168
|
+
const edges = measurements.map(() => []);
|
|
1169
|
+
scenes.forEach((k) => {
|
|
1170
|
+
const nudged = lengths.slice();
|
|
1171
|
+
nudged[k] += 2 ** -7;
|
|
1172
|
+
respond(nudged).forEach((length, i) => {
|
|
1173
|
+
if (i !== k && Math.abs(length - base[i]) > 1e-6) edges[i].push(k);
|
|
1174
|
+
});
|
|
1175
|
+
});
|
|
1176
|
+
return edges;
|
|
1177
|
+
};
|
|
1178
|
+
const unsettled = (solved) => solved === null || solved.reported.some((window) => window.some((point) => !(Math.abs(point) <= 2 ** 48)));
|
|
591
1179
|
const counted = measurements.map(() => new Set());
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
1180
|
+
const everySpacer = {
|
|
1181
|
+
endsAsRefreshed: true,
|
|
1182
|
+
startsAsRefreshed: false
|
|
1183
|
+
};
|
|
1184
|
+
let solved = solve(null, everySpacer, Math.max(64, 2 * measurements.length + 2), (index, layers) => layers.forEach((k) => counted[index].add(k)));
|
|
1185
|
+
const fallback = () => {
|
|
1186
|
+
if (unsettled(solved)) return fallbackOrder(measurements, counted);
|
|
1187
|
+
if (!needsConvergence) return null;
|
|
1188
|
+
const edges = activeEdges(solved.lengths, everySpacer);
|
|
1189
|
+
if (hasCycle(scenes, edges)) return fallbackOrder(measurements, counted);
|
|
1190
|
+
return hasCycle(scenes, refreshOrderEdges(measurements, solved.lengths, edges)) ? { isBefore: (a, b) => a < b } : null;
|
|
1191
|
+
};
|
|
1192
|
+
const order = fallback();
|
|
1193
|
+
if (order) {
|
|
1194
|
+
const asReported = {
|
|
1195
|
+
endsAsRefreshed: false,
|
|
1196
|
+
startsAsRefreshed: false
|
|
1197
|
+
};
|
|
1198
|
+
solved = solve(order, asReported, 2 * measurements.length + 2);
|
|
1199
|
+
if (unsettled(solved)) solved = solve(order, asReported, Math.max(64, 2 * measurements.length + 2), null, 4, .5);
|
|
1200
|
+
if (unsettled(solved)) solved = solve(order, {
|
|
1201
|
+
endsAsRefreshed: true,
|
|
1202
|
+
startsAsRefreshed: true
|
|
1203
|
+
}, 2 * measurements.length + 2);
|
|
1204
|
+
}
|
|
1205
|
+
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.");
|
|
1206
|
+
const { reported, engaged } = solved;
|
|
1207
|
+
const scenePlans = measurements.map(({ kind }, index) => {
|
|
1208
|
+
if (kind !== "scene") return null;
|
|
1209
|
+
const [engagedStart, engagedEnd] = engaged[index];
|
|
1210
|
+
const outerDwell = scenes.reduce((total, k) => k > index && engaged[k][1] <= engagedStart + .05 ? total + (engaged[k][1] - engaged[k][0]) : total, 0);
|
|
599
1211
|
return {
|
|
600
|
-
|
|
601
|
-
|
|
1212
|
+
freezeStart: reported[index][0],
|
|
1213
|
+
freezeEnd: reported[index][1],
|
|
1214
|
+
engagedStart,
|
|
1215
|
+
engagedEnd,
|
|
1216
|
+
stickyTop: deps.structureTop - (engagedStart - outerDwell),
|
|
1217
|
+
paddingHeight: engagedEnd - engagedStart
|
|
602
1218
|
};
|
|
603
1219
|
});
|
|
604
|
-
const windows =
|
|
605
|
-
|
|
1220
|
+
const windows = scenes.map((k) => ({
|
|
1221
|
+
freezeStart: engaged[k][0],
|
|
1222
|
+
freezeEnd: engaged[k][1]
|
|
1223
|
+
}));
|
|
1224
|
+
const finalPlans = scenePlans.map((plan, index) => plan ?? planCover(measurements, index, windows, passDeps));
|
|
606
1225
|
finalPlans.forEach((plan, index) => deps.onPlanned(index, plan));
|
|
607
1226
|
return finalPlans;
|
|
608
1227
|
};
|
|
@@ -649,7 +1268,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
649
1268
|
const snapshot = snapshots.get(target);
|
|
650
1269
|
target.style.scrollMarginTop = snapshot ? snapshot.inline : "";
|
|
651
1270
|
};
|
|
652
|
-
const
|
|
1271
|
+
const stopRamps = () => {
|
|
653
1272
|
if (sheet) {
|
|
654
1273
|
document.adoptedStyleSheets = document.adoptedStyleSheets.filter((one) => one !== sheet);
|
|
655
1274
|
sheet = null;
|
|
@@ -659,31 +1278,37 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
659
1278
|
jsRamps = [];
|
|
660
1279
|
jsHost = null;
|
|
661
1280
|
};
|
|
1281
|
+
const startRamps = (ramps, host) => {
|
|
1282
|
+
if (animationHost !== host) {
|
|
1283
|
+
animationHost?.removeAttribute(`data-${instanceId}`);
|
|
1284
|
+
animationHost = host;
|
|
1285
|
+
animationHost.setAttribute(`data-${instanceId}`, "");
|
|
1286
|
+
}
|
|
1287
|
+
if (usesJsRamp) {
|
|
1288
|
+
jsRamps = ramps;
|
|
1289
|
+
jsHost = host;
|
|
1290
|
+
applyJsRamp();
|
|
1291
|
+
return;
|
|
1292
|
+
}
|
|
1293
|
+
if (!sheet) {
|
|
1294
|
+
sheet = new CSSStyleSheet();
|
|
1295
|
+
document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
|
|
1296
|
+
}
|
|
1297
|
+
sheet.replaceSync(buildStylesheet(instanceId, ramps));
|
|
1298
|
+
};
|
|
1299
|
+
const release = () => {
|
|
1300
|
+
written.forEach(restoreTarget);
|
|
1301
|
+
written = new Set();
|
|
1302
|
+
stopRamps();
|
|
1303
|
+
};
|
|
662
1304
|
return {
|
|
663
1305
|
sync(scenes, host, measureNaturalTops) {
|
|
664
1306
|
const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
|
|
665
1307
|
if (targetSelector === null || !ramps.length || !host) {
|
|
666
|
-
|
|
667
|
-
written = new Set();
|
|
668
|
-
clearAnimation();
|
|
1308
|
+
release();
|
|
669
1309
|
return;
|
|
670
1310
|
}
|
|
671
|
-
|
|
672
|
-
animationHost?.removeAttribute(`data-${instanceId}`);
|
|
673
|
-
animationHost = host;
|
|
674
|
-
animationHost.setAttribute(`data-${instanceId}`, "");
|
|
675
|
-
}
|
|
676
|
-
if (usesJsRamp) {
|
|
677
|
-
jsRamps = ramps;
|
|
678
|
-
jsHost = host;
|
|
679
|
-
applyJsRamp();
|
|
680
|
-
} else {
|
|
681
|
-
if (!sheet) {
|
|
682
|
-
sheet = new CSSStyleSheet();
|
|
683
|
-
document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
|
|
684
|
-
}
|
|
685
|
-
sheet.replaceSync(buildStylesheet(instanceId, ramps));
|
|
686
|
-
}
|
|
1311
|
+
startRamps(ramps, host);
|
|
687
1312
|
const targets = Array.from(rootElement.querySelectorAll(targetSelector));
|
|
688
1313
|
const naturalTops = measureNaturalTops(targets);
|
|
689
1314
|
targets.forEach((target) => {
|
|
@@ -710,9 +1335,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
710
1335
|
},
|
|
711
1336
|
restore() {
|
|
712
1337
|
if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
|
|
713
|
-
|
|
714
|
-
written = new Set();
|
|
715
|
-
clearAnimation();
|
|
1338
|
+
release();
|
|
716
1339
|
}
|
|
717
1340
|
};
|
|
718
1341
|
};
|
|
@@ -730,7 +1353,7 @@ const buildStructure = (rootElement, layers) => {
|
|
|
730
1353
|
let outermost = null;
|
|
731
1354
|
for (const layer of layers) {
|
|
732
1355
|
if (layer.kind !== "scene") continue;
|
|
733
|
-
const wrapped = wrapScene(inner);
|
|
1356
|
+
const wrapped = wrapScene(inner, inner === rootElement);
|
|
734
1357
|
layer.container = wrapped.container;
|
|
735
1358
|
layer.wrapper = wrapped.wrapper;
|
|
736
1359
|
layer.padding = wrapped.padding;
|
|
@@ -811,23 +1434,27 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
|
|
|
811
1434
|
const endResolved = layer.end === null ? null : prefixSpacedRelativeEnd(startResolved, resolveMaybeFn(layer.end));
|
|
812
1435
|
const elementHeight = measureUsedHeight(layer.trigger);
|
|
813
1436
|
const endTriggerIsSelf = layer.endTrigger === layer.trigger;
|
|
1437
|
+
const indicesWhere = (test) => [...indexByTrigger].filter(([trigger]) => test(trigger)).map(([, index]) => index);
|
|
814
1438
|
const endTriggerIndex = indexByTrigger.get(layer.endTrigger) ?? null;
|
|
815
1439
|
const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
|
|
1440
|
+
const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
|
|
816
1441
|
const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
|
|
817
1442
|
return {
|
|
818
1443
|
kind: layer.kind,
|
|
819
1444
|
start,
|
|
820
1445
|
triggerTop: documentTop(layer.trigger),
|
|
821
1446
|
triggerHeight: elementHeight,
|
|
822
|
-
triggerEnclosedBy:
|
|
1447
|
+
triggerEnclosedBy: indicesWhere((trigger) => trigger.contains(layer.trigger)),
|
|
823
1448
|
wrapperTop: layer.wrapper ? documentTop(layer.wrapper) : 0,
|
|
824
1449
|
coverTop: layer.kind === "cover" ? documentTop(layer.cover) : 0,
|
|
825
1450
|
end,
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
1451
|
+
endTrigger: {
|
|
1452
|
+
isSelf: endTriggerIsSelf,
|
|
1453
|
+
index: endTriggerIndex,
|
|
1454
|
+
height: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
|
|
1455
|
+
enclosedBy: endTriggerInContainer ? indicesWhere((trigger) => trigger.contains(layer.endTrigger)) : [],
|
|
1456
|
+
nests: endTriggerInContainer ? indicesWhere((other) => other !== layer.endTrigger && layer.endTrigger.contains(other)) : []
|
|
1457
|
+
}
|
|
831
1458
|
};
|
|
832
1459
|
};
|
|
833
1460
|
const EXCLUDED_VAR_KEYS = [
|
|
@@ -860,6 +1487,10 @@ const resolvePinReleaseScroll = (endTrigger, classifiedEnd, engageScroll, viewpo
|
|
|
860
1487
|
case "clause": return toScroll(endTrigger, documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight));
|
|
861
1488
|
}
|
|
862
1489
|
};
|
|
1490
|
+
const removeItem = (list, item) => {
|
|
1491
|
+
const index = list.indexOf(item);
|
|
1492
|
+
if (index !== -1) list.splice(index, 1);
|
|
1493
|
+
};
|
|
863
1494
|
const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
|
|
864
1495
|
var StickyScrollTrigger = class {
|
|
865
1496
|
#rootElement;
|
|
@@ -874,6 +1505,7 @@ var StickyScrollTrigger = class {
|
|
|
874
1505
|
#scrollTriggerClass = null;
|
|
875
1506
|
#pinLayers = [];
|
|
876
1507
|
#scrollMarginSync;
|
|
1508
|
+
#dormancyClient = null;
|
|
877
1509
|
constructor(root, options = {}) {
|
|
878
1510
|
this.#rootElement = resolveRoot(root);
|
|
879
1511
|
const scrollMarginTargets = options.scrollMarginTargets === void 0 ? "[id]" : options.scrollMarginTargets;
|
|
@@ -882,7 +1514,26 @@ var StickyScrollTrigger = class {
|
|
|
882
1514
|
} catch {
|
|
883
1515
|
throw new Error(`StickyScrollTrigger: scrollMarginTargets "${scrollMarginTargets}" is not a valid CSS selector.`);
|
|
884
1516
|
}
|
|
1517
|
+
const optimization = options.nestedStickyOptimization === void 0 ? "auto" : options.nestedStickyOptimization;
|
|
1518
|
+
if (![
|
|
1519
|
+
"auto",
|
|
1520
|
+
"always",
|
|
1521
|
+
"off"
|
|
1522
|
+
].includes(optimization)) throw new Error(`StickyScrollTrigger: nestedStickyOptimization must be 'auto', 'always' or 'off', got ${String(optimization)}.`);
|
|
885
1523
|
this.#scrollMarginSync = createScrollMarginSync(this.#rootElement, scrollMarginTargets);
|
|
1524
|
+
if (optimization === "always" || optimization === "auto" && isWebKit()) {
|
|
1525
|
+
this.#dormancyClient = {
|
|
1526
|
+
mode: optimization,
|
|
1527
|
+
ownedElements: () => this.#ownedStickyElements()
|
|
1528
|
+
};
|
|
1529
|
+
registerDormancyClient(this.#dormancyClient);
|
|
1530
|
+
}
|
|
1531
|
+
}
|
|
1532
|
+
#ownedStickyElements() {
|
|
1533
|
+
return [...this.#builtLayers.flatMap((layer) => layer.wrapper ? [layer.wrapper] : []), ...this.#wrappedPinTriggers()];
|
|
1534
|
+
}
|
|
1535
|
+
#wrappedPinTriggers() {
|
|
1536
|
+
return this.#pinLayers.flatMap(({ trigger, inner }) => inner ? [trigger] : []);
|
|
886
1537
|
}
|
|
887
1538
|
#unbuild() {
|
|
888
1539
|
if (!this.#built) return;
|
|
@@ -921,7 +1572,12 @@ var StickyScrollTrigger = class {
|
|
|
921
1572
|
throw error;
|
|
922
1573
|
});
|
|
923
1574
|
}
|
|
924
|
-
|
|
1575
|
+
const restoreDormancy = takeGsapRefreshRestore();
|
|
1576
|
+
if (!restoreDormancy) return result;
|
|
1577
|
+
return { render: (time) => {
|
|
1578
|
+
result?.render?.(time);
|
|
1579
|
+
restoreDormancy();
|
|
1580
|
+
} };
|
|
925
1581
|
};
|
|
926
1582
|
}
|
|
927
1583
|
#wrapUnwrappedPins() {
|
|
@@ -953,34 +1609,17 @@ var StickyScrollTrigger = class {
|
|
|
953
1609
|
}
|
|
954
1610
|
#unwrapPinLayer(layer) {
|
|
955
1611
|
if (!layer.outer) return false;
|
|
1612
|
+
releaseDormant([layer.trigger]);
|
|
956
1613
|
unwrapPin(layer.outer, layer.trigger, layer.savedPosition);
|
|
957
1614
|
layer.outer = null;
|
|
958
1615
|
layer.inner = null;
|
|
959
1616
|
return true;
|
|
960
1617
|
}
|
|
961
1618
|
#resetSceneCoverStickyState() {
|
|
962
|
-
|
|
963
|
-
wrapper,
|
|
964
|
-
position: wrapper.style.position,
|
|
965
|
-
top: wrapper.style.top
|
|
966
|
-
}));
|
|
967
|
-
wrapperSnapshots.forEach(({ wrapper }) => resetStickyPosition(wrapper));
|
|
968
|
-
return () => {
|
|
969
|
-
wrapperSnapshots.forEach(({ wrapper, position, top }) => {
|
|
970
|
-
wrapper.style.position = position;
|
|
971
|
-
wrapper.style.top = top;
|
|
972
|
-
});
|
|
973
|
-
};
|
|
1619
|
+
return stripStickyPositions(this.#layers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
|
|
974
1620
|
}
|
|
975
1621
|
#resetPinStickyState() {
|
|
976
|
-
|
|
977
|
-
trigger,
|
|
978
|
-
position: captureInlinePosition(trigger)
|
|
979
|
-
}));
|
|
980
|
-
snapshots.forEach(({ trigger }) => resetStickyPosition(trigger));
|
|
981
|
-
return () => {
|
|
982
|
-
snapshots.forEach(({ trigger, position }) => restoreInlinePosition(trigger, position));
|
|
983
|
-
};
|
|
1622
|
+
return stripStickyPositions(this.#wrappedPinTriggers());
|
|
984
1623
|
}
|
|
985
1624
|
#resetStickyState() {
|
|
986
1625
|
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
@@ -1035,7 +1674,7 @@ var StickyScrollTrigger = class {
|
|
|
1035
1674
|
const topPx = resolveAnchorTop(classifiedStart.value, triggerHeight, viewportHeight);
|
|
1036
1675
|
const toScroll = (element, reachedAt) => this.#addDwellBeforeReach(element, reachedAt);
|
|
1037
1676
|
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.#
|
|
1677
|
+
const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
|
|
1039
1678
|
const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
|
|
1040
1679
|
applyStickyPosition(layer.trigger, topPx);
|
|
1041
1680
|
layer.inner.style.height = `${Math.max(0, Math.min(height, room))}px`;
|
|
@@ -1073,6 +1712,8 @@ var StickyScrollTrigger = class {
|
|
|
1073
1712
|
const layer = active[index];
|
|
1074
1713
|
layer.freezeStart = plan.freezeStart;
|
|
1075
1714
|
layer.freezeEnd = plan.freezeEnd;
|
|
1715
|
+
layer.engagedStart = plan.engagedStart;
|
|
1716
|
+
layer.engagedEnd = plan.engagedEnd;
|
|
1076
1717
|
if (!layer.wrapper) return;
|
|
1077
1718
|
applyStickyPosition(layer.wrapper, plan.stickyTop);
|
|
1078
1719
|
if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
|
|
@@ -1086,6 +1727,23 @@ var StickyScrollTrigger = class {
|
|
|
1086
1727
|
}
|
|
1087
1728
|
refresh() {
|
|
1088
1729
|
if (this.#destroyed) return;
|
|
1730
|
+
let failure = null;
|
|
1731
|
+
try {
|
|
1732
|
+
this.#refreshLayout();
|
|
1733
|
+
} catch (error) {
|
|
1734
|
+
failure = { error };
|
|
1735
|
+
}
|
|
1736
|
+
try {
|
|
1737
|
+
rebuildDormancy(this.#scrollTriggerClass);
|
|
1738
|
+
} catch (error) {
|
|
1739
|
+
clearDormancy();
|
|
1740
|
+
queueMicrotask(() => {
|
|
1741
|
+
throw error;
|
|
1742
|
+
});
|
|
1743
|
+
}
|
|
1744
|
+
if (failure) throw failure.error;
|
|
1745
|
+
}
|
|
1746
|
+
#refreshLayout() {
|
|
1089
1747
|
if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
|
|
1090
1748
|
this.#unbuild();
|
|
1091
1749
|
this.#build();
|
|
@@ -1115,10 +1773,7 @@ var StickyScrollTrigger = class {
|
|
|
1115
1773
|
});
|
|
1116
1774
|
}
|
|
1117
1775
|
#syncScrollMargins() {
|
|
1118
|
-
this.#scrollMarginSync.sync(this.#
|
|
1119
|
-
freezeStart,
|
|
1120
|
-
freezeEnd
|
|
1121
|
-
})), this.#outermostContainer, (targets) => {
|
|
1776
|
+
this.#scrollMarginSync.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
|
|
1122
1777
|
if (!targets.length) return [];
|
|
1123
1778
|
const restoreStickyState = this.#resetStickyState();
|
|
1124
1779
|
const tops = targets.map((target) => documentTop(target));
|
|
@@ -1157,8 +1812,7 @@ var StickyScrollTrigger = class {
|
|
|
1157
1812
|
invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
|
|
1158
1813
|
onKill: (self) => {
|
|
1159
1814
|
this.#captureScrollTriggerClass(self);
|
|
1160
|
-
|
|
1161
|
-
if (index !== -1) this.#layers.splice(index, 1);
|
|
1815
|
+
removeItem(this.#layers, layer);
|
|
1162
1816
|
this.#dirty = true;
|
|
1163
1817
|
this.#scheduleRebuild();
|
|
1164
1818
|
onKill?.(self);
|
|
@@ -1181,7 +1835,9 @@ var StickyScrollTrigger = class {
|
|
|
1181
1835
|
start,
|
|
1182
1836
|
end,
|
|
1183
1837
|
freezeStart: 0,
|
|
1184
|
-
freezeEnd: 0
|
|
1838
|
+
freezeEnd: 0,
|
|
1839
|
+
engagedStart: 0,
|
|
1840
|
+
engagedEnd: 0
|
|
1185
1841
|
}, onKill, rest);
|
|
1186
1842
|
}
|
|
1187
1843
|
createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
|
|
@@ -1201,7 +1857,9 @@ var StickyScrollTrigger = class {
|
|
|
1201
1857
|
start,
|
|
1202
1858
|
end,
|
|
1203
1859
|
freezeStart: 0,
|
|
1204
|
-
freezeEnd: 0
|
|
1860
|
+
freezeEnd: 0,
|
|
1861
|
+
engagedStart: 0,
|
|
1862
|
+
engagedEnd: 0
|
|
1205
1863
|
};
|
|
1206
1864
|
const vars = this.#registerLayer(layer, (self) => {
|
|
1207
1865
|
this.#coverRestoreByLayer.get(layer)?.();
|
|
@@ -1234,8 +1892,7 @@ var StickyScrollTrigger = class {
|
|
|
1234
1892
|
trigger,
|
|
1235
1893
|
onKill: (self) => {
|
|
1236
1894
|
this.#captureScrollTriggerClass(self);
|
|
1237
|
-
|
|
1238
|
-
if (index !== -1) this.#pinLayers.splice(index, 1);
|
|
1895
|
+
removeItem(this.#pinLayers, layer);
|
|
1239
1896
|
if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
|
|
1240
1897
|
onKill?.(self);
|
|
1241
1898
|
},
|
|
@@ -1263,10 +1920,13 @@ var StickyScrollTrigger = class {
|
|
|
1263
1920
|
}
|
|
1264
1921
|
#addDwellBeforeReach(element, reachedAt) {
|
|
1265
1922
|
if (!this.#rootElement.contains(element)) return reachedAt;
|
|
1266
|
-
return reachedAt + dwellBeforeReach(reachedAt, this.#
|
|
1923
|
+
return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
|
|
1267
1924
|
}
|
|
1268
|
-
#
|
|
1269
|
-
return this.#layers.
|
|
1925
|
+
#engagedWindows() {
|
|
1926
|
+
return this.#layers.flatMap((layer) => layer.kind === "scene" ? [{
|
|
1927
|
+
freezeStart: layer.engagedStart,
|
|
1928
|
+
freezeEnd: layer.engagedEnd
|
|
1929
|
+
}] : []);
|
|
1270
1930
|
}
|
|
1271
1931
|
static getScrollTop(elementInput, instances) {
|
|
1272
1932
|
const element = resolveElement(elementInput, "StickyScrollTrigger.getScrollTop");
|
|
@@ -1296,6 +1956,7 @@ var StickyScrollTrigger = class {
|
|
|
1296
1956
|
destroy() {
|
|
1297
1957
|
if (this.#destroyed) return;
|
|
1298
1958
|
this.#destroyed = true;
|
|
1959
|
+
unregisterDormancyClient(this.#dormancyClient);
|
|
1299
1960
|
this.#scrollMarginSync.restore();
|
|
1300
1961
|
this.#restoreCoverLifts();
|
|
1301
1962
|
this.#unbuild();
|