sticky-scroll-trigger 0.12.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
|
|
@@ -86,10 +86,6 @@ const resetStickyPosition = (el) => {
|
|
|
86
86
|
el.style.position = "";
|
|
87
87
|
el.style.top = "";
|
|
88
88
|
};
|
|
89
|
-
const applyStickyPosition = (el, topPx) => {
|
|
90
|
-
el.style.position = "sticky";
|
|
91
|
-
el.style.top = `${topPx}px`;
|
|
92
|
-
};
|
|
93
89
|
const captureInlinePosition = (el) => ({
|
|
94
90
|
position: el.style.position,
|
|
95
91
|
top: el.style.top
|
|
@@ -103,6 +99,15 @@ const stripStickyPositions = (elements) => {
|
|
|
103
99
|
elements.forEach(resetStickyPosition);
|
|
104
100
|
return () => elements.forEach((el, i) => restoreInlinePosition(el, saved[i]));
|
|
105
101
|
};
|
|
102
|
+
const insertSpacers = (spacers) => {
|
|
103
|
+
const inserted = spacers.map(({ after, height }) => {
|
|
104
|
+
const spacer = document.createElement("div");
|
|
105
|
+
spacer.style.cssText = `height:${height}px;margin:0;padding:0;border:0`;
|
|
106
|
+
after.after(spacer);
|
|
107
|
+
return spacer;
|
|
108
|
+
});
|
|
109
|
+
return () => inserted.forEach((spacer) => spacer.remove());
|
|
110
|
+
};
|
|
106
111
|
const wrapScene = (inner, holdTrailingMargin) => {
|
|
107
112
|
if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
|
|
108
113
|
const container = document.createElement("div");
|
|
@@ -205,6 +210,41 @@ const liftAboveStickyWrapper = (cover) => {
|
|
|
205
210
|
lifted.length = 0;
|
|
206
211
|
};
|
|
207
212
|
};
|
|
213
|
+
const classOf = (self) => self.constructor;
|
|
214
|
+
const isRefreshing = (cls) => cls?.isRefreshing === true;
|
|
215
|
+
const isScrolling = (cls) => Boolean(cls?.isScrolling?.());
|
|
216
|
+
const isScrollingOrUpdating = (cls) => Boolean(cls?.isScrolling?.() || cls?.isUpdating === true);
|
|
217
|
+
const addGsapListener = (cls, type, callback) => {
|
|
218
|
+
cls?.addEventListener?.(type, callback);
|
|
219
|
+
};
|
|
220
|
+
const removeGsapListener = (cls, type, callback) => {
|
|
221
|
+
cls?.removeEventListener?.(type, callback);
|
|
222
|
+
};
|
|
223
|
+
const refreshAll = (cls) => {
|
|
224
|
+
if (typeof cls?.refresh === "function") cls.refresh();
|
|
225
|
+
};
|
|
226
|
+
const scrollRecord = (cls, zero = false) => {
|
|
227
|
+
if (!cls || !isRefreshing(cls)) return null;
|
|
228
|
+
const scrollFunc = cls.getScrollFunc?.(window);
|
|
229
|
+
if (!(scrollFunc && typeof scrollFunc.rec === "number" && (zero || scrollFunc.rec))) return null;
|
|
230
|
+
const record = scrollFunc;
|
|
231
|
+
return {
|
|
232
|
+
read: () => record.rec,
|
|
233
|
+
write: (value) => {
|
|
234
|
+
record.rec = value;
|
|
235
|
+
}
|
|
236
|
+
};
|
|
237
|
+
};
|
|
238
|
+
const syncScrollCache = (cls) => {
|
|
239
|
+
const scrollFunc = cls?.getScrollFunc?.(window);
|
|
240
|
+
if (typeof scrollFunc !== "function") return;
|
|
241
|
+
const cached = scrollFunc();
|
|
242
|
+
if (typeof cached !== "number" || Math.abs(cached - window.scrollY) >= .5) scrollFunc(window.scrollY);
|
|
243
|
+
};
|
|
244
|
+
const revertAfterMeasure = (restore, result) => ({ render: (time) => {
|
|
245
|
+
result?.render?.(time);
|
|
246
|
+
restore();
|
|
247
|
+
} });
|
|
208
248
|
const AUTO_MIN_DEPTH = 7;
|
|
209
249
|
const MAX_CHAIN_IN_BAND = 4;
|
|
210
250
|
const BUFFER_FLOOR_PX = 325;
|
|
@@ -280,7 +320,7 @@ let gsapPhase = "idle";
|
|
|
280
320
|
let adoptedMidRefresh = false;
|
|
281
321
|
let scannedThisTask = null;
|
|
282
322
|
const gsapClasses = new Set();
|
|
283
|
-
const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => cls
|
|
323
|
+
const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => isRefreshing(cls));
|
|
284
324
|
const stateAt = (record, scroll) => {
|
|
285
325
|
if (!record.demotable) return "in";
|
|
286
326
|
if (scroll < record.lo - buffer) return "before";
|
|
@@ -358,22 +398,22 @@ const onGsapRefreshInit = () => {
|
|
|
358
398
|
queueMicrotask(onGsapRefreshDone);
|
|
359
399
|
if (records.length) update(0);
|
|
360
400
|
}
|
|
361
|
-
return
|
|
401
|
+
return revertAfterMeasure(restoreAfterGsapMeasure);
|
|
362
402
|
};
|
|
363
403
|
const adoptGsapClass = (cls) => {
|
|
364
404
|
if (gsapClasses.has(cls)) return;
|
|
365
|
-
if (cls
|
|
405
|
+
if (isRefreshing(cls)) adoptedMidRefresh = true;
|
|
366
406
|
gsapClasses.add(cls);
|
|
367
|
-
cls
|
|
368
|
-
cls
|
|
407
|
+
addGsapListener(cls, "refresh", onGsapRefreshDone);
|
|
408
|
+
addGsapListener(cls, "refreshInit", onGsapRefreshInit);
|
|
369
409
|
};
|
|
370
410
|
const dropGsapClassesLater = () => {
|
|
371
411
|
if (!gsapClasses.size) return;
|
|
372
412
|
queueMicrotask(() => {
|
|
373
413
|
if (liveClients().length) return;
|
|
374
414
|
gsapClasses.forEach((cls) => {
|
|
375
|
-
cls
|
|
376
|
-
cls
|
|
415
|
+
removeGsapListener(cls, "refresh", onGsapRefreshDone);
|
|
416
|
+
removeGsapListener(cls, "refreshInit", onGsapRefreshInit);
|
|
377
417
|
});
|
|
378
418
|
gsapClasses.clear();
|
|
379
419
|
});
|
|
@@ -606,7 +646,14 @@ const rebuildDormancy = (scrollTriggerClass) => {
|
|
|
606
646
|
update(gsapPhase === "measuring" ? 0 : (gsapPhase === "restored" ? scrollBeforeGsapRefresh : null) ?? scroll);
|
|
607
647
|
listen(true);
|
|
608
648
|
};
|
|
609
|
-
const takeGsapRefreshRestore = () =>
|
|
649
|
+
const takeGsapRefreshRestore = () => {
|
|
650
|
+
if (!adoptedMidRefresh || !gsapRefreshing()) return null;
|
|
651
|
+
onGsapRefreshInit();
|
|
652
|
+
return restoreAfterGsapMeasure;
|
|
653
|
+
};
|
|
654
|
+
const setGsapRefreshReturn = (scroll) => {
|
|
655
|
+
if (gsapPhase !== "idle") scrollBeforeGsapRefresh = scroll;
|
|
656
|
+
};
|
|
610
657
|
const clearDormancy = clearTable;
|
|
611
658
|
const releaseDormant = (elements) => {
|
|
612
659
|
const released = new Set(elements);
|
|
@@ -637,6 +684,24 @@ const unregisterDormancyClient = (client) => {
|
|
|
637
684
|
if (liveClients().length) queueRebuild();
|
|
638
685
|
else teardown();
|
|
639
686
|
};
|
|
687
|
+
const commitSticky = (el, topPx) => {
|
|
688
|
+
el.style.position = "sticky";
|
|
689
|
+
el.style.top = `${topPx}px`;
|
|
690
|
+
};
|
|
691
|
+
const commitPosition = (el, saved) => {
|
|
692
|
+
el.style.position = saved.position;
|
|
693
|
+
el.style.top = saved.top;
|
|
694
|
+
};
|
|
695
|
+
const commitHeight = (el, height) => {
|
|
696
|
+
el.style.height = height;
|
|
697
|
+
};
|
|
698
|
+
const clearStickyForRead = (el) => {
|
|
699
|
+
el.style.position = "";
|
|
700
|
+
el.style.top = "";
|
|
701
|
+
};
|
|
702
|
+
const clearHeightForRead = (el) => {
|
|
703
|
+
el.style.height = "";
|
|
704
|
+
};
|
|
640
705
|
const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
|
|
641
706
|
const KEYWORD_FRACTIONS = {
|
|
642
707
|
top: 0,
|
|
@@ -1287,7 +1352,6 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
1287
1352
|
if (usesJsRamp) {
|
|
1288
1353
|
jsRamps = ramps;
|
|
1289
1354
|
jsHost = host;
|
|
1290
|
-
applyJsRamp();
|
|
1291
1355
|
return;
|
|
1292
1356
|
}
|
|
1293
1357
|
if (!sheet) {
|
|
@@ -1302,6 +1366,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
1302
1366
|
stopRamps();
|
|
1303
1367
|
};
|
|
1304
1368
|
return {
|
|
1369
|
+
targets: () => targetSelector === null ? [] : Array.from(rootElement.querySelectorAll(targetSelector)),
|
|
1305
1370
|
sync(scenes, host, measureNaturalTops) {
|
|
1306
1371
|
const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
|
|
1307
1372
|
if (targetSelector === null || !ramps.length || !host) {
|
|
@@ -1333,6 +1398,9 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
|
|
|
1333
1398
|
});
|
|
1334
1399
|
written = next;
|
|
1335
1400
|
},
|
|
1401
|
+
applyRamps() {
|
|
1402
|
+
applyJsRamp();
|
|
1403
|
+
},
|
|
1336
1404
|
restore() {
|
|
1337
1405
|
if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
|
|
1338
1406
|
release();
|
|
@@ -1362,6 +1430,11 @@ const buildStructure = (rootElement, layers) => {
|
|
|
1362
1430
|
}
|
|
1363
1431
|
return outermost;
|
|
1364
1432
|
};
|
|
1433
|
+
const unbuildCover = (layer) => {
|
|
1434
|
+
if (!layer.wrapper) return;
|
|
1435
|
+
unwrapCover(layer.wrapper);
|
|
1436
|
+
layer.wrapper = null;
|
|
1437
|
+
};
|
|
1365
1438
|
const unbuildStructure = (rootElement, layers, outermostContainer) => {
|
|
1366
1439
|
if (outermostContainer) {
|
|
1367
1440
|
outermostContainer.parentNode?.insertBefore(rootElement, outermostContainer);
|
|
@@ -1369,15 +1442,13 @@ const unbuildStructure = (rootElement, layers, outermostContainer) => {
|
|
|
1369
1442
|
}
|
|
1370
1443
|
for (let i = layers.length - 1; i >= 0; i -= 1) {
|
|
1371
1444
|
const layer = layers[i];
|
|
1372
|
-
if (layer.kind === "cover"
|
|
1373
|
-
|
|
1374
|
-
|
|
1375
|
-
layer.wrapper = null;
|
|
1376
|
-
if (layer.kind === "scene") {
|
|
1445
|
+
if (layer.kind === "cover") unbuildCover(layer);
|
|
1446
|
+
else {
|
|
1447
|
+
layer.wrapper = null;
|
|
1377
1448
|
layer.container = null;
|
|
1378
1449
|
layer.padding = null;
|
|
1379
1450
|
}
|
|
1380
|
-
}
|
|
1451
|
+
}
|
|
1381
1452
|
};
|
|
1382
1453
|
const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex) => {
|
|
1383
1454
|
if (endResolved === null) return { mode: "auto" };
|
|
@@ -1439,6 +1510,8 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
|
|
|
1439
1510
|
const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
|
|
1440
1511
|
const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
|
|
1441
1512
|
const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
|
|
1513
|
+
const { end: endInput } = layer;
|
|
1514
|
+
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;
|
|
1442
1515
|
return {
|
|
1443
1516
|
kind: layer.kind,
|
|
1444
1517
|
start,
|
|
@@ -1454,7 +1527,8 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
|
|
|
1454
1527
|
height: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
|
|
1455
1528
|
enclosedBy: endTriggerInContainer ? indicesWhere((trigger) => trigger.contains(layer.endTrigger)) : [],
|
|
1456
1529
|
nests: endTriggerInContainer ? indicesWhere((other) => other !== layer.endTrigger && layer.endTrigger.contains(other)) : []
|
|
1457
|
-
}
|
|
1530
|
+
},
|
|
1531
|
+
liveEnd
|
|
1458
1532
|
};
|
|
1459
1533
|
};
|
|
1460
1534
|
const EXCLUDED_VAR_KEYS = [
|
|
@@ -1491,20 +1565,94 @@ const removeItem = (list, item) => {
|
|
|
1491
1565
|
const index = list.indexOf(item);
|
|
1492
1566
|
if (index !== -1) list.splice(index, 1);
|
|
1493
1567
|
};
|
|
1568
|
+
const suspendLiveEvaluations = (evaluation, resolving) => {
|
|
1569
|
+
const resumes = [];
|
|
1570
|
+
for (let current = evaluation; current; current = current.outer) resumes.unshift(current.suspend(resolving && current === evaluation));
|
|
1571
|
+
return () => resumes.forEach((resume) => resume());
|
|
1572
|
+
};
|
|
1573
|
+
const liveEndValue = (spec) => {
|
|
1574
|
+
if (spec.mode === "dwell") return spec.distancePx;
|
|
1575
|
+
return spec.mode === "absolute" ? spec.value : 0;
|
|
1576
|
+
};
|
|
1577
|
+
const LIVE_END_ROUNDS = 6;
|
|
1578
|
+
const LIVE_END_TOLERANCE_PX = .5;
|
|
1494
1579
|
const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
|
|
1580
|
+
const pendingDisarms = new Set();
|
|
1581
|
+
const pendingKeeps = new Set();
|
|
1582
|
+
const pendingCatchUps = new Map();
|
|
1583
|
+
let unbuildCount = 0;
|
|
1584
|
+
let refreshedInGsapRefresh = null;
|
|
1585
|
+
const armedInstances = new Set();
|
|
1586
|
+
let liveEvaluation = null;
|
|
1587
|
+
let layerHandlerDepth = 0;
|
|
1588
|
+
const scrollBackTo = (top) => {
|
|
1589
|
+
if (Math.abs(window.scrollY - top) >= .5) window.scrollTo({
|
|
1590
|
+
top,
|
|
1591
|
+
behavior: "instant"
|
|
1592
|
+
});
|
|
1593
|
+
};
|
|
1594
|
+
const holdLiveEvaluationForGsapRefresh = (cls) => {
|
|
1595
|
+
const evaluation = liveEvaluation;
|
|
1596
|
+
if (!evaluation) return;
|
|
1597
|
+
const resume = suspendLiveEvaluations(evaluation, false);
|
|
1598
|
+
const record = scrollRecord(cls, true);
|
|
1599
|
+
if (record && Math.abs(record.read() - evaluation.scroll) >= .5) {
|
|
1600
|
+
scrollBackTo(Math.round(evaluation.scroll));
|
|
1601
|
+
syncScrollCache(cls);
|
|
1602
|
+
record.write(window.scrollY);
|
|
1603
|
+
setGsapRefreshReturn(window.scrollY);
|
|
1604
|
+
}
|
|
1605
|
+
const depth = layerHandlerDepth - 1;
|
|
1606
|
+
let held = true;
|
|
1607
|
+
liveEvaluation = null;
|
|
1608
|
+
const onRefresh = () => {
|
|
1609
|
+
if (!held || layerHandlerDepth > depth) return;
|
|
1610
|
+
held = false;
|
|
1611
|
+
resume();
|
|
1612
|
+
if (!evaluation.ended) liveEvaluation = evaluation;
|
|
1613
|
+
};
|
|
1614
|
+
addGsapListener(cls, "refresh", onRefresh);
|
|
1615
|
+
queueMicrotask(() => removeGsapListener(cls, "refresh", onRefresh));
|
|
1616
|
+
};
|
|
1617
|
+
const REST_POLL_MS = 100;
|
|
1618
|
+
const runEach = (...steps) => {
|
|
1619
|
+
let failure = null;
|
|
1620
|
+
steps.forEach((step) => {
|
|
1621
|
+
try {
|
|
1622
|
+
step();
|
|
1623
|
+
} catch (error) {
|
|
1624
|
+
if (!failure) failure = { error };
|
|
1625
|
+
else queueMicrotask(() => {
|
|
1626
|
+
throw error;
|
|
1627
|
+
});
|
|
1628
|
+
}
|
|
1629
|
+
});
|
|
1630
|
+
if (failure) throw failure.error;
|
|
1631
|
+
};
|
|
1495
1632
|
var StickyScrollTrigger = class {
|
|
1496
1633
|
#rootElement;
|
|
1497
1634
|
#layers = [];
|
|
1498
1635
|
#builtLayers = [];
|
|
1636
|
+
#measuredStructure = null;
|
|
1499
1637
|
#coverRestoreByLayer = new WeakMap();
|
|
1500
1638
|
#built = false;
|
|
1501
1639
|
#dirty = false;
|
|
1502
1640
|
#outermostContainer = null;
|
|
1503
1641
|
#destroyed = false;
|
|
1504
|
-
#
|
|
1642
|
+
#depth = 0;
|
|
1643
|
+
#refreshInitNestedUsed = false;
|
|
1644
|
+
#measureAgain = false;
|
|
1645
|
+
#keepContentPending = false;
|
|
1646
|
+
#deferredRun = null;
|
|
1647
|
+
#restTimer = null;
|
|
1648
|
+
#pendingKeep = null;
|
|
1505
1649
|
#scrollTriggerClass = null;
|
|
1506
1650
|
#pinLayers = [];
|
|
1507
|
-
#scrollMarginSync;
|
|
1651
|
+
#scrollMarginSync = null;
|
|
1652
|
+
#scrollMarginTargets;
|
|
1653
|
+
#armed = false;
|
|
1654
|
+
#dispatchObserver = null;
|
|
1655
|
+
#readsPageHeight = false;
|
|
1508
1656
|
#dormancyClient = null;
|
|
1509
1657
|
constructor(root, options = {}) {
|
|
1510
1658
|
this.#rootElement = resolveRoot(root);
|
|
@@ -1520,15 +1668,101 @@ var StickyScrollTrigger = class {
|
|
|
1520
1668
|
"always",
|
|
1521
1669
|
"off"
|
|
1522
1670
|
].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
|
-
|
|
1671
|
+
this.#scrollMarginTargets = scrollMarginTargets;
|
|
1672
|
+
if (optimization === "always" || optimization === "auto" && isWebKit()) this.#dormancyClient = {
|
|
1673
|
+
mode: optimization,
|
|
1674
|
+
ownedElements: () => this.#ownedStickyElements()
|
|
1675
|
+
};
|
|
1676
|
+
}
|
|
1677
|
+
#arm() {
|
|
1678
|
+
if (pendingDisarms.delete(this)) this.#keepContentPending = false;
|
|
1679
|
+
if (this.#armed) return;
|
|
1680
|
+
this.#armed = true;
|
|
1681
|
+
armedInstances.add(this);
|
|
1682
|
+
pendingKeeps.forEach((keep) => {
|
|
1683
|
+
if (keep.owner.#overlaps(this)) keep.cancelled = true;
|
|
1684
|
+
});
|
|
1685
|
+
this.#scrollMarginSync = createScrollMarginSync(this.#rootElement, this.#scrollMarginTargets);
|
|
1686
|
+
if (this.#dormancyClient) registerDormancyClient(this.#dormancyClient);
|
|
1687
|
+
}
|
|
1688
|
+
#disarmIfEmpty() {
|
|
1689
|
+
if (this.#armed && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) {
|
|
1690
|
+
if (pendingDisarms.has(this)) return;
|
|
1691
|
+
const cls = this.#scrollTriggerClass;
|
|
1692
|
+
if (!isRefreshing(cls) && isScrollingOrUpdating(cls)) {
|
|
1693
|
+
pendingDisarms.add(this);
|
|
1694
|
+
queueMicrotask(() => this.#settleWhenAtRest());
|
|
1695
|
+
return;
|
|
1696
|
+
}
|
|
1697
|
+
this.#disarmKeepingContent(true, true);
|
|
1530
1698
|
}
|
|
1531
1699
|
}
|
|
1700
|
+
#flushOverlappingDisarms() {
|
|
1701
|
+
if (this.#destroyed) return;
|
|
1702
|
+
pendingDisarms.forEach((other) => {
|
|
1703
|
+
if (other !== this && other.#overlaps(this)) other.#flushPendingDisarmForRevert();
|
|
1704
|
+
});
|
|
1705
|
+
}
|
|
1706
|
+
#disarmKeepingContent(keepContent, onlyAtRest = false) {
|
|
1707
|
+
const position = keepContent && this.#built ? this.#naturalScrollTop(this.#builtLayers) : null;
|
|
1708
|
+
this.#keepContentPending = false;
|
|
1709
|
+
this.#disarm();
|
|
1710
|
+
if (!position) return;
|
|
1711
|
+
if (scrollRecord(this.#scrollTriggerClass)) {
|
|
1712
|
+
this.#keepContent(position);
|
|
1713
|
+
return;
|
|
1714
|
+
}
|
|
1715
|
+
if (this.#pendingKeep) pendingKeeps.delete(this.#pendingKeep);
|
|
1716
|
+
this.#pendingKeep = {
|
|
1717
|
+
owner: this,
|
|
1718
|
+
position,
|
|
1719
|
+
cls: this.#scrollTriggerClass,
|
|
1720
|
+
onlyAtRest,
|
|
1721
|
+
cancelled: false
|
|
1722
|
+
};
|
|
1723
|
+
pendingKeeps.add(this.#pendingKeep);
|
|
1724
|
+
queueMicrotask(() => this.#applyPendingKeep());
|
|
1725
|
+
}
|
|
1726
|
+
#applyPendingKeep() {
|
|
1727
|
+
const keep = this.#pendingKeep;
|
|
1728
|
+
if (!keep) return;
|
|
1729
|
+
this.#pendingKeep = null;
|
|
1730
|
+
pendingKeeps.delete(keep);
|
|
1731
|
+
if (keep.cancelled || keep.onlyAtRest && isScrolling(keep.cls)) return;
|
|
1732
|
+
this.#keepContent(keep.position, keep.cls);
|
|
1733
|
+
}
|
|
1734
|
+
#overlaps(other) {
|
|
1735
|
+
return this.#rootElement.contains(other.#rootElement) || other.#rootElement.contains(this.#rootElement);
|
|
1736
|
+
}
|
|
1737
|
+
#settleWhenAtRest() {
|
|
1738
|
+
if (this.#destroyed || this.#restTimer !== null) return;
|
|
1739
|
+
if (isScrolling(this.#scrollTriggerClass)) {
|
|
1740
|
+
this.#restTimer = setTimeout(() => {
|
|
1741
|
+
this.#restTimer = null;
|
|
1742
|
+
this.#settleWhenAtRest();
|
|
1743
|
+
}, REST_POLL_MS);
|
|
1744
|
+
return;
|
|
1745
|
+
}
|
|
1746
|
+
const run = this.#deferredRun;
|
|
1747
|
+
this.#deferredRun = null;
|
|
1748
|
+
runEach(() => this.#flushPendingDisarm(), () => run?.());
|
|
1749
|
+
}
|
|
1750
|
+
#flushPendingDisarm(keepContent = true, onlyAtRest = false) {
|
|
1751
|
+
if (pendingDisarms.delete(this) && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) this.#disarmKeepingContent(keepContent, onlyAtRest);
|
|
1752
|
+
}
|
|
1753
|
+
#flushPendingDisarmForRevert() {
|
|
1754
|
+
this.#flushPendingDisarm(!isScrolling(this.#scrollTriggerClass), true);
|
|
1755
|
+
}
|
|
1756
|
+
#disarm() {
|
|
1757
|
+
this.#armed = false;
|
|
1758
|
+
armedInstances.delete(this);
|
|
1759
|
+
unregisterDormancyClient(this.#dormancyClient);
|
|
1760
|
+
this.#scrollMarginSync?.restore();
|
|
1761
|
+
this.#scrollMarginSync = null;
|
|
1762
|
+
this.#restoreCoverLifts();
|
|
1763
|
+
this.#unbuild();
|
|
1764
|
+
this.#builtLayers = [];
|
|
1765
|
+
}
|
|
1532
1766
|
#ownedStickyElements() {
|
|
1533
1767
|
return [...this.#builtLayers.flatMap((layer) => layer.wrapper ? [layer.wrapper] : []), ...this.#wrappedPinTriggers()];
|
|
1534
1768
|
}
|
|
@@ -1538,6 +1772,8 @@ var StickyScrollTrigger = class {
|
|
|
1538
1772
|
#unbuild() {
|
|
1539
1773
|
if (!this.#built) return;
|
|
1540
1774
|
unbuildStructure(this.#rootElement, this.#builtLayers, this.#outermostContainer);
|
|
1775
|
+
unbuildCount += 1;
|
|
1776
|
+
this.#measuredStructure = null;
|
|
1541
1777
|
this.#outermostContainer = null;
|
|
1542
1778
|
this.#built = false;
|
|
1543
1779
|
}
|
|
@@ -1547,39 +1783,151 @@ var StickyScrollTrigger = class {
|
|
|
1547
1783
|
this.#built = true;
|
|
1548
1784
|
this.#dirty = false;
|
|
1549
1785
|
}
|
|
1786
|
+
#catchUp() {
|
|
1787
|
+
this.#flushPendingDisarm();
|
|
1788
|
+
this.#runRefresh();
|
|
1789
|
+
this.#applyPendingKeep();
|
|
1790
|
+
}
|
|
1550
1791
|
#scheduleRebuild() {
|
|
1551
|
-
if (this.#
|
|
1552
|
-
this.#
|
|
1792
|
+
if (this.#destroyed) return;
|
|
1793
|
+
if (this.#built) this.#keepContentPending = true;
|
|
1794
|
+
if (pendingCatchUps.has(this)) return;
|
|
1795
|
+
const cls = this.#scrollTriggerClass;
|
|
1796
|
+
const pending = () => pendingCatchUps.get(this) === catchUpNow;
|
|
1797
|
+
const catchUpNow = () => {
|
|
1798
|
+
if (!pending()) return false;
|
|
1799
|
+
pendingCatchUps.delete(this);
|
|
1800
|
+
if (this.#destroyed) return false;
|
|
1801
|
+
try {
|
|
1802
|
+
this.#catchUp();
|
|
1803
|
+
} catch (error) {
|
|
1804
|
+
queueMicrotask(() => {
|
|
1805
|
+
throw error;
|
|
1806
|
+
});
|
|
1807
|
+
}
|
|
1808
|
+
return true;
|
|
1809
|
+
};
|
|
1810
|
+
pendingCatchUps.set(this, catchUpNow);
|
|
1811
|
+
const onRefreshInit = () => {
|
|
1812
|
+
if (!catchUpNow()) return void 0;
|
|
1813
|
+
const restoreDormancy = takeGsapRefreshRestore();
|
|
1814
|
+
return restoreDormancy ? revertAfterMeasure(restoreDormancy) : void 0;
|
|
1815
|
+
};
|
|
1816
|
+
addGsapListener(cls, "refreshInit", onRefreshInit);
|
|
1817
|
+
const run = () => {
|
|
1818
|
+
try {
|
|
1819
|
+
if (pending() && !this.#destroyed) refreshAll(this.#scrollTriggerClass);
|
|
1820
|
+
} finally {
|
|
1821
|
+
removeGsapListener(cls, "refreshInit", onRefreshInit);
|
|
1822
|
+
catchUpNow();
|
|
1823
|
+
}
|
|
1824
|
+
};
|
|
1553
1825
|
queueMicrotask(() => {
|
|
1554
|
-
this.#
|
|
1555
|
-
|
|
1556
|
-
|
|
1557
|
-
|
|
1826
|
+
if (pending() && !this.#destroyed && isScrolling(cls)) {
|
|
1827
|
+
const earlier = this.#deferredRun;
|
|
1828
|
+
this.#deferredRun = earlier ? () => runEach(earlier, run) : run;
|
|
1829
|
+
this.#settleWhenAtRest();
|
|
1830
|
+
return;
|
|
1831
|
+
}
|
|
1832
|
+
run();
|
|
1558
1833
|
});
|
|
1559
1834
|
}
|
|
1560
1835
|
#captureScrollTriggerClass(self) {
|
|
1561
1836
|
if (this.#destroyed) return;
|
|
1562
|
-
this.#scrollTriggerClass = self
|
|
1837
|
+
this.#scrollTriggerClass = classOf(self);
|
|
1563
1838
|
}
|
|
1564
1839
|
#createAutoRefreshHandler(userOnRefreshInit) {
|
|
1565
|
-
|
|
1840
|
+
const handle = (self) => {
|
|
1566
1841
|
this.#captureScrollTriggerClass(self);
|
|
1842
|
+
if (isRefreshing(this.#scrollTriggerClass)) holdLiveEvaluationForGsapRefresh(this.#scrollTriggerClass);
|
|
1567
1843
|
const result = userOnRefreshInit?.(self);
|
|
1844
|
+
const inGsapRefresh = isRefreshing(this.#scrollTriggerClass);
|
|
1845
|
+
let caughtUp = false;
|
|
1846
|
+
let refreshed = false;
|
|
1847
|
+
if (inGsapRefresh) {
|
|
1848
|
+
[...pendingCatchUps].forEach(([owner, catchUpNow]) => owner !== this && catchUpNow());
|
|
1849
|
+
caughtUp = pendingCatchUps.get(this)?.() === true;
|
|
1850
|
+
if (caughtUp) this.#dispatchObserver?.takeRecords();
|
|
1851
|
+
}
|
|
1852
|
+
const unchanged = inGsapRefresh && !userOnRefreshInit && !this.#dirty && (caughtUp || this.#dispatchObserver !== null && this.#dispatchObserver.takeRecords().length === 0);
|
|
1568
1853
|
try {
|
|
1569
|
-
|
|
1854
|
+
if (!unchanged) {
|
|
1855
|
+
refreshed = true;
|
|
1856
|
+
this.#refreshFrom(true);
|
|
1857
|
+
}
|
|
1570
1858
|
} catch (error) {
|
|
1571
1859
|
queueMicrotask(() => {
|
|
1572
1860
|
throw error;
|
|
1573
1861
|
});
|
|
1574
1862
|
}
|
|
1863
|
+
if (inGsapRefresh) {
|
|
1864
|
+
this.#watchGsapRefresh();
|
|
1865
|
+
if (refreshed || caughtUp) this.#remeasureEarlierInGsapRefresh();
|
|
1866
|
+
}
|
|
1575
1867
|
const restoreDormancy = takeGsapRefreshRestore();
|
|
1576
|
-
|
|
1577
|
-
|
|
1578
|
-
|
|
1579
|
-
|
|
1580
|
-
|
|
1868
|
+
return restoreDormancy ? revertAfterMeasure(restoreDormancy, result) : result;
|
|
1869
|
+
};
|
|
1870
|
+
return (self) => {
|
|
1871
|
+
layerHandlerDepth += 1;
|
|
1872
|
+
try {
|
|
1873
|
+
return handle(self);
|
|
1874
|
+
} finally {
|
|
1875
|
+
layerHandlerDepth -= 1;
|
|
1876
|
+
}
|
|
1581
1877
|
};
|
|
1582
1878
|
}
|
|
1879
|
+
#watchGsapRefresh() {
|
|
1880
|
+
if (this.#dispatchObserver) {
|
|
1881
|
+
this.#dispatchObserver.takeRecords();
|
|
1882
|
+
return;
|
|
1883
|
+
}
|
|
1884
|
+
const observer = new MutationObserver(() => {});
|
|
1885
|
+
const cls = this.#scrollTriggerClass;
|
|
1886
|
+
const end = () => {
|
|
1887
|
+
observer.disconnect();
|
|
1888
|
+
if (this.#dispatchObserver === observer) this.#dispatchObserver = null;
|
|
1889
|
+
queueMicrotask(() => removeGsapListener(cls, "refresh", end));
|
|
1890
|
+
};
|
|
1891
|
+
observer.observe(document, {
|
|
1892
|
+
subtree: true,
|
|
1893
|
+
childList: true,
|
|
1894
|
+
attributes: true,
|
|
1895
|
+
characterData: true
|
|
1896
|
+
});
|
|
1897
|
+
this.#dispatchObserver = observer;
|
|
1898
|
+
addGsapListener(cls, "refresh", end);
|
|
1899
|
+
queueMicrotask(end);
|
|
1900
|
+
}
|
|
1901
|
+
#remeasureEarlierInGsapRefresh() {
|
|
1902
|
+
const refreshed = refreshedInGsapRefresh ?? new Map();
|
|
1903
|
+
if (!refreshedInGsapRefresh) {
|
|
1904
|
+
refreshedInGsapRefresh = refreshed;
|
|
1905
|
+
queueMicrotask(() => {
|
|
1906
|
+
if (refreshedInGsapRefresh === refreshed) refreshedInGsapRefresh = null;
|
|
1907
|
+
});
|
|
1908
|
+
}
|
|
1909
|
+
refreshed.set(this, this.#outsideReads());
|
|
1910
|
+
refreshed.forEach((reads, other) => {
|
|
1911
|
+
if (other.#destroyed || reads === other.#outsideReads()) return;
|
|
1912
|
+
try {
|
|
1913
|
+
other.#refreshFrom(true);
|
|
1914
|
+
} catch (error) {
|
|
1915
|
+
queueMicrotask(() => {
|
|
1916
|
+
throw error;
|
|
1917
|
+
});
|
|
1918
|
+
}
|
|
1919
|
+
other.#dispatchObserver?.takeRecords();
|
|
1920
|
+
refreshed.set(other, other.#outsideReads());
|
|
1921
|
+
});
|
|
1922
|
+
}
|
|
1923
|
+
#outsideReads() {
|
|
1924
|
+
const reads = [documentTop(this.#rootElement)];
|
|
1925
|
+
if (this.#readsPageHeight) reads.push(measureDocumentHeightWithoutPinRanges());
|
|
1926
|
+
[...this.#layers, ...this.#pinLayers].forEach(({ endTrigger }) => {
|
|
1927
|
+
if (!this.#rootElement.contains(endTrigger)) reads.push(documentTop(endTrigger));
|
|
1928
|
+
});
|
|
1929
|
+
return reads.join(",");
|
|
1930
|
+
}
|
|
1583
1931
|
#wrapUnwrappedPins() {
|
|
1584
1932
|
this.#pinLayers.forEach((layer) => {
|
|
1585
1933
|
if (layer.outer) return;
|
|
@@ -1596,16 +1944,14 @@ var StickyScrollTrigger = class {
|
|
|
1596
1944
|
range: inner.style.height
|
|
1597
1945
|
}] : []);
|
|
1598
1946
|
wrapped.forEach(({ outer, inner }) => {
|
|
1599
|
-
outer
|
|
1600
|
-
inner
|
|
1947
|
+
clearHeightForRead(outer);
|
|
1948
|
+
clearHeightForRead(inner);
|
|
1601
1949
|
});
|
|
1602
1950
|
const reserved = wrapped.map(({ outer }) => measureUsedHeight(outer));
|
|
1603
1951
|
wrapped.forEach(({ outer }, index) => {
|
|
1604
|
-
outer
|
|
1605
|
-
});
|
|
1606
|
-
wrapped.forEach(({ inner, range }) => {
|
|
1607
|
-
inner.style.height = range;
|
|
1952
|
+
commitHeight(outer, `${reserved[index]}px`);
|
|
1608
1953
|
});
|
|
1954
|
+
wrapped.forEach(({ inner, range }) => commitHeight(inner, range));
|
|
1609
1955
|
}
|
|
1610
1956
|
#unwrapPinLayer(layer) {
|
|
1611
1957
|
if (!layer.outer) return false;
|
|
@@ -1616,10 +1962,16 @@ var StickyScrollTrigger = class {
|
|
|
1616
1962
|
return true;
|
|
1617
1963
|
}
|
|
1618
1964
|
#resetSceneCoverStickyState() {
|
|
1619
|
-
return stripStickyPositions(this.#
|
|
1965
|
+
return stripStickyPositions(this.#builtLayers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
|
|
1620
1966
|
}
|
|
1621
1967
|
#resetPinStickyState() {
|
|
1622
|
-
|
|
1968
|
+
const restores = this.#pinLayers.filter(({ inner }) => inner).map((layer) => ({
|
|
1969
|
+
layer,
|
|
1970
|
+
restore: stripStickyPositions([layer.trigger])
|
|
1971
|
+
}));
|
|
1972
|
+
return () => restores.forEach(({ layer, restore }) => {
|
|
1973
|
+
if (layer.inner) restore();
|
|
1974
|
+
});
|
|
1623
1975
|
}
|
|
1624
1976
|
#resetStickyState() {
|
|
1625
1977
|
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
@@ -1629,43 +1981,63 @@ var StickyScrollTrigger = class {
|
|
|
1629
1981
|
restoreSceneCoverStickyState();
|
|
1630
1982
|
};
|
|
1631
1983
|
}
|
|
1632
|
-
#
|
|
1633
|
-
const
|
|
1984
|
+
#refreshGeometry(viewportHeight) {
|
|
1985
|
+
const active = this.#layers.filter((layer) => layer.wrapper !== null);
|
|
1986
|
+
const wrappers = active.flatMap(({ wrapper }) => wrapper ? [wrapper] : []);
|
|
1987
|
+
const savedWrappers = wrappers.map(captureInlinePosition);
|
|
1988
|
+
const pins = this.#pinLayers.map((layer) => ({
|
|
1634
1989
|
layer,
|
|
1635
1990
|
position: captureInlinePosition(layer.trigger),
|
|
1636
|
-
|
|
1991
|
+
range: layer.inner ? layer.inner.style.height : ""
|
|
1637
1992
|
}));
|
|
1638
|
-
|
|
1639
|
-
|
|
1640
|
-
|
|
1641
|
-
|
|
1642
|
-
|
|
1643
|
-
|
|
1644
|
-
|
|
1645
|
-
|
|
1993
|
+
wrappers.forEach(clearStickyForRead);
|
|
1994
|
+
pins.forEach(({ layer }) => clearStickyForRead(layer.trigger));
|
|
1995
|
+
let stickyTops;
|
|
1996
|
+
let marginTops;
|
|
1997
|
+
try {
|
|
1998
|
+
const measured = active.length ? this.#measureLayers(viewportHeight, active) : null;
|
|
1999
|
+
marginTops = this.#measureScrollMarginTargets(active);
|
|
2000
|
+
stickyTops = measured ? this.#planLayerPositions(viewportHeight, active, measured) : new Map();
|
|
2001
|
+
this.#readsPageHeight = pins.length > 0 || (measured?.measured.some(({ end }) => end.mode === "max") ?? false);
|
|
2002
|
+
} catch (error) {
|
|
2003
|
+
wrappers.forEach((wrapper, i) => commitPosition(wrapper, savedWrappers[i]));
|
|
2004
|
+
pins.forEach(({ layer, position }) => {
|
|
2005
|
+
if (layer.inner) commitPosition(layer.trigger, position);
|
|
1646
2006
|
});
|
|
1647
|
-
|
|
1648
|
-
|
|
1649
|
-
|
|
1650
|
-
if (!this.#pinLayers.length) return;
|
|
1651
|
-
const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
|
|
1652
|
-
const restorePinState = this.#resetPinState();
|
|
2007
|
+
throw error;
|
|
2008
|
+
}
|
|
2009
|
+
let plannedPins = [];
|
|
1653
2010
|
try {
|
|
1654
|
-
|
|
2011
|
+
if (pins.length) {
|
|
2012
|
+
pins.forEach(({ layer }) => {
|
|
2013
|
+
if (layer.inner) clearHeightForRead(layer.inner);
|
|
2014
|
+
});
|
|
2015
|
+
plannedPins = this.#planPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
|
|
2016
|
+
}
|
|
1655
2017
|
} catch (error) {
|
|
1656
|
-
|
|
2018
|
+
stickyTops.forEach((top, wrapper) => commitSticky(wrapper, top));
|
|
2019
|
+
pins.forEach(({ layer, position, range }) => {
|
|
2020
|
+
if (!layer.inner) return;
|
|
2021
|
+
commitPosition(layer.trigger, position);
|
|
2022
|
+
commitHeight(layer.inner, range);
|
|
2023
|
+
});
|
|
1657
2024
|
throw error;
|
|
1658
|
-
} finally {
|
|
1659
|
-
restoreSceneCoverStickyState();
|
|
1660
2025
|
}
|
|
1661
|
-
|
|
1662
|
-
|
|
1663
|
-
this.#pinLayers.forEach((layer) => {
|
|
2026
|
+
stickyTops.forEach((top, wrapper) => commitSticky(wrapper, top));
|
|
2027
|
+
plannedPins.forEach(({ layer, topPx, range }) => {
|
|
1664
2028
|
if (!layer.inner) return;
|
|
2029
|
+
commitSticky(layer.trigger, topPx);
|
|
2030
|
+
commitHeight(layer.inner, `${range}px`);
|
|
2031
|
+
});
|
|
2032
|
+
this.#syncScrollMargins(marginTops);
|
|
2033
|
+
}
|
|
2034
|
+
#planPinLayers(viewportHeight, documentHeight) {
|
|
2035
|
+
return this.#pinLayers.flatMap((layer) => {
|
|
2036
|
+
if (!layer.inner) return [];
|
|
1665
2037
|
const resolvedStart = resolveMaybeFn(layer.start);
|
|
1666
2038
|
const resolvedEnd = prefixSpacedRelativeEnd(resolvedStart, resolveMaybeFn(layer.end));
|
|
1667
2039
|
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
|
|
2040
|
+
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
2041
|
const triggerTop = documentTop(layer.trigger);
|
|
1670
2042
|
const triggerHeight = measureUsedHeight(layer.trigger);
|
|
1671
2043
|
const triggerMarginBottom = parseFloat(getComputedStyle(layer.trigger).marginBottom) || 0;
|
|
@@ -1676,38 +2048,39 @@ var StickyScrollTrigger = class {
|
|
|
1676
2048
|
const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
|
|
1677
2049
|
const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
|
|
1678
2050
|
const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
|
|
1679
|
-
|
|
1680
|
-
|
|
2051
|
+
return [{
|
|
2052
|
+
layer,
|
|
2053
|
+
topPx,
|
|
2054
|
+
range: Math.max(0, Math.min(height, room))
|
|
2055
|
+
}];
|
|
1681
2056
|
});
|
|
1682
2057
|
}
|
|
1683
|
-
#
|
|
1684
|
-
if (!this.#layers.length) return;
|
|
1685
|
-
const active = this.#layers.filter((layer) => layer.wrapper !== null);
|
|
1686
|
-
if (!active.length) return;
|
|
1687
|
-
const restoreStickyState = this.#resetSceneCoverStickyState();
|
|
1688
|
-
const restorePinStickyState = this.#resetPinStickyState();
|
|
1689
|
-
try {
|
|
1690
|
-
this.#planLayerPositions(viewportHeight, active);
|
|
1691
|
-
} catch (error) {
|
|
1692
|
-
restoreStickyState();
|
|
1693
|
-
throw error;
|
|
1694
|
-
} finally {
|
|
1695
|
-
restorePinStickyState();
|
|
1696
|
-
}
|
|
1697
|
-
}
|
|
1698
|
-
#planLayerPositions(viewportHeight, active) {
|
|
2058
|
+
#measureLayers(viewportHeight, active) {
|
|
1699
2059
|
const structureTop = this.#outermostContainer ? documentTop(this.#outermostContainer) : 0;
|
|
2060
|
+
this.#measuredStructure = {
|
|
2061
|
+
top: structureTop,
|
|
2062
|
+
unbuilds: unbuildCount
|
|
2063
|
+
};
|
|
1700
2064
|
const indexByTrigger = new Map();
|
|
1701
2065
|
active.forEach((layer, index) => {
|
|
1702
2066
|
indexByTrigger.set(layer.trigger, index);
|
|
1703
2067
|
});
|
|
1704
|
-
|
|
2068
|
+
return {
|
|
2069
|
+
structureTop,
|
|
2070
|
+
measured: active.map((layer, ownIndex) => measureLayer(this.#rootElement, viewportHeight, layer, ownIndex, indexByTrigger))
|
|
2071
|
+
};
|
|
2072
|
+
}
|
|
2073
|
+
#planLayerPositions(viewportHeight, active, { structureTop, measured }) {
|
|
2074
|
+
const needsLiveRemeasure = measured.some((measurement) => measurement.end.mode === "clause" && measurement.end.measureLive);
|
|
2075
|
+
const needsMaxRemeasure = measured.some((measurement) => measurement.end.mode === "max");
|
|
1705
2076
|
let documentMaxScroll = 0;
|
|
2077
|
+
let measureLive = false;
|
|
2078
|
+
const stickyTops = new Map();
|
|
1706
2079
|
const applyLayers = () => planLayers(measured, {
|
|
1707
2080
|
viewportHeight,
|
|
1708
2081
|
structureTop,
|
|
1709
2082
|
documentMaxScroll,
|
|
1710
|
-
measureLiveEndTriggerTop: (index) => documentTop(active[index].endTrigger),
|
|
2083
|
+
measureLiveEndTriggerTop: (index) => measureLive ? documentTop(active[index].endTrigger) : 0,
|
|
1711
2084
|
onPlanned: (index, plan) => {
|
|
1712
2085
|
const layer = active[index];
|
|
1713
2086
|
layer.freezeStart = plan.freezeStart;
|
|
@@ -1715,23 +2088,138 @@ var StickyScrollTrigger = class {
|
|
|
1715
2088
|
layer.engagedStart = plan.engagedStart;
|
|
1716
2089
|
layer.engagedEnd = plan.engagedEnd;
|
|
1717
2090
|
if (!layer.wrapper) return;
|
|
1718
|
-
|
|
1719
|
-
if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding
|
|
2091
|
+
stickyTops.set(layer.wrapper, plan.stickyTop);
|
|
2092
|
+
if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) commitHeight(layer.padding, `${plan.paddingHeight}px`);
|
|
1720
2093
|
}
|
|
1721
2094
|
});
|
|
2095
|
+
this.#reevaluateLiveEnds(active, measured, () => {
|
|
2096
|
+
const heights = active.map(() => 0);
|
|
2097
|
+
planLayers(measured, {
|
|
2098
|
+
viewportHeight,
|
|
2099
|
+
structureTop,
|
|
2100
|
+
documentMaxScroll,
|
|
2101
|
+
measureLiveEndTriggerTop: () => 0,
|
|
2102
|
+
onPlanned: (index, plan) => {
|
|
2103
|
+
heights[index] = plan.paddingHeight ?? 0;
|
|
2104
|
+
}
|
|
2105
|
+
});
|
|
2106
|
+
return heights;
|
|
2107
|
+
});
|
|
1722
2108
|
applyLayers();
|
|
1723
|
-
|
|
1724
|
-
|
|
1725
|
-
if (needsMaxRemeasure) documentMaxScroll = measureDocumentMaxScroll(viewportHeight);
|
|
2109
|
+
if (needsMaxRemeasure) documentMaxScroll = Math.max(0, measureDocumentHeightWithoutPinRanges() - viewportHeight);
|
|
2110
|
+
measureLive = true;
|
|
1726
2111
|
if (needsLiveRemeasure || needsMaxRemeasure) applyLayers();
|
|
2112
|
+
return stickyTops;
|
|
2113
|
+
}
|
|
2114
|
+
#reevaluateLiveEnds(active, measured, planPaddings) {
|
|
2115
|
+
const live = measured.flatMap(({ liveEnd }, index) => liveEnd ? [{
|
|
2116
|
+
index,
|
|
2117
|
+
liveEnd
|
|
2118
|
+
}] : []);
|
|
2119
|
+
if (!live.length) return;
|
|
2120
|
+
const scrollBefore = window.scrollY;
|
|
2121
|
+
try {
|
|
2122
|
+
for (let round = 0; round < LIVE_END_ROUNDS; round += 1) {
|
|
2123
|
+
const planned = planPaddings();
|
|
2124
|
+
let moved = false;
|
|
2125
|
+
live.forEach(({ index, liveEnd }) => {
|
|
2126
|
+
const next = this.#evaluateLiveEnd(active, planned, index, liveEnd, scrollBefore);
|
|
2127
|
+
const current = measured[index].end;
|
|
2128
|
+
if (!next || next.mode !== current.mode) return;
|
|
2129
|
+
if (Math.abs(liveEndValue(next) - liveEndValue(current)) <= LIVE_END_TOLERANCE_PX) return;
|
|
2130
|
+
measured[index] = {
|
|
2131
|
+
...measured[index],
|
|
2132
|
+
end: next
|
|
2133
|
+
};
|
|
2134
|
+
moved = true;
|
|
2135
|
+
});
|
|
2136
|
+
if (!moved) break;
|
|
2137
|
+
}
|
|
2138
|
+
} finally {
|
|
2139
|
+
scrollBackTo(scrollBefore);
|
|
2140
|
+
}
|
|
2141
|
+
}
|
|
2142
|
+
#evaluateLiveEnd(active, planned, index, liveEnd, scroll) {
|
|
2143
|
+
const spacers = active.flatMap((layer, k) => k < index && layer.kind === "scene" && planned[k] ? [{
|
|
2144
|
+
after: layer.trigger,
|
|
2145
|
+
height: planned[k]
|
|
2146
|
+
}] : []);
|
|
2147
|
+
const setUp = () => {
|
|
2148
|
+
const later = [...armedInstances].filter((other) => other !== this && compareDocumentOrder(this.#rootElement, other.#rootElement) < 0);
|
|
2149
|
+
const paddings = [this, ...later].flatMap((instance) => instance.#layers.flatMap((layer) => layer.kind === "scene" && layer.padding ? [layer.padding] : []));
|
|
2150
|
+
const heights = paddings.map((padding) => padding.style.height);
|
|
2151
|
+
paddings.forEach((padding) => commitHeight(padding, "0px"));
|
|
2152
|
+
const removeSpacers = insertSpacers(spacers);
|
|
2153
|
+
return () => {
|
|
2154
|
+
removeSpacers();
|
|
2155
|
+
paddings.forEach((padding, k) => {
|
|
2156
|
+
if (padding.style.height === "0px") commitHeight(padding, heights[k]);
|
|
2157
|
+
});
|
|
2158
|
+
};
|
|
2159
|
+
};
|
|
2160
|
+
let takeDown = () => {};
|
|
2161
|
+
let holds = 0;
|
|
2162
|
+
const evaluation = {
|
|
2163
|
+
resolved: false,
|
|
2164
|
+
ended: false,
|
|
2165
|
+
outer: liveEvaluation,
|
|
2166
|
+
scroll: liveEvaluation?.scroll ?? scroll,
|
|
2167
|
+
suspend: (resolving) => {
|
|
2168
|
+
if (resolving) evaluation.resolved = true;
|
|
2169
|
+
holds += 1;
|
|
2170
|
+
if (holds === 1) {
|
|
2171
|
+
takeDown();
|
|
2172
|
+
takeDown = () => {};
|
|
2173
|
+
}
|
|
2174
|
+
return () => {
|
|
2175
|
+
holds -= 1;
|
|
2176
|
+
if (holds === 0 && !evaluation.ended) takeDown = setUp();
|
|
2177
|
+
};
|
|
2178
|
+
}
|
|
2179
|
+
};
|
|
2180
|
+
try {
|
|
2181
|
+
takeDown = setUp();
|
|
2182
|
+
liveEvaluation = evaluation;
|
|
2183
|
+
const next = liveEnd();
|
|
2184
|
+
return evaluation.resolved ? null : next;
|
|
2185
|
+
} finally {
|
|
2186
|
+
evaluation.ended = true;
|
|
2187
|
+
liveEvaluation = evaluation.outer;
|
|
2188
|
+
takeDown();
|
|
2189
|
+
}
|
|
1727
2190
|
}
|
|
1728
2191
|
refresh() {
|
|
1729
|
-
|
|
2192
|
+
this.#refreshFrom(false);
|
|
2193
|
+
}
|
|
2194
|
+
#refreshFrom(refreshInit) {
|
|
2195
|
+
if (this.#depth > 0 && !this.#dirty) {
|
|
2196
|
+
if (!refreshInit) {
|
|
2197
|
+
this.#measureAgain = true;
|
|
2198
|
+
return;
|
|
2199
|
+
}
|
|
2200
|
+
if (this.#refreshInitNestedUsed) return;
|
|
2201
|
+
this.#refreshInitNestedUsed = true;
|
|
2202
|
+
}
|
|
2203
|
+
this.#runRefresh();
|
|
2204
|
+
}
|
|
2205
|
+
#runRefresh() {
|
|
2206
|
+
if (this.#depth > 0) this.#measureAgain = true;
|
|
2207
|
+
if (this.#destroyed || !this.#armed || pendingDisarms.has(this)) return;
|
|
1730
2208
|
let failure = null;
|
|
2209
|
+
const position = this.#keepContentPending ? this.#naturalScrollTop(this.#builtLayers) : null;
|
|
2210
|
+
this.#keepContentPending = false;
|
|
2211
|
+
this.#depth += 1;
|
|
1731
2212
|
try {
|
|
1732
2213
|
this.#refreshLayout();
|
|
2214
|
+
if (this.#depth === 1 && this.#measureAgain && !this.#destroyed && this.#armed && !pendingDisarms.has(this)) this.#refreshLayout();
|
|
1733
2215
|
} catch (error) {
|
|
1734
2216
|
failure = { error };
|
|
2217
|
+
} finally {
|
|
2218
|
+
this.#depth -= 1;
|
|
2219
|
+
if (this.#depth === 0) {
|
|
2220
|
+
this.#refreshInitNestedUsed = false;
|
|
2221
|
+
this.#measureAgain = false;
|
|
2222
|
+
}
|
|
1735
2223
|
}
|
|
1736
2224
|
try {
|
|
1737
2225
|
rebuildDormancy(this.#scrollTriggerClass);
|
|
@@ -1741,8 +2229,50 @@ var StickyScrollTrigger = class {
|
|
|
1741
2229
|
throw error;
|
|
1742
2230
|
});
|
|
1743
2231
|
}
|
|
2232
|
+
this.#scrollMarginSync?.applyRamps();
|
|
2233
|
+
if (!failure && position !== null) this.#keepContent(position);
|
|
1744
2234
|
if (failure) throw failure.error;
|
|
1745
2235
|
}
|
|
2236
|
+
#naturalScrollTop(layers) {
|
|
2237
|
+
const measured = this.#measuredStructure;
|
|
2238
|
+
const moved = measured && this.#outermostContainer && measured.unbuilds !== unbuildCount ? documentTop(this.#outermostContainer) - measured.top : 0;
|
|
2239
|
+
const scroll = (scrollRecord(this.#scrollTriggerClass)?.read() ?? window.scrollY) - moved;
|
|
2240
|
+
const consumed = new Map();
|
|
2241
|
+
layers.forEach((layer) => {
|
|
2242
|
+
if (layer.kind !== "scene") return;
|
|
2243
|
+
consumed.set(layer.trigger, scroll > layer.engagedEnd ? Infinity : dwellConsumedAt(scroll, this.#engagedWindows([layer])));
|
|
2244
|
+
});
|
|
2245
|
+
return {
|
|
2246
|
+
natural: scroll - dwellConsumedAt(scroll, this.#engagedWindows(layers)) + moved,
|
|
2247
|
+
consumed
|
|
2248
|
+
};
|
|
2249
|
+
}
|
|
2250
|
+
#keepContent(position, cls = this.#scrollTriggerClass) {
|
|
2251
|
+
const target = this.#keptScrollTop(position);
|
|
2252
|
+
const record = scrollRecord(this.#scrollTriggerClass);
|
|
2253
|
+
if (record) {
|
|
2254
|
+
record.write(target);
|
|
2255
|
+
return;
|
|
2256
|
+
}
|
|
2257
|
+
if (isRefreshing(cls)) return;
|
|
2258
|
+
if (Math.abs(window.scrollY - target) >= .5) window.scrollTo({
|
|
2259
|
+
top: Math.round(target),
|
|
2260
|
+
behavior: "instant"
|
|
2261
|
+
});
|
|
2262
|
+
syncScrollCache(cls);
|
|
2263
|
+
}
|
|
2264
|
+
#keptScrollTop({ natural, consumed }) {
|
|
2265
|
+
let earlierDwell = 0;
|
|
2266
|
+
let target = natural;
|
|
2267
|
+
this.#builtLayers.flatMap((layer) => layer.kind === "scene" ? [layer] : []).sort((a, b) => a.engagedStart - b.engagedStart).forEach((layer) => {
|
|
2268
|
+
const dwell = layer.engagedEnd - layer.engagedStart;
|
|
2269
|
+
const before = consumed.get(layer.trigger);
|
|
2270
|
+
if (before !== void 0) target += Math.min(before, dwell);
|
|
2271
|
+
else if (layer.engagedStart < natural + earlierDwell - .05) target += dwell;
|
|
2272
|
+
earlierDwell += dwell;
|
|
2273
|
+
});
|
|
2274
|
+
return target;
|
|
2275
|
+
}
|
|
1746
2276
|
#refreshLayout() {
|
|
1747
2277
|
if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
|
|
1748
2278
|
this.#unbuild();
|
|
@@ -1756,9 +2286,7 @@ var StickyScrollTrigger = class {
|
|
|
1756
2286
|
this.#liftCovers();
|
|
1757
2287
|
}
|
|
1758
2288
|
const viewportHeight = this.#layers.length || this.#pinLayers.length ? measureViewportHeight() : 0;
|
|
1759
|
-
this.#
|
|
1760
|
-
this.#refreshPins(viewportHeight);
|
|
1761
|
-
this.#syncScrollMargins();
|
|
2289
|
+
this.#refreshGeometry(viewportHeight);
|
|
1762
2290
|
}
|
|
1763
2291
|
#coverLayers() {
|
|
1764
2292
|
return this.#layers.filter((layer) => layer.kind === "cover");
|
|
@@ -1772,15 +2300,21 @@ var StickyScrollTrigger = class {
|
|
|
1772
2300
|
this.#coverRestoreByLayer.set(layer, liftAboveStickyWrapper(pin?.outer ?? layer.cover));
|
|
1773
2301
|
});
|
|
1774
2302
|
}
|
|
1775
|
-
#syncScrollMargins() {
|
|
1776
|
-
this.#scrollMarginSync
|
|
1777
|
-
|
|
1778
|
-
|
|
1779
|
-
|
|
1780
|
-
|
|
1781
|
-
|
|
2303
|
+
#syncScrollMargins(tops) {
|
|
2304
|
+
this.#scrollMarginSync?.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
|
|
2305
|
+
const late = targets.filter((target) => !tops.has(target));
|
|
2306
|
+
if (late.length) {
|
|
2307
|
+
const restoreStickyState = this.#resetStickyState();
|
|
2308
|
+
late.forEach((target) => tops.set(target, documentTop(target)));
|
|
2309
|
+
restoreStickyState();
|
|
2310
|
+
}
|
|
2311
|
+
return targets.map((target) => tops.get(target));
|
|
1782
2312
|
});
|
|
1783
2313
|
}
|
|
2314
|
+
#measureScrollMarginTargets(active) {
|
|
2315
|
+
const targets = this.#scrollMarginSync && active.some(({ kind }) => kind === "scene") ? this.#scrollMarginSync.targets() : [];
|
|
2316
|
+
return new Map(targets.map((target) => [target, documentTop(target)]));
|
|
2317
|
+
}
|
|
1784
2318
|
#assertNoExcludedVars(rest, context) {
|
|
1785
2319
|
const found = EXCLUDED_VAR_KEYS.filter((key) => key in rest);
|
|
1786
2320
|
if (found.length === 0) return;
|
|
@@ -1802,8 +2336,10 @@ var StickyScrollTrigger = class {
|
|
|
1802
2336
|
if (this.#destroyed) throw new Error("StickyScrollTrigger: cannot register a new layer after destroy() has been called.");
|
|
1803
2337
|
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
2338
|
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.`);
|
|
2339
|
+
this.#arm();
|
|
1805
2340
|
this.#layers.push(layer);
|
|
1806
2341
|
this.#dirty = true;
|
|
2342
|
+
if (this.#depth > 0) this.#measureAgain = true;
|
|
1807
2343
|
return {
|
|
1808
2344
|
...rest,
|
|
1809
2345
|
trigger: layer.trigger,
|
|
@@ -1812,9 +2348,14 @@ var StickyScrollTrigger = class {
|
|
|
1812
2348
|
invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
|
|
1813
2349
|
onKill: (self) => {
|
|
1814
2350
|
this.#captureScrollTriggerClass(self);
|
|
2351
|
+
if (!this.#layers.includes(layer)) {
|
|
2352
|
+
onKill?.(self);
|
|
2353
|
+
return;
|
|
2354
|
+
}
|
|
1815
2355
|
removeItem(this.#layers, layer);
|
|
1816
2356
|
this.#dirty = true;
|
|
1817
2357
|
this.#scheduleRebuild();
|
|
2358
|
+
this.#disarmIfEmpty();
|
|
1818
2359
|
onKill?.(self);
|
|
1819
2360
|
},
|
|
1820
2361
|
onRefreshInit: this.#createAutoRefreshHandler(rest.onRefreshInit)
|
|
@@ -1822,6 +2363,7 @@ var StickyScrollTrigger = class {
|
|
|
1822
2363
|
}
|
|
1823
2364
|
createStickyTrigger({ trigger: triggerInput, start = "0 0", end = "100% 0", endTrigger: endTriggerInput, onKill, ...rest }) {
|
|
1824
2365
|
this.#assertNoExcludedVars(rest, "createStickyTrigger");
|
|
2366
|
+
this.#flushOverlappingDisarms();
|
|
1825
2367
|
const trigger = resolveElement(triggerInput, "createStickyTrigger");
|
|
1826
2368
|
this.#assertTriggerInsideRoot(trigger, "createStickyTrigger");
|
|
1827
2369
|
const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createStickyTrigger");
|
|
@@ -1842,6 +2384,7 @@ var StickyScrollTrigger = class {
|
|
|
1842
2384
|
}
|
|
1843
2385
|
createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
|
|
1844
2386
|
this.#assertNoExcludedVars(rest, "createOverlapScroll");
|
|
2387
|
+
this.#flushOverlappingDisarms();
|
|
1845
2388
|
const trigger = resolveElement(triggerInput, "createOverlapScroll");
|
|
1846
2389
|
this.#assertTriggerInsideRoot(trigger, "createOverlapScroll");
|
|
1847
2390
|
const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createOverlapScroll");
|
|
@@ -1863,6 +2406,7 @@ var StickyScrollTrigger = class {
|
|
|
1863
2406
|
};
|
|
1864
2407
|
const vars = this.#registerLayer(layer, (self) => {
|
|
1865
2408
|
this.#coverRestoreByLayer.get(layer)?.();
|
|
2409
|
+
unbuildCover(layer);
|
|
1866
2410
|
onKill?.(self);
|
|
1867
2411
|
}, rest);
|
|
1868
2412
|
this.#coverRestoreByLayer.set(layer, liftAboveStickyWrapper(coverElement));
|
|
@@ -1870,6 +2414,7 @@ var StickyScrollTrigger = class {
|
|
|
1870
2414
|
}
|
|
1871
2415
|
createStickyPin({ trigger: triggerInput, start, top, endTrigger: endTriggerInput, end = "bottom top", onKill, ...rest }) {
|
|
1872
2416
|
this.#assertNoExcludedVars(rest, "createStickyPin");
|
|
2417
|
+
this.#flushOverlappingDisarms();
|
|
1873
2418
|
if (this.#destroyed) throw new Error("StickyScrollTrigger: cannot register a new pin after destroy() has been called.");
|
|
1874
2419
|
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
2420
|
const trigger = resolveElement(triggerInput, "createStickyPin");
|
|
@@ -1886,7 +2431,9 @@ var StickyScrollTrigger = class {
|
|
|
1886
2431
|
endTrigger,
|
|
1887
2432
|
end
|
|
1888
2433
|
};
|
|
2434
|
+
this.#arm();
|
|
1889
2435
|
this.#pinLayers.push(layer);
|
|
2436
|
+
if (this.#depth > 0) this.#measureAgain = true;
|
|
1890
2437
|
return {
|
|
1891
2438
|
...rest,
|
|
1892
2439
|
trigger,
|
|
@@ -1894,12 +2441,21 @@ var StickyScrollTrigger = class {
|
|
|
1894
2441
|
this.#captureScrollTriggerClass(self);
|
|
1895
2442
|
removeItem(this.#pinLayers, layer);
|
|
1896
2443
|
if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
|
|
2444
|
+
this.#disarmIfEmpty();
|
|
1897
2445
|
onKill?.(self);
|
|
1898
2446
|
},
|
|
1899
2447
|
onRefreshInit: this.#createAutoRefreshHandler(rest.onRefreshInit)
|
|
1900
2448
|
};
|
|
1901
2449
|
}
|
|
1902
2450
|
resolveScrollPosition(elementInput, position) {
|
|
2451
|
+
const resume = liveEvaluation && suspendLiveEvaluations(liveEvaluation, true);
|
|
2452
|
+
try {
|
|
2453
|
+
return this.#resolveScrollPosition(elementInput, position);
|
|
2454
|
+
} finally {
|
|
2455
|
+
resume?.();
|
|
2456
|
+
}
|
|
2457
|
+
}
|
|
2458
|
+
#resolveScrollPosition(elementInput, position) {
|
|
1903
2459
|
const element = resolveElement(elementInput, "resolveScrollPosition");
|
|
1904
2460
|
const resolved = resolveMaybeFn(position);
|
|
1905
2461
|
const viewportHeight = measureViewportHeight();
|
|
@@ -1922,8 +2478,8 @@ var StickyScrollTrigger = class {
|
|
|
1922
2478
|
if (!this.#rootElement.contains(element)) return reachedAt;
|
|
1923
2479
|
return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
|
|
1924
2480
|
}
|
|
1925
|
-
#engagedWindows() {
|
|
1926
|
-
return
|
|
2481
|
+
#engagedWindows(layers = this.#builtLayers) {
|
|
2482
|
+
return layers.flatMap((layer) => layer.kind === "scene" ? [{
|
|
1927
2483
|
freezeStart: layer.engagedStart,
|
|
1928
2484
|
freezeEnd: layer.engagedEnd
|
|
1929
2485
|
}] : []);
|
|
@@ -1939,6 +2495,7 @@ var StickyScrollTrigger = class {
|
|
|
1939
2495
|
}
|
|
1940
2496
|
createResolvedTrigger({ trigger: triggerInput, start = "top bottom", end = "bottom top", endTrigger: endTriggerInput, ...rest }) {
|
|
1941
2497
|
this.#assertNoExcludedVars(rest, "createResolvedTrigger");
|
|
2498
|
+
this.#flushOverlappingDisarms();
|
|
1942
2499
|
const trigger = resolveElement(triggerInput, "createResolvedTrigger");
|
|
1943
2500
|
const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createResolvedTrigger");
|
|
1944
2501
|
return {
|
|
@@ -1955,13 +2512,17 @@ var StickyScrollTrigger = class {
|
|
|
1955
2512
|
}
|
|
1956
2513
|
destroy() {
|
|
1957
2514
|
if (this.#destroyed) return;
|
|
2515
|
+
runEach(() => this.#flushPendingDisarmForRevert(), () => this.#tearDown());
|
|
2516
|
+
}
|
|
2517
|
+
#tearDown() {
|
|
2518
|
+
if (this.#restTimer !== null) clearTimeout(this.#restTimer);
|
|
2519
|
+
this.#restTimer = null;
|
|
1958
2520
|
this.#destroyed = true;
|
|
1959
|
-
|
|
1960
|
-
this.#
|
|
1961
|
-
|
|
1962
|
-
this.#
|
|
2521
|
+
const run = this.#deferredRun;
|
|
2522
|
+
this.#deferredRun = null;
|
|
2523
|
+
run?.();
|
|
2524
|
+
if (this.#armed) this.#disarm();
|
|
1963
2525
|
this.#layers.length = 0;
|
|
1964
|
-
this.#builtLayers = [];
|
|
1965
2526
|
this.#pinLayers.forEach((layer) => this.#unwrapPinLayer(layer));
|
|
1966
2527
|
this.#pinLayers.length = 0;
|
|
1967
2528
|
this.#scrollTriggerClass = null;
|