sticky-scroll-trigger 0.12.0 → 0.13.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.13.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
|
|
@@ -1288,7 +1288,6 @@ var StickyScrollTrigger = (function() {
|
|
|
1288
1288
|
if (usesJsRamp) {
|
|
1289
1289
|
jsRamps = ramps;
|
|
1290
1290
|
jsHost = host;
|
|
1291
|
-
applyJsRamp();
|
|
1292
1291
|
return;
|
|
1293
1292
|
}
|
|
1294
1293
|
if (!sheet) {
|
|
@@ -1334,6 +1333,9 @@ var StickyScrollTrigger = (function() {
|
|
|
1334
1333
|
});
|
|
1335
1334
|
written = next;
|
|
1336
1335
|
},
|
|
1336
|
+
applyRamps() {
|
|
1337
|
+
applyJsRamp();
|
|
1338
|
+
},
|
|
1337
1339
|
restore() {
|
|
1338
1340
|
if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
|
|
1339
1341
|
release();
|
|
@@ -1363,6 +1365,11 @@ var StickyScrollTrigger = (function() {
|
|
|
1363
1365
|
}
|
|
1364
1366
|
return outermost;
|
|
1365
1367
|
};
|
|
1368
|
+
const unbuildCover = (layer) => {
|
|
1369
|
+
if (!layer.wrapper) return;
|
|
1370
|
+
unwrapCover(layer.wrapper);
|
|
1371
|
+
layer.wrapper = null;
|
|
1372
|
+
};
|
|
1366
1373
|
const unbuildStructure = (rootElement, layers, outermostContainer) => {
|
|
1367
1374
|
if (outermostContainer) {
|
|
1368
1375
|
outermostContainer.parentNode?.insertBefore(rootElement, outermostContainer);
|
|
@@ -1370,15 +1377,13 @@ var StickyScrollTrigger = (function() {
|
|
|
1370
1377
|
}
|
|
1371
1378
|
for (let i = layers.length - 1; i >= 0; i -= 1) {
|
|
1372
1379
|
const layer = layers[i];
|
|
1373
|
-
if (layer.kind === "cover"
|
|
1374
|
-
|
|
1375
|
-
|
|
1376
|
-
layer.wrapper = null;
|
|
1377
|
-
if (layer.kind === "scene") {
|
|
1380
|
+
if (layer.kind === "cover") unbuildCover(layer);
|
|
1381
|
+
else {
|
|
1382
|
+
layer.wrapper = null;
|
|
1378
1383
|
layer.container = null;
|
|
1379
1384
|
layer.padding = null;
|
|
1380
1385
|
}
|
|
1381
|
-
}
|
|
1386
|
+
}
|
|
1382
1387
|
};
|
|
1383
1388
|
const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex) => {
|
|
1384
1389
|
if (endResolved === null) return { mode: "auto" };
|
|
@@ -1493,19 +1498,45 @@ var StickyScrollTrigger = (function() {
|
|
|
1493
1498
|
if (index !== -1) list.splice(index, 1);
|
|
1494
1499
|
};
|
|
1495
1500
|
const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
|
|
1501
|
+
const pendingDisarms = new Set();
|
|
1502
|
+
const pendingKeeps = new Set();
|
|
1503
|
+
let unbuildCount = 0;
|
|
1504
|
+
const REST_POLL_MS = 100;
|
|
1505
|
+
const runEach = (...steps) => {
|
|
1506
|
+
let failure = null;
|
|
1507
|
+
steps.forEach((step) => {
|
|
1508
|
+
try {
|
|
1509
|
+
step();
|
|
1510
|
+
} catch (error) {
|
|
1511
|
+
if (!failure) failure = { error };
|
|
1512
|
+
else queueMicrotask(() => {
|
|
1513
|
+
throw error;
|
|
1514
|
+
});
|
|
1515
|
+
}
|
|
1516
|
+
});
|
|
1517
|
+
if (failure) throw failure.error;
|
|
1518
|
+
};
|
|
1496
1519
|
var StickyScrollTrigger = class {
|
|
1497
1520
|
#rootElement;
|
|
1498
1521
|
#layers = [];
|
|
1499
1522
|
#builtLayers = [];
|
|
1523
|
+
#measuredStructure = null;
|
|
1500
1524
|
#coverRestoreByLayer = new WeakMap();
|
|
1501
1525
|
#built = false;
|
|
1502
1526
|
#dirty = false;
|
|
1503
1527
|
#outermostContainer = null;
|
|
1504
1528
|
#destroyed = false;
|
|
1505
1529
|
#rebuildScheduled = false;
|
|
1530
|
+
#keepContentPending = false;
|
|
1531
|
+
#deferredRun = null;
|
|
1532
|
+
#restTimer = null;
|
|
1533
|
+
#pendingKeep = null;
|
|
1506
1534
|
#scrollTriggerClass = null;
|
|
1507
1535
|
#pinLayers = [];
|
|
1508
|
-
#scrollMarginSync;
|
|
1536
|
+
#scrollMarginSync = null;
|
|
1537
|
+
#scrollMarginTargets;
|
|
1538
|
+
#armed = false;
|
|
1539
|
+
#dispatchObserver = null;
|
|
1509
1540
|
#dormancyClient = null;
|
|
1510
1541
|
constructor(root, options = {}) {
|
|
1511
1542
|
this.#rootElement = resolveRoot(root);
|
|
@@ -1521,14 +1552,101 @@ var StickyScrollTrigger = (function() {
|
|
|
1521
1552
|
"always",
|
|
1522
1553
|
"off"
|
|
1523
1554
|
].includes(optimization)) throw new Error(`StickyScrollTrigger: nestedStickyOptimization must be 'auto', 'always' or 'off', got ${String(optimization)}.`);
|
|
1524
|
-
this.#
|
|
1525
|
-
if (optimization === "always" || optimization === "auto" && isWebKit()) {
|
|
1526
|
-
|
|
1527
|
-
|
|
1528
|
-
|
|
1529
|
-
|
|
1530
|
-
|
|
1555
|
+
this.#scrollMarginTargets = scrollMarginTargets;
|
|
1556
|
+
if (optimization === "always" || optimization === "auto" && isWebKit()) this.#dormancyClient = {
|
|
1557
|
+
mode: optimization,
|
|
1558
|
+
ownedElements: () => this.#ownedStickyElements()
|
|
1559
|
+
};
|
|
1560
|
+
}
|
|
1561
|
+
#arm() {
|
|
1562
|
+
if (pendingDisarms.delete(this)) this.#keepContentPending = false;
|
|
1563
|
+
if (this.#armed) return;
|
|
1564
|
+
this.#armed = true;
|
|
1565
|
+
pendingKeeps.forEach((keep) => {
|
|
1566
|
+
if (keep.owner.#overlaps(this)) keep.cancelled = true;
|
|
1567
|
+
});
|
|
1568
|
+
this.#scrollMarginSync = createScrollMarginSync(this.#rootElement, this.#scrollMarginTargets);
|
|
1569
|
+
if (this.#dormancyClient) registerDormancyClient(this.#dormancyClient);
|
|
1570
|
+
}
|
|
1571
|
+
#disarmIfEmpty() {
|
|
1572
|
+
if (this.#armed && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) {
|
|
1573
|
+
if (pendingDisarms.has(this)) return;
|
|
1574
|
+
if (!this.#scrollTriggerClass?.isRefreshing && this.#scrolling()) {
|
|
1575
|
+
pendingDisarms.add(this);
|
|
1576
|
+
queueMicrotask(() => this.#settleWhenAtRest());
|
|
1577
|
+
return;
|
|
1578
|
+
}
|
|
1579
|
+
this.#disarmKeepingContent(true, true);
|
|
1580
|
+
}
|
|
1581
|
+
}
|
|
1582
|
+
#flushOverlappingDisarms() {
|
|
1583
|
+
if (this.#destroyed) return;
|
|
1584
|
+
pendingDisarms.forEach((other) => {
|
|
1585
|
+
if (other !== this && other.#overlaps(this)) other.#flushPendingDisarmForRevert();
|
|
1586
|
+
});
|
|
1587
|
+
}
|
|
1588
|
+
#scrolling() {
|
|
1589
|
+
const cls = this.#scrollTriggerClass;
|
|
1590
|
+
return Boolean(cls?.isScrolling?.() || cls?.isUpdating === true);
|
|
1591
|
+
}
|
|
1592
|
+
#disarmKeepingContent(keepContent, onlyAtRest = false) {
|
|
1593
|
+
const position = keepContent && this.#built ? this.#naturalScrollTop(this.#builtLayers) : null;
|
|
1594
|
+
this.#keepContentPending = false;
|
|
1595
|
+
this.#disarm();
|
|
1596
|
+
if (!position) return;
|
|
1597
|
+
if (this.#gsapScrollRecord()) {
|
|
1598
|
+
this.#keepContent(position);
|
|
1599
|
+
return;
|
|
1600
|
+
}
|
|
1601
|
+
if (this.#pendingKeep) pendingKeeps.delete(this.#pendingKeep);
|
|
1602
|
+
this.#pendingKeep = {
|
|
1603
|
+
owner: this,
|
|
1604
|
+
position,
|
|
1605
|
+
cls: this.#scrollTriggerClass,
|
|
1606
|
+
onlyAtRest,
|
|
1607
|
+
cancelled: false
|
|
1608
|
+
};
|
|
1609
|
+
pendingKeeps.add(this.#pendingKeep);
|
|
1610
|
+
queueMicrotask(() => this.#applyPendingKeep());
|
|
1611
|
+
}
|
|
1612
|
+
#applyPendingKeep() {
|
|
1613
|
+
const keep = this.#pendingKeep;
|
|
1614
|
+
if (!keep) return;
|
|
1615
|
+
this.#pendingKeep = null;
|
|
1616
|
+
pendingKeeps.delete(keep);
|
|
1617
|
+
if (keep.cancelled || keep.onlyAtRest && keep.cls?.isScrolling?.()) return;
|
|
1618
|
+
this.#keepContent(keep.position, keep.cls);
|
|
1619
|
+
}
|
|
1620
|
+
#overlaps(other) {
|
|
1621
|
+
return this.#rootElement.contains(other.#rootElement) || other.#rootElement.contains(this.#rootElement);
|
|
1622
|
+
}
|
|
1623
|
+
#settleWhenAtRest() {
|
|
1624
|
+
if (this.#destroyed || this.#restTimer !== null) return;
|
|
1625
|
+
if (this.#scrollTriggerClass?.isScrolling?.()) {
|
|
1626
|
+
this.#restTimer = setTimeout(() => {
|
|
1627
|
+
this.#restTimer = null;
|
|
1628
|
+
this.#settleWhenAtRest();
|
|
1629
|
+
}, REST_POLL_MS);
|
|
1630
|
+
return;
|
|
1531
1631
|
}
|
|
1632
|
+
const run = this.#deferredRun;
|
|
1633
|
+
this.#deferredRun = null;
|
|
1634
|
+
runEach(() => this.#flushPendingDisarm(), () => run?.());
|
|
1635
|
+
}
|
|
1636
|
+
#flushPendingDisarm(keepContent = true, onlyAtRest = false) {
|
|
1637
|
+
if (pendingDisarms.delete(this) && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) this.#disarmKeepingContent(keepContent, onlyAtRest);
|
|
1638
|
+
}
|
|
1639
|
+
#flushPendingDisarmForRevert() {
|
|
1640
|
+
this.#flushPendingDisarm(!this.#scrollTriggerClass?.isScrolling?.(), true);
|
|
1641
|
+
}
|
|
1642
|
+
#disarm() {
|
|
1643
|
+
this.#armed = false;
|
|
1644
|
+
unregisterDormancyClient(this.#dormancyClient);
|
|
1645
|
+
this.#scrollMarginSync?.restore();
|
|
1646
|
+
this.#scrollMarginSync = null;
|
|
1647
|
+
this.#restoreCoverLifts();
|
|
1648
|
+
this.#unbuild();
|
|
1649
|
+
this.#builtLayers = [];
|
|
1532
1650
|
}
|
|
1533
1651
|
#ownedStickyElements() {
|
|
1534
1652
|
return [...this.#builtLayers.flatMap((layer) => layer.wrapper ? [layer.wrapper] : []), ...this.#wrappedPinTriggers()];
|
|
@@ -1539,6 +1657,8 @@ var StickyScrollTrigger = (function() {
|
|
|
1539
1657
|
#unbuild() {
|
|
1540
1658
|
if (!this.#built) return;
|
|
1541
1659
|
unbuildStructure(this.#rootElement, this.#builtLayers, this.#outermostContainer);
|
|
1660
|
+
unbuildCount += 1;
|
|
1661
|
+
this.#measuredStructure = null;
|
|
1542
1662
|
this.#outermostContainer = null;
|
|
1543
1663
|
this.#built = false;
|
|
1544
1664
|
}
|
|
@@ -1548,14 +1668,48 @@ var StickyScrollTrigger = (function() {
|
|
|
1548
1668
|
this.#built = true;
|
|
1549
1669
|
this.#dirty = false;
|
|
1550
1670
|
}
|
|
1671
|
+
#catchUp() {
|
|
1672
|
+
this.#flushPendingDisarm();
|
|
1673
|
+
this.refresh();
|
|
1674
|
+
this.#applyPendingKeep();
|
|
1675
|
+
}
|
|
1551
1676
|
#scheduleRebuild() {
|
|
1552
|
-
if (this.#
|
|
1677
|
+
if (this.#destroyed) return;
|
|
1678
|
+
if (this.#built) this.#keepContentPending = true;
|
|
1679
|
+
if (this.#rebuildScheduled) return;
|
|
1553
1680
|
this.#rebuildScheduled = true;
|
|
1554
|
-
|
|
1681
|
+
const cls = this.#scrollTriggerClass;
|
|
1682
|
+
const onRefreshInit = () => {
|
|
1683
|
+
if (!this.#rebuildScheduled || this.#destroyed) return void 0;
|
|
1684
|
+
try {
|
|
1685
|
+
this.#catchUp();
|
|
1686
|
+
} catch (error) {
|
|
1687
|
+
queueMicrotask(() => {
|
|
1688
|
+
throw error;
|
|
1689
|
+
});
|
|
1690
|
+
} finally {
|
|
1691
|
+
this.#rebuildScheduled = false;
|
|
1692
|
+
}
|
|
1693
|
+
const restoreDormancy = takeGsapRefreshRestore();
|
|
1694
|
+
return restoreDormancy ? { render: () => restoreDormancy() } : void 0;
|
|
1695
|
+
};
|
|
1696
|
+
cls?.addEventListener?.("refreshInit", onRefreshInit);
|
|
1697
|
+
const run = () => {
|
|
1698
|
+
cls?.removeEventListener?.("refreshInit", onRefreshInit);
|
|
1699
|
+
if (!this.#rebuildScheduled) return;
|
|
1555
1700
|
this.#rebuildScheduled = false;
|
|
1556
1701
|
if (this.#destroyed) return;
|
|
1557
|
-
this
|
|
1702
|
+
this.#catchUp();
|
|
1558
1703
|
if (typeof this.#scrollTriggerClass?.refresh === "function") this.#scrollTriggerClass.refresh();
|
|
1704
|
+
};
|
|
1705
|
+
queueMicrotask(() => {
|
|
1706
|
+
if (this.#rebuildScheduled && !this.#destroyed && cls?.isScrolling?.()) {
|
|
1707
|
+
const earlier = this.#deferredRun;
|
|
1708
|
+
this.#deferredRun = earlier ? () => runEach(earlier, run) : run;
|
|
1709
|
+
this.#settleWhenAtRest();
|
|
1710
|
+
return;
|
|
1711
|
+
}
|
|
1712
|
+
run();
|
|
1559
1713
|
});
|
|
1560
1714
|
}
|
|
1561
1715
|
#captureScrollTriggerClass(self) {
|
|
@@ -1566,13 +1720,16 @@ var StickyScrollTrigger = (function() {
|
|
|
1566
1720
|
return (self) => {
|
|
1567
1721
|
this.#captureScrollTriggerClass(self);
|
|
1568
1722
|
const result = userOnRefreshInit?.(self);
|
|
1723
|
+
const inGsapRefresh = this.#scrollTriggerClass?.isRefreshing === true;
|
|
1724
|
+
const unchanged = inGsapRefresh && !userOnRefreshInit && this.#dispatchObserver !== null && this.#dispatchObserver.takeRecords().length === 0;
|
|
1569
1725
|
try {
|
|
1570
|
-
this.refresh();
|
|
1726
|
+
if (!unchanged) this.refresh();
|
|
1571
1727
|
} catch (error) {
|
|
1572
1728
|
queueMicrotask(() => {
|
|
1573
1729
|
throw error;
|
|
1574
1730
|
});
|
|
1575
1731
|
}
|
|
1732
|
+
if (inGsapRefresh) this.#watchGsapRefresh();
|
|
1576
1733
|
const restoreDormancy = takeGsapRefreshRestore();
|
|
1577
1734
|
if (!restoreDormancy) return result;
|
|
1578
1735
|
return { render: (time) => {
|
|
@@ -1581,6 +1738,28 @@ var StickyScrollTrigger = (function() {
|
|
|
1581
1738
|
} };
|
|
1582
1739
|
};
|
|
1583
1740
|
}
|
|
1741
|
+
#watchGsapRefresh() {
|
|
1742
|
+
if (this.#dispatchObserver) {
|
|
1743
|
+
this.#dispatchObserver.takeRecords();
|
|
1744
|
+
return;
|
|
1745
|
+
}
|
|
1746
|
+
const observer = new MutationObserver(() => {});
|
|
1747
|
+
const cls = this.#scrollTriggerClass;
|
|
1748
|
+
const end = () => {
|
|
1749
|
+
observer.disconnect();
|
|
1750
|
+
if (this.#dispatchObserver === observer) this.#dispatchObserver = null;
|
|
1751
|
+
queueMicrotask(() => cls?.removeEventListener?.("refresh", end));
|
|
1752
|
+
};
|
|
1753
|
+
observer.observe(document, {
|
|
1754
|
+
subtree: true,
|
|
1755
|
+
childList: true,
|
|
1756
|
+
attributes: true,
|
|
1757
|
+
characterData: true
|
|
1758
|
+
});
|
|
1759
|
+
this.#dispatchObserver = observer;
|
|
1760
|
+
cls?.addEventListener?.("refresh", end);
|
|
1761
|
+
queueMicrotask(end);
|
|
1762
|
+
}
|
|
1584
1763
|
#wrapUnwrappedPins() {
|
|
1585
1764
|
this.#pinLayers.forEach((layer) => {
|
|
1586
1765
|
if (layer.outer) return;
|
|
@@ -1617,7 +1796,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1617
1796
|
return true;
|
|
1618
1797
|
}
|
|
1619
1798
|
#resetSceneCoverStickyState() {
|
|
1620
|
-
return stripStickyPositions(this.#
|
|
1799
|
+
return stripStickyPositions(this.#builtLayers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
|
|
1621
1800
|
}
|
|
1622
1801
|
#resetPinStickyState() {
|
|
1623
1802
|
return stripStickyPositions(this.#wrappedPinTriggers());
|
|
@@ -1666,7 +1845,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1666
1845
|
const resolvedStart = resolveMaybeFn(layer.start);
|
|
1667
1846
|
const resolvedEnd = prefixSpacedRelativeEnd(resolvedStart, resolveMaybeFn(layer.end));
|
|
1668
1847
|
const classifiedEnd = classifyPosition(resolvedEnd);
|
|
1669
|
-
if (classifiedEnd.kind === "max") throw new Error(`StickyScrollTrigger: createStickyPin's end "${resolvedEnd}" uses GSAP's 'max' keyword, which isn't supported here
|
|
1848
|
+
if (classifiedEnd.kind === "max") throw new Error(`StickyScrollTrigger: createStickyPin's end "${resolvedEnd}" uses GSAP's 'max' keyword, which isn't supported here. Use a position clause against endTrigger, such as 'top top'.`);
|
|
1670
1849
|
const triggerTop = documentTop(layer.trigger);
|
|
1671
1850
|
const triggerHeight = measureUsedHeight(layer.trigger);
|
|
1672
1851
|
const triggerMarginBottom = parseFloat(getComputedStyle(layer.trigger).marginBottom) || 0;
|
|
@@ -1698,12 +1877,17 @@ var StickyScrollTrigger = (function() {
|
|
|
1698
1877
|
}
|
|
1699
1878
|
#planLayerPositions(viewportHeight, active) {
|
|
1700
1879
|
const structureTop = this.#outermostContainer ? documentTop(this.#outermostContainer) : 0;
|
|
1880
|
+
this.#measuredStructure = {
|
|
1881
|
+
top: structureTop,
|
|
1882
|
+
unbuilds: unbuildCount
|
|
1883
|
+
};
|
|
1701
1884
|
const indexByTrigger = new Map();
|
|
1702
1885
|
active.forEach((layer, index) => {
|
|
1703
1886
|
indexByTrigger.set(layer.trigger, index);
|
|
1704
1887
|
});
|
|
1705
1888
|
const measured = active.map((layer, ownIndex) => measureLayer(this.#rootElement, viewportHeight, layer, ownIndex, indexByTrigger));
|
|
1706
1889
|
let documentMaxScroll = 0;
|
|
1890
|
+
const stickyTops = new Map();
|
|
1707
1891
|
const applyLayers = () => planLayers(measured, {
|
|
1708
1892
|
viewportHeight,
|
|
1709
1893
|
structureTop,
|
|
@@ -1716,7 +1900,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1716
1900
|
layer.engagedStart = plan.engagedStart;
|
|
1717
1901
|
layer.engagedEnd = plan.engagedEnd;
|
|
1718
1902
|
if (!layer.wrapper) return;
|
|
1719
|
-
|
|
1903
|
+
stickyTops.set(layer.wrapper, plan.stickyTop);
|
|
1720
1904
|
if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
|
|
1721
1905
|
}
|
|
1722
1906
|
});
|
|
@@ -1725,10 +1909,13 @@ var StickyScrollTrigger = (function() {
|
|
|
1725
1909
|
const needsMaxRemeasure = measured.some((measurement) => measurement.end.mode === "max");
|
|
1726
1910
|
if (needsMaxRemeasure) documentMaxScroll = measureDocumentMaxScroll(viewportHeight);
|
|
1727
1911
|
if (needsLiveRemeasure || needsMaxRemeasure) applyLayers();
|
|
1912
|
+
stickyTops.forEach((top, wrapper) => applyStickyPosition(wrapper, top));
|
|
1728
1913
|
}
|
|
1729
1914
|
refresh() {
|
|
1730
|
-
if (this.#destroyed) return;
|
|
1915
|
+
if (this.#destroyed || !this.#armed || pendingDisarms.has(this)) return;
|
|
1731
1916
|
let failure = null;
|
|
1917
|
+
const position = this.#keepContentPending ? this.#naturalScrollTop(this.#builtLayers) : null;
|
|
1918
|
+
this.#keepContentPending = false;
|
|
1732
1919
|
try {
|
|
1733
1920
|
this.#refreshLayout();
|
|
1734
1921
|
} catch (error) {
|
|
@@ -1742,8 +1929,58 @@ var StickyScrollTrigger = (function() {
|
|
|
1742
1929
|
throw error;
|
|
1743
1930
|
});
|
|
1744
1931
|
}
|
|
1932
|
+
this.#scrollMarginSync?.applyRamps();
|
|
1933
|
+
if (!failure && position !== null) this.#keepContent(position);
|
|
1745
1934
|
if (failure) throw failure.error;
|
|
1746
1935
|
}
|
|
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
|
+
#naturalScrollTop(layers) {
|
|
1942
|
+
const measured = this.#measuredStructure;
|
|
1943
|
+
const moved = measured && this.#outermostContainer && measured.unbuilds !== unbuildCount ? documentTop(this.#outermostContainer) - measured.top : 0;
|
|
1944
|
+
const scroll = (this.#gsapScrollRecord()?.rec ?? window.scrollY) - moved;
|
|
1945
|
+
const consumed = new Map();
|
|
1946
|
+
layers.forEach((layer) => {
|
|
1947
|
+
if (layer.kind !== "scene") return;
|
|
1948
|
+
consumed.set(layer.trigger, scroll > layer.engagedEnd ? Infinity : dwellConsumedAt(scroll, this.#engagedWindows([layer])));
|
|
1949
|
+
});
|
|
1950
|
+
return {
|
|
1951
|
+
natural: scroll - dwellConsumedAt(scroll, this.#engagedWindows(layers)) + moved,
|
|
1952
|
+
consumed
|
|
1953
|
+
};
|
|
1954
|
+
}
|
|
1955
|
+
#keepContent(position, cls = this.#scrollTriggerClass) {
|
|
1956
|
+
const target = this.#keptScrollTop(position);
|
|
1957
|
+
const record = this.#gsapScrollRecord();
|
|
1958
|
+
if (record) {
|
|
1959
|
+
record.rec = target;
|
|
1960
|
+
return;
|
|
1961
|
+
}
|
|
1962
|
+
if (cls?.isRefreshing) return;
|
|
1963
|
+
if (Math.abs(window.scrollY - target) >= .5) window.scrollTo({
|
|
1964
|
+
top: Math.round(target),
|
|
1965
|
+
behavior: "instant"
|
|
1966
|
+
});
|
|
1967
|
+
const scrollFunc = cls?.getScrollFunc?.(window);
|
|
1968
|
+
if (typeof scrollFunc !== "function") return;
|
|
1969
|
+
const cached = scrollFunc();
|
|
1970
|
+
if (typeof cached !== "number" || Math.abs(cached - window.scrollY) >= .5) scrollFunc(window.scrollY);
|
|
1971
|
+
}
|
|
1972
|
+
#keptScrollTop({ natural, consumed }) {
|
|
1973
|
+
let earlierDwell = 0;
|
|
1974
|
+
let target = natural;
|
|
1975
|
+
this.#builtLayers.flatMap((layer) => layer.kind === "scene" ? [layer] : []).sort((a, b) => a.engagedStart - b.engagedStart).forEach((layer) => {
|
|
1976
|
+
const dwell = layer.engagedEnd - layer.engagedStart;
|
|
1977
|
+
const before = consumed.get(layer.trigger);
|
|
1978
|
+
if (before !== void 0) target += Math.min(before, dwell);
|
|
1979
|
+
else if (layer.engagedStart < natural + earlierDwell - .05) target += dwell;
|
|
1980
|
+
earlierDwell += dwell;
|
|
1981
|
+
});
|
|
1982
|
+
return target;
|
|
1983
|
+
}
|
|
1747
1984
|
#refreshLayout() {
|
|
1748
1985
|
if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
|
|
1749
1986
|
this.#unbuild();
|
|
@@ -1774,7 +2011,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1774
2011
|
});
|
|
1775
2012
|
}
|
|
1776
2013
|
#syncScrollMargins() {
|
|
1777
|
-
this.#scrollMarginSync
|
|
2014
|
+
this.#scrollMarginSync?.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
|
|
1778
2015
|
if (!targets.length) return [];
|
|
1779
2016
|
const restoreStickyState = this.#resetStickyState();
|
|
1780
2017
|
const tops = targets.map((target) => documentTop(target));
|
|
@@ -1803,6 +2040,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1803
2040
|
if (this.#destroyed) throw new Error("StickyScrollTrigger: cannot register a new layer after destroy() has been called.");
|
|
1804
2041
|
this.#assertTriggerAvailable(this.#layers, layer.trigger, `StickyScrollTrigger: ${describeElement(layer.trigger)} is already registered as a trigger for another layer. Each element can be used once per controller instance, across createStickyTrigger and createOverlapScroll: reusing one makes endTrigger resolution ambiguous.`);
|
|
1805
2042
|
this.#assertTriggerAvailable(this.#pinLayers, layer.trigger, `StickyScrollTrigger: ${describeElement(layer.trigger)} is already registered as a pin trigger (createStickyPin). Using the same element as both a Scene/Cover trigger and a pin trigger wraps it twice and produces conflicting position:sticky behavior.`);
|
|
2043
|
+
this.#arm();
|
|
1806
2044
|
this.#layers.push(layer);
|
|
1807
2045
|
this.#dirty = true;
|
|
1808
2046
|
return {
|
|
@@ -1816,6 +2054,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1816
2054
|
removeItem(this.#layers, layer);
|
|
1817
2055
|
this.#dirty = true;
|
|
1818
2056
|
this.#scheduleRebuild();
|
|
2057
|
+
this.#disarmIfEmpty();
|
|
1819
2058
|
onKill?.(self);
|
|
1820
2059
|
},
|
|
1821
2060
|
onRefreshInit: this.#createAutoRefreshHandler(rest.onRefreshInit)
|
|
@@ -1823,6 +2062,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1823
2062
|
}
|
|
1824
2063
|
createStickyTrigger({ trigger: triggerInput, start = "0 0", end = "100% 0", endTrigger: endTriggerInput, onKill, ...rest }) {
|
|
1825
2064
|
this.#assertNoExcludedVars(rest, "createStickyTrigger");
|
|
2065
|
+
this.#flushOverlappingDisarms();
|
|
1826
2066
|
const trigger = resolveElement(triggerInput, "createStickyTrigger");
|
|
1827
2067
|
this.#assertTriggerInsideRoot(trigger, "createStickyTrigger");
|
|
1828
2068
|
const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createStickyTrigger");
|
|
@@ -1843,6 +2083,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1843
2083
|
}
|
|
1844
2084
|
createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
|
|
1845
2085
|
this.#assertNoExcludedVars(rest, "createOverlapScroll");
|
|
2086
|
+
this.#flushOverlappingDisarms();
|
|
1846
2087
|
const trigger = resolveElement(triggerInput, "createOverlapScroll");
|
|
1847
2088
|
this.#assertTriggerInsideRoot(trigger, "createOverlapScroll");
|
|
1848
2089
|
const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createOverlapScroll");
|
|
@@ -1864,6 +2105,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1864
2105
|
};
|
|
1865
2106
|
const vars = this.#registerLayer(layer, (self) => {
|
|
1866
2107
|
this.#coverRestoreByLayer.get(layer)?.();
|
|
2108
|
+
unbuildCover(layer);
|
|
1867
2109
|
onKill?.(self);
|
|
1868
2110
|
}, rest);
|
|
1869
2111
|
this.#coverRestoreByLayer.set(layer, liftAboveStickyWrapper(coverElement));
|
|
@@ -1871,6 +2113,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1871
2113
|
}
|
|
1872
2114
|
createStickyPin({ trigger: triggerInput, start, top, endTrigger: endTriggerInput, end = "bottom top", onKill, ...rest }) {
|
|
1873
2115
|
this.#assertNoExcludedVars(rest, "createStickyPin");
|
|
2116
|
+
this.#flushOverlappingDisarms();
|
|
1874
2117
|
if (this.#destroyed) throw new Error("StickyScrollTrigger: cannot register a new pin after destroy() has been called.");
|
|
1875
2118
|
if (start !== void 0 && top !== void 0) throw new Error("StickyScrollTrigger: createStickyPin accepts either start or top, not both (top: 20 is start: 'top 20px'). Use top for a plain px distance from the viewport's top edge, start for anything else.");
|
|
1876
2119
|
const trigger = resolveElement(triggerInput, "createStickyPin");
|
|
@@ -1887,6 +2130,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1887
2130
|
endTrigger,
|
|
1888
2131
|
end
|
|
1889
2132
|
};
|
|
2133
|
+
this.#arm();
|
|
1890
2134
|
this.#pinLayers.push(layer);
|
|
1891
2135
|
return {
|
|
1892
2136
|
...rest,
|
|
@@ -1895,6 +2139,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1895
2139
|
this.#captureScrollTriggerClass(self);
|
|
1896
2140
|
removeItem(this.#pinLayers, layer);
|
|
1897
2141
|
if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
|
|
2142
|
+
this.#disarmIfEmpty();
|
|
1898
2143
|
onKill?.(self);
|
|
1899
2144
|
},
|
|
1900
2145
|
onRefreshInit: this.#createAutoRefreshHandler(rest.onRefreshInit)
|
|
@@ -1923,8 +2168,8 @@ var StickyScrollTrigger = (function() {
|
|
|
1923
2168
|
if (!this.#rootElement.contains(element)) return reachedAt;
|
|
1924
2169
|
return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
|
|
1925
2170
|
}
|
|
1926
|
-
#engagedWindows() {
|
|
1927
|
-
return
|
|
2171
|
+
#engagedWindows(layers = this.#builtLayers) {
|
|
2172
|
+
return layers.flatMap((layer) => layer.kind === "scene" ? [{
|
|
1928
2173
|
freezeStart: layer.engagedStart,
|
|
1929
2174
|
freezeEnd: layer.engagedEnd
|
|
1930
2175
|
}] : []);
|
|
@@ -1940,6 +2185,7 @@ var StickyScrollTrigger = (function() {
|
|
|
1940
2185
|
}
|
|
1941
2186
|
createResolvedTrigger({ trigger: triggerInput, start = "top bottom", end = "bottom top", endTrigger: endTriggerInput, ...rest }) {
|
|
1942
2187
|
this.#assertNoExcludedVars(rest, "createResolvedTrigger");
|
|
2188
|
+
this.#flushOverlappingDisarms();
|
|
1943
2189
|
const trigger = resolveElement(triggerInput, "createResolvedTrigger");
|
|
1944
2190
|
const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createResolvedTrigger");
|
|
1945
2191
|
return {
|
|
@@ -1956,13 +2202,17 @@ var StickyScrollTrigger = (function() {
|
|
|
1956
2202
|
}
|
|
1957
2203
|
destroy() {
|
|
1958
2204
|
if (this.#destroyed) return;
|
|
2205
|
+
runEach(() => this.#flushPendingDisarmForRevert(), () => this.#tearDown());
|
|
2206
|
+
}
|
|
2207
|
+
#tearDown() {
|
|
2208
|
+
if (this.#restTimer !== null) clearTimeout(this.#restTimer);
|
|
2209
|
+
this.#restTimer = null;
|
|
1959
2210
|
this.#destroyed = true;
|
|
1960
|
-
|
|
1961
|
-
this.#
|
|
1962
|
-
|
|
1963
|
-
this.#
|
|
2211
|
+
const run = this.#deferredRun;
|
|
2212
|
+
this.#deferredRun = null;
|
|
2213
|
+
run?.();
|
|
2214
|
+
if (this.#armed) this.#disarm();
|
|
1964
2215
|
this.#layers.length = 0;
|
|
1965
|
-
this.#builtLayers = [];
|
|
1966
2216
|
this.#pinLayers.forEach((layer) => this.#unwrapPinLayer(layer));
|
|
1967
2217
|
this.#pinLayers.length = 0;
|
|
1968
2218
|
this.#scrollTriggerClass = null;
|