sticky-scroll-trigger 0.13.0 → 0.14.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
/*!
|
|
2
2
|
* @license
|
|
3
|
-
* StickyScrollTrigger v0.
|
|
3
|
+
* StickyScrollTrigger v0.14.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
|
|
@@ -87,10 +87,6 @@ var StickyScrollTrigger = (function() {
|
|
|
87
87
|
el.style.position = "";
|
|
88
88
|
el.style.top = "";
|
|
89
89
|
};
|
|
90
|
-
const applyStickyPosition = (el, topPx) => {
|
|
91
|
-
el.style.position = "sticky";
|
|
92
|
-
el.style.top = `${topPx}px`;
|
|
93
|
-
};
|
|
94
90
|
const captureInlinePosition = (el) => ({
|
|
95
91
|
position: el.style.position,
|
|
96
92
|
top: el.style.top
|
|
@@ -104,6 +100,15 @@ var StickyScrollTrigger = (function() {
|
|
|
104
100
|
elements.forEach(resetStickyPosition);
|
|
105
101
|
return () => elements.forEach((el, i) => restoreInlinePosition(el, saved[i]));
|
|
106
102
|
};
|
|
103
|
+
const insertSpacers = (spacers) => {
|
|
104
|
+
const inserted = spacers.map(({ after, height }) => {
|
|
105
|
+
const spacer = document.createElement("div");
|
|
106
|
+
spacer.style.cssText = `height:${height}px;margin:0;padding:0;border:0`;
|
|
107
|
+
after.after(spacer);
|
|
108
|
+
return spacer;
|
|
109
|
+
});
|
|
110
|
+
return () => inserted.forEach((spacer) => spacer.remove());
|
|
111
|
+
};
|
|
107
112
|
const wrapScene = (inner, holdTrailingMargin) => {
|
|
108
113
|
if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
|
|
109
114
|
const container = document.createElement("div");
|
|
@@ -206,6 +211,41 @@ var StickyScrollTrigger = (function() {
|
|
|
206
211
|
lifted.length = 0;
|
|
207
212
|
};
|
|
208
213
|
};
|
|
214
|
+
const classOf = (self) => self.constructor;
|
|
215
|
+
const isRefreshing = (cls) => cls?.isRefreshing === true;
|
|
216
|
+
const isScrolling = (cls) => Boolean(cls?.isScrolling?.());
|
|
217
|
+
const isScrollingOrUpdating = (cls) => Boolean(cls?.isScrolling?.() || cls?.isUpdating === true);
|
|
218
|
+
const addGsapListener = (cls, type, callback) => {
|
|
219
|
+
cls?.addEventListener?.(type, callback);
|
|
220
|
+
};
|
|
221
|
+
const removeGsapListener = (cls, type, callback) => {
|
|
222
|
+
cls?.removeEventListener?.(type, callback);
|
|
223
|
+
};
|
|
224
|
+
const refreshAll = (cls) => {
|
|
225
|
+
if (typeof cls?.refresh === "function") cls.refresh();
|
|
226
|
+
};
|
|
227
|
+
const scrollRecord = (cls, zero = false) => {
|
|
228
|
+
if (!cls || !isRefreshing(cls)) return null;
|
|
229
|
+
const scrollFunc = cls.getScrollFunc?.(window);
|
|
230
|
+
if (!(scrollFunc && typeof scrollFunc.rec === "number" && (zero || scrollFunc.rec))) return null;
|
|
231
|
+
const record = scrollFunc;
|
|
232
|
+
return {
|
|
233
|
+
read: () => record.rec,
|
|
234
|
+
write: (value) => {
|
|
235
|
+
record.rec = value;
|
|
236
|
+
}
|
|
237
|
+
};
|
|
238
|
+
};
|
|
239
|
+
const syncScrollCache = (cls) => {
|
|
240
|
+
const scrollFunc = cls?.getScrollFunc?.(window);
|
|
241
|
+
if (typeof scrollFunc !== "function") return;
|
|
242
|
+
const cached = scrollFunc();
|
|
243
|
+
if (typeof cached !== "number" || Math.abs(cached - window.scrollY) >= .5) scrollFunc(window.scrollY);
|
|
244
|
+
};
|
|
245
|
+
const revertAfterMeasure = (restore, result) => ({ render: (time) => {
|
|
246
|
+
result?.render?.(time);
|
|
247
|
+
restore();
|
|
248
|
+
} });
|
|
209
249
|
const AUTO_MIN_DEPTH = 7;
|
|
210
250
|
const MAX_CHAIN_IN_BAND = 4;
|
|
211
251
|
const BUFFER_FLOOR_PX = 325;
|
|
@@ -281,7 +321,7 @@ var StickyScrollTrigger = (function() {
|
|
|
281
321
|
let adoptedMidRefresh = false;
|
|
282
322
|
let scannedThisTask = null;
|
|
283
323
|
const gsapClasses = new Set();
|
|
284
|
-
const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => cls
|
|
324
|
+
const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => isRefreshing(cls));
|
|
285
325
|
const stateAt = (record, scroll) => {
|
|
286
326
|
if (!record.demotable) return "in";
|
|
287
327
|
if (scroll < record.lo - buffer) return "before";
|
|
@@ -359,22 +399,22 @@ var StickyScrollTrigger = (function() {
|
|
|
359
399
|
queueMicrotask(onGsapRefreshDone);
|
|
360
400
|
if (records.length) update(0);
|
|
361
401
|
}
|
|
362
|
-
return
|
|
402
|
+
return revertAfterMeasure(restoreAfterGsapMeasure);
|
|
363
403
|
};
|
|
364
404
|
const adoptGsapClass = (cls) => {
|
|
365
405
|
if (gsapClasses.has(cls)) return;
|
|
366
|
-
if (cls
|
|
406
|
+
if (isRefreshing(cls)) adoptedMidRefresh = true;
|
|
367
407
|
gsapClasses.add(cls);
|
|
368
|
-
cls
|
|
369
|
-
cls
|
|
408
|
+
addGsapListener(cls, "refresh", onGsapRefreshDone);
|
|
409
|
+
addGsapListener(cls, "refreshInit", onGsapRefreshInit);
|
|
370
410
|
};
|
|
371
411
|
const dropGsapClassesLater = () => {
|
|
372
412
|
if (!gsapClasses.size) return;
|
|
373
413
|
queueMicrotask(() => {
|
|
374
414
|
if (liveClients().length) return;
|
|
375
415
|
gsapClasses.forEach((cls) => {
|
|
376
|
-
cls
|
|
377
|
-
cls
|
|
416
|
+
removeGsapListener(cls, "refresh", onGsapRefreshDone);
|
|
417
|
+
removeGsapListener(cls, "refreshInit", onGsapRefreshInit);
|
|
378
418
|
});
|
|
379
419
|
gsapClasses.clear();
|
|
380
420
|
});
|
|
@@ -607,7 +647,14 @@ var StickyScrollTrigger = (function() {
|
|
|
607
647
|
update(gsapPhase === "measuring" ? 0 : (gsapPhase === "restored" ? scrollBeforeGsapRefresh : null) ?? scroll);
|
|
608
648
|
listen(true);
|
|
609
649
|
};
|
|
610
|
-
const takeGsapRefreshRestore = () =>
|
|
650
|
+
const takeGsapRefreshRestore = () => {
|
|
651
|
+
if (!adoptedMidRefresh || !gsapRefreshing()) return null;
|
|
652
|
+
onGsapRefreshInit();
|
|
653
|
+
return restoreAfterGsapMeasure;
|
|
654
|
+
};
|
|
655
|
+
const setGsapRefreshReturn = (scroll) => {
|
|
656
|
+
if (gsapPhase !== "idle") scrollBeforeGsapRefresh = scroll;
|
|
657
|
+
};
|
|
611
658
|
const clearDormancy = clearTable;
|
|
612
659
|
const releaseDormant = (elements) => {
|
|
613
660
|
const released = new Set(elements);
|
|
@@ -638,6 +685,24 @@ var StickyScrollTrigger = (function() {
|
|
|
638
685
|
if (liveClients().length) queueRebuild();
|
|
639
686
|
else teardown();
|
|
640
687
|
};
|
|
688
|
+
const commitSticky = (el, topPx) => {
|
|
689
|
+
el.style.position = "sticky";
|
|
690
|
+
el.style.top = `${topPx}px`;
|
|
691
|
+
};
|
|
692
|
+
const commitPosition = (el, saved) => {
|
|
693
|
+
el.style.position = saved.position;
|
|
694
|
+
el.style.top = saved.top;
|
|
695
|
+
};
|
|
696
|
+
const commitHeight = (el, height) => {
|
|
697
|
+
el.style.height = height;
|
|
698
|
+
};
|
|
699
|
+
const clearStickyForRead = (el) => {
|
|
700
|
+
el.style.position = "";
|
|
701
|
+
el.style.top = "";
|
|
702
|
+
};
|
|
703
|
+
const clearHeightForRead = (el) => {
|
|
704
|
+
el.style.height = "";
|
|
705
|
+
};
|
|
641
706
|
const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
|
|
642
707
|
const KEYWORD_FRACTIONS = {
|
|
643
708
|
top: 0,
|
|
@@ -1302,6 +1367,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1302
1367
|
stopRamps();
|
|
1303
1368
|
};
|
|
1304
1369
|
return {
|
|
1370
|
+
targets: () => targetSelector === null ? [] : Array.from(rootElement.querySelectorAll(targetSelector)),
|
|
1305
1371
|
sync(scenes, host, measureNaturalTops) {
|
|
1306
1372
|
const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
|
|
1307
1373
|
if (targetSelector === null || !ramps.length || !host) {
|
|
@@ -1445,6 +1511,8 @@ var StickyScrollTrigger = (function() {
|
|
|
1445
1511
|
const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
|
|
1446
1512
|
const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
|
|
1447
1513
|
const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
|
|
1514
|
+
const { end: endInput } = layer;
|
|
1515
|
+
const liveEnd = layer.kind === "scene" && typeof endInput === "function" && (end.mode === "dwell" || end.mode === "absolute") ? () => resolveEndSpec(rootElement, viewportHeight, layer, prefixSpacedRelativeEnd(startResolved, endInput()), ownIndex, endTriggerIndex) : void 0;
|
|
1448
1516
|
return {
|
|
1449
1517
|
kind: layer.kind,
|
|
1450
1518
|
start,
|
|
@@ -1460,7 +1528,8 @@ var StickyScrollTrigger = (function() {
|
|
|
1460
1528
|
height: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
|
|
1461
1529
|
enclosedBy: endTriggerInContainer ? indicesWhere((trigger) => trigger.contains(layer.endTrigger)) : [],
|
|
1462
1530
|
nests: endTriggerInContainer ? indicesWhere((other) => other !== layer.endTrigger && layer.endTrigger.contains(other)) : []
|
|
1463
|
-
}
|
|
1531
|
+
},
|
|
1532
|
+
liveEnd
|
|
1464
1533
|
};
|
|
1465
1534
|
};
|
|
1466
1535
|
const EXCLUDED_VAR_KEYS = [
|
|
@@ -1497,10 +1566,55 @@ var StickyScrollTrigger = (function() {
|
|
|
1497
1566
|
const index = list.indexOf(item);
|
|
1498
1567
|
if (index !== -1) list.splice(index, 1);
|
|
1499
1568
|
};
|
|
1569
|
+
const suspendLiveEvaluations = (evaluation, resolving) => {
|
|
1570
|
+
const resumes = [];
|
|
1571
|
+
for (let current = evaluation; current; current = current.outer) resumes.unshift(current.suspend(resolving && current === evaluation));
|
|
1572
|
+
return () => resumes.forEach((resume) => resume());
|
|
1573
|
+
};
|
|
1574
|
+
const liveEndValue = (spec) => {
|
|
1575
|
+
if (spec.mode === "dwell") return spec.distancePx;
|
|
1576
|
+
return spec.mode === "absolute" ? spec.value : 0;
|
|
1577
|
+
};
|
|
1578
|
+
const LIVE_END_ROUNDS = 6;
|
|
1579
|
+
const LIVE_END_TOLERANCE_PX = .5;
|
|
1500
1580
|
const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
|
|
1501
1581
|
const pendingDisarms = new Set();
|
|
1502
1582
|
const pendingKeeps = new Set();
|
|
1583
|
+
const pendingCatchUps = new Map();
|
|
1503
1584
|
let unbuildCount = 0;
|
|
1585
|
+
let refreshedInGsapRefresh = null;
|
|
1586
|
+
const armedInstances = new Set();
|
|
1587
|
+
let liveEvaluation = null;
|
|
1588
|
+
let layerHandlerDepth = 0;
|
|
1589
|
+
const scrollBackTo = (top) => {
|
|
1590
|
+
if (Math.abs(window.scrollY - top) >= .5) window.scrollTo({
|
|
1591
|
+
top,
|
|
1592
|
+
behavior: "instant"
|
|
1593
|
+
});
|
|
1594
|
+
};
|
|
1595
|
+
const holdLiveEvaluationForGsapRefresh = (cls) => {
|
|
1596
|
+
const evaluation = liveEvaluation;
|
|
1597
|
+
if (!evaluation) return;
|
|
1598
|
+
const resume = suspendLiveEvaluations(evaluation, false);
|
|
1599
|
+
const record = scrollRecord(cls, true);
|
|
1600
|
+
if (record && Math.abs(record.read() - evaluation.scroll) >= .5) {
|
|
1601
|
+
scrollBackTo(Math.round(evaluation.scroll));
|
|
1602
|
+
syncScrollCache(cls);
|
|
1603
|
+
record.write(window.scrollY);
|
|
1604
|
+
setGsapRefreshReturn(window.scrollY);
|
|
1605
|
+
}
|
|
1606
|
+
const depth = layerHandlerDepth - 1;
|
|
1607
|
+
let held = true;
|
|
1608
|
+
liveEvaluation = null;
|
|
1609
|
+
const onRefresh = () => {
|
|
1610
|
+
if (!held || layerHandlerDepth > depth) return;
|
|
1611
|
+
held = false;
|
|
1612
|
+
resume();
|
|
1613
|
+
if (!evaluation.ended) liveEvaluation = evaluation;
|
|
1614
|
+
};
|
|
1615
|
+
addGsapListener(cls, "refresh", onRefresh);
|
|
1616
|
+
queueMicrotask(() => removeGsapListener(cls, "refresh", onRefresh));
|
|
1617
|
+
};
|
|
1504
1618
|
const REST_POLL_MS = 100;
|
|
1505
1619
|
const runEach = (...steps) => {
|
|
1506
1620
|
let failure = null;
|
|
@@ -1526,7 +1640,9 @@ var StickyScrollTrigger = (function() {
|
|
|
1526
1640
|
#dirty = false;
|
|
1527
1641
|
#outermostContainer = null;
|
|
1528
1642
|
#destroyed = false;
|
|
1529
|
-
#
|
|
1643
|
+
#depth = 0;
|
|
1644
|
+
#refreshInitNestedUsed = false;
|
|
1645
|
+
#measureAgain = false;
|
|
1530
1646
|
#keepContentPending = false;
|
|
1531
1647
|
#deferredRun = null;
|
|
1532
1648
|
#restTimer = null;
|
|
@@ -1537,6 +1653,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1537
1653
|
#scrollMarginTargets;
|
|
1538
1654
|
#armed = false;
|
|
1539
1655
|
#dispatchObserver = null;
|
|
1656
|
+
#readsPageHeight = false;
|
|
1540
1657
|
#dormancyClient = null;
|
|
1541
1658
|
constructor(root, options = {}) {
|
|
1542
1659
|
this.#rootElement = resolveRoot(root);
|
|
@@ -1562,6 +1679,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1562
1679
|
if (pendingDisarms.delete(this)) this.#keepContentPending = false;
|
|
1563
1680
|
if (this.#armed) return;
|
|
1564
1681
|
this.#armed = true;
|
|
1682
|
+
armedInstances.add(this);
|
|
1565
1683
|
pendingKeeps.forEach((keep) => {
|
|
1566
1684
|
if (keep.owner.#overlaps(this)) keep.cancelled = true;
|
|
1567
1685
|
});
|
|
@@ -1571,7 +1689,8 @@ var StickyScrollTrigger = (function() {
|
|
|
1571
1689
|
#disarmIfEmpty() {
|
|
1572
1690
|
if (this.#armed && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) {
|
|
1573
1691
|
if (pendingDisarms.has(this)) return;
|
|
1574
|
-
|
|
1692
|
+
const cls = this.#scrollTriggerClass;
|
|
1693
|
+
if (!isRefreshing(cls) && isScrollingOrUpdating(cls)) {
|
|
1575
1694
|
pendingDisarms.add(this);
|
|
1576
1695
|
queueMicrotask(() => this.#settleWhenAtRest());
|
|
1577
1696
|
return;
|
|
@@ -1585,16 +1704,12 @@ var StickyScrollTrigger = (function() {
|
|
|
1585
1704
|
if (other !== this && other.#overlaps(this)) other.#flushPendingDisarmForRevert();
|
|
1586
1705
|
});
|
|
1587
1706
|
}
|
|
1588
|
-
#scrolling() {
|
|
1589
|
-
const cls = this.#scrollTriggerClass;
|
|
1590
|
-
return Boolean(cls?.isScrolling?.() || cls?.isUpdating === true);
|
|
1591
|
-
}
|
|
1592
1707
|
#disarmKeepingContent(keepContent, onlyAtRest = false) {
|
|
1593
1708
|
const position = keepContent && this.#built ? this.#naturalScrollTop(this.#builtLayers) : null;
|
|
1594
1709
|
this.#keepContentPending = false;
|
|
1595
1710
|
this.#disarm();
|
|
1596
1711
|
if (!position) return;
|
|
1597
|
-
if (this.#
|
|
1712
|
+
if (scrollRecord(this.#scrollTriggerClass)) {
|
|
1598
1713
|
this.#keepContent(position);
|
|
1599
1714
|
return;
|
|
1600
1715
|
}
|
|
@@ -1614,7 +1729,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1614
1729
|
if (!keep) return;
|
|
1615
1730
|
this.#pendingKeep = null;
|
|
1616
1731
|
pendingKeeps.delete(keep);
|
|
1617
|
-
if (keep.cancelled || keep.onlyAtRest && keep.cls
|
|
1732
|
+
if (keep.cancelled || keep.onlyAtRest && isScrolling(keep.cls)) return;
|
|
1618
1733
|
this.#keepContent(keep.position, keep.cls);
|
|
1619
1734
|
}
|
|
1620
1735
|
#overlaps(other) {
|
|
@@ -1622,7 +1737,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1622
1737
|
}
|
|
1623
1738
|
#settleWhenAtRest() {
|
|
1624
1739
|
if (this.#destroyed || this.#restTimer !== null) return;
|
|
1625
|
-
if (this.#scrollTriggerClass
|
|
1740
|
+
if (isScrolling(this.#scrollTriggerClass)) {
|
|
1626
1741
|
this.#restTimer = setTimeout(() => {
|
|
1627
1742
|
this.#restTimer = null;
|
|
1628
1743
|
this.#settleWhenAtRest();
|
|
@@ -1637,10 +1752,11 @@ var StickyScrollTrigger = (function() {
|
|
|
1637
1752
|
if (pendingDisarms.delete(this) && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) this.#disarmKeepingContent(keepContent, onlyAtRest);
|
|
1638
1753
|
}
|
|
1639
1754
|
#flushPendingDisarmForRevert() {
|
|
1640
|
-
this.#flushPendingDisarm(!this.#scrollTriggerClass
|
|
1755
|
+
this.#flushPendingDisarm(!isScrolling(this.#scrollTriggerClass), true);
|
|
1641
1756
|
}
|
|
1642
1757
|
#disarm() {
|
|
1643
1758
|
this.#armed = false;
|
|
1759
|
+
armedInstances.delete(this);
|
|
1644
1760
|
unregisterDormancyClient(this.#dormancyClient);
|
|
1645
1761
|
this.#scrollMarginSync?.restore();
|
|
1646
1762
|
this.#scrollMarginSync = null;
|
|
@@ -1670,40 +1786,45 @@ var StickyScrollTrigger = (function() {
|
|
|
1670
1786
|
}
|
|
1671
1787
|
#catchUp() {
|
|
1672
1788
|
this.#flushPendingDisarm();
|
|
1673
|
-
this
|
|
1789
|
+
this.#runRefresh();
|
|
1674
1790
|
this.#applyPendingKeep();
|
|
1675
1791
|
}
|
|
1676
1792
|
#scheduleRebuild() {
|
|
1677
1793
|
if (this.#destroyed) return;
|
|
1678
1794
|
if (this.#built) this.#keepContentPending = true;
|
|
1679
|
-
if (this
|
|
1680
|
-
this.#rebuildScheduled = true;
|
|
1795
|
+
if (pendingCatchUps.has(this)) return;
|
|
1681
1796
|
const cls = this.#scrollTriggerClass;
|
|
1682
|
-
const
|
|
1683
|
-
|
|
1797
|
+
const pending = () => pendingCatchUps.get(this) === catchUpNow;
|
|
1798
|
+
const catchUpNow = () => {
|
|
1799
|
+
if (!pending()) return false;
|
|
1800
|
+
pendingCatchUps.delete(this);
|
|
1801
|
+
if (this.#destroyed) return false;
|
|
1684
1802
|
try {
|
|
1685
1803
|
this.#catchUp();
|
|
1686
1804
|
} catch (error) {
|
|
1687
1805
|
queueMicrotask(() => {
|
|
1688
1806
|
throw error;
|
|
1689
1807
|
});
|
|
1690
|
-
} finally {
|
|
1691
|
-
this.#rebuildScheduled = false;
|
|
1692
1808
|
}
|
|
1809
|
+
return true;
|
|
1810
|
+
};
|
|
1811
|
+
pendingCatchUps.set(this, catchUpNow);
|
|
1812
|
+
const onRefreshInit = () => {
|
|
1813
|
+
if (!catchUpNow()) return void 0;
|
|
1693
1814
|
const restoreDormancy = takeGsapRefreshRestore();
|
|
1694
|
-
return restoreDormancy ?
|
|
1815
|
+
return restoreDormancy ? revertAfterMeasure(restoreDormancy) : void 0;
|
|
1695
1816
|
};
|
|
1696
|
-
cls
|
|
1817
|
+
addGsapListener(cls, "refreshInit", onRefreshInit);
|
|
1697
1818
|
const run = () => {
|
|
1698
|
-
|
|
1699
|
-
|
|
1700
|
-
|
|
1701
|
-
|
|
1702
|
-
|
|
1703
|
-
|
|
1819
|
+
try {
|
|
1820
|
+
if (pending() && !this.#destroyed) refreshAll(this.#scrollTriggerClass);
|
|
1821
|
+
} finally {
|
|
1822
|
+
removeGsapListener(cls, "refreshInit", onRefreshInit);
|
|
1823
|
+
catchUpNow();
|
|
1824
|
+
}
|
|
1704
1825
|
};
|
|
1705
1826
|
queueMicrotask(() => {
|
|
1706
|
-
if (
|
|
1827
|
+
if (pending() && !this.#destroyed && isScrolling(cls)) {
|
|
1707
1828
|
const earlier = this.#deferredRun;
|
|
1708
1829
|
this.#deferredRun = earlier ? () => runEach(earlier, run) : run;
|
|
1709
1830
|
this.#settleWhenAtRest();
|
|
@@ -1714,28 +1835,46 @@ var StickyScrollTrigger = (function() {
|
|
|
1714
1835
|
}
|
|
1715
1836
|
#captureScrollTriggerClass(self) {
|
|
1716
1837
|
if (this.#destroyed) return;
|
|
1717
|
-
this.#scrollTriggerClass = self
|
|
1838
|
+
this.#scrollTriggerClass = classOf(self);
|
|
1718
1839
|
}
|
|
1719
1840
|
#createAutoRefreshHandler(userOnRefreshInit) {
|
|
1720
|
-
|
|
1841
|
+
const handle = (self) => {
|
|
1721
1842
|
this.#captureScrollTriggerClass(self);
|
|
1843
|
+
if (isRefreshing(this.#scrollTriggerClass)) holdLiveEvaluationForGsapRefresh(this.#scrollTriggerClass);
|
|
1722
1844
|
const result = userOnRefreshInit?.(self);
|
|
1723
|
-
const inGsapRefresh = this.#scrollTriggerClass
|
|
1724
|
-
|
|
1845
|
+
const inGsapRefresh = isRefreshing(this.#scrollTriggerClass);
|
|
1846
|
+
let caughtUp = false;
|
|
1847
|
+
let refreshed = false;
|
|
1848
|
+
if (inGsapRefresh) {
|
|
1849
|
+
[...pendingCatchUps].forEach(([owner, catchUpNow]) => owner !== this && catchUpNow());
|
|
1850
|
+
caughtUp = pendingCatchUps.get(this)?.() === true;
|
|
1851
|
+
if (caughtUp) this.#dispatchObserver?.takeRecords();
|
|
1852
|
+
}
|
|
1853
|
+
const unchanged = inGsapRefresh && !userOnRefreshInit && !this.#dirty && (caughtUp || this.#dispatchObserver !== null && this.#dispatchObserver.takeRecords().length === 0);
|
|
1725
1854
|
try {
|
|
1726
|
-
if (!unchanged)
|
|
1855
|
+
if (!unchanged) {
|
|
1856
|
+
refreshed = true;
|
|
1857
|
+
this.#refreshFrom(true);
|
|
1858
|
+
}
|
|
1727
1859
|
} catch (error) {
|
|
1728
1860
|
queueMicrotask(() => {
|
|
1729
1861
|
throw error;
|
|
1730
1862
|
});
|
|
1731
1863
|
}
|
|
1732
|
-
if (inGsapRefresh)
|
|
1864
|
+
if (inGsapRefresh) {
|
|
1865
|
+
this.#watchGsapRefresh();
|
|
1866
|
+
if (refreshed || caughtUp) this.#remeasureEarlierInGsapRefresh();
|
|
1867
|
+
}
|
|
1733
1868
|
const restoreDormancy = takeGsapRefreshRestore();
|
|
1734
|
-
|
|
1735
|
-
|
|
1736
|
-
|
|
1737
|
-
|
|
1738
|
-
|
|
1869
|
+
return restoreDormancy ? revertAfterMeasure(restoreDormancy, result) : result;
|
|
1870
|
+
};
|
|
1871
|
+
return (self) => {
|
|
1872
|
+
layerHandlerDepth += 1;
|
|
1873
|
+
try {
|
|
1874
|
+
return handle(self);
|
|
1875
|
+
} finally {
|
|
1876
|
+
layerHandlerDepth -= 1;
|
|
1877
|
+
}
|
|
1739
1878
|
};
|
|
1740
1879
|
}
|
|
1741
1880
|
#watchGsapRefresh() {
|
|
@@ -1748,7 +1887,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1748
1887
|
const end = () => {
|
|
1749
1888
|
observer.disconnect();
|
|
1750
1889
|
if (this.#dispatchObserver === observer) this.#dispatchObserver = null;
|
|
1751
|
-
queueMicrotask(() => cls
|
|
1890
|
+
queueMicrotask(() => removeGsapListener(cls, "refresh", end));
|
|
1752
1891
|
};
|
|
1753
1892
|
observer.observe(document, {
|
|
1754
1893
|
subtree: true,
|
|
@@ -1757,9 +1896,39 @@ var StickyScrollTrigger = (function() {
|
|
|
1757
1896
|
characterData: true
|
|
1758
1897
|
});
|
|
1759
1898
|
this.#dispatchObserver = observer;
|
|
1760
|
-
cls
|
|
1899
|
+
addGsapListener(cls, "refresh", end);
|
|
1761
1900
|
queueMicrotask(end);
|
|
1762
1901
|
}
|
|
1902
|
+
#remeasureEarlierInGsapRefresh() {
|
|
1903
|
+
const refreshed = refreshedInGsapRefresh ?? new Map();
|
|
1904
|
+
if (!refreshedInGsapRefresh) {
|
|
1905
|
+
refreshedInGsapRefresh = refreshed;
|
|
1906
|
+
queueMicrotask(() => {
|
|
1907
|
+
if (refreshedInGsapRefresh === refreshed) refreshedInGsapRefresh = null;
|
|
1908
|
+
});
|
|
1909
|
+
}
|
|
1910
|
+
refreshed.set(this, this.#outsideReads());
|
|
1911
|
+
refreshed.forEach((reads, other) => {
|
|
1912
|
+
if (other.#destroyed || reads === other.#outsideReads()) return;
|
|
1913
|
+
try {
|
|
1914
|
+
other.#refreshFrom(true);
|
|
1915
|
+
} catch (error) {
|
|
1916
|
+
queueMicrotask(() => {
|
|
1917
|
+
throw error;
|
|
1918
|
+
});
|
|
1919
|
+
}
|
|
1920
|
+
other.#dispatchObserver?.takeRecords();
|
|
1921
|
+
refreshed.set(other, other.#outsideReads());
|
|
1922
|
+
});
|
|
1923
|
+
}
|
|
1924
|
+
#outsideReads() {
|
|
1925
|
+
const reads = [documentTop(this.#rootElement)];
|
|
1926
|
+
if (this.#readsPageHeight) reads.push(measureDocumentHeightWithoutPinRanges());
|
|
1927
|
+
[...this.#layers, ...this.#pinLayers].forEach(({ endTrigger }) => {
|
|
1928
|
+
if (!this.#rootElement.contains(endTrigger)) reads.push(documentTop(endTrigger));
|
|
1929
|
+
});
|
|
1930
|
+
return reads.join(",");
|
|
1931
|
+
}
|
|
1763
1932
|
#wrapUnwrappedPins() {
|
|
1764
1933
|
this.#pinLayers.forEach((layer) => {
|
|
1765
1934
|
if (layer.outer) return;
|
|
@@ -1776,16 +1945,14 @@ var StickyScrollTrigger = (function() {
|
|
|
1776
1945
|
range: inner.style.height
|
|
1777
1946
|
}] : []);
|
|
1778
1947
|
wrapped.forEach(({ outer, inner }) => {
|
|
1779
|
-
outer
|
|
1780
|
-
inner
|
|
1948
|
+
clearHeightForRead(outer);
|
|
1949
|
+
clearHeightForRead(inner);
|
|
1781
1950
|
});
|
|
1782
1951
|
const reserved = wrapped.map(({ outer }) => measureUsedHeight(outer));
|
|
1783
1952
|
wrapped.forEach(({ outer }, index) => {
|
|
1784
|
-
outer
|
|
1785
|
-
});
|
|
1786
|
-
wrapped.forEach(({ inner, range }) => {
|
|
1787
|
-
inner.style.height = range;
|
|
1953
|
+
commitHeight(outer, `${reserved[index]}px`);
|
|
1788
1954
|
});
|
|
1955
|
+
wrapped.forEach(({ inner, range }) => commitHeight(inner, range));
|
|
1789
1956
|
}
|
|
1790
1957
|
#unwrapPinLayer(layer) {
|
|
1791
1958
|
if (!layer.outer) return false;
|
|
@@ -1799,7 +1966,13 @@ var StickyScrollTrigger = (function() {
|
|
|
1799
1966
|
return stripStickyPositions(this.#builtLayers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
|
|
1800
1967
|
}
|
|
1801
1968
|
#resetPinStickyState() {
|
|
1802
|
-
|
|
1969
|
+
const restores = this.#pinLayers.filter(({ inner }) => inner).map((layer) => ({
|
|
1970
|
+
layer,
|
|
1971
|
+
restore: stripStickyPositions([layer.trigger])
|
|
1972
|
+
}));
|
|
1973
|
+
return () => restores.forEach(({ layer, restore }) => {
|
|
1974
|
+
if (layer.inner) restore();
|
|
1975
|
+
});
|
|
1803
1976
|
}
|
|
1804
1977
|
#resetStickyState() {
|
|
1805
1978
|
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
@@ -1809,39 +1982,59 @@ var StickyScrollTrigger = (function() {
|
|
|
1809
1982
|
restoreSceneCoverStickyState();
|
|
1810
1983
|
};
|
|
1811
1984
|
}
|
|
1812
|
-
#
|
|
1813
|
-
const
|
|
1985
|
+
#refreshGeometry(viewportHeight) {
|
|
1986
|
+
const active = this.#layers.filter((layer) => layer.wrapper !== null);
|
|
1987
|
+
const wrappers = active.flatMap(({ wrapper }) => wrapper ? [wrapper] : []);
|
|
1988
|
+
const savedWrappers = wrappers.map(captureInlinePosition);
|
|
1989
|
+
const pins = this.#pinLayers.map((layer) => ({
|
|
1814
1990
|
layer,
|
|
1815
1991
|
position: captureInlinePosition(layer.trigger),
|
|
1816
|
-
|
|
1992
|
+
range: layer.inner ? layer.inner.style.height : ""
|
|
1817
1993
|
}));
|
|
1818
|
-
|
|
1819
|
-
|
|
1820
|
-
|
|
1821
|
-
|
|
1822
|
-
|
|
1823
|
-
|
|
1824
|
-
|
|
1825
|
-
|
|
1994
|
+
wrappers.forEach(clearStickyForRead);
|
|
1995
|
+
pins.forEach(({ layer }) => clearStickyForRead(layer.trigger));
|
|
1996
|
+
let stickyTops;
|
|
1997
|
+
let marginTops;
|
|
1998
|
+
try {
|
|
1999
|
+
const measured = active.length ? this.#measureLayers(viewportHeight, active) : null;
|
|
2000
|
+
marginTops = this.#measureScrollMarginTargets(active);
|
|
2001
|
+
stickyTops = measured ? this.#planLayerPositions(viewportHeight, active, measured) : new Map();
|
|
2002
|
+
this.#readsPageHeight = pins.length > 0 || (measured?.measured.some(({ end }) => end.mode === "max") ?? false);
|
|
2003
|
+
} catch (error) {
|
|
2004
|
+
wrappers.forEach((wrapper, i) => commitPosition(wrapper, savedWrappers[i]));
|
|
2005
|
+
pins.forEach(({ layer, position }) => {
|
|
2006
|
+
if (layer.inner) commitPosition(layer.trigger, position);
|
|
1826
2007
|
});
|
|
1827
|
-
|
|
1828
|
-
|
|
1829
|
-
|
|
1830
|
-
if (!this.#pinLayers.length) return;
|
|
1831
|
-
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
1832
|
-
const restorePinState = this.#resetPinState();
|
|
2008
|
+
throw error;
|
|
2009
|
+
}
|
|
2010
|
+
let plannedPins = [];
|
|
1833
2011
|
try {
|
|
1834
|
-
|
|
2012
|
+
if (pins.length) {
|
|
2013
|
+
pins.forEach(({ layer }) => {
|
|
2014
|
+
if (layer.inner) clearHeightForRead(layer.inner);
|
|
2015
|
+
});
|
|
2016
|
+
plannedPins = this.#planPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
|
|
2017
|
+
}
|
|
1835
2018
|
} catch (error) {
|
|
1836
|
-
|
|
2019
|
+
stickyTops.forEach((top, wrapper) => commitSticky(wrapper, top));
|
|
2020
|
+
pins.forEach(({ layer, position, range }) => {
|
|
2021
|
+
if (!layer.inner) return;
|
|
2022
|
+
commitPosition(layer.trigger, position);
|
|
2023
|
+
commitHeight(layer.inner, range);
|
|
2024
|
+
});
|
|
1837
2025
|
throw error;
|
|
1838
|
-
} finally {
|
|
1839
|
-
restoreSceneCoverStickyState();
|
|
1840
2026
|
}
|
|
1841
|
-
|
|
1842
|
-
|
|
1843
|
-
this.#pinLayers.forEach((layer) => {
|
|
2027
|
+
stickyTops.forEach((top, wrapper) => commitSticky(wrapper, top));
|
|
2028
|
+
plannedPins.forEach(({ layer, topPx, range }) => {
|
|
1844
2029
|
if (!layer.inner) return;
|
|
2030
|
+
commitSticky(layer.trigger, topPx);
|
|
2031
|
+
commitHeight(layer.inner, `${range}px`);
|
|
2032
|
+
});
|
|
2033
|
+
this.#syncScrollMargins(marginTops);
|
|
2034
|
+
}
|
|
2035
|
+
#planPinLayers(viewportHeight, documentHeight) {
|
|
2036
|
+
return this.#pinLayers.flatMap((layer) => {
|
|
2037
|
+
if (!layer.inner) return [];
|
|
1845
2038
|
const resolvedStart = resolveMaybeFn(layer.start);
|
|
1846
2039
|
const resolvedEnd = prefixSpacedRelativeEnd(resolvedStart, resolveMaybeFn(layer.end));
|
|
1847
2040
|
const classifiedEnd = classifyPosition(resolvedEnd);
|
|
@@ -1856,26 +2049,14 @@ var StickyScrollTrigger = (function() {
|
|
|
1856
2049
|
const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
|
|
1857
2050
|
const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
|
|
1858
2051
|
const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
|
|
1859
|
-
|
|
1860
|
-
|
|
2052
|
+
return [{
|
|
2053
|
+
layer,
|
|
2054
|
+
topPx,
|
|
2055
|
+
range: Math.max(0, Math.min(height, room))
|
|
2056
|
+
}];
|
|
1861
2057
|
});
|
|
1862
2058
|
}
|
|
1863
|
-
#
|
|
1864
|
-
if (!this.#layers.length) return;
|
|
1865
|
-
const active = this.#layers.filter((layer) => layer.wrapper !== null);
|
|
1866
|
-
if (!active.length) return;
|
|
1867
|
-
const restoreStickyState = this.#resetSceneCoverStickyState();
|
|
1868
|
-
const restorePinStickyState = this.#resetPinStickyState();
|
|
1869
|
-
try {
|
|
1870
|
-
this.#planLayerPositions(viewportHeight, active);
|
|
1871
|
-
} catch (error) {
|
|
1872
|
-
restoreStickyState();
|
|
1873
|
-
throw error;
|
|
1874
|
-
} finally {
|
|
1875
|
-
restorePinStickyState();
|
|
1876
|
-
}
|
|
1877
|
-
}
|
|
1878
|
-
#planLayerPositions(viewportHeight, active) {
|
|
2059
|
+
#measureLayers(viewportHeight, active) {
|
|
1879
2060
|
const structureTop = this.#outermostContainer ? documentTop(this.#outermostContainer) : 0;
|
|
1880
2061
|
this.#measuredStructure = {
|
|
1881
2062
|
top: structureTop,
|
|
@@ -1885,14 +2066,22 @@ var StickyScrollTrigger = (function() {
|
|
|
1885
2066
|
active.forEach((layer, index) => {
|
|
1886
2067
|
indexByTrigger.set(layer.trigger, index);
|
|
1887
2068
|
});
|
|
1888
|
-
|
|
2069
|
+
return {
|
|
2070
|
+
structureTop,
|
|
2071
|
+
measured: active.map((layer, ownIndex) => measureLayer(this.#rootElement, viewportHeight, layer, ownIndex, indexByTrigger))
|
|
2072
|
+
};
|
|
2073
|
+
}
|
|
2074
|
+
#planLayerPositions(viewportHeight, active, { structureTop, measured }) {
|
|
2075
|
+
const needsLiveRemeasure = measured.some((measurement) => measurement.end.mode === "clause" && measurement.end.measureLive);
|
|
2076
|
+
const needsMaxRemeasure = measured.some((measurement) => measurement.end.mode === "max");
|
|
1889
2077
|
let documentMaxScroll = 0;
|
|
2078
|
+
let measureLive = false;
|
|
1890
2079
|
const stickyTops = new Map();
|
|
1891
2080
|
const applyLayers = () => planLayers(measured, {
|
|
1892
2081
|
viewportHeight,
|
|
1893
2082
|
structureTop,
|
|
1894
2083
|
documentMaxScroll,
|
|
1895
|
-
measureLiveEndTriggerTop: (index) => documentTop(active[index].endTrigger),
|
|
2084
|
+
measureLiveEndTriggerTop: (index) => measureLive ? documentTop(active[index].endTrigger) : 0,
|
|
1896
2085
|
onPlanned: (index, plan) => {
|
|
1897
2086
|
const layer = active[index];
|
|
1898
2087
|
layer.freezeStart = plan.freezeStart;
|
|
@@ -1901,25 +2090,137 @@ var StickyScrollTrigger = (function() {
|
|
|
1901
2090
|
layer.engagedEnd = plan.engagedEnd;
|
|
1902
2091
|
if (!layer.wrapper) return;
|
|
1903
2092
|
stickyTops.set(layer.wrapper, plan.stickyTop);
|
|
1904
|
-
if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding
|
|
2093
|
+
if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) commitHeight(layer.padding, `${plan.paddingHeight}px`);
|
|
1905
2094
|
}
|
|
1906
2095
|
});
|
|
2096
|
+
this.#reevaluateLiveEnds(active, measured, () => {
|
|
2097
|
+
const heights = active.map(() => 0);
|
|
2098
|
+
planLayers(measured, {
|
|
2099
|
+
viewportHeight,
|
|
2100
|
+
structureTop,
|
|
2101
|
+
documentMaxScroll,
|
|
2102
|
+
measureLiveEndTriggerTop: () => 0,
|
|
2103
|
+
onPlanned: (index, plan) => {
|
|
2104
|
+
heights[index] = plan.paddingHeight ?? 0;
|
|
2105
|
+
}
|
|
2106
|
+
});
|
|
2107
|
+
return heights;
|
|
2108
|
+
});
|
|
1907
2109
|
applyLayers();
|
|
1908
|
-
|
|
1909
|
-
|
|
1910
|
-
if (needsMaxRemeasure) documentMaxScroll = measureDocumentMaxScroll(viewportHeight);
|
|
2110
|
+
if (needsMaxRemeasure) documentMaxScroll = Math.max(0, measureDocumentHeightWithoutPinRanges() - viewportHeight);
|
|
2111
|
+
measureLive = true;
|
|
1911
2112
|
if (needsLiveRemeasure || needsMaxRemeasure) applyLayers();
|
|
1912
|
-
stickyTops
|
|
2113
|
+
return stickyTops;
|
|
2114
|
+
}
|
|
2115
|
+
#reevaluateLiveEnds(active, measured, planPaddings) {
|
|
2116
|
+
const live = measured.flatMap(({ liveEnd }, index) => liveEnd ? [{
|
|
2117
|
+
index,
|
|
2118
|
+
liveEnd
|
|
2119
|
+
}] : []);
|
|
2120
|
+
if (!live.length) return;
|
|
2121
|
+
const scrollBefore = window.scrollY;
|
|
2122
|
+
try {
|
|
2123
|
+
for (let round = 0; round < LIVE_END_ROUNDS; round += 1) {
|
|
2124
|
+
const planned = planPaddings();
|
|
2125
|
+
let moved = false;
|
|
2126
|
+
live.forEach(({ index, liveEnd }) => {
|
|
2127
|
+
const next = this.#evaluateLiveEnd(active, planned, index, liveEnd, scrollBefore);
|
|
2128
|
+
const current = measured[index].end;
|
|
2129
|
+
if (!next || next.mode !== current.mode) return;
|
|
2130
|
+
if (Math.abs(liveEndValue(next) - liveEndValue(current)) <= LIVE_END_TOLERANCE_PX) return;
|
|
2131
|
+
measured[index] = {
|
|
2132
|
+
...measured[index],
|
|
2133
|
+
end: next
|
|
2134
|
+
};
|
|
2135
|
+
moved = true;
|
|
2136
|
+
});
|
|
2137
|
+
if (!moved) break;
|
|
2138
|
+
}
|
|
2139
|
+
} finally {
|
|
2140
|
+
scrollBackTo(scrollBefore);
|
|
2141
|
+
}
|
|
2142
|
+
}
|
|
2143
|
+
#evaluateLiveEnd(active, planned, index, liveEnd, scroll) {
|
|
2144
|
+
const spacers = active.flatMap((layer, k) => k < index && layer.kind === "scene" && planned[k] ? [{
|
|
2145
|
+
after: layer.trigger,
|
|
2146
|
+
height: planned[k]
|
|
2147
|
+
}] : []);
|
|
2148
|
+
const setUp = () => {
|
|
2149
|
+
const later = [...armedInstances].filter((other) => other !== this && compareDocumentOrder(this.#rootElement, other.#rootElement) < 0);
|
|
2150
|
+
const paddings = [this, ...later].flatMap((instance) => instance.#layers.flatMap((layer) => layer.kind === "scene" && layer.padding ? [layer.padding] : []));
|
|
2151
|
+
const heights = paddings.map((padding) => padding.style.height);
|
|
2152
|
+
paddings.forEach((padding) => commitHeight(padding, "0px"));
|
|
2153
|
+
const removeSpacers = insertSpacers(spacers);
|
|
2154
|
+
return () => {
|
|
2155
|
+
removeSpacers();
|
|
2156
|
+
paddings.forEach((padding, k) => {
|
|
2157
|
+
if (padding.style.height === "0px") commitHeight(padding, heights[k]);
|
|
2158
|
+
});
|
|
2159
|
+
};
|
|
2160
|
+
};
|
|
2161
|
+
let takeDown = () => {};
|
|
2162
|
+
let holds = 0;
|
|
2163
|
+
const evaluation = {
|
|
2164
|
+
resolved: false,
|
|
2165
|
+
ended: false,
|
|
2166
|
+
outer: liveEvaluation,
|
|
2167
|
+
scroll: liveEvaluation?.scroll ?? scroll,
|
|
2168
|
+
suspend: (resolving) => {
|
|
2169
|
+
if (resolving) evaluation.resolved = true;
|
|
2170
|
+
holds += 1;
|
|
2171
|
+
if (holds === 1) {
|
|
2172
|
+
takeDown();
|
|
2173
|
+
takeDown = () => {};
|
|
2174
|
+
}
|
|
2175
|
+
return () => {
|
|
2176
|
+
holds -= 1;
|
|
2177
|
+
if (holds === 0 && !evaluation.ended) takeDown = setUp();
|
|
2178
|
+
};
|
|
2179
|
+
}
|
|
2180
|
+
};
|
|
2181
|
+
try {
|
|
2182
|
+
takeDown = setUp();
|
|
2183
|
+
liveEvaluation = evaluation;
|
|
2184
|
+
const next = liveEnd();
|
|
2185
|
+
return evaluation.resolved ? null : next;
|
|
2186
|
+
} finally {
|
|
2187
|
+
evaluation.ended = true;
|
|
2188
|
+
liveEvaluation = evaluation.outer;
|
|
2189
|
+
takeDown();
|
|
2190
|
+
}
|
|
1913
2191
|
}
|
|
1914
2192
|
refresh() {
|
|
2193
|
+
this.#refreshFrom(false);
|
|
2194
|
+
}
|
|
2195
|
+
#refreshFrom(refreshInit) {
|
|
2196
|
+
if (this.#depth > 0 && !this.#dirty) {
|
|
2197
|
+
if (!refreshInit) {
|
|
2198
|
+
this.#measureAgain = true;
|
|
2199
|
+
return;
|
|
2200
|
+
}
|
|
2201
|
+
if (this.#refreshInitNestedUsed) return;
|
|
2202
|
+
this.#refreshInitNestedUsed = true;
|
|
2203
|
+
}
|
|
2204
|
+
this.#runRefresh();
|
|
2205
|
+
}
|
|
2206
|
+
#runRefresh() {
|
|
2207
|
+
if (this.#depth > 0) this.#measureAgain = true;
|
|
1915
2208
|
if (this.#destroyed || !this.#armed || pendingDisarms.has(this)) return;
|
|
1916
2209
|
let failure = null;
|
|
1917
2210
|
const position = this.#keepContentPending ? this.#naturalScrollTop(this.#builtLayers) : null;
|
|
1918
2211
|
this.#keepContentPending = false;
|
|
2212
|
+
this.#depth += 1;
|
|
1919
2213
|
try {
|
|
1920
2214
|
this.#refreshLayout();
|
|
2215
|
+
if (this.#depth === 1 && this.#measureAgain && !this.#destroyed && this.#armed && !pendingDisarms.has(this)) this.#refreshLayout();
|
|
1921
2216
|
} catch (error) {
|
|
1922
2217
|
failure = { error };
|
|
2218
|
+
} finally {
|
|
2219
|
+
this.#depth -= 1;
|
|
2220
|
+
if (this.#depth === 0) {
|
|
2221
|
+
this.#refreshInitNestedUsed = false;
|
|
2222
|
+
this.#measureAgain = false;
|
|
2223
|
+
}
|
|
1923
2224
|
}
|
|
1924
2225
|
try {
|
|
1925
2226
|
rebuildDormancy(this.#scrollTriggerClass);
|
|
@@ -1933,15 +2234,10 @@ var StickyScrollTrigger = (function() {
|
|
|
1933
2234
|
if (!failure && position !== null) this.#keepContent(position);
|
|
1934
2235
|
if (failure) throw failure.error;
|
|
1935
2236
|
}
|
|
1936
|
-
#gsapScrollRecord() {
|
|
1937
|
-
if (!this.#scrollTriggerClass?.isRefreshing) return null;
|
|
1938
|
-
const scrollFunc = this.#scrollTriggerClass.getScrollFunc?.(window);
|
|
1939
|
-
return scrollFunc && typeof scrollFunc.rec === "number" && scrollFunc.rec ? scrollFunc : null;
|
|
1940
|
-
}
|
|
1941
2237
|
#naturalScrollTop(layers) {
|
|
1942
2238
|
const measured = this.#measuredStructure;
|
|
1943
2239
|
const moved = measured && this.#outermostContainer && measured.unbuilds !== unbuildCount ? documentTop(this.#outermostContainer) - measured.top : 0;
|
|
1944
|
-
const scroll = (this.#
|
|
2240
|
+
const scroll = (scrollRecord(this.#scrollTriggerClass)?.read() ?? window.scrollY) - moved;
|
|
1945
2241
|
const consumed = new Map();
|
|
1946
2242
|
layers.forEach((layer) => {
|
|
1947
2243
|
if (layer.kind !== "scene") return;
|
|
@@ -1954,20 +2250,17 @@ var StickyScrollTrigger = (function() {
|
|
|
1954
2250
|
}
|
|
1955
2251
|
#keepContent(position, cls = this.#scrollTriggerClass) {
|
|
1956
2252
|
const target = this.#keptScrollTop(position);
|
|
1957
|
-
const record = this.#
|
|
2253
|
+
const record = scrollRecord(this.#scrollTriggerClass);
|
|
1958
2254
|
if (record) {
|
|
1959
|
-
record.
|
|
2255
|
+
record.write(target);
|
|
1960
2256
|
return;
|
|
1961
2257
|
}
|
|
1962
|
-
if (cls
|
|
2258
|
+
if (isRefreshing(cls)) return;
|
|
1963
2259
|
if (Math.abs(window.scrollY - target) >= .5) window.scrollTo({
|
|
1964
2260
|
top: Math.round(target),
|
|
1965
2261
|
behavior: "instant"
|
|
1966
2262
|
});
|
|
1967
|
-
|
|
1968
|
-
if (typeof scrollFunc !== "function") return;
|
|
1969
|
-
const cached = scrollFunc();
|
|
1970
|
-
if (typeof cached !== "number" || Math.abs(cached - window.scrollY) >= .5) scrollFunc(window.scrollY);
|
|
2263
|
+
syncScrollCache(cls);
|
|
1971
2264
|
}
|
|
1972
2265
|
#keptScrollTop({ natural, consumed }) {
|
|
1973
2266
|
let earlierDwell = 0;
|
|
@@ -1994,9 +2287,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1994
2287
|
this.#liftCovers();
|
|
1995
2288
|
}
|
|
1996
2289
|
const viewportHeight = this.#layers.length || this.#pinLayers.length ? measureViewportHeight() : 0;
|
|
1997
|
-
this.#
|
|
1998
|
-
this.#refreshPins(viewportHeight);
|
|
1999
|
-
this.#syncScrollMargins();
|
|
2290
|
+
this.#refreshGeometry(viewportHeight);
|
|
2000
2291
|
}
|
|
2001
2292
|
#coverLayers() {
|
|
2002
2293
|
return this.#layers.filter((layer) => layer.kind === "cover");
|
|
@@ -2010,15 +2301,21 @@ var StickyScrollTrigger = (function() {
|
|
|
2010
2301
|
this.#coverRestoreByLayer.set(layer, liftAboveStickyWrapper(pin?.outer ?? layer.cover));
|
|
2011
2302
|
});
|
|
2012
2303
|
}
|
|
2013
|
-
#syncScrollMargins() {
|
|
2304
|
+
#syncScrollMargins(tops) {
|
|
2014
2305
|
this.#scrollMarginSync?.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
|
|
2015
|
-
|
|
2016
|
-
|
|
2017
|
-
|
|
2018
|
-
|
|
2019
|
-
|
|
2306
|
+
const late = targets.filter((target) => !tops.has(target));
|
|
2307
|
+
if (late.length) {
|
|
2308
|
+
const restoreStickyState = this.#resetStickyState();
|
|
2309
|
+
late.forEach((target) => tops.set(target, documentTop(target)));
|
|
2310
|
+
restoreStickyState();
|
|
2311
|
+
}
|
|
2312
|
+
return targets.map((target) => tops.get(target));
|
|
2020
2313
|
});
|
|
2021
2314
|
}
|
|
2315
|
+
#measureScrollMarginTargets(active) {
|
|
2316
|
+
const targets = this.#scrollMarginSync && active.some(({ kind }) => kind === "scene") ? this.#scrollMarginSync.targets() : [];
|
|
2317
|
+
return new Map(targets.map((target) => [target, documentTop(target)]));
|
|
2318
|
+
}
|
|
2022
2319
|
#assertNoExcludedVars(rest, context) {
|
|
2023
2320
|
const found = EXCLUDED_VAR_KEYS.filter((key) => key in rest);
|
|
2024
2321
|
if (found.length === 0) return;
|
|
@@ -2043,6 +2340,7 @@ var StickyScrollTrigger = (function() {
|
|
|
2043
2340
|
this.#arm();
|
|
2044
2341
|
this.#layers.push(layer);
|
|
2045
2342
|
this.#dirty = true;
|
|
2343
|
+
if (this.#depth > 0) this.#measureAgain = true;
|
|
2046
2344
|
return {
|
|
2047
2345
|
...rest,
|
|
2048
2346
|
trigger: layer.trigger,
|
|
@@ -2051,6 +2349,10 @@ var StickyScrollTrigger = (function() {
|
|
|
2051
2349
|
invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
|
|
2052
2350
|
onKill: (self) => {
|
|
2053
2351
|
this.#captureScrollTriggerClass(self);
|
|
2352
|
+
if (!this.#layers.includes(layer)) {
|
|
2353
|
+
onKill?.(self);
|
|
2354
|
+
return;
|
|
2355
|
+
}
|
|
2054
2356
|
removeItem(this.#layers, layer);
|
|
2055
2357
|
this.#dirty = true;
|
|
2056
2358
|
this.#scheduleRebuild();
|
|
@@ -2132,6 +2434,7 @@ var StickyScrollTrigger = (function() {
|
|
|
2132
2434
|
};
|
|
2133
2435
|
this.#arm();
|
|
2134
2436
|
this.#pinLayers.push(layer);
|
|
2437
|
+
if (this.#depth > 0) this.#measureAgain = true;
|
|
2135
2438
|
return {
|
|
2136
2439
|
...rest,
|
|
2137
2440
|
trigger,
|
|
@@ -2146,6 +2449,14 @@ var StickyScrollTrigger = (function() {
|
|
|
2146
2449
|
};
|
|
2147
2450
|
}
|
|
2148
2451
|
resolveScrollPosition(elementInput, position) {
|
|
2452
|
+
const resume = liveEvaluation && suspendLiveEvaluations(liveEvaluation, true);
|
|
2453
|
+
try {
|
|
2454
|
+
return this.#resolveScrollPosition(elementInput, position);
|
|
2455
|
+
} finally {
|
|
2456
|
+
resume?.();
|
|
2457
|
+
}
|
|
2458
|
+
}
|
|
2459
|
+
#resolveScrollPosition(elementInput, position) {
|
|
2149
2460
|
const element = resolveElement(elementInput, "resolveScrollPosition");
|
|
2150
2461
|
const resolved = resolveMaybeFn(position);
|
|
2151
2462
|
const viewportHeight = measureViewportHeight();
|