Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

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.tsx
index 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.ts
index 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.ts
index 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.tsx
index 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.ts
deleted file mode 100644
index 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.ts
deleted file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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();
+}