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