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