sticky-scroll-trigger 0.11.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 +29 -7
- package/dist/StickyScrollTrigger.d.ts +4 -1
- package/dist/StickyScrollTrigger.global.js +604 -121
- package/dist/StickyScrollTrigger.global.min.js +2 -2
- package/dist/StickyScrollTrigger.js +604 -121
- 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,6 +98,11 @@ const restoreInlinePosition = (el, saved) => {
|
|
|
98
98
|
el.style.position = saved.position;
|
|
99
99
|
el.style.top = saved.top;
|
|
100
100
|
};
|
|
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
|
+
};
|
|
101
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");
|
|
@@ -200,6 +205,438 @@ const liftAboveStickyWrapper = (cover) => {
|
|
|
200
205
|
lifted.length = 0;
|
|
201
206
|
};
|
|
202
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
|
+
};
|
|
203
640
|
const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
|
|
204
641
|
const KEYWORD_FRACTIONS = {
|
|
205
642
|
top: 0,
|
|
@@ -240,19 +677,20 @@ const assertNotClamped = (trimmed) => {
|
|
|
240
677
|
const inner = trimmed.slice(6).replace(/\)$/, "").trim();
|
|
241
678
|
throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
|
|
242
679
|
};
|
|
243
|
-
const
|
|
680
|
+
const splitClause = (position) => {
|
|
244
681
|
const trimmed = position.trim();
|
|
245
682
|
assertNotClamped(trimmed);
|
|
246
|
-
|
|
247
|
-
return elementHeight * elementClause.fraction + elementClause.offsetPx;
|
|
683
|
+
return trimmed.split(/\s+/);
|
|
248
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);
|
|
249
690
|
const resolveElementFraction = (position) => resolveElementAnchor(position, 1) - resolveElementAnchor(position, 0);
|
|
250
691
|
const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
|
|
251
|
-
const
|
|
252
|
-
|
|
253
|
-
const viewportToken = trimmed.split(/\s+/)[1] ?? "top";
|
|
254
|
-
const viewportClause = parseClauseToken(viewportToken, viewportHeight);
|
|
255
|
-
return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - resolveElementAnchor(trimmed, elementHeight);
|
|
692
|
+
const [elementToken, viewportToken = "top"] = splitClause(position);
|
|
693
|
+
return anchorWithin(viewportToken, viewportHeight) - anchorWithin(elementToken, elementHeight);
|
|
256
694
|
};
|
|
257
695
|
const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
|
|
258
696
|
const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
|
|
@@ -262,9 +700,7 @@ const prefixSpacedRelativeEnd = (start, endResolved) => {
|
|
|
262
700
|
if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
|
|
263
701
|
const startResolved = resolveMaybeFn(start);
|
|
264
702
|
if (typeof startResolved !== "string") return endResolved;
|
|
265
|
-
const
|
|
266
|
-
assertNotClamped(trimmedStart);
|
|
267
|
-
const [elementToken] = trimmedStart.split(/\s+/);
|
|
703
|
+
const [elementToken] = splitClause(startResolved);
|
|
268
704
|
try {
|
|
269
705
|
parseClauseToken(elementToken, 0);
|
|
270
706
|
} catch (error) {
|
|
@@ -313,16 +749,18 @@ const classifyPosition = (resolved) => {
|
|
|
313
749
|
};
|
|
314
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));
|
|
315
751
|
const nestedIn = (measurements, index) => measurements.flatMap(({ triggerEnclosedBy }, k) => k !== index && triggerEnclosedBy.includes(index) ? [k] : []);
|
|
316
|
-
const anchorShare = (measurements, world,
|
|
752
|
+
const anchorShare = ({ measurements, world, order, ownIndex }, index, freezeStart, box, reachedAt) => {
|
|
753
|
+
const { enclosedBy, anchorElement } = box;
|
|
317
754
|
const measurement = measurements[index];
|
|
318
755
|
if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? world.unpaddedStart(index, ownIndex, freezeStart) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
|
|
319
756
|
if (order && isHeldIn(measurements, index, enclosedBy, anchorElement, order)) return 0;
|
|
320
757
|
if (box.nests.includes(index)) return box.fraction;
|
|
321
758
|
return measurement.triggerTop + measurement.triggerHeight <= box.top + .05 ? 1 : 0;
|
|
322
759
|
};
|
|
323
|
-
const gapsBeforeEndAnchor = (
|
|
760
|
+
const gapsBeforeEndAnchor = (context, windows, box, reachedAt, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
|
|
761
|
+
const { ownIndex, order } = context;
|
|
324
762
|
if (index === ownIndex || order && order.isBefore(ownIndex, index)) return total;
|
|
325
|
-
const weight = anchorShare(
|
|
763
|
+
const weight = anchorShare(context, index, freezeStart, box, reachedAt);
|
|
326
764
|
if (weight === 0) return total;
|
|
327
765
|
counted?.add(index);
|
|
328
766
|
return total + weight * (freezeEnd - freezeStart);
|
|
@@ -386,8 +824,64 @@ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, pre
|
|
|
386
824
|
runs: []
|
|
387
825
|
};
|
|
388
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
|
+
};
|
|
389
838
|
const { start } = measurement;
|
|
390
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
|
+
};
|
|
391
885
|
let freezeEnd;
|
|
392
886
|
switch (measurement.end.mode) {
|
|
393
887
|
case "dwell":
|
|
@@ -401,55 +895,8 @@ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, pre
|
|
|
401
895
|
case "auto":
|
|
402
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.`);
|
|
403
897
|
case "clause": {
|
|
404
|
-
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.
|
|
405
|
-
|
|
406
|
-
const nests = nestedIn(measurements, index);
|
|
407
|
-
const weight = resolveElementFraction(measurement.end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
|
|
408
|
-
const dwellInside = measurements.reduce((total, other, k) => {
|
|
409
|
-
if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
|
|
410
|
-
recount.counted.add(k);
|
|
411
|
-
return total + weight * paddingOf(k);
|
|
412
|
-
}, 0);
|
|
413
|
-
if (start.mode === "clause") {
|
|
414
|
-
freezeEnd = freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
|
|
415
|
-
break;
|
|
416
|
-
}
|
|
417
|
-
const dwellAbove = measurements.reduce((total, other, k) => {
|
|
418
|
-
if (k === index || other.kind !== "scene" || nests.includes(k) || other.triggerTop + other.triggerHeight > measurement.triggerTop + .05 || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
|
|
419
|
-
recount.counted.add(k);
|
|
420
|
-
return total + paddingOf(k);
|
|
421
|
-
}, 0);
|
|
422
|
-
freezeEnd = Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
|
|
423
|
-
break;
|
|
424
|
-
}
|
|
425
|
-
let endTop;
|
|
426
|
-
if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
|
|
427
|
-
else {
|
|
428
|
-
const rawTop = measurement.endTriggerIndex === null ? measurement.end.rawTop : measurements[measurement.endTriggerIndex].triggerTop;
|
|
429
|
-
if (rawTop === null) endTop = 0;
|
|
430
|
-
else {
|
|
431
|
-
const box = {
|
|
432
|
-
top: rawTop,
|
|
433
|
-
fraction: resolveElementFraction(measurement.end.clause),
|
|
434
|
-
nests: measurement.endTriggerNests
|
|
435
|
-
};
|
|
436
|
-
const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, world, w, box, rawTop - anchorOffsetEnd, measurement.endTriggerEnclosedBy, index, measurement.endTriggerIndex, order, counted);
|
|
437
|
-
endTop = rawTop + gaps(knownWindows());
|
|
438
|
-
recount.runs.push((w) => gaps(w, recount.counted));
|
|
439
|
-
}
|
|
440
|
-
}
|
|
441
|
-
let layoutStart;
|
|
442
|
-
if (start.mode === "absolute") layoutStart = start.value;
|
|
443
|
-
else {
|
|
444
|
-
const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, world, w, {
|
|
445
|
-
top: measurement.triggerTop,
|
|
446
|
-
fraction: start.elementFraction,
|
|
447
|
-
nests: nestedIn(measurements, index)
|
|
448
|
-
}, measurement.triggerTop - start.anchorOffset, measurement.triggerEnclosedBy, index, index, order, counted);
|
|
449
|
-
layoutStart = measurement.triggerTop - start.anchorOffset + gaps(knownWindows());
|
|
450
|
-
recount.runs.push((w) => gaps(w, recount.counted));
|
|
451
|
-
}
|
|
452
|
-
freezeEnd = freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
|
|
898
|
+
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
|
|
899
|
+
freezeEnd = measurement.endTrigger.isSelf ? selfClauseEnd(measurement.end, anchorOffsetEnd) : elementClauseEnd(measurement.end, anchorOffsetEnd);
|
|
453
900
|
break;
|
|
454
901
|
}
|
|
455
902
|
}
|
|
@@ -491,9 +938,9 @@ const planCover = (measurements, index, windows, { viewportHeight, documentMaxSc
|
|
|
491
938
|
freezeEnd = documentMaxScroll + measurement.end.offsetPx;
|
|
492
939
|
break;
|
|
493
940
|
case "clause": {
|
|
494
|
-
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.
|
|
941
|
+
const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
|
|
495
942
|
if (measurement.end.measureLive) freezeEnd = measureLiveEndTriggerTop(index) - anchorOffsetEnd;
|
|
496
|
-
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);
|
|
497
944
|
break;
|
|
498
945
|
}
|
|
499
946
|
}
|
|
@@ -564,7 +1011,7 @@ const refreshOrderEdges = (measurements, lengths, edges) => {
|
|
|
564
1011
|
const before = measurements.map(() => []);
|
|
565
1012
|
edges.forEach((movers, i) => {
|
|
566
1013
|
const measurement = measurements[i];
|
|
567
|
-
const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.
|
|
1014
|
+
const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.endTrigger.isSelf ? measurement.endTrigger.enclosedBy : measurement.triggerEnclosedBy).filter((m) => m !== measurement.endTrigger.index);
|
|
568
1015
|
movers.forEach((k) => {
|
|
569
1016
|
if (lengths[k] <= .05) return;
|
|
570
1017
|
before[i].push(k);
|
|
@@ -821,7 +1268,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
821
1268
|
const snapshot = snapshots.get(target);
|
|
822
1269
|
target.style.scrollMarginTop = snapshot ? snapshot.inline : "";
|
|
823
1270
|
};
|
|
824
|
-
const
|
|
1271
|
+
const stopRamps = () => {
|
|
825
1272
|
if (sheet) {
|
|
826
1273
|
document.adoptedStyleSheets = document.adoptedStyleSheets.filter((one) => one !== sheet);
|
|
827
1274
|
sheet = null;
|
|
@@ -831,31 +1278,37 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
831
1278
|
jsRamps = [];
|
|
832
1279
|
jsHost = null;
|
|
833
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
|
+
};
|
|
834
1304
|
return {
|
|
835
1305
|
sync(scenes, host, measureNaturalTops) {
|
|
836
1306
|
const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
|
|
837
1307
|
if (targetSelector === null || !ramps.length || !host) {
|
|
838
|
-
|
|
839
|
-
written = new Set();
|
|
840
|
-
clearAnimation();
|
|
1308
|
+
release();
|
|
841
1309
|
return;
|
|
842
1310
|
}
|
|
843
|
-
|
|
844
|
-
animationHost?.removeAttribute(`data-${instanceId}`);
|
|
845
|
-
animationHost = host;
|
|
846
|
-
animationHost.setAttribute(`data-${instanceId}`, "");
|
|
847
|
-
}
|
|
848
|
-
if (usesJsRamp) {
|
|
849
|
-
jsRamps = ramps;
|
|
850
|
-
jsHost = host;
|
|
851
|
-
applyJsRamp();
|
|
852
|
-
} else {
|
|
853
|
-
if (!sheet) {
|
|
854
|
-
sheet = new CSSStyleSheet();
|
|
855
|
-
document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
|
|
856
|
-
}
|
|
857
|
-
sheet.replaceSync(buildStylesheet(instanceId, ramps));
|
|
858
|
-
}
|
|
1311
|
+
startRamps(ramps, host);
|
|
859
1312
|
const targets = Array.from(rootElement.querySelectorAll(targetSelector));
|
|
860
1313
|
const naturalTops = measureNaturalTops(targets);
|
|
861
1314
|
targets.forEach((target) => {
|
|
@@ -882,9 +1335,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
882
1335
|
},
|
|
883
1336
|
restore() {
|
|
884
1337
|
if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
|
|
885
|
-
|
|
886
|
-
written = new Set();
|
|
887
|
-
clearAnimation();
|
|
1338
|
+
release();
|
|
888
1339
|
}
|
|
889
1340
|
};
|
|
890
1341
|
};
|
|
@@ -983,23 +1434,27 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
|
|
|
983
1434
|
const endResolved = layer.end === null ? null : prefixSpacedRelativeEnd(startResolved, resolveMaybeFn(layer.end));
|
|
984
1435
|
const elementHeight = measureUsedHeight(layer.trigger);
|
|
985
1436
|
const endTriggerIsSelf = layer.endTrigger === layer.trigger;
|
|
1437
|
+
const indicesWhere = (test) => [...indexByTrigger].filter(([trigger]) => test(trigger)).map(([, index]) => index);
|
|
986
1438
|
const endTriggerIndex = indexByTrigger.get(layer.endTrigger) ?? null;
|
|
987
1439
|
const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
|
|
1440
|
+
const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
|
|
988
1441
|
const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
|
|
989
1442
|
return {
|
|
990
1443
|
kind: layer.kind,
|
|
991
1444
|
start,
|
|
992
1445
|
triggerTop: documentTop(layer.trigger),
|
|
993
1446
|
triggerHeight: elementHeight,
|
|
994
|
-
triggerEnclosedBy:
|
|
1447
|
+
triggerEnclosedBy: indicesWhere((trigger) => trigger.contains(layer.trigger)),
|
|
995
1448
|
wrapperTop: layer.wrapper ? documentTop(layer.wrapper) : 0,
|
|
996
1449
|
coverTop: layer.kind === "cover" ? documentTop(layer.cover) : 0,
|
|
997
1450
|
end,
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
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
|
+
}
|
|
1003
1458
|
};
|
|
1004
1459
|
};
|
|
1005
1460
|
const EXCLUDED_VAR_KEYS = [
|
|
@@ -1032,6 +1487,10 @@ const resolvePinReleaseScroll = (endTrigger, classifiedEnd, engageScroll, viewpo
|
|
|
1032
1487
|
case "clause": return toScroll(endTrigger, documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight));
|
|
1033
1488
|
}
|
|
1034
1489
|
};
|
|
1490
|
+
const removeItem = (list, item) => {
|
|
1491
|
+
const index = list.indexOf(item);
|
|
1492
|
+
if (index !== -1) list.splice(index, 1);
|
|
1493
|
+
};
|
|
1035
1494
|
const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
|
|
1036
1495
|
var StickyScrollTrigger = class {
|
|
1037
1496
|
#rootElement;
|
|
@@ -1046,6 +1505,7 @@ var StickyScrollTrigger = class {
|
|
|
1046
1505
|
#scrollTriggerClass = null;
|
|
1047
1506
|
#pinLayers = [];
|
|
1048
1507
|
#scrollMarginSync;
|
|
1508
|
+
#dormancyClient = null;
|
|
1049
1509
|
constructor(root, options = {}) {
|
|
1050
1510
|
this.#rootElement = resolveRoot(root);
|
|
1051
1511
|
const scrollMarginTargets = options.scrollMarginTargets === void 0 ? "[id]" : options.scrollMarginTargets;
|
|
@@ -1054,7 +1514,26 @@ var StickyScrollTrigger = class {
|
|
|
1054
1514
|
} catch {
|
|
1055
1515
|
throw new Error(`StickyScrollTrigger: scrollMarginTargets "${scrollMarginTargets}" is not a valid CSS selector.`);
|
|
1056
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)}.`);
|
|
1057
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] : []);
|
|
1058
1537
|
}
|
|
1059
1538
|
#unbuild() {
|
|
1060
1539
|
if (!this.#built) return;
|
|
@@ -1093,7 +1572,12 @@ var StickyScrollTrigger = class {
|
|
|
1093
1572
|
throw error;
|
|
1094
1573
|
});
|
|
1095
1574
|
}
|
|
1096
|
-
|
|
1575
|
+
const restoreDormancy = takeGsapRefreshRestore();
|
|
1576
|
+
if (!restoreDormancy) return result;
|
|
1577
|
+
return { render: (time) => {
|
|
1578
|
+
result?.render?.(time);
|
|
1579
|
+
restoreDormancy();
|
|
1580
|
+
} };
|
|
1097
1581
|
};
|
|
1098
1582
|
}
|
|
1099
1583
|
#wrapUnwrappedPins() {
|
|
@@ -1125,34 +1609,17 @@ var StickyScrollTrigger = class {
|
|
|
1125
1609
|
}
|
|
1126
1610
|
#unwrapPinLayer(layer) {
|
|
1127
1611
|
if (!layer.outer) return false;
|
|
1612
|
+
releaseDormant([layer.trigger]);
|
|
1128
1613
|
unwrapPin(layer.outer, layer.trigger, layer.savedPosition);
|
|
1129
1614
|
layer.outer = null;
|
|
1130
1615
|
layer.inner = null;
|
|
1131
1616
|
return true;
|
|
1132
1617
|
}
|
|
1133
1618
|
#resetSceneCoverStickyState() {
|
|
1134
|
-
|
|
1135
|
-
wrapper,
|
|
1136
|
-
position: wrapper.style.position,
|
|
1137
|
-
top: wrapper.style.top
|
|
1138
|
-
}));
|
|
1139
|
-
wrapperSnapshots.forEach(({ wrapper }) => resetStickyPosition(wrapper));
|
|
1140
|
-
return () => {
|
|
1141
|
-
wrapperSnapshots.forEach(({ wrapper, position, top }) => {
|
|
1142
|
-
wrapper.style.position = position;
|
|
1143
|
-
wrapper.style.top = top;
|
|
1144
|
-
});
|
|
1145
|
-
};
|
|
1619
|
+
return stripStickyPositions(this.#layers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
|
|
1146
1620
|
}
|
|
1147
1621
|
#resetPinStickyState() {
|
|
1148
|
-
|
|
1149
|
-
trigger,
|
|
1150
|
-
position: captureInlinePosition(trigger)
|
|
1151
|
-
}));
|
|
1152
|
-
snapshots.forEach(({ trigger }) => resetStickyPosition(trigger));
|
|
1153
|
-
return () => {
|
|
1154
|
-
snapshots.forEach(({ trigger, position }) => restoreInlinePosition(trigger, position));
|
|
1155
|
-
};
|
|
1622
|
+
return stripStickyPositions(this.#wrappedPinTriggers());
|
|
1156
1623
|
}
|
|
1157
1624
|
#resetStickyState() {
|
|
1158
1625
|
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
@@ -1260,6 +1727,23 @@ var StickyScrollTrigger = class {
|
|
|
1260
1727
|
}
|
|
1261
1728
|
refresh() {
|
|
1262
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() {
|
|
1263
1747
|
if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
|
|
1264
1748
|
this.#unbuild();
|
|
1265
1749
|
this.#build();
|
|
@@ -1328,8 +1812,7 @@ var StickyScrollTrigger = class {
|
|
|
1328
1812
|
invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
|
|
1329
1813
|
onKill: (self) => {
|
|
1330
1814
|
this.#captureScrollTriggerClass(self);
|
|
1331
|
-
|
|
1332
|
-
if (index !== -1) this.#layers.splice(index, 1);
|
|
1815
|
+
removeItem(this.#layers, layer);
|
|
1333
1816
|
this.#dirty = true;
|
|
1334
1817
|
this.#scheduleRebuild();
|
|
1335
1818
|
onKill?.(self);
|
|
@@ -1409,8 +1892,7 @@ var StickyScrollTrigger = class {
|
|
|
1409
1892
|
trigger,
|
|
1410
1893
|
onKill: (self) => {
|
|
1411
1894
|
this.#captureScrollTriggerClass(self);
|
|
1412
|
-
|
|
1413
|
-
if (index !== -1) this.#pinLayers.splice(index, 1);
|
|
1895
|
+
removeItem(this.#pinLayers, layer);
|
|
1414
1896
|
if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
|
|
1415
1897
|
onKill?.(self);
|
|
1416
1898
|
},
|
|
@@ -1474,6 +1956,7 @@ var StickyScrollTrigger = class {
|
|
|
1474
1956
|
destroy() {
|
|
1475
1957
|
if (this.#destroyed) return;
|
|
1476
1958
|
this.#destroyed = true;
|
|
1959
|
+
unregisterDormancyClient(this.#dormancyClient);
|
|
1477
1960
|
this.#scrollMarginSync.restore();
|
|
1478
1961
|
this.#restoreCoverLifts();
|
|
1479
1962
|
this.#unbuild();
|