Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
fix(splits): keep the clicked link in view when it opens a new split (#6950)
gbirman569a92bbb9a9
diff --git a/apps/web/src/components/app/split-layout/components/SplitPanel.tsx b/apps/web/src/components/app/split-layout/components/SplitPanel.tsxindex 92139048ab..72e64fc063 100644--- a/apps/web/src/components/app/split-layout/components/SplitPanel.tsx+++ b/apps/web/src/components/app/split-layout/components/SplitPanel.tsx@@ -10,6 +10,7 @@ import { MobilePageActionRow } from '@components/app/mobile/MobilePageActionRow'import { SplitPanelControllerProvider } from '@components/app/split-panel';import { isSoloSettings } from '@core/constant/SettingsState';import { splitContainerAttribute } from '@core/dom-selectors';+import { EVENT_MODIFIER_KEYS } from '@core/hotkey/constants';import { useHotkeyDOMScope } from '@core/hotkey/hotkeys';import { isTouchDevice } from '@core/mobile/isTouchDevice';import { getSafeAreaInset } from '@core/mobile/safeAreaInsets';@@ -67,6 +68,7 @@ export function SplitPanel(props: SplitPanelProps) {const [bottomPanel, setBottomPanel] =createSignal<SplitBottomPanelRegistration>();const panelSize = createElementSize(panelRef);+ let pointerTarget: Element | undefined;const layoutRefs: SplitPanelContextType['layoutRefs'] = {};const headerCollapseController = createPriorityCollapseController();@@ -228,6 +230,7 @@ export function SplitPanel(props: SplitPanelProps) {replaceOwnedSlot: ownedSlots.replace,panelSize,panelRef,+ pointerTarget: () => pointerTarget,}}><SplitDrawerGroup panelSize={panelSize}>@@ -261,6 +264,23 @@ export function SplitPanel(props: SplitPanelProps) {props.setPanelRef(ref);attachHotKeys(ref);}}+ on:pointerdown={{+ capture: true,+ handleEvent: (e) => {+ pointerTarget =+ e.target instanceof Element ? e.target : undefined;+ },+ }}+ // A split opened from the keyboard has no pressed element to keep+ // in view. Modifiers are held through Shift- and Cmd-clicks.+ on:keydown={{+ capture: true,+ handleEvent: (e) => {+ if (!EVENT_MODIFIER_KEYS.has(e.key.toLowerCase())) {+ pointerTarget = undefined;+ }+ },+ }}data-split-id={props.split.id}{...splitContainerAttribute}data-modal={props.handle.isSpotLight()}diff --git a/apps/web/src/components/app/split-layout/context.ts b/apps/web/src/components/app/split-layout/context.tsindex aac8b6a612..c2af487e19 100644--- a/apps/web/src/components/app/split-layout/context.ts+++ b/apps/web/src/components/app/split-layout/context.ts@@ -84,6 +84,8 @@ export type SplitPanelContextType = {isInlinePreview?: boolean;isPanelActive: Accessor<boolean>;panelRef: Accessor<HTMLElement | null>;+ /** The element last pressed in the panel, kept in view when it opens a split. */+ pointerTarget?: () => Element | undefined;panelSize: NullableSize;contentOffsetTop: Accessor<number>;setContentOffsetTop: Setter<number>;diff --git a/apps/web/src/components/app/split-layout/layout.ts b/apps/web/src/components/app/split-layout/layout.tsindex b10fd6a88d..3a6c3250ee 100644--- a/apps/web/src/components/app/split-layout/layout.ts+++ b/apps/web/src/components/app/split-layout/layout.ts@@ -1,5 +1,9 @@import { globalSplitManager } from '@app/signal/splitLayout';import { isTouchDevice } from '@core/mobile/isTouchDevice';+import {+ captureElementScrollAnchor,+ holdScrollAnchor,+} from '@core/util/scrollAnchor';import { useContext } from 'solid-js';import { SplitPanelContext } from './context';import type {@@ -30,11 +34,26 @@ export function useSplitLayout() {const requestedHandle = options?.handle ?? splitPanelContext?.handle;const handle = requestedHandle?.isPopover() ? undefined : requestedHandle;- return splitManager.openWithSplit(content, {+ // A new split narrows this one and reflows its content under an unchanged+ // scrollTop, which can push what was just clicked out of view.+ const clickedAnchor = preferNewSplit+ ? captureElementScrollAnchor(splitPanelContext?.pointerTarget?.())+ : undefined;++ const result = splitManager.openWithSplit(content, {...options,preferNewSplit,handle,});++ if (+ clickedAnchor &&+ result.status === 'opened' &&+ result.split.id !== splitPanelContext?.handle.id+ ) {+ holdScrollAnchor(clickedAnchor.scroller, clickedAnchor.anchor);+ }+ return result;}function replaceOrInsertSplit(diff --git a/apps/web/src/features/block-md/component/Notebook.tsx b/apps/web/src/features/block-md/component/Notebook.tsxindex 3332f090d2..26080f0b62 100644--- a/apps/web/src/features/block-md/component/Notebook.tsx+++ b/apps/web/src/features/block-md/component/Notebook.tsx@@ -18,6 +18,11 @@ import { useIsMacroTeam } from '@core/context/team';import { registerHotkey } from '@core/hotkey/hotkeys';import { TOKENS } from '@core/hotkey/tokens';import { isMobile } from '@core/mobile/isMobile';+import {+ captureScrollAnchor,+ restoreScrollAnchor,+ type ScrollAnchor,+} from '@core/util/scrollAnchor';import type { LoroManager } from '@macro-inc/collaboration/collab/manager';import { makeResizeObserver } from '@solid-primitives/resize-observer';import { makePersisted } from '@solid-primitives/storage';@@ -47,11 +52,6 @@ import {MarkdownOutline,useMarkdownOutline,} from './MarkdownOutline';-import {- captureScrollAnchor,- restoreScrollAnchor,- type ScrollAnchor,-} from './scrollAnchor';import { TaskDuplicateMatchPill } from './TaskDuplicateMatches';import { TitleEditor } from './TitleEditor';import {diff --git a/apps/web/src/features/block-md/component/scrollAnchor.test.ts b/apps/web/src/features/block-md/component/scrollAnchor.test.tsdeleted file mode 100644index 3a508c92f0..0000000000--- a/apps/web/src/features/block-md/component/scrollAnchor.test.ts+++ /dev/null@@ -1,116 +0,0 @@-/**- * @vitest-environment jsdom- */--import { afterEach, describe, expect, it, vi } from 'vitest';-import { captureScrollAnchor, restoreScrollAnchor } from './scrollAnchor';--const rect = (top: number, bottom: number) =>- ({- top,- bottom,- left: 0,- right: 0,- width: 0,- height: bottom - top,- }) as DOMRect;--function setup(blockTops: number[]) {- const scroller = document.createElement('div');- const root = document.createElement('div');- scroller.append(root);- document.body.append(scroller);- vi.spyOn(scroller, 'getBoundingClientRect').mockReturnValue(rect(0, 500));- const tops = [...blockTops];- const blocks = tops.map((_, i) => {- const block = document.createElement('p');- block.textContent = `block ${i}`;- vi.spyOn(block, 'getBoundingClientRect').mockImplementation(() =>- rect(tops[i]!, tops[i]! + 100)- );- root.append(block);- return block;- });- return { scroller, root, blocks, tops };-}--afterEach(() => {- Reflect.deleteProperty(document, 'caretRangeFromPoint');- Reflect.deleteProperty(Range.prototype, 'getClientRects');- document.body.replaceChildren();- getSelection()?.removeAllRanges();- vi.restoreAllMocks();-});--describe('scroll anchor', () => {- it('keeps the first visible block in place when the document reflows', () => {- const { scroller, root, tops } = setup([-250, -150, -50, 50]);- scroller.scrollTop = 1000;-- const anchor = captureScrollAnchor(scroller, root);- expect(anchor?.top).toBe(-50);-- tops[2] = 250;- restoreScrollAnchor(scroller, anchor!);- expect(scroller.scrollTop).toBe(1300);- });-- it('prefers the on-screen selection over the first visible block', () => {- const { scroller, root, blocks } = setup([0, 100, 200, 300]);- let selectionTop = 320;- const range = document.createRange();- range.selectNodeContents(blocks[3]!);- // jsdom has no layout, so Range lacks getClientRects.- range.getClientRects = () =>- [rect(selectionTop, selectionTop + 20)] as unknown as DOMRectList;- getSelection()?.addRange(range);- scroller.scrollTop = 1000;-- const anchor = captureScrollAnchor(scroller, root);- expect(anchor?.top).toBe(320);-- selectionTop = 1120;- restoreScrollAnchor(scroller, anchor!);- expect(scroller.scrollTop).toBe(1800);- });-- it('anchors text at the viewport top inside a block that starts above it', () => {- const { scroller, root, blocks } = setup([-300, 400]);- vi.spyOn(blocks[0]!, 'getBoundingClientRect').mockReturnValue(- rect(-300, 300)- );- const text = blocks[0]!.firstChild!;- let caretTop = 5;- // jsdom has no layout, so caret hit-testing and Range rects are stubbed.- document.caretRangeFromPoint = () => {- const range = document.createRange();- range.setStart(text, 3);- return range;- };- Range.prototype.getClientRects = function (this: Range) {- return (this.startContainer === text- ? [rect(caretTop, caretTop + 20)]- : []) as unknown as DOMRectList;- };- scroller.scrollTop = 1000;-- const anchor = captureScrollAnchor(scroller, root);- expect(anchor?.top).toBe(5);-- // The block rewraps taller while its own top stays put.- caretTop = 85;- restoreScrollAnchor(scroller, anchor!);- expect(scroller.scrollTop).toBe(1080);- });-- it('ignores a selection outside the editor', () => {- const { scroller, root } = setup([0, 100]);- const outside = document.createElement('input');- document.body.append(outside);- const range = document.createRange();- range.selectNode(outside);- getSelection()?.addRange(range);-- expect(captureScrollAnchor(scroller, root)?.top).toBe(0);- });-});diff --git a/apps/web/src/features/block-md/component/scrollAnchor.ts b/apps/web/src/features/block-md/component/scrollAnchor.tsdeleted file mode 100644index 9b93c44527..0000000000--- a/apps/web/src/features/block-md/component/scrollAnchor.ts+++ /dev/null@@ -1,81 +0,0 @@-/**- * A point in the document whose on-screen position should survive a reflow.- * `top` is its viewport offset when captured; `measure` reads it again.- */-export type ScrollAnchor = {- top: number;- measure: () => number | undefined;-};--function rangeTop(range: Range): number | undefined {- const rect = range.getClientRects()[0];- return rect?.top;-}--function caretRangeAt(doc: Document, x: number, y: number): Range | undefined {- const position = doc.caretPositionFromPoint?.(x, y);- if (position) {- const range = doc.createRange();- range.setStart(position.offsetNode, position.offset);- return range;- }- return doc.caretRangeFromPoint?.(x, y) ?? undefined;-}--/**- * Captures the point the reader is looking at: the editor selection when it is- * on screen, otherwise the first editor text that reaches into the viewport.- */-export function captureScrollAnchor(- scroller: HTMLElement,- editorRoot: HTMLElement-): ScrollAnchor | undefined {- const view = scroller.getBoundingClientRect();- const isOnScreen = (top: number) => top >= view.top && top <= view.bottom;-- const selection = editorRoot.ownerDocument.getSelection();- if (selection && selection.rangeCount > 0) {- const range = selection.getRangeAt(0);- const top = editorRoot.contains(range.startContainer)- ? rangeTop(range)- : undefined;- if (top !== undefined && isOnScreen(top)) {- return { top, measure: () => rangeTop(range) };- }- }-- for (const block of editorRoot.children) {- const rect = block.getBoundingClientRect();- if (rect.bottom <= view.top) continue;- if (rect.top >= view.bottom) return undefined;- // A block that starts above the viewport rewraps above it too, so anchor- // the text at the viewport's top edge rather than the block's top.- if (rect.top < view.top) {- const range = caretRangeAt(- editorRoot.ownerDocument,- rect.left + 1,- view.top + 1- );- if (range && block.contains(range.startContainer)) {- const top = rangeTop(range);- if (top !== undefined) return { top, measure: () => rangeTop(range) };- }- }- return {- top: rect.top,- measure: () =>- block.isConnected ? block.getBoundingClientRect().top : undefined,- };- }- return undefined;-}--/** Scrolls so the anchor is back at the viewport offset it was captured at. */-export function restoreScrollAnchor(- scroller: HTMLElement,- anchor: ScrollAnchor-) {- const top = anchor.measure();- if (top === undefined) return;- scroller.scrollTop += top - anchor.top;-}diff --git a/apps/web/src/lib/core/util/scrollAnchor.test.ts b/apps/web/src/lib/core/util/scrollAnchor.test.tsnew file mode 100644index 0000000000..ded4594ad8--- /dev/null+++ b/apps/web/src/lib/core/util/scrollAnchor.test.ts@@ -0,0 +1,271 @@+/**+ * @vitest-environment jsdom+ */++import { afterEach, describe, expect, it, vi } from 'vitest';+import {+ captureElementScrollAnchor,+ captureScrollAnchor,+ holdScrollAnchor,+ restoreScrollAnchor,+} from './scrollAnchor';++const rect = (top: number, bottom: number) =>+ ({+ top,+ bottom,+ left: 0,+ right: 0,+ width: 0,+ height: bottom - top,+ }) as DOMRect;++function setup(blockTops: number[]) {+ const scroller = document.createElement('div');+ const root = document.createElement('div');+ scroller.append(root);+ document.body.append(scroller);+ vi.spyOn(scroller, 'getBoundingClientRect').mockReturnValue(rect(0, 500));+ const tops = [...blockTops];+ const blocks = tops.map((_, i) => {+ const block = document.createElement('p');+ block.textContent = `block ${i}`;+ vi.spyOn(block, 'getBoundingClientRect').mockImplementation(() =>+ rect(tops[i]!, tops[i]! + 100)+ );+ root.append(block);+ return block;+ });+ return { scroller, root, blocks, tops };+}++afterEach(() => {+ vi.useRealTimers();+ vi.unstubAllGlobals();+ Reflect.deleteProperty(document, 'caretRangeFromPoint');+ Reflect.deleteProperty(Range.prototype, 'getClientRects');+ document.body.replaceChildren();+ getSelection()?.removeAllRanges();+ vi.restoreAllMocks();+});++describe('scroll anchor', () => {+ it('keeps the first visible block in place when the document reflows', () => {+ const { scroller, root, tops } = setup([-250, -150, -50, 50]);+ scroller.scrollTop = 1000;++ const anchor = captureScrollAnchor(scroller, root);+ expect(anchor?.top).toBe(-50);++ tops[2] = 250;+ restoreScrollAnchor(scroller, anchor!);+ expect(scroller.scrollTop).toBe(1300);+ });++ it('prefers the on-screen selection over the first visible block', () => {+ const { scroller, root, blocks } = setup([0, 100, 200, 300]);+ let selectionTop = 320;+ const range = document.createRange();+ range.selectNodeContents(blocks[3]!);+ // jsdom has no layout, so Range lacks getClientRects.+ range.getClientRects = () =>+ [rect(selectionTop, selectionTop + 20)] as unknown as DOMRectList;+ getSelection()?.addRange(range);+ scroller.scrollTop = 1000;++ const anchor = captureScrollAnchor(scroller, root);+ expect(anchor?.top).toBe(320);++ selectionTop = 1120;+ restoreScrollAnchor(scroller, anchor!);+ expect(scroller.scrollTop).toBe(1800);+ });++ it('anchors text at the viewport top inside a block that starts above it', () => {+ const { scroller, root, blocks } = setup([-300, 400]);+ vi.spyOn(blocks[0]!, 'getBoundingClientRect').mockReturnValue(+ rect(-300, 300)+ );+ const text = blocks[0]!.firstChild!;+ let caretTop = 5;+ // jsdom has no layout, so caret hit-testing and Range rects are stubbed.+ document.caretRangeFromPoint = () => {+ const range = document.createRange();+ range.setStart(text, 3);+ return range;+ };+ Range.prototype.getClientRects = function (this: Range) {+ return (this.startContainer === text+ ? [rect(caretTop, caretTop + 20)]+ : []) as unknown as DOMRectList;+ };+ scroller.scrollTop = 1000;++ const anchor = captureScrollAnchor(scroller, root);+ expect(anchor?.top).toBe(5);++ // The block rewraps taller while its own top stays put.+ caretTop = 85;+ restoreScrollAnchor(scroller, anchor!);+ expect(scroller.scrollTop).toBe(1080);+ });++ it('ignores a selection outside the editor', () => {+ const { scroller, root } = setup([0, 100]);+ const outside = document.createElement('input');+ document.body.append(outside);+ const range = document.createRange();+ range.selectNode(outside);+ getSelection()?.addRange(range);++ expect(captureScrollAnchor(scroller, root)?.top).toBe(0);+ });+});++function setupScrolledElement(top: number) {+ const scroller = document.createElement('div');+ scroller.style.overflowY = 'auto';+ const content = document.createElement('div');+ const element = document.createElement('span');+ content.append(element);+ scroller.append(content);+ document.body.append(scroller);+ // jsdom has no layout, so the scroll extent and rects are stubbed.+ Object.defineProperty(scroller, 'scrollHeight', {+ value: 5000,+ configurable: true,+ });+ Object.defineProperty(scroller, 'clientHeight', { value: 500 });+ vi.spyOn(scroller, 'getBoundingClientRect').mockReturnValue(rect(0, 500));+ const position = { top };+ vi.spyOn(element, 'getBoundingClientRect').mockImplementation(() =>+ rect(position.top, position.top + 20)+ );+ scroller.scrollTop = 1000;+ return { scroller, element, position };+}++function stubResizeObserver() {+ const callbacks = new Set<ResizeObserverCallback>();+ vi.stubGlobal(+ 'ResizeObserver',+ class {+ constructor(private callback: ResizeObserverCallback) {+ callbacks.add(callback);+ }+ observe() {}+ disconnect() {+ callbacks.delete(this.callback);+ }+ }+ );+ const notify = () => {+ for (const callback of callbacks) {+ callback([], {} as ResizeObserver);+ }+ };+ return { notify, isObserving: () => callbacks.size > 0 };+}++describe('element scroll anchor', () => {+ it('anchors an element that is on screen in its scroll container', () => {+ const { scroller, position, element } = setupScrolledElement(450);++ const captured = captureElementScrollAnchor(element);+ expect(captured?.scroller).toBe(scroller);+ expect(captured?.anchor.top).toBe(450);++ position.top = 700;+ restoreScrollAnchor(scroller, captured!.anchor);+ expect(scroller.scrollTop).toBe(1250);+ });++ it('ignores an element scrolled out of view', () => {+ const { element } = setupScrolledElement(620);++ expect(captureElementScrollAnchor(element)).toBeUndefined();+ });++ it('ignores an element without a scroll container', () => {+ const element = document.createElement('span');+ document.body.append(element);++ expect(captureElementScrollAnchor(element)).toBeUndefined();+ });++ it('anchors a tall element that starts above the viewport', () => {+ const { scroller, element } = setupScrolledElement(-200);+ vi.spyOn(element, 'getBoundingClientRect').mockReturnValue(rect(-200, 300));++ const captured = captureElementScrollAnchor(element);+ expect(captured?.scroller).toBe(scroller);+ expect(captured?.anchor.top).toBe(-200);+ });++ it('skips an inner scroll container that does not overflow', () => {+ const { scroller, element } = setupScrolledElement(450);+ const inner = document.createElement('div');+ inner.style.overflowY = 'auto';+ element.replaceWith(inner);+ inner.append(element);++ expect(captureElementScrollAnchor(element)?.scroller).toBe(scroller);+ });++ it('falls back to a scroll container whose content still fits', () => {+ const { scroller, element } = setupScrolledElement(450);+ Object.defineProperty(scroller, 'scrollHeight', { value: 500 });++ expect(captureElementScrollAnchor(element)?.scroller).toBe(scroller);+ });++ it('holds the element in place through later reflows', () => {+ vi.useFakeTimers();+ const resize = stubResizeObserver();+ const { scroller, position, element } = setupScrolledElement(450);+ const { anchor } = captureElementScrollAnchor(element)!;++ position.top = 700;+ holdScrollAnchor(scroller, anchor);+ expect(scroller.scrollTop).toBe(1250);+ expect(scroller.style.overflowAnchor).toBe('none');++ // A component re-lays out after the width change and reflows again.+ position.top = 600;+ resize.notify();+ expect(scroller.scrollTop).toBe(1400);++ vi.advanceTimersByTime(1000);+ expect(resize.isObserving()).toBe(false);+ expect(scroller.style.overflowAnchor).toBe('');+ });++ it('lets the user scroll away during the hold', () => {+ vi.useFakeTimers();+ const resize = stubResizeObserver();+ const { scroller, position, element } = setupScrolledElement(450);+ const { anchor } = captureElementScrollAnchor(element)!;++ holdScrollAnchor(scroller, anchor);+ scroller.dispatchEvent(new WheelEvent('wheel'));++ position.top = 700;+ resize.notify();+ expect(scroller.scrollTop).toBe(1000);+ expect(resize.isObserving()).toBe(false);+ });++ it('restores native scroll anchoring after back-to-back holds', () => {+ vi.useFakeTimers();+ stubResizeObserver();+ const { scroller, element } = setupScrolledElement(450);+ scroller.style.overflowAnchor = 'auto';++ holdScrollAnchor(scroller, captureElementScrollAnchor(element)!.anchor);+ vi.advanceTimersByTime(500);+ holdScrollAnchor(scroller, captureElementScrollAnchor(element)!.anchor);+ vi.advanceTimersByTime(1000);++ expect(scroller.style.overflowAnchor).toBe('auto');+ });+});diff --git a/apps/web/src/lib/core/util/scrollAnchor.ts b/apps/web/src/lib/core/util/scrollAnchor.tsnew file mode 100644index 0000000000..b71ef96852--- /dev/null+++ b/apps/web/src/lib/core/util/scrollAnchor.ts@@ -0,0 +1,169 @@+/**+ * A point in the document whose on-screen position should survive a reflow.+ * `top` is its viewport offset when captured; `measure` reads it again.+ */+export type ScrollAnchor = {+ top: number;+ measure: () => number | undefined;+};++function rangeTop(range: Range): number | undefined {+ const rect = range.getClientRects()[0];+ return rect?.top;+}++function caretRangeAt(doc: Document, x: number, y: number): Range | undefined {+ const position = doc.caretPositionFromPoint?.(x, y);+ if (position) {+ const range = doc.createRange();+ range.setStart(position.offsetNode, position.offset);+ return range;+ }+ return doc.caretRangeFromPoint?.(x, y) ?? undefined;+}++/**+ * Captures the point the reader is looking at: the editor selection when it is+ * on screen, otherwise the first editor text that reaches into the viewport.+ */+export function captureScrollAnchor(+ scroller: HTMLElement,+ editorRoot: HTMLElement+): ScrollAnchor | undefined {+ const view = scroller.getBoundingClientRect();+ const isOnScreen = (top: number) => top >= view.top && top <= view.bottom;++ const selection = editorRoot.ownerDocument.getSelection();+ if (selection && selection.rangeCount > 0) {+ const range = selection.getRangeAt(0);+ const top = editorRoot.contains(range.startContainer)+ ? rangeTop(range)+ : undefined;+ if (top !== undefined && isOnScreen(top)) {+ return { top, measure: () => rangeTop(range) };+ }+ }++ for (const block of editorRoot.children) {+ const rect = block.getBoundingClientRect();+ if (rect.bottom <= view.top) continue;+ if (rect.top >= view.bottom) return undefined;+ // A block that starts above the viewport rewraps above it too, so anchor+ // the text at the viewport's top edge rather than the block's top.+ if (rect.top < view.top) {+ const range = caretRangeAt(+ editorRoot.ownerDocument,+ rect.left + 1,+ view.top + 1+ );+ if (range && block.contains(range.startContainer)) {+ const top = rangeTop(range);+ if (top !== undefined) return { top, measure: () => rangeTop(range) };+ }+ }+ return {+ top: rect.top,+ measure: () =>+ block.isConnected ? block.getBoundingClientRect().top : undefined,+ };+ }+ return undefined;+}++/** Scrolls so the anchor is back at the viewport offset it was captured at. */+export function restoreScrollAnchor(+ scroller: HTMLElement,+ anchor: ScrollAnchor+) {+ const top = anchor.measure();+ if (top === undefined) return;+ scroller.scrollTop += top - anchor.top;+}++/**+ * The nearest ancestor that scrolls vertically. When none overflows yet, the+ * nearest one styled to scroll, since the reflow can make it overflow.+ */+function verticalScrollParent(element: Element): HTMLElement | undefined {+ let styled: HTMLElement | undefined;+ for (+ let parent = element.parentElement;+ parent;+ parent = parent.parentElement+ ) {+ if (!/auto|scroll/.test(getComputedStyle(parent).overflowY)) continue;+ if (parent.scrollHeight > parent.clientHeight) return parent;+ styled ??= parent;+ }+ return styled;+}++/**+ * Anchors on `element` when any of it is on screen in the nearest container+ * that scrolls it vertically.+ */+export function captureElementScrollAnchor(+ element: Element | undefined+): { scroller: HTMLElement; anchor: ScrollAnchor } | undefined {+ if (!element?.isConnected) return undefined;+ const scroller = verticalScrollParent(element);+ if (!scroller) return undefined;++ const view = scroller.getBoundingClientRect();+ const { top, bottom } = element.getBoundingClientRect();+ if (bottom < view.top || top > view.bottom) return undefined;++ return {+ scroller,+ anchor: {+ top,+ measure: () =>+ element.isConnected ? element.getBoundingClientRect().top : undefined,+ },+ };+}++const SCROLL_HOLD_MS = 1000;+const USER_SCROLL_EVENTS = [+ 'wheel',+ 'touchstart',+ 'pointerdown',+ 'keydown',+] as const;+const activeHolds = new WeakMap<HTMLElement, () => void>();++/**+ * Keeps the anchor at its captured offset while the scroller's layout settles+ * after a change the caller just made. A width change can reflow content in+ * several passes, as components re-lay out in their own ResizeObservers, so+ * one restore is not enough. Native scroll anchoring is off meanwhile so it+ * cannot shift the page towards a different anchor, and user scroll input+ * ends the hold. A new hold on the same scroller replaces the previous one.+ */+export function holdScrollAnchor(scroller: HTMLElement, anchor: ScrollAnchor) {+ activeHolds.get(scroller)?.();+ const restore = () => restoreScrollAnchor(scroller, anchor);+ const overflowAnchor = scroller.style.overflowAnchor;+ scroller.style.overflowAnchor = 'none';++ const observer = new ResizeObserver(restore);+ observer.observe(scroller);+ for (const child of scroller.children) observer.observe(child);++ const release = () => {+ activeHolds.delete(scroller);+ clearTimeout(timeout);+ observer.disconnect();+ scroller.style.overflowAnchor = overflowAnchor;+ for (const type of USER_SCROLL_EVENTS) {+ scroller.removeEventListener(type, release);+ }+ };+ const timeout = setTimeout(release, SCROLL_HOLD_MS);+ for (const type of USER_SCROLL_EVENTS) {+ scroller.addEventListener(type, release, { passive: true });+ }+ activeHolds.set(scroller, release);++ restore();+}