Skip to content

armgit / memos

Public Imported from GitHub
0

Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.

fix(web): untrap focus mode in the memo grid and use a dark scrim token for overlays (#6310)

Wally98f9c215c4ba
diff --git a/web/src/components/ColumnGrid/ColumnGrid.tsx b/web/src/components/ColumnGrid/ColumnGrid.tsx
index 20b1a2362..9bfa40390 100644
--- a/web/src/components/ColumnGrid/ColumnGrid.tsx
+++ b/web/src/components/ColumnGrid/ColumnGrid.tsx
@@ -1,5 +1,7 @@
import { useDirection } from "@base-ui/react/direction-provider";
import { type ReactNode, useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+import { cn } from "@/lib/utils";
+import { useColumnGridUntrapped } from "./ColumnGridContext";
interface ColumnGridProps<T> {
items: T[];
@@ -85,6 +87,7 @@ function ColumnGrid<T>({
maxColumnWidth,
}: ColumnGridProps<T>) {
const direction = useDirection();
+ const { untrappedKeys } = useColumnGridUntrapped();
const containerRef = useRef<HTMLDivElement>(null);
const itemRefs = useRef<Map<string, HTMLDivElement>>(new Map());
const refCallbacks = useRef<Map<string, (el: HTMLDivElement | null) => void>>(new Map());
@@ -187,13 +190,14 @@ function ColumnGrid<T>({
for (const { key, el } of ordered) {
const target = pos.get(key);
if (!target) continue;
- // The leading tile (the note composer) is positioned with left/top rather than a
- // transform so it never becomes the containing block for its own position:fixed
- // descendants. A transform (or will-change:transform) here would trap the editor's
- // focus-mode overlay — which is meant to cover the viewport — inside this column tile.
- // The leading tile is pinned to column one's top and only shifts horizontally on
- // resize (which snaps anyway), so it loses no animation by skipping the transform.
- if (key === LEADING_KEY) {
+ // Untrapped tiles are positioned with left/top rather than a transform so they never
+ // become the containing block for their own position:fixed descendants. A transform
+ // (or will-change:transform) would trap the editor's focus-mode overlay — which is
+ // meant to cover the viewport — inside this column tile. The leading composer tile
+ // always opts out; a memo tile opts out while its inline editor is in focus mode. Both
+ // are pinned horizontally and only shift on resize (which snaps anyway), so neither
+ // loses an animation that matters.
+ if (key === LEADING_KEY || untrappedKeys.has(key)) {
el.style.transition = "none";
el.style.transform = "";
el.style.left = `${target.x}px`;
@@ -202,10 +206,13 @@ function ColumnGrid<T>({
}
el.style.transition = "none";
el.style.transform = `translate3d(${target.x}px, ${target.y}px, 0)`;
+ // Clear any left/top left behind by a previous untrapped stint.
+ el.style.left = "";
+ el.style.top = "";
}
setContainerHeight(Math.max(0, ...columnY.map((h) => h - GRID_GAP)));
- }, [items, getKey, estimateHeight, priorityKey, maxColumns, maxColumnWidth, direction]);
+ }, [items, getKey, estimateHeight, priorityKey, maxColumns, maxColumnWidth, direction, untrappedKeys]);
// Keep a stable reference so observer callbacks always run the latest layout.
const relayoutRef = useRef(relayout);
@@ -299,12 +306,16 @@ function ColumnGrid<T>({
)}
{items.map((item) => {
const key = getKey(item);
+ const isUntrapped = untrappedKeys.has(key);
return (
<div
key={key}
ref={getItemRef(key)}
- className="absolute top-0 left-0 transition-transform duration-200 ease-out motion-reduce:transition-none"
- style={{ willChange: "transform" }}
+ className={cn(
+ "absolute top-0 left-0",
+ !isUntrapped && "transition-transform duration-200 ease-out motion-reduce:transition-none",
+ )}
+ style={isUntrapped ? undefined : { willChange: "transform" }}
>
{renderItem(item)}
</div>
diff --git a/web/src/components/ColumnGrid/ColumnGridContext.tsx b/web/src/components/ColumnGrid/ColumnGridContext.tsx
new file mode 100644
index 000000000..42a56d164
--- /dev/null
+++ b/web/src/components/ColumnGrid/ColumnGridContext.tsx
@@ -0,0 +1,54 @@
+import { createContext, type ReactNode, useCallback, useContext, useMemo, useState } from "react";
+
+interface ColumnGridUntrappedValue {
+ /** Keys of tiles that must not be positioned with a transform. */
+ untrappedKeys: ReadonlySet<string>;
+ /** Adds a tile to the untrapped set. */
+ setUntrappedKey: (key: string) => void;
+ /** Removes a tile from the untrapped set. */
+ clearUntrappedKey: (key: string) => void;
+}
+
+// Defaults keep MemoView working outside a grid (flow list, detail page, comments).
+const ColumnGridUntrappedContext = createContext<ColumnGridUntrappedValue>({
+ untrappedKeys: new Set(),
+ setUntrappedKey: () => {},
+ clearUntrappedKey: () => {},
+});
+
+/**
+ * Lets tiles opt out of the grid's transform positioning while they host a
+ * `position: fixed` surface (the inline editor's focus mode). A transformed
+ * ancestor is the containing block for fixed descendants, which would trap the
+ * focus-mode overlay inside the card instead of covering the viewport. The
+ * leading composer tile already opts out the same way; see ColumnGrid.relayout.
+ *
+ * A set, not a single key: inline editors are independently openable, so more
+ * than one card can hold focus mode at a time and each must keep its own tile
+ * untrapped.
+ */
+export function ColumnGridUntrappedProvider({ children }: { children: ReactNode }) {
+ const [untrappedKeys, setUntrappedKeys] = useState<ReadonlySet<string>>(() => new Set());
+ const setUntrappedKey = useCallback((key: string) => {
+ setUntrappedKeys((current) => {
+ if (current.has(key)) return current;
+ const next = new Set(current);
+ next.add(key);
+ return next;
+ });
+ }, []);
+ const clearUntrappedKey = useCallback((key: string) => {
+ setUntrappedKeys((current) => {
+ if (!current.has(key)) return current;
+ const next = new Set(current);
+ next.delete(key);
+ return next;
+ });
+ }, []);
+ // Memoized so consumers re-render only when the set itself changes; both
+ // callbacks stay stable, so effects keyed on them do not re-run.
+ const value = useMemo(() => ({ untrappedKeys, setUntrappedKey, clearUntrappedKey }), [untrappedKeys, setUntrappedKey, clearUntrappedKey]);
+ return <ColumnGridUntrappedContext.Provider value={value}>{children}</ColumnGridUntrappedContext.Provider>;
+}
+
+export const useColumnGridUntrapped = () => useContext(ColumnGridUntrappedContext);
diff --git a/web/src/components/ColumnGrid/index.ts b/web/src/components/ColumnGrid/index.ts
index 9cb4bdcad..d4e1ec438 100644
--- a/web/src/components/ColumnGrid/index.ts
+++ b/web/src/components/ColumnGrid/index.ts
@@ -1,4 +1,5 @@
import ColumnGrid from "./ColumnGrid";
export { assignColumnsByEstimatedHeight, columnCountForWidth, GRID_GAP } from "./ColumnGrid";
+export { ColumnGridUntrappedProvider, useColumnGridUntrapped } from "./ColumnGridContext";
export default ColumnGrid;
diff --git a/web/src/components/MemoEditor/constants.ts b/web/src/components/MemoEditor/constants.ts
index 723bc94b6..77aadd247 100644
--- a/web/src/components/MemoEditor/constants.ts
+++ b/web/src/components/MemoEditor/constants.ts
@@ -1,5 +1,5 @@
export const FOCUS_MODE_STYLES = {
- backdrop: "fixed inset-0 bg-black/20 backdrop-blur-sm z-40",
+ backdrop: "fixed inset-0 bg-overlay/20 backdrop-blur-sm z-overlay",
container: {
base: "fixed z-50 w-auto max-w-5xl mx-auto shadow-2xl border-border h-auto overflow-y-auto",
spacing: "top-2 left-2 right-2 bottom-2 sm:top-4 sm:left-4 sm:right-4 sm:bottom-4 md:top-8 md:left-8 md:right-8 md:bottom-8",
diff --git a/web/src/components/MemoEditor/index.tsx b/web/src/components/MemoEditor/index.tsx
index a88269b55..28301d87d 100644
--- a/web/src/components/MemoEditor/index.tsx
+++ b/web/src/components/MemoEditor/index.tsx
@@ -45,6 +45,7 @@ const MemoEditorImpl: React.FC<MemoEditorProps> = ({
defaultLocation,
autoFocus,
onFocusModeExit,
+ onFocusModeChange,
placeholder,
defaultCreateTime,
onConfirm,
@@ -59,6 +60,10 @@ const MemoEditorImpl: React.FC<MemoEditorProps> = ({
// typing (which changes content) does not re-render the editor shell and its
// toolbar/metadata children.
const isFocusMode = useEditorSelector((s) => s.ui.isFocusMode);
+ // Report focus-mode changes so a host can react; inline hosts pass nothing.
+ useEffect(() => {
+ onFocusModeChange?.(isFocusMode);
+ }, [isFocusMode, onFocusModeChange]);
const isSaving = useEditorSelector((s) => s.ui.isLoading.saving);
const hasTimestamp = useEditorSelector((s) => Boolean(s.timestamps.createTime));
const { userGeneralSetting } = useAuth();
diff --git a/web/src/components/MemoEditor/types/components.ts b/web/src/components/MemoEditor/types/components.ts
index b9d1595a1..2570a096b 100644
--- a/web/src/components/MemoEditor/types/components.ts
+++ b/web/src/components/MemoEditor/types/components.ts
@@ -23,6 +23,12 @@ export interface MemoEditorProps {
* and exits by calling this to dismiss the host rather than collapsing in place.
*/
onFocusModeExit?: () => void;
+ /**
+ * Reports inline focus-mode changes. A host reacts to the editor taking over
+ * the viewport, e.g. the memo grid untraps its tile so the fixed focus-mode
+ * surface is not contained by a transformed ancestor.
+ */
+ onFocusModeChange?: (isFocusMode: boolean) => void;
/**
* Default `createTime` for a *new* memo (create mode only). When set, the
* editor seeds both `createTime` and `updateTime` to this value and renders
diff --git a/web/src/components/MemoView/MemoView.tsx b/web/src/components/MemoView/MemoView.tsx
index e9904f7ac..09b30518f 100644
--- a/web/src/components/MemoView/MemoView.tsx
+++ b/web/src/components/MemoView/MemoView.tsx
@@ -4,6 +4,7 @@ import {
memo,
Suspense,
useCallback,
+ useEffect,
useImperativeHandle,
useLayoutEffect,
useMemo,
@@ -11,6 +12,7 @@ import {
useState,
} from "react";
import { useLocation } from "react-router-dom";
+import { useColumnGridUntrapped } from "@/components/ColumnGrid/ColumnGridContext";
import { useResolvedUser } from "@/components/MemoContent/MentionResolutionContext";
import { loadMemoEditor } from "@/components/MemoEditor/loader";
import type { MemoEditorProps } from "@/components/MemoEditor/types";
@@ -89,6 +91,28 @@ const MemoView = forwardRef<MemoViewHandle, MemoViewProps>((props, ref) => {
}, [EditorComponent, focusMountedEditor, showEditor]);
const closeEditor = useCallback(() => setShowEditor(false), []);
+ // The grid keys tiles by memo name (see getMemoKey), so the focused editor
+ // identifies its own tile by name and untraps it for the duration.
+ const { setUntrappedKey, clearUntrappedKey } = useColumnGridUntrapped();
+ const handleFocusModeChange = useCallback(
+ (isFocusMode: boolean) => {
+ if (isFocusMode) {
+ setUntrappedKey(memoData.name);
+ } else {
+ clearUntrappedKey(memoData.name);
+ }
+ },
+ [memoData.name, setUntrappedKey, clearUntrappedKey],
+ );
+ // Release the slot when the editor closes or this card unmounts. Both calls
+ // are ownership-scoped, so mounting cards never clobber another card's slot.
+ useEffect(() => {
+ if (!showEditor) {
+ clearUntrappedKey(memoData.name);
+ }
+ }, [showEditor, memoData.name, clearUntrappedKey]);
+ useEffect(() => () => clearUntrappedKey(memoData.name), [memoData.name, clearUntrappedKey]);
+
useImperativeHandle(ref, () => ({ openEditor }), [openEditor]);
const isInMemoDetailPage = isMemoDetailPath(location.pathname, memoData.name);
@@ -214,6 +238,7 @@ const MemoView = forwardRef<MemoViewHandle, MemoViewProps>((props, ref) => {
parentMemoName={memoData.parent || undefined}
onConfirm={closeEditor}
onCancel={closeEditor}
+ onFocusModeChange={handleFocusModeChange}
/>
</div>
) : (
diff --git a/web/src/components/PagedMemoList/PagedMemoList.tsx b/web/src/components/PagedMemoList/PagedMemoList.tsx
index 310c85875..79e6543c7 100644
--- a/web/src/components/PagedMemoList/PagedMemoList.tsx
+++ b/web/src/components/PagedMemoList/PagedMemoList.tsx
@@ -16,7 +16,7 @@ import { cn } from "@/lib/utils";
import { State } from "@/types/proto/api/v1/common_pb";
import type { Memo } from "@/types/proto/api/v1/memo_service_pb";
import { useTranslate } from "@/utils/i18n";
-import ColumnGrid, { columnCountForWidth, GRID_GAP } from "../ColumnGrid";
+import ColumnGrid, { ColumnGridUntrappedProvider, columnCountForWidth, GRID_GAP } from "../ColumnGrid";
import MemoFilters from "../MemoFilters";
import Placeholder from "../Placeholder";
import MemoListError from "./MemoListError";
@@ -281,17 +281,19 @@ const PagedMemoList = (props: Props) => {
<div className={cn("flex flex-col justify-start w-full mx-auto", useGrid ? "max-w-none" : "max-w-2xl")}>
{useGrid ? (
<>
- <ColumnGrid
- items={displayMemoList}
- getKey={getMemoKey}
- renderItem={(memo) => props.renderer(memo, { compact: effectiveCompact })}
- estimateHeight={estimateMemoCardHeight}
- header={headerContent}
- leading={gridLeading}
- priorityKey={priorityKey}
- maxColumns={maxColumns}
- maxColumnWidth={MAX_COLUMN_WIDTH}
- />
+ <ColumnGridUntrappedProvider>
+ <ColumnGrid
+ items={displayMemoList}
+ getKey={getMemoKey}
+ renderItem={(memo) => props.renderer(memo, { compact: effectiveCompact })}
+ estimateHeight={estimateMemoCardHeight}
+ header={headerContent}
+ leading={gridLeading}
+ priorityKey={priorityKey}
+ maxColumns={maxColumns}
+ maxColumnWidth={MAX_COLUMN_WIDTH}
+ />
+ </ColumnGridUntrappedProvider>
{!isDisplayPending && footer}
</>
) : (
diff --git a/web/src/components/ui/dialog.tsx b/web/src/components/ui/dialog.tsx
index 5e2dd5063..482e990ce 100644
--- a/web/src/components/ui/dialog.tsx
+++ b/web/src/components/ui/dialog.tsx
@@ -17,7 +17,7 @@ const DialogOverlay = React.forwardRef<HTMLDivElement, DialogPrimitive.Backdrop.
ref={ref}
data-slot="dialog-overlay"
className={cn(
- "fixed inset-0 z-overlay bg-foreground/50 transition-opacity duration-200 data-starting-style:opacity-0 data-ending-style:opacity-0",
+ "fixed inset-0 z-overlay bg-overlay/50 transition-opacity duration-200 data-starting-style:opacity-0 data-ending-style:opacity-0",
className,
)}
{...props}
diff --git a/web/src/components/ui/sheet.tsx b/web/src/components/ui/sheet.tsx
index 6ce41c8fd..17ba1621b 100644
--- a/web/src/components/ui/sheet.tsx
+++ b/web/src/components/ui/sheet.tsx
@@ -27,7 +27,7 @@ const SheetOverlay = React.forwardRef<HTMLDivElement, SheetPrimitive.Backdrop.Pr
ref={ref}
data-slot="sheet-overlay"
className={cn(
- "fixed inset-0 z-overlay bg-foreground/50 transition-opacity duration-300 data-starting-style:opacity-0 data-ending-style:opacity-0",
+ "fixed inset-0 z-overlay bg-overlay/50 transition-opacity duration-300 data-starting-style:opacity-0 data-ending-style:opacity-0",
className,
)}
{...props}
diff --git a/web/src/themes/COLOR_GUIDE.md b/web/src/themes/COLOR_GUIDE.md
index aa0fdf9d8..c1fe92234 100644
--- a/web/src/themes/COLOR_GUIDE.md
+++ b/web/src/themes/COLOR_GUIDE.md
@@ -53,12 +53,14 @@ The color system supports both light and dark themes automatically through CSS c
| `--card-foreground` | Very dark | Near white | Text on card backgrounds |
| `--popover` | Pure white | Darker gray | Overlay backgrounds |
| `--popover-foreground` | Dark gray | Light gray | Text on overlay backgrounds |
+| `--overlay` | Pure black | Pure black | Scrim behind modals |
**When to use:**
- Page backgrounds (`--background`)
- Content cards and panels (`--card`)
- Tooltips, dropdowns, modals (`--popover`)
+- Modal scrims (`--overlay`, always with an alpha utility: `bg-overlay/50` for dialogs and sheets, `bg-overlay/20` for focus mode)
### ✏️ Text & Content Colors
diff --git a/web/src/themes/default-dark.css b/web/src/themes/default-dark.css
index ade1fb250..82f263363 100644
--- a/web/src/themes/default-dark.css
+++ b/web/src/themes/default-dark.css
@@ -41,6 +41,9 @@
--input: oklch(0.42 0.011 255);
--ring: oklch(0.58 0.095 250);
+ /* Overlay - neutral scrim; alpha comes from the utility (bg-overlay/50) */
+ --overlay: oklch(0 0 0);
+
/* Sidebar - anchored but no longer near-black */
--sidebar: oklch(0.21 0.009 255);
--sidebar-foreground: oklch(0.76 0.007 255);
diff --git a/web/src/themes/default.css b/web/src/themes/default.css
index a1507494e..e5b560366 100644
--- a/web/src/themes/default.css
+++ b/web/src/themes/default.css
@@ -22,6 +22,10 @@
--border: oklch(0.8847 0.0069 97.3627);
--input: oklch(0.7621 0.0156 98.3528);
--ring: oklch(0.45 0.08 250);
+ /* Overlay - neutral scrim base behind dialogs, sheets, and focus mode.
+ Alpha comes from the utility (bg-overlay/50, bg-overlay/20), so every
+ theme dims rather than tinting with --foreground. */
+ --overlay: oklch(0 0 0);
--sidebar: oklch(0.9663 0.008 98.8792);
--sidebar-foreground: oklch(0.359 0.0051 106.6524);
--sidebar-accent: oklch(0.9245 0.0138 92.9892);
@@ -67,6 +71,7 @@
--color-border: var(--border);
--color-input: var(--input);
--color-ring: var(--ring);
+ --color-overlay: var(--overlay);
--color-sidebar: var(--sidebar);
--color-sidebar-foreground: var(--sidebar-foreground);
--color-sidebar-accent: var(--sidebar-accent);
diff --git a/web/src/themes/paper.css b/web/src/themes/paper.css
index 291c96755..10d0c5ce0 100644
--- a/web/src/themes/paper.css
+++ b/web/src/themes/paper.css
@@ -22,6 +22,8 @@
--border: oklch(0.85 0.025 72);
--input: oklch(0.8 0.03 75);
--ring: oklch(0.45 0.08 45);
+ /* Overlay - neutral scrim; alpha comes from the utility (bg-overlay/50) */
+ --overlay: oklch(0 0 0);
--sidebar: oklch(0.9647 0.0118 83.7892);
--sidebar-foreground: oklch(0.2941 0.0196 67.6524);
--sidebar-accent: oklch(0.9412 0.0196 78.9456);
diff --git a/web/tests/column-grid-untrapped.test.tsx b/web/tests/column-grid-untrapped.test.tsx
new file mode 100644
index 000000000..676b0b31b
--- /dev/null
+++ b/web/tests/column-grid-untrapped.test.tsx
@@ -0,0 +1,92 @@
+import { fireEvent, render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import ColumnGrid, { ColumnGridUntrappedProvider, GRID_GAP, useColumnGridUntrapped } from "@/components/ColumnGrid";
+
+// Regression test for #6288: an inline editor's focus mode renders position:fixed
+// UI inside a grid tile. A tile positioned with a transform (or will-change:
+// transform) is the containing block for fixed descendants, so the focus-mode
+// surface gets trapped inside the card. The untrapped set switches those tiles
+// to left/top for the duration.
+
+interface Item {
+ key: string;
+}
+
+const TileConsumer = ({ itemKey }: { itemKey: string }) => {
+ const { setUntrappedKey, clearUntrappedKey } = useColumnGridUntrapped();
+ return (
+ <>
+ <button type="button" data-testid={`untrap-${itemKey}`} onClick={() => setUntrappedKey(itemKey)}>
+ untrap {itemKey}
+ </button>
+ <button type="button" data-testid={`clear-${itemKey}`} onClick={() => clearUntrappedKey(itemKey)}>
+ clear {itemKey}
+ </button>
+ </>
+ );
+};
+
+const renderGrid = () => {
+ const items: Item[] = [{ key: "a" }, { key: "b" }];
+ render(
+ <ColumnGridUntrappedProvider>
+ <ColumnGrid
+ items={items}
+ getKey={(item) => item.key}
+ renderItem={(item) => (
+ <div data-testid={`tile-${item.key}`}>
+ <TileConsumer itemKey={item.key} />
+ </div>
+ )}
+ />
+ </ColumnGridUntrappedProvider>,
+ );
+};
+
+const tileWrapper = (key: string) => screen.getByTestId(`tile-${key}`).parentElement as HTMLElement;
+
+describe("ColumnGrid untrapped tile", () => {
+ it("positions every tile with a transform by default", () => {
+ renderGrid();
+ for (const key of ["a", "b"]) {
+ const el = tileWrapper(key);
+ expect(el.style.transform).toContain("translate3d");
+ expect(el.style.willChange).toBe("transform");
+ expect(el.className).toContain("transition-transform");
+ }
+ });
+
+ it("positions the untrapped tile with left/top so it cannot contain fixed descendants", () => {
+ renderGrid();
+ fireEvent.click(screen.getByTestId("untrap-b"));
+
+ const untrapped = tileWrapper("b");
+ expect(untrapped.style.transform).toBe("");
+ expect(untrapped.style.willChange).toBe("");
+ // jsdom reports every tile as zero-height, so the second tile's y is one gap down.
+ expect(untrapped.style.left).toBe("0px");
+ expect(untrapped.style.top).toBe(`${GRID_GAP}px`);
+ expect(untrapped.className).not.toContain("transition-transform");
+
+ const other = tileWrapper("a");
+ expect(other.style.transform).toContain("translate3d");
+ expect(other.style.willChange).toBe("transform");
+ });
+
+ it("keeps every focused tile untrapped when two editors claim focus mode", () => {
+ renderGrid();
+ fireEvent.click(screen.getByTestId("untrap-a"));
+ fireEvent.click(screen.getByTestId("untrap-b"));
+
+ for (const key of ["a", "b"]) {
+ const el = tileWrapper(key);
+ expect(el.style.transform).toBe("");
+ expect(el.style.willChange).toBe("");
+ }
+
+ // Releasing one claim must not retrap the other tile.
+ fireEvent.click(screen.getByTestId("clear-a"));
+ expect(tileWrapper("a").style.transform).toContain("translate3d");
+ expect(tileWrapper("b").style.transform).toBe("");
+ });
+});