diff --git a/apps/desktop/package.json b/apps/desktop/package.json index 560dc0ff..120038a1 100644 --- a/apps/desktop/package.json +++ b/apps/desktop/package.json @@ -1,7 +1,7 @@ { "name": "@zennotes/desktop", "productName": "ZenNotes", - "version": "2.76.0", + "version": "2.77.0", "description": "ZenNotes desktop shell", "private": true, "main": "./out/main/index.js", diff --git a/apps/desktop/src/main/app-config.ts b/apps/desktop/src/main/app-config.ts index 46d99b40..c20c78e4 100644 --- a/apps/desktop/src/main/app-config.ts +++ b/apps/desktop/src/main/app-config.ts @@ -96,6 +96,11 @@ const SCALAR_FIELDS: Partial> = { tomlKey: 'fzf_path', comment: 'absolute path to fzf; empty = look on $PATH' }, + searchTaggedBlocks: { + section: 'search', + tomlKey: 'tagged_blocks', + comment: 'with a #tag in Search notes, list the tagged blocks under each note' + }, // editor livePreview: { section: 'editor', @@ -179,6 +184,11 @@ const SCALAR_FIELDS: Partial> = { tomlKey: 'list_indent_guides', comment: 'vertical guide lines at each nested list level' }, + linkPopoverOnHover: { + section: 'editor', + tomlKey: 'link_popover_on_hover', + comment: 'resting the pointer on a [[wikilink]] opens the link popover' + }, editorScrollOff: { section: 'editor', tomlKey: 'scroll_off', diff --git a/apps/desktop/src/main/vault.test.ts b/apps/desktop/src/main/vault.test.ts index cb636443..6aa98e2e 100644 --- a/apps/desktop/src/main/vault.test.ts +++ b/apps/desktop/src/main/vault.test.ts @@ -1010,6 +1010,22 @@ describe('listNotes metadata parsing', () => { expect(note?.tags).toEqual(['realtag']) }) + it('does not index #tags or [[links]] inside a fence in a CRLF note', async () => { + const root = await makeTempDir('zennotes-meta-fence-crlf-') + await ensureVaultLayout(root) + const rel = 'inbox/windows.md' + await writeFile( + path.join(root, rel), + '# Notes\r\n\r\n```c\r\n#include \r\n// [[Secret Note]]\r\n```\r\n\r\n#realtag [[Real Link]]\r\n', + 'utf8' + ) + + const notes = await listNotes(root) + const note = notes.find((n) => n.path === rel) + expect(note?.tags).toEqual(['realtag']) + expect(note?.wikilinks).toEqual(['Real Link']) + }) + it('indexes frontmatter tags as first-class note tags', async () => { const root = await makeTempDir('zennotes-meta-frontmatter-tags-') await ensureVaultLayout(root) diff --git a/apps/desktop/src/main/vault.ts b/apps/desktop/src/main/vault.ts index a1b403d4..e89a34c7 100644 --- a/apps/desktop/src/main/vault.ts +++ b/apps/desktop/src/main/vault.ts @@ -1979,8 +1979,9 @@ async function folderOf(root: string, absPath: string): Promise { }) }) +describe('list_notes metadata skips fenced code', () => { + it('does not index #tags or [[links]] inside a fence in a CRLF note', async () => { + await writeFile( + path.join(root, 'inbox', 'Windows.md'), + '# Notes\r\n\r\n```c\r\n#include \r\n// [[Secret Note]]\r\n```\r\n\r\n#realtag [[Real Link]]\r\n' + ) + + const notes = await listNotes(root) + const note = notes.find((n) => n.path === 'inbox/Windows.md') + expect(note?.tags).toEqual(['realtag']) + expect(note?.wikilinks).toEqual(['Real Link']) + }) +}) + describe('remapped system folders (#398)', () => { it('classifies a remapped trash directory as trash and keeps its tasks out', async () => { await mkdir(path.join(root, '.zennotes'), { recursive: true }) diff --git a/apps/desktop/src/mcp/vault-ops.ts b/apps/desktop/src/mcp/vault-ops.ts index 59a66085..07473f4d 100644 --- a/apps/desktop/src/mcp/vault-ops.ts +++ b/apps/desktop/src/mcp/vault-ops.ts @@ -658,7 +658,7 @@ async function folderOf(root: string, abs: string): Promise { * never read code as content. Line-based and indentation-tolerant: a fence * nested under a list item is still a code block (#293). Mirrors * `stripCodeContent` in apps/desktop/src/main/vault.ts, - * packages/app-core/src/lib/{tags,wikilinks}.ts, and + * packages/shared-domain/src/tag-scan.ts, packages/app-core/src/lib/wikilinks.ts, and * internal/vault/parse.go in ZenNotes/znserver — keep all five in sync. */ function stripCodeContent(body: string): string { @@ -669,7 +669,8 @@ function stripCodeContent(body: string): string { let fenceLen = 0 for (let i = 0; i < lines.length; i++) { const line = lines[i] as string - const m = /^[ \t]*(`{3,}|~{3,})(.*)$/.exec(line) + // `.` never matches `\r`, so the `\r?` is what lets a CRLF-saved fence line match. + const m = /^[ \t]*(`{3,}|~{3,})(.*)\r?$/.exec(line) if (m) { const marker = m[1] as string const char = marker[0] as string diff --git a/apps/quicklook/package.json b/apps/quicklook/package.json index 24ae2d8e..182f2dd7 100644 --- a/apps/quicklook/package.json +++ b/apps/quicklook/package.json @@ -1,7 +1,7 @@ { "name": "@zennotes/quicklook", "private": true, - "version": "2.76.0", + "version": "2.77.0", "type": "module", "description": "The macOS Quick Look preview for Markdown files: the page it renders and the Swift extension that serves it", "homepage": "https://zennotes.org", diff --git a/apps/share-viewer/package.json b/apps/share-viewer/package.json index 94297305..ab493ac0 100644 --- a/apps/share-viewer/package.json +++ b/apps/share-viewer/package.json @@ -1,7 +1,7 @@ { "name": "@zennotes/share-viewer", "private": true, - "version": "2.76.0", + "version": "2.77.0", "type": "module", "description": "Read-only renderer for publicly shared ZenNotes, embedded by the zennotes.org website", "homepage": "https://zennotes.org", diff --git a/apps/web/package.json b/apps/web/package.json index 9ee0f6b8..c0789489 100644 --- a/apps/web/package.json +++ b/apps/web/package.json @@ -1,7 +1,7 @@ { "name": "@zennotes/web", "private": true, - "version": "2.76.0", + "version": "2.77.0", "type": "module", "description": "ZenNotes web client for self-hosted and hosted deployments", "homepage": "https://zennotes.org", diff --git a/package-lock.json b/package-lock.json index 84d3910f..1dc724e5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "zennotes-monorepo", - "version": "2.76.0", + "version": "2.77.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "zennotes-monorepo", - "version": "2.76.0", + "version": "2.77.0", "hasInstallScript": true, "workspaces": [ "apps/*", @@ -23,7 +23,7 @@ }, "apps/desktop": { "name": "@zennotes/desktop", - "version": "2.76.0", + "version": "2.77.0", "license": "MIT", "dependencies": { "@codemirror/autocomplete": "^6.18.3", @@ -915,7 +915,7 @@ }, "apps/quicklook": { "name": "@zennotes/quicklook", - "version": "2.76.0", + "version": "2.77.0", "dependencies": { "@codemirror/autocomplete": "^6.18.3", "@codemirror/commands": "^6.7.1", @@ -989,7 +989,7 @@ }, "apps/share-viewer": { "name": "@zennotes/share-viewer", - "version": "2.76.0", + "version": "2.77.0", "dependencies": { "@codemirror/autocomplete": "^6.18.3", "@codemirror/commands": "^6.7.1", @@ -1061,7 +1061,7 @@ }, "apps/web": { "name": "@zennotes/web", - "version": "2.76.0", + "version": "2.77.0", "dependencies": { "@codemirror/autocomplete": "^6.18.3", "@codemirror/commands": "^6.7.1", @@ -16409,7 +16409,7 @@ }, "packages/app-core": { "name": "@zennotes/app-core", - "version": "2.76.0", + "version": "2.77.0", "dependencies": { "@codemirror/autocomplete": "^6.18.3", "@codemirror/commands": "^6.7.1", @@ -16498,14 +16498,14 @@ }, "packages/bridge-contract": { "name": "@zennotes/bridge-contract", - "version": "2.76.0", + "version": "2.77.0", "devDependencies": { "typescript": "^5.7.2" } }, "packages/shared-domain": { "name": "@zennotes/shared-domain", - "version": "2.76.0", + "version": "2.77.0", "dependencies": { "@scure/bip39": "2.4.0", "@zennotes/bridge-contract": "*", @@ -16519,7 +16519,7 @@ }, "packages/shared-ui": { "name": "@zennotes/shared-ui", - "version": "2.76.0" + "version": "2.77.0" } } } diff --git a/package.json b/package.json index 2fd6ffa7..53204304 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "zennotes-monorepo", "private": true, - "version": "2.76.0", + "version": "2.77.0", "description": "ZenNotes monorepo for desktop, web, and self-hosted server builds", "packageManager": "npm@10.9.2", "engines": { diff --git a/packages/app-core/package.json b/packages/app-core/package.json index 2f2aa29b..c55eb663 100644 --- a/packages/app-core/package.json +++ b/packages/app-core/package.json @@ -1,11 +1,12 @@ { "name": "@zennotes/app-core", "private": true, - "version": "2.76.0", + "version": "2.77.0", "type": "module", "exports": { "./main": "./src/main.tsx", "./navigation": "./src/navigation.ts", + "./calendar": "./src/calendar.tsx", "./notes": "./src/notes.ts", "./shell": "./src/shell.ts", "./browse": "./src/browse.ts", diff --git a/packages/app-core/src/App.tsx b/packages/app-core/src/App.tsx index 899a8d48..eb309a44 100644 --- a/packages/app-core/src/App.tsx +++ b/packages/app-core/src/App.tsx @@ -174,6 +174,10 @@ const Editor = lazy(async () => { return { default: module.Editor } }) +const LinkPopover = lazy(async () => { + const module = await import('./components/LinkPopover') + return { default: module.LinkPopover } +}) const PinnedReferencePane = lazy(async () => { const module = await import('./components/PinnedReferencePane') return { default: module.PinnedReferencePane } @@ -370,6 +374,7 @@ function App(): JSX.Element { const init = useStore((s) => s.init) const workspaceRestored = useStore((s) => s.workspaceRestored && !s.workspaceTransitioning) const searchOpen = useStore((s) => s.searchOpen) + const linkPopoverOpen = useStore((s) => s.linkPopover !== null) const setSearchOpen = useStore((s) => s.setSearchOpen) const vaultTextSearchOpen = useStore((s) => s.vaultTextSearchOpen) const setVaultTextSearchOpen = useStore((s) => s.setVaultTextSearchOpen) @@ -1340,6 +1345,11 @@ function App(): JSX.Element { )} + {linkPopoverOpen && ( + + + + )} diff --git a/packages/app-core/src/calendar.tsx b/packages/app-core/src/calendar.tsx new file mode 100644 index 00000000..8b1d90a2 --- /dev/null +++ b/packages/app-core/src/calendar.tsx @@ -0,0 +1,15 @@ +import { CalendarPanel } from './components/CalendarPanel' +import { useStore } from './store' + +/** + * The date calendar as a surface of its own, for hosts that open it from a + * main screen instead of beside a note (the phone shells' Calendar entry), + * so it works with no note open. It orients on the open note when that is a + * daily or weekly note, else on today. `onOpen` runs once it has opened a + * day, a week or a task's line; a host that shows it as a sheet closes it + * there. + */ +export function DateCalendar({ onOpen }: { onOpen?: () => void }): JSX.Element { + const note = useStore((s) => s.activeNote) + return +} diff --git a/packages/app-core/src/components/CalendarPanel.test.ts b/packages/app-core/src/components/CalendarPanel.test.ts new file mode 100644 index 00000000..3e590fed --- /dev/null +++ b/packages/app-core/src/components/CalendarPanel.test.ts @@ -0,0 +1,140 @@ +// @vitest-environment jsdom + +import { act, createElement } from 'react' +import { createRoot, type Root } from 'react-dom/client' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import type { NoteMeta } from '@shared/ipc' +import { useStore } from '../store' +import { dailyNoteLocationForDate } from '../lib/vault-layout' +import { CalendarPanel } from './CalendarPanel' + +;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true + +const confirmApp = vi.hoisted(() => vi.fn(async () => true)) +vi.mock('../lib/confirm-requests', () => ({ confirmApp })) + +function isoDate(d: Date): string { + return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}` +} + +function dailyNote(date: Date): NoteMeta { + const { title, subpath } = dailyNoteLocationForDate(date, useStore.getState().vaultSettings) + return { + path: `inbox/${subpath ? `${subpath}/` : ''}${title}.md`, + title, + folder: 'inbox', + siblingOrder: 0, + createdAt: 0, + updatedAt: 0, + size: 0, + tags: [], + wikilinks: [], + hasAttachments: false, + assetEmbeds: [], + excerpt: '' + } +} + +/** A press then its click, the order a browser fires them in. */ +function tap(el: Element, pointerType: 'touch' | 'mouse'): void { + const down = new Event('pointerdown', { bubbles: true }) + Object.defineProperty(down, 'pointerType', { value: pointerType }) + act(() => { + el.dispatchEvent(down) + el.dispatchEvent(new MouseEvent('click', { bubbles: true })) + }) +} + +describe('CalendarPanel: a day on a touch screen', () => { + let host: HTMLDivElement + let root: Root + let originalState: ReturnType + const openDailyNoteForDate = vi.fn(async (_date: Date) => {}) + const today = new Date() + const tomorrow = new Date(today.getFullYear(), today.getMonth(), today.getDate() + 1) + + beforeEach(() => { + originalState = useStore.getState() + Object.defineProperty(Element.prototype, 'scrollIntoView', { + configurable: true, + value: vi.fn() + }) + const settings = originalState.vaultSettings + useStore.setState({ + vaultSettings: { ...settings, dailyNotes: { ...settings.dailyNotes, enabled: true } }, + notes: [], + vaultTasks: [], + tasksLoading: true, + openDailyNoteForDate + }) + confirmApp.mockClear() + openDailyNoteForDate.mockClear() + host = document.createElement('div') + document.body.append(host) + root = createRoot(host) + }) + + afterEach(() => { + act(() => root.unmount()) + host.remove() + useStore.setState(originalState, true) + }) + + function day(date: Date): Element { + const cell = host.querySelector(`[data-cal-day="${isoDate(date)}"]`) + if (!cell) throw new Error(`no cell for ${isoDate(date)}`) + return cell + } + + it('stands on its own with no note, oriented on today', () => { + act(() => root.render(createElement(CalendarPanel, { note: null }))) + expect(day(today).className).toContain('ring-accent/60') + }) + + it('selects with the first tap and offers to create the day with a second', async () => { + act(() => root.render(createElement(CalendarPanel, { note: null }))) + tap(day(tomorrow), 'touch') + expect(day(tomorrow).className).toContain('ring-accent/60') + expect(confirmApp).not.toHaveBeenCalled() + + tap(day(tomorrow), 'touch') + await act(async () => {}) + expect(confirmApp).toHaveBeenCalledWith(expect.objectContaining({ title: 'New daily note' })) + expect(openDailyNoteForDate).toHaveBeenCalledTimes(1) + expect(isoDate(openDailyNoteForDate.mock.calls[0][0])).toBe(isoDate(tomorrow)) + }) + + it("opens an existing day's note on the tap that lands on the selected day", async () => { + useStore.setState({ notes: [dailyNote(today)] }) + const onOpen = vi.fn() + act(() => root.render(createElement(CalendarPanel, { note: null, onOpen }))) + tap(day(today), 'touch') + await act(async () => {}) + expect(confirmApp).not.toHaveBeenCalled() + expect(openDailyNoteForDate).toHaveBeenCalledTimes(1) + expect(onOpen).toHaveBeenCalledTimes(1) + }) + + it('stays open when the new day is declined', async () => { + confirmApp.mockResolvedValueOnce(false) + const onOpen = vi.fn() + act(() => root.render(createElement(CalendarPanel, { note: null, onOpen }))) + tap(day(today), 'touch') + await act(async () => {}) + expect(confirmApp).toHaveBeenCalledTimes(1) + expect(openDailyNoteForDate).not.toHaveBeenCalled() + expect(onOpen).not.toHaveBeenCalled() + }) + + it('keeps a mouse click to select only', async () => { + useStore.setState({ notes: [dailyNote(today)] }) + act(() => root.render(createElement(CalendarPanel, { note: null }))) + tap(day(today), 'mouse') + tap(day(tomorrow), 'mouse') + tap(day(tomorrow), 'mouse') + await act(async () => {}) + expect(day(tomorrow).className).toContain('ring-accent/60') + expect(confirmApp).not.toHaveBeenCalled() + expect(openDailyNoteForDate).not.toHaveBeenCalled() + }) +}) diff --git a/packages/app-core/src/components/CalendarPanel.tsx b/packages/app-core/src/components/CalendarPanel.tsx index 4817952e..bdc1a7f8 100644 --- a/packages/app-core/src/components/CalendarPanel.tsx +++ b/packages/app-core/src/components/CalendarPanel.tsx @@ -114,25 +114,56 @@ function dotsFor(stats: NoteStats | undefined): { count: number; faint: boolean export function CalendarPanel({ note, - fitWidth + fitWidth, + onOpen }: { - note: NoteContent + /** The note beside the calendar, or null where the calendar stands on its + * own with no note open (the phones' Calendar entry); it then orients on + * today. */ + note: NoteContent | null /** Width to render at when the pane has less room than the width the user * chose; see lib/side-panel-fit. (#805) */ fitWidth?: number + /** Called once the calendar has opened a day, a week or a task's line, even + * a note that was already open, so a host that shows it as a sheet can put + * it away. Beside a note it stays open, so the pane passes none. */ + onOpen?: () => void }): JSX.Element { const notes = useStore((s) => s.notes) const vaultSettings = useStore((s) => s.vaultSettings) const vimMode = useStore((s) => s.vimMode) - const openDailyNoteForDate = useStore((s) => s.openDailyNoteForDate) - const openWeeklyNoteForDate = useStore((s) => s.openWeeklyNoteForDate) + const storeOpenDailyNote = useStore((s) => s.openDailyNoteForDate) + const storeOpenWeeklyNote = useStore((s) => s.openWeeklyNoteForDate) const vaultTasks = useStore((s) => s.vaultTasks) const showArchivedTasks = useStore((s) => s.showArchivedTasks) const tasksLoading = useStore((s) => s.tasksLoading) const refreshTasks = useStore((s) => s.refreshTasks) const addTaskForDate = useStore((s) => s.addTaskForDate) const toggleTaskFromList = useStore((s) => s.toggleTaskFromList) - const openTaskAt = useStore((s) => s.openTaskAt) + const storeOpenTask = useStore((s) => s.openTaskAt) + const onOpenRef = useRef(onOpen) + onOpenRef.current = onOpen + const openDailyNoteForDate = useCallback( + async (date: Date) => { + await storeOpenDailyNote(date) + onOpenRef.current?.() + }, + [storeOpenDailyNote] + ) + const openWeeklyNoteForDate = useCallback( + async (date: Date) => { + await storeOpenWeeklyNote(date) + onOpenRef.current?.() + }, + [storeOpenWeeklyNote] + ) + const openTaskAt = useCallback( + async (task: VaultTask) => { + await storeOpenTask(task) + onOpenRef.current?.() + }, + [storeOpenTask] + ) const applyTaskMutation = useStore((s) => s.applyTaskMutation) const moveTaskToDate = useStore((s) => s.moveTaskToDate) const deleteTaskFromList = useStore((s) => s.deleteTaskFromList) @@ -153,7 +184,10 @@ export function CalendarPanel({ ) // The date the active note represents — what the calendar orients around. - const active = useMemo(() => classifyDateNote(note, vaultSettings), [note, vaultSettings]) + const active = useMemo( + () => (note ? classifyDateNote(note, vaultSettings) : null), + [note, vaultSettings] + ) const refDate = active?.date ?? new Date() const activeDayIso = active?.kind === 'daily' ? isoDateStr(active.date) : null const activeWeekIso = active?.kind === 'weekly' ? isoWeekStr(active.date) : null @@ -172,7 +206,7 @@ export function CalendarPanel({ useEffect(() => { setAnchor(new Date(refDate.getFullYear(), refDate.getMonth(), 1)) // eslint-disable-next-line react-hooks/exhaustive-deps - }, [note.path]) + }, [note?.path]) // Calendar key -> NoteMeta for the daily/weekly notes that exist on disk. const { dailyByDate, weeklyByWeek } = useMemo( @@ -187,8 +221,13 @@ export function CalendarPanel({ useEffect(() => { setSelectedIso(activeDayIso ?? todayIso) // eslint-disable-next-line react-hooks/exhaustive-deps - }, [note.path]) + }, [note?.path]) const selectedDate = useMemo(() => parseIsoDate(selectedIso), [selectedIso]) + // A finger has no double-click, so on a touch screen a second tap on the + // selected day opens it, the way a phone's own calendar opens the day it + // shows. The first tap still only selects, which keeps that week's tasks + // below a tap away; a mouse keeps click to select, double-click to open. + const touchPressRef = useRef(false) const selectedWeekIso = useMemo(() => isoWeekStr(selectedDate), [selectedDate]) // Tasks scheduled for the selected day. Tasks written in a daily note inherit @@ -1020,7 +1059,16 @@ export function CalendarPanel({ key={iso} type="button" data-cal-day={iso} - onClick={() => dailyEnabled && setSelectedIso(iso)} + onPointerDown={(e) => { + touchPressRef.current = e.pointerType === 'touch' + }} + onClick={() => { + const touch = touchPressRef.current + touchPressRef.current = false + if (!dailyEnabled) return + if (touch && iso === selectedIso) void openOrCreateDay(day, iso) + else setSelectedIso(iso) + }} onDoubleClick={() => void openOrCreateDay(day, iso)} onContextMenu={(e) => openDayMenu(e, day, iso)} onMouseEnter={(e) => armHover(e.currentTarget, dayMeta)} diff --git a/packages/app-core/src/components/CloudPendingConflictResolver.test.ts b/packages/app-core/src/components/CloudPendingConflictResolver.test.ts index 087e35fb..5425a82b 100644 --- a/packages/app-core/src/components/CloudPendingConflictResolver.test.ts +++ b/packages/app-core/src/components/CloudPendingConflictResolver.test.ts @@ -8,7 +8,10 @@ import type { CloudSyncPendingConflictDetails, CloudSyncRunSummary, } from "@zennotes/bridge-contract/cloud-sync"; -import { CloudPendingConflictResolver } from "./CloudPendingConflictResolver"; +import { + CLOUD_CONFLICT_LOAD_TIMEOUT_MS, + CloudPendingConflictResolver, +} from "./CloudPendingConflictResolver"; import { clearCloudSyncStatus, syncCloudVaultWithStatus, @@ -462,6 +465,91 @@ describe("CloudPendingConflictResolver", () => { view.unmount(); }); + // Discord, 2026-10-26: on a phone whose sync was stuck, the sheet showed + // "Loading the versions kept for you…" with Finish later greyed out, and + // closing the app was the only way out. + it("ends a load that never answers in an error with Retry and Details", async () => { + vi.useFakeTimers(); + try { + bridge.getCloudConflict.mockReturnValueOnce(new Promise(() => {})); + useCloudSyncStatusStore.setState({ phase: "syncing" }); + const view = mount({}); + await act(async () => Promise.resolve()); + expect(view.host.textContent).toContain("Loading the versions kept for you"); + expect(button(view.host, "Finish later").disabled).toBe(false); + + await act(async () => { + vi.advanceTimersByTime(CLOUD_CONFLICT_LOAD_TIMEOUT_MS); + }); + const alert = view.host.querySelector('[role="alert"]'); + expect(alert?.textContent).toContain("taking too long to open the two versions"); + expect(alert?.querySelector("[data-cloud-error-details]")?.textContent).toContain( + "Loading conflict item-1 (Plans/Trip.md) did not finish within 20 seconds.", + ); + expect(view.host.textContent).not.toContain("Loading the versions kept for you"); + + await act(async () => button(view.host, "Retry").click()); + expect(bridge.getCloudConflict).toHaveBeenCalledTimes(2); + expect(view.host.querySelector('[role="alert"]')).toBeNull(); + expect(view.host.textContent).toContain("Combined note"); + view.unmount(); + } finally { + vi.useRealTimers(); + } + }); + + it("shows a load that fails with Retry instead of loading forever", async () => { + bridge.getCloudConflict.mockRejectedValueOnce(new Error("Disk is full")); + const view = mount({}); + await act(async () => Promise.resolve()); + + expect(view.host.querySelector('[role="alert"]')?.textContent).toContain("Disk is full"); + expect(view.host.textContent).not.toContain("Loading the versions kept for you"); + + await act(async () => button(view.host, "Retry").click()); + expect(bridge.getCloudConflict).toHaveBeenCalledTimes(2); + expect(view.host.querySelector('[role="alert"]')).toBeNull(); + expect(view.host.textContent).toContain("Combined note"); + view.unmount(); + }); + + it("shows both versions when a slow load answers after the deadline", async () => { + vi.useFakeTimers(); + try { + let answer!: (value: CloudSyncPendingConflictDetails) => void; + bridge.getCloudConflict.mockReturnValueOnce( + new Promise((resolve) => { answer = resolve; }), + ); + const view = mount({}); + await act(async () => { + vi.advanceTimersByTime(CLOUD_CONFLICT_LOAD_TIMEOUT_MS); + }); + expect(view.host.querySelector('[role="alert"]')).not.toBeNull(); + + await act(async () => answer(details)); + expect(view.host.querySelector('[role="alert"]')).toBeNull(); + expect(view.host.textContent).toContain("Combined note"); + expect(bridge.getCloudConflict).toHaveBeenCalledOnce(); + view.unmount(); + } finally { + vi.useRealTimers(); + } + }); + + it("can be left with Finish later while a sync is running", async () => { + useCloudSyncStatusStore.setState({ phase: "syncing" }); + const onClose = vi.fn(); + const view = mount({ onClose }); + await act(async () => Promise.resolve()); + expect(button(view.host, "Use other device").disabled).toBe(true); + + await act(async () => button(view.host, "Finish later").click()); + await act(async () => button(view.host, "Save & finish later").click()); + expect(onClose).toHaveBeenCalledOnce(); + expect(bridge.saveCloudConflictDraft).not.toHaveBeenCalled(); + view.unmount(); + }); + it("explains a delete conflict as a human choice", async () => { bridge.getCloudConflict.mockResolvedValue({ ...details, diff --git a/packages/app-core/src/components/CloudPendingConflictResolver.tsx b/packages/app-core/src/components/CloudPendingConflictResolver.tsx index 48330482..115cada8 100644 --- a/packages/app-core/src/components/CloudPendingConflictResolver.tsx +++ b/packages/app-core/src/components/CloudPendingConflictResolver.tsx @@ -21,6 +21,11 @@ import { randomUUID } from "@zennotes/shared-domain/random-uuid"; type ChangeChoice = "local" | "cloud" | "both"; type WholeVersionChoice = "local" | "cloud"; +/** Both versions are one local file and at most one small download. A load + * still going after this is waiting on something else: the desktop, for + * one, still lets a running sync finish first. */ +export const CLOUD_CONFLICT_LOAD_TIMEOUT_MS = 20_000; + export function CloudPendingConflictResolver({ conflict, summary, @@ -73,6 +78,7 @@ export function CloudPendingConflictResolver({ useEffect(() => { let cancelled = false; + let overdue = false; setDetails(null); setChoices({}); if (!reload.keepError) setError(null); @@ -81,10 +87,21 @@ export function CloudPendingConflictResolver({ setFinishLaterOpen(false); setCombineOpen(false); setWholeVersionChoice(null); + // A load that never answered kept this sheet on its loading line, and the + // only way out was closing the app. Past the deadline it says so and + // offers Retry; an answer that still arrives replaces the error. + const deadline = window.setTimeout(() => { + if (cancelled) return; + overdue = true; + setReloading(false); + setError(loadTooSlow(conflict)); + }, CLOUD_CONFLICT_LOAD_TIMEOUT_MS); void bridge .getCloudConflict(conflict.id, reviewId.current) .then((next) => { if (cancelled) return; + window.clearTimeout(deadline); + if (overdue) setError(null); setReloading(false); const initialDraft = next.draft_text ?? @@ -104,11 +121,13 @@ export function CloudPendingConflictResolver({ }) .catch((cause) => { if (cancelled) return; + window.clearTimeout(deadline); setReloading(false); setError(message(cause)); }); return () => { cancelled = true; + window.clearTimeout(deadline); }; }, [bridge, conflict.id, reload]); @@ -268,10 +287,12 @@ export function CloudPendingConflictResolver({ {conflictExplanation(conflict)}

+ {/* Not held by a running sync: a draft is saved before every run and + cannot change during one, so leaving never waits on that run. */} + + )} )} @@ -990,6 +1025,15 @@ function safeId(value: string): string { return value.replace(/[^a-zA-Z0-9_-]/g, "-"); } +function loadTooSlow(conflict: CloudSyncPendingConflict): CloudErrorCopy { + return { + message: + "ZenNotes is taking too long to open the two versions of this file. Both versions are safe, and nothing was changed. Choose Retry, or Finish later to come back to it.", + detail: `Loading conflict ${conflict.id} (${conflict.path}) did not finish within ${CLOUD_CONFLICT_LOAD_TIMEOUT_MS / 1000} seconds.`, + kind: "other", + }; +} + /** Without this the resolver showed "Error invoking remote method * 'cloud-vault-conflict:resolve': Error: ..." whole. */ function message(error: unknown): CloudErrorCopy { diff --git a/packages/app-core/src/components/ConnectionsPanel.tsx b/packages/app-core/src/components/ConnectionsPanel.tsx index 6e51c931..ca4381fe 100644 --- a/packages/app-core/src/components/ConnectionsPanel.tsx +++ b/packages/app-core/src/components/ConnectionsPanel.tsx @@ -127,6 +127,8 @@ export function ConnectionsPanel({ outgoing.resolvedItems.length + outgoing.attachmentItems.length + outgoing.missingItems.length + + // The way to the vault-wide list, under this note's missing links. + (outgoing.missingItems.length > 0 ? 1 : 0) + backlinks.length + mentions.length @@ -339,6 +341,12 @@ export function ConnectionsPanel({ rowIndex={rowIndex++} /> ))} + {outgoing.missingItems.length > 0 && ( + + )}
@@ -680,3 +688,31 @@ function ConnectionKeyHint({ ) } + +/** + * Under a note's missing links: the way to every missing link in the vault, + * the Unresolved Links view. A row like the others so `j`/`k` reach it. + */ +function AllUnresolvedLinksRow({ + active, + rowIndex +}: { + active: boolean + rowIndex: number +}): JSX.Element { + const openUnresolvedLinksView = useStore((s) => s.openUnresolvedLinksView) + return ( + + ) +} diff --git a/packages/app-core/src/components/Editor.tsx b/packages/app-core/src/components/Editor.tsx index b30888e9..a2d1d35a 100644 --- a/packages/app-core/src/components/Editor.tsx +++ b/packages/app-core/src/components/Editor.tsx @@ -95,6 +95,7 @@ import { registerNoteMoveExCommands } from "../lib/vim-ex-commands"; import { promptImageWidth, setImageWidthFromInput } from "../lib/image-resize"; import { copyLinkAtCursor } from "../lib/link-copy"; import { followLinkTarget } from "../lib/follow-link"; +import { openLinkPopoverAtCursor } from "../lib/link-popover-open"; let vimCommandsRegistered = false; let syncedVimBindings: Partial> = {}; @@ -214,6 +215,13 @@ function syncVimKeymaps(overrides: KeymapOverrides): void { toVimSequence(getKeymapBinding(overrides, "vim.createNoteFromLink")), ].filter((binding): binding is string => !!binding), }, + { + id: "vim.linkPopover", + action: "zenLinkPopover", + bindings: [ + toVimSequence(getKeymapBinding(overrides, "vim.linkPopover")), + ].filter((binding): binding is string => !!binding), + }, { id: "vim.paneFocusLeft", action: "focusPaneLeft", @@ -662,6 +670,9 @@ function registerVimCommands(): void { Vim.defineEx("tasks", "tasks", () => { void useStore.getState().openTasksView(); }); + Vim.defineEx("unresolved", "unres", () => { + void useStore.getState().openUnresolvedLinksView(); + }); // Quick-add a whole-note task file. `:newtask` (or `:task`) prompts for a // title and creates it at the configured tasks location; `:newtask ` @@ -823,6 +834,13 @@ function registerVimCommands(): void { }); }); + // `K` on a [[wikilink]]: its note in the link popover, keyboard inside. + // Inside the popover's own editor it chains to the next link's note. + Vim.defineAction("zenLinkPopover", (cm: ReturnType) => { + const view = (cm as unknown as { cm6?: EditorView }).cm6; + if (view) openLinkPopoverAtCursor(view); + }); + Vim.defineAction("goToDefinition", (cm: ReturnType) => { const view = (cm as unknown as { cm6?: EditorView }).cm6; if (!view) return; diff --git a/packages/app-core/src/components/EditorPane.tsx b/packages/app-core/src/components/EditorPane.tsx index 263c7593..92de089a 100644 --- a/packages/app-core/src/components/EditorPane.tsx +++ b/packages/app-core/src/components/EditorPane.tsx @@ -74,6 +74,15 @@ import { keyBindingsFor, vimHalfPageKeymap } from '../lib/vim-half-page-keymap' import { scrollOff } from '../lib/cm-scrolloff' import { followLinkTarget } from '../lib/follow-link' import { pointerOverRange } from '../lib/cm-pointer-range' +import { + openLinkPopoverAtCursor, + pointerLeftWikilink, + pointerOverWikilink, + rangeRect +} from '../lib/link-popover-open' +import { isInsideCode } from '../lib/cm-wikilink-render' +import { isUnresolvedLinksTabPath } from '@shared/unresolved-links' +import { UnresolvedLinksView } from './UnresolvedLinksView' import { setHoveredLink } from '../lib/hovered-link' import { setYankToClipboardEnabled, @@ -251,6 +260,7 @@ import { CheckSquareIcon, CloseIcon, PaperclipIcon, + LinkIcon, DocumentIcon, FileDownIcon, FeedbackIcon, @@ -410,6 +420,9 @@ function buildEditorKeymap(vimMode: boolean, overrides: KeymapOverrides): Extens // Join a hard-wrapped paragraph back into one line so the pane wraps it // (#676). Mode-agnostic like the line moves; Vim mode also has `gq`. ...keyBindingsFor(getKeymapBinding(overrides, 'editor.reflowParagraph'), reflowParagraph), + // The note a [[wikilink]] names, in the link popover, keyboard inside. + // Mode-agnostic; Vim mode also has it as `K`. + ...keyBindingsFor(getKeymapBinding(overrides, 'editor.linkPopover'), openLinkPopoverAtCursor), // Step across inline markers, so a formatted word can be finished without // reaching for the arrow keys. Mode-agnostic like the line moves. (#490) ...keyBindingsFor(getKeymapBinding(overrides, 'editor.hopMarkerForward'), markerHop.forward), @@ -2215,22 +2228,36 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element { } const line = view.state.doc.lineAt(pos) const link = linkRangeAtCursor(line.text, pos - line.from) - setHoveredLink( - link && - pointerOverRange( - view, - line.from + link.from, - line.from + link.to, - event.clientX, - event.clientY - ) - ? link.target - : null - ) + const over = + !!link && + pointerOverRange( + view, + line.from + link.from, + line.from + link.to, + event.clientX, + event.clientY + ) + setHoveredLink(over && link ? link.target : null) + // Resting on a [[wikilink]] opens its note in the link popover. + // Not while a button is down (a selection drag crossing a link), + // and not for `[[...]]` inside code, which is text. + const from = line.from + (link?.from ?? 0) + if ( + over && + link?.kind === 'wikilink' && + event.buttons === 0 && + !isInsideCode(view.state, from) + ) { + const to = line.from + link.to + pointerOverWikilink(link.target, viewPathRef.current, () => rangeRect(view, from, to)) + } else { + pointerLeftWikilink() + } return false }, mouseleave: () => { setHoveredLink(null) + pointerLeftWikilink() return false }, click: (event) => { @@ -3276,6 +3303,7 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element { isArchive: false, isTrash: false, isAssetsView: false, + isUnresolvedLinks: false, isAsset: false, isDiagram: false, isDatabase: false @@ -3343,6 +3371,13 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element { isAssetsView: true } } + if (isUnresolvedLinksTabPath(path)) { + return { + ...base, + title: 'Unresolved Links', + isUnresolvedLinks: true + } + } if (isAssetTabPath(path)) { const assetPath = assetPathFromTab(path) return { @@ -3441,6 +3476,7 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element { isHelpTabPath(path) || isArchiveTabPath(path) || isTrashTabPath(path) || + isUnresolvedLinksTabPath(path) || isAssetTabPath(path) || isDiagramTabPath(path) || isDatabaseTabPath(path) @@ -3549,6 +3585,7 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element { isArchive: boolean isTrash: boolean isAssetsView: boolean + isUnresolvedLinks: boolean isAsset: boolean isDiagram: boolean }) => { @@ -3562,6 +3599,7 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element { tab.isArchive || tab.isTrash || tab.isAssetsView || + tab.isUnresolvedLinks || tab.isAsset || tab.isDiagram return ( @@ -3736,6 +3774,9 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element { {tab.isAssetsView && ( )} + {tab.isUnresolvedLinks && ( + + )} {tab.isAsset && ( )} @@ -4448,6 +4489,8 @@ export function EditorPane({ pane }: { pane: PaneLeaf }): JSX.Element { ) : isAssetsViewTabPath(activeTab) ? ( + ) : isUnresolvedLinksTabPath(activeTab) ? ( + ) : activeTab && isAssetTabPath(activeTab) ? ( isDatabaseCsvPath(assetPathFromTab(activeTab) ?? '') ? ( l f') { return chord( diff --git a/packages/app-core/src/components/LinkPopover.tsx b/packages/app-core/src/components/LinkPopover.tsx new file mode 100644 index 00000000..bbba3c37 --- /dev/null +++ b/packages/app-core/src/components/LinkPopover.tsx @@ -0,0 +1,551 @@ +/** + * The link popover: rest the pointer on a `[[wikilink]]` (or press `K` on + * it) and the note it names opens in a small floating editor over the note + * you are in, Logseq-style. A link no note answers yet offers to create the + * note, and the new note opens right there for typing. + * + * The editor edits the store's path-keyed `noteContents`, the same buffer + * every pane and the pinned reference pane use, so an edit here shows up in + * an open tab of the same note and saves through the same debounced path. + * The store keeps that buffer alive while the popover shows it (see + * `linkPopoverHolds`) and saves it on close. + * + * Keys: VimNav stands down inside the popover (it is a self-keyed surface), + * and the popover owns Escape: it closes from Vim normal mode (insert and + * visual mode get their own Escape first) and hands focus back to whatever + * had it before, usually the editor the link was in. + */ +import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react' +import { createPortal } from 'react-dom' +import { Annotation, EditorSelection, EditorState, type Transaction } from '@codemirror/state' +import { EditorView, highlightActiveLine, keymap, tooltips } from '@codemirror/view' +import { Vim, getCM, vim } from '@replit/codemirror-vim' +import { history } from '@codemirror/commands' +import { autocompletion, completionStatus } from '@codemirror/autocomplete' +import { defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language' +import { wikilinkNoteName } from '@shared/unresolved-links' +import { useStore } from '../store' +import { noteEditingLockExtension, noteEditingSync, refreshNoteEditingLock } from '../lib/note-lifecycle-lock' +import { scrollerClickFocus } from '../lib/cm-scroller-click-focus' +import { vimAwareMarkdownKeymap } from '../lib/cm-vim-default-keymap' +import { isTouchPrimaryDevice, vimImeGuard } from '../lib/cm-vim-ime-guard' +import { vimVisualHighlightExtension } from '../lib/cm-vim-visual-highlight' +import { noteMarkdown } from '../lib/cm-markdown-language' +import { customCodeFenceHighlightExtension } from '../lib/cm-custom-code-languages' +import { markdownLinkExtension } from '../lib/cm-markdown-links' +import { listIndentWidth, markdownListIndentPlugin } from '../lib/cm-markdown-list-indent' +import { livePreviewPlugin } from '../lib/cm-live-preview' +import { frontmatterStyle, frontmatterTagExtension } from '../lib/cm-frontmatter' +import { slashCommandRender, slashCommandSource } from '../lib/cm-slash-commands' +import { calloutTypeSource } from '../lib/cm-callouts' +import { dateShortcutSource } from '../lib/cm-date-shortcuts' +import { wikilinkBlockSource, wikilinkHeadingSource, wikilinkSource } from '../lib/cm-wikilinks' +import { hashtagSource } from '../lib/cm-hashtag-complete' +import { frontmatterTagSource } from '../lib/cm-frontmatter-tag-complete' +import { completionKeymapExtension, completionNavKeymap } from '../lib/cm-completion-nav' +import { editorTabSize } from '../lib/editor-tab-size' +import { appMarkdownSnippetExtension } from '../lib/markdown-snippets-config' +import { cursorDrawSelection } from '../lib/cm-cursor-blink' +import { formatKeymapBinding, getKeymapBinding, matchesShortcutBinding } from '../lib/keymaps' +import { keyBindingsFor } from '../lib/vim-half-page-keymap' +import { isEditorInsertMode, isEditorVisualMode } from '../lib/vim-nav' +import { linkAnchorOffset, linkCreateDestination } from '../lib/link-popover' +import { getSystemFolderLabel } from '../lib/system-folder-labels' +import { + openLinkPopoverAtCursor, + pointerEnteredLinkPopover, + pointerLeftLinkPopover, + resetLinkPopoverHover +} from '../lib/link-popover-open' +import { createNoteForLinkInPlace, createNoteFromLinkNow } from '../lib/create-note-from-link' +import { openWikilinkTarget } from '../lib/wikilink-navigation' +import { focusEditorNormalMode } from '../lib/editor-focus' +import { Button, IconButton } from './ui' +import { ArrowUpRightIcon, CloseIcon, LinkIcon } from './icons' +import { buildReferenceKeymap, paperHighlight } from './PinnedReferencePane' + +const programmatic = Annotation.define() + +const OPEN_IN_TAB_BINDING = 'Mod+Enter' + +/** Viewport room kept clear around the popover. */ +const EDGE = 12 +const GAP = 6 +const MAX_WIDTH = 520 +const MAX_HEIGHT = 440 +const MIN_ROOM = 220 + +interface Placement { + left: number + width: number + top?: number + bottom?: number + maxHeight: number +} + +/** Under the link when there is room, above it otherwise, always on screen. */ +function placementFor(rect: { left: number; top: number; bottom: number }): Placement { + const vw = window.innerWidth + const vh = window.innerHeight + const width = Math.min(MAX_WIDTH, vw - EDGE * 2) + const left = Math.min(Math.max(EDGE, rect.left - 12), vw - width - EDGE) + const below = vh - rect.bottom - GAP - EDGE + const above = rect.top - GAP - EDGE + if (below >= MIN_ROOM || below >= above) { + return { left, width, top: rect.bottom + GAP, maxHeight: Math.min(MAX_HEIGHT, below) } + } + return { left, width, bottom: vh - rect.top + GAP, maxHeight: Math.min(MAX_HEIGHT, above) } +} + +export function LinkPopover(): JSX.Element | null { + const popover = useStore((s) => s.linkPopover) + const note = useStore((s) => + s.linkPopover?.path ? s.notes.find((n) => n.path === s.linkPopover?.path) ?? null : null + ) + const content = useStore((s) => + s.linkPopover?.path ? s.noteContents[s.linkPopover.path] ?? null : null + ) + const isDirty = useStore((s) => + s.linkPopover?.path ? s.noteDirty[s.linkPopover.path] ?? false : false + ) + const keymapOverrides = useStore((s) => s.keymapOverrides) + const closeLinkPopover = useStore((s) => s.closeLinkPopover) + const pinLinkPopover = useStore((s) => s.pinLinkPopover) + const showNoteInLinkPopover = useStore((s) => s.showNoteInLinkPopover) + const selectedPath = useStore((s) => s.selectedPath) + const vaultRoot = useStore((s) => s.vault?.root ?? null) + const systemFolderLabels = useStore((s) => s.systemFolderLabels) + + const rootRef = useRef(null) + const viewRef = useRef(null) + const createRef = useRef(null) + // Where the keyboard was before the popover took it; Escape gives it back. + const returnFocusRef = useRef(null) + const [creating, setCreating] = useState(false) + const [createError, setCreateError] = useState(null) + + const placement = useMemo( + () => (popover ? placementFor(popover.anchorRect) : null), + [popover?.anchorRect] + ) + + const rememberReturnFocus = useCallback(() => { + const active = document.activeElement + if (!(active instanceof HTMLElement)) return + if (rootRef.current?.contains(active)) return + if (active === document.body) return + returnFocusRef.current = active + }, []) + + const close = useCallback( + (restoreFocus: boolean) => { + const hadFocus = + !!rootRef.current && rootRef.current.contains(document.activeElement) + resetLinkPopoverHover() + closeLinkPopover() + const back = returnFocusRef.current + returnFocusRef.current = null + if (!restoreFocus || !hadFocus) return + // The note editor goes back to Vim normal mode on the cursor it had + // (CodeMirror keeps the selection while blurred); anything else, such + // as the Unresolved Links list, just takes focus back. + const mainView = useStore.getState().editorViewRef + if (back?.isConnected && !mainView?.dom.contains(back)) { + back.focus({ preventScroll: true }) + return + } + focusEditorNormalMode() + }, + [closeLinkPopover] + ) + + // A popover is about a link in the note on screen; another note, or + // another vault, leaves it behind. + const firstSelected = useRef(selectedPath) + useEffect(() => { + if (selectedPath === firstSelected.current) return + close(false) + }, [selectedPath, close]) + const firstVault = useRef(vaultRoot) + useEffect(() => { + if (vaultRoot === firstVault.current) return + close(false) + }, [vaultRoot, close]) + + // Keyboard-opened popovers take focus; remember where it came from first. + useLayoutEffect(() => { + if (!popover?.focus) return + rememberReturnFocus() + if (!popover.path) { + requestAnimationFrame(() => createRef.current?.focus({ preventScroll: true })) + } + }, [popover?.serial, popover?.focus, popover?.path, rememberReturnFocus]) + + useEffect(() => { + setCreateError(null) + setCreating(false) + }, [popover?.serial]) + + // Outside clicks close a pinned popover; keys typed elsewhere close a + // hover popover, which is only ever a glance; scrolling the page under a + // hover popover moves its link away from it. + useEffect(() => { + if (!popover) return + const onPointerDown = (e: PointerEvent): void => { + const target = e.target as Node | null + if (target && rootRef.current?.contains(target)) return + // Completion menus of the popover editor render into document.body. + if ((target as HTMLElement | null)?.closest?.('.cm-tooltip')) return + close(false) + } + const onKeyDown = (e: KeyboardEvent): void => { + const target = e.target as Node | null + if (target && rootRef.current?.contains(target)) return + if (useStore.getState().linkPopover?.mode === 'hover') close(false) + } + const onScroll = (e: Event): void => { + const target = e.target as Node | null + if (target && rootRef.current?.contains(target)) return + if (useStore.getState().linkPopover?.mode === 'hover') close(false) + } + window.addEventListener('pointerdown', onPointerDown, true) + window.addEventListener('keydown', onKeyDown, true) + window.addEventListener('scroll', onScroll, true) + return () => { + window.removeEventListener('pointerdown', onPointerDown, true) + window.removeEventListener('keydown', onKeyDown, true) + window.removeEventListener('scroll', onScroll, true) + } + }, [popover !== null, close]) + + const openInTab = useCallback(() => { + const current = useStore.getState().linkPopover + if (!current) return + close(false) + if (current.path) { + void openWikilinkTarget(current.path, current.target).then(() => focusEditorNormalMode()) + } else { + void createNoteFromLinkNow(current.target) + } + }, [close]) + + const create = useCallback(async () => { + const current = useStore.getState().linkPopover + if (!current || current.path || creating) return + setCreating(true) + setCreateError(null) + const path = await createNoteForLinkInPlace(current.target) + // The popover may have closed while the note was being written. + if (useStore.getState().linkPopover?.serial !== current.serial) return + setCreating(false) + if (path) { + await showNoteInLinkPopover(path) + return + } + // A weekly or monthly note is made by opening it (its template runs + // there), so that one link leaves the popover for the main editor. + const name = wikilinkNoteName(current.target) + if (name && !/[\\:*?"<>|]/.test(name)) { + close(false) + void createNoteFromLinkNow(current.target) + return + } + setCreateError('This link cannot name a note file.') + }, [close, creating, showNoteInLinkPopover]) + + const onKeyDownCapture = useCallback( + (e: React.KeyboardEvent) => { + const native = e.nativeEvent + const state = useStore.getState() + if (matchesShortcutBinding(native, OPEN_IN_TAB_BINDING)) { + e.preventDefault() + e.stopPropagation() + openInTab() + return + } + if (e.key !== 'Escape' || native.isComposing) return + const view = viewRef.current + if (view && view.hasFocus) { + // An open completion menu, Vim insert or visual mode: their Escape first. + if (completionStatus(view.state) === 'active') return + if (isEditorInsertMode(view, state.vimMode) || isEditorVisualMode(view, state.vimMode)) return + } + e.preventDefault() + e.stopPropagation() + close(true) + }, + [close, openInTab] + ) + + if (!popover || !placement) return null + + const exists = !!popover.path + const title = exists + ? note?.title ?? popover.path!.split('/').pop()!.replace(/\.md$/i, '') + : wikilinkNoteName(popover.target) || popover.target + const destination = exists ? null : linkCreateDestination(popover.target) + const subtitle = exists + ? popover.path! + : destination + ? `Not written yet · new note in ${getSystemFolderLabel(destination.folder, systemFolderLabels)}${destination.subpath ? ` / ${destination.subpath}` : ''}` + : 'Not written yet' + const openHint = formatKeymapBinding(OPEN_IN_TAB_BINDING, 'shortcut') + + return createPortal( +
{ + rememberReturnFocus() + pinLinkPopover() + }} + onFocusCapture={() => pinLinkPopover()} + onKeyDownCapture={onKeyDownCapture} + > +
+ +
+
+ {title} + {exists && isDirty && ( + + )} +
+
{subtitle}
+
+ + + + close(true)} + > + + +
+ {exists ? ( + content ? ( + + ) : ( +
Loading…
+ ) + ) : ( +
+

+ No note answers this link yet. Create it and write it here, without leaving the note you are in. +

+
+ + Enter to create · Esc to close +
+ {createError &&

{createError}

} +
+ )} +
, + document.body + ) +} + +/** + * The popover's editor, mounted per note. Same building blocks as the pinned + * reference pane's editor, without its gutters: a popover is a glance and a + * few lines of writing, not a second workspace. + */ +function PopoverNoteEditor({ + path, + target, + focus, + created, + serial, + viewRef, + keymapOverrides +}: { + path: string + target: string + focus: boolean + created: boolean + serial: number + viewRef: React.MutableRefObject + keymapOverrides: ReturnType['keymapOverrides'] +}): JSX.Element { + const content = useStore((s) => s.noteContents[path] ?? null) + const updateNoteBody = useStore((s) => s.updateNoteBody) + const pathRef = useRef(path) + pathRef.current = path + + const setContainerRef = useCallback( + (el: HTMLDivElement | null) => { + if (!el) { + viewRef.current?.destroy() + viewRef.current = null + return + } + if (viewRef.current) return + const s0 = useStore.getState() + const body = s0.noteContents[path]?.body ?? '' + const state = EditorState.create({ + doc: body, + extensions: [ + noteEditingLockExtension(() => ({ vault: useStore.getState().vault, path: pathRef.current })), + appMarkdownSnippetExtension(), + s0.vimMode ? vim() : [], + vimImeGuard(() => useStore.getState().vimBlockImeInNormalMode && !isTouchPrimaryDevice()), + vimVisualHighlightExtension, + history(), + scrollerClickFocus, + cursorDrawSelection(s0.cursorBlink), + editorTabSize(s0.editorTabSize), + listIndentWidth(s0.editorTabSize), + highlightActiveLine(), + EditorView.lineWrapping, + noteMarkdown(), + customCodeFenceHighlightExtension, + markdownLinkExtension, + vimAwareMarkdownKeymap, + markdownListIndentPlugin, + frontmatterStyle, + frontmatterTagExtension, + syntaxHighlighting(paperHighlight), + syntaxHighlighting(defaultHighlightStyle, { fallback: true }), + s0.livePreview ? livePreviewPlugin : [], + tooltips({ parent: document.body }), + autocompletion({ + defaultKeymap: false, + override: [ + slashCommandSource, + calloutTypeSource, + dateShortcutSource, + frontmatterTagSource, + hashtagSource, + wikilinkSource, + wikilinkHeadingSource, + wikilinkBlockSource + ], + addToOptions: [{ render: slashCommandRender.render, position: 0 }], + icons: false, + optionClass: (completion) => { + const kind = (completion as { _kind?: string })._kind + if (kind === 'wikilink') return 'wikilink-cmd-option' + if (kind === 'callout') return 'callout-cmd-option' + return 'slash-cmd-option' + } + }), + completionNavKeymap, + completionKeymapExtension, + keymap.of([ + // The popover for a link inside the popover replaces this one, + // so a chain of notes can be followed without leaving the note + // underneath. + ...keyBindingsFor(getKeymapBinding(keymapOverrides, 'editor.linkPopover'), (view) => + openLinkPopoverAtCursor(view) + ) + ]), + buildReferenceKeymap(s0.vimMode, keymapOverrides), + EditorView.updateListener.of((upd) => { + if (!upd.docChanged) return + if (upd.transactions.some((tr: Transaction) => tr.annotation(programmatic))) return + updateNoteBody(pathRef.current, upd.state.doc.toString()) + }) + ] + }) + const view = new EditorView({ state, parent: el }) + viewRef.current = view + }, + // The view is built once per note; the component is keyed by path. + // eslint-disable-next-line react-hooks/exhaustive-deps + [] + ) + + // Edits made elsewhere (an open tab of the same note, a sync) flow in. + useEffect(() => { + const view = viewRef.current + if (!view || !content) return + const next = content.body + if (view.state.doc.toString() === next) return + const sel = view.state.selection.main + refreshNoteEditingLock(view) + view.dispatch({ + changes: { from: 0, to: view.state.doc.length, insert: next }, + annotations: [programmatic.of(true), noteEditingSync.of(true)], + selection: { + anchor: Math.min(sel.anchor, next.length), + head: Math.min(sel.head, next.length) + } + }) + }, [content?.body, viewRef]) + + // Place the cursor and, when the popover was opened from a key, take the + // keyboard. A link's anchor wins; a note just created starts at its end, + // in insert mode, ready for the first sentence. + useLayoutEffect(() => { + const view = viewRef.current + if (!view) return + const doc = view.state.doc + const anchor = linkAnchorOffset(doc.toString(), target) + const at = anchor ?? (created ? doc.length : 0) + view.dispatch({ + selection: EditorSelection.cursor(Math.min(at, doc.length)), + effects: EditorView.scrollIntoView(Math.min(at, doc.length), { y: 'start', yMargin: 8 }) + }) + if (!focus) return + const raf = requestAnimationFrame(() => { + view.focus() + if (created && useStore.getState().vimMode) { + const cm = getCM(view) + if (cm && !cm.state.vim?.insertMode) Vim.handleKey(cm, 'a', 'user') + } + }) + return () => cancelAnimationFrame(raf) + }, [serial, focus, created, path, target, viewRef]) + + // Unsaved edits are saved by the store as the popover closes; a note + // switched away from inside the popover saves on its own debounce. + return ( +
+ ) +} diff --git a/packages/app-core/src/components/PinnedReferencePane.tsx b/packages/app-core/src/components/PinnedReferencePane.tsx index 63add99c..eee88797 100644 --- a/packages/app-core/src/components/PinnedReferencePane.tsx +++ b/packages/app-core/src/components/PinnedReferencePane.tsx @@ -73,7 +73,7 @@ export const pinnedRefPaneId = PINNED_REF_PANE_ID const programmatic = Annotation.define() -const paperHighlight = HighlightStyle.define([ +export const paperHighlight = HighlightStyle.define([ { tag: t.heading1, class: 'tok-heading1' }, { tag: t.heading2, class: 'tok-heading2' }, { tag: t.heading3, class: 'tok-heading3' }, @@ -133,7 +133,7 @@ function lineNumberExtension(mode: LineNumberMode): Extension { ] } -function buildReferenceKeymap(vimMode: boolean, overrides: KeymapOverrides): Extension { +export function buildReferenceKeymap(vimMode: boolean, overrides: KeymapOverrides): Extension { return keymap.of([ // Note search must precede the find bar only while its binding is set. ...keyBindingsFor(getKeymapBinding(overrides, 'global.searchNotesNonVim'), () => { diff --git a/packages/app-core/src/components/SearchPalette.tsx b/packages/app-core/src/components/SearchPalette.tsx index 8c5a30dd..1f6d1cd4 100644 --- a/packages/app-core/src/components/SearchPalette.tsx +++ b/packages/app-core/src/components/SearchPalette.tsx @@ -19,8 +19,16 @@ import { import { resolveSystemFolderLabels } from '../lib/system-folder-labels' import { isPrimaryNotesAtRoot, noteFolderLabel } from '../lib/vault-layout' import { useToastStore } from '../lib/toast' +import { openTaggedBlock, useTagBlockIndex } from '../lib/tag-block-index' +import { buildSearchPaletteRows, type SearchPaletteRow } from '../lib/search-palette-rows' import { Modal } from './ui/Modal' import { SearchCreateForm, type SearchCreateTarget } from './SearchCreateForm' +import { TaggedBlockText } from './TaggedBlockText' + +const NO_NOTES: NoteMeta[] = [] +const RESULT_LIMIT = 20 +// The cursor's key for the create row, which no note path can equal. +const CREATE_ROW_KEY = '\0create' export function SearchPalette(): JSX.Element { const notes = useStore((s) => s.notes) @@ -31,8 +39,16 @@ export function SearchPalette(): JSX.Element { const vault = useStore((s) => s.vault) const vaultSettings = useStore((s) => s.vaultSettings) const systemFolderLabels = useStore((s) => s.systemFolderLabels) + const searchTaggedBlocks = useStore((s) => s.searchTaggedBlocks) + const openTagViewFor = useStore((s) => s.openTagViewFor) const [query, setQuery] = useState('') - const [active, setActive] = useState(0) + // The cursor follows a row's key: tagged blocks fill in under their notes + // after the notes list, and the highlighted row must not drift while they + // do. `index` is the fallback when the key leaves the list. + const [cursor, setCursor] = useState<{ key: string | null; index: number }>({ + key: null, + index: 0 + }) // While set, the palette shows the New note form instead of the results. const [draft, setDraft] = useState(null) const inputRef = useRef(null) @@ -47,16 +63,58 @@ export function SearchPalette(): JSX.Element { const { freeText, tagTokens } = useMemo(() => parseNoteSearchQuery(query), [query]) const results = useMemo(() => { - return searchNoteIndex(searchIndex, query, { limit: 20 }) + return searchNoteIndex(searchIndex, query, { limit: RESULT_LIMIT }) }, [query, searchIndex]) + // Tagged blocks under the notes (#837), only for a query with a #tag and + // the setting on. Free text can match a block anywhere in a tagged note, so + // it reads every note carrying the tags; a bare tag query lists the results' + // blocks only, and only those are read. + const showBlocks = searchTaggedBlocks && tagTokens.length > 0 + const taggedNotes = useMemo(() => { + if (!showBlocks) return NO_NOTES + return notes.filter( + (n) => + n.folder !== 'trash' && + tagTokens.every((tag) => n.tags.some((t) => t.toLowerCase() === tag)) + ) + }, [showBlocks, notes, tagTokens]) + const tagBlocks = useTagBlockIndex(showBlocks ? (freeText ? taggedNotes : results) : NO_NOTES) + const rows = useMemo( + () => + buildSearchPaletteRows({ + results, + tagged: taggedNotes, + blocksByPath: tagBlocks.blocksByPath, + tagTokens, + freeText, + enabled: searchTaggedBlocks, + limit: RESULT_LIMIT + }), + [results, taggedNotes, tagBlocks.blocksByPath, tagTokens, freeText, searchTaggedBlocks] + ) + // A search that finds nothing is often the moment the note should start // existing (#826). The free text drafts the note to create (its `#tags` - // become the note's tags); the create row sits after the results, at index - // results.length, and leads to a form where the name, folder and tags can + // become the note's tags); the create row sits after the result rows, at + // index rows.length, and leads to a form where the name, folder and tags can // still change, so it shows even when the name is taken or not yet valid. const createRow = useMemo(() => searchCreateDraft(freeText, tagTokens), [freeText, tagTokens]) - const rowCount = results.length + (createRow ? 1 : 0) + const rowKeys = useMemo( + () => [...rows.map((row) => row.key), ...(createRow ? [CREATE_ROW_KEY] : [])], + [rows, createRow] + ) + const rowCount = rowKeys.length + const active = useMemo(() => { + if (cursor.key !== null) { + const at = rowKeys.indexOf(cursor.key) + if (at >= 0) return at + } + return Math.max(0, Math.min(cursor.index, rowCount - 1)) + }, [rowKeys, rowCount, cursor]) + const setActive = (index: number): void => + setCursor({ key: rowKeys[index] ?? null, index }) + const createRowIndex = rows.length const labels: AreaLabels = useMemo(() => { const resolved = resolveSystemFolderLabels(systemFolderLabels) return { @@ -76,7 +134,7 @@ export function SearchPalette(): JSX.Element { if (!draft) inputRef.current?.focus() }, [draft]) - useEffect(() => setActive(0), [query]) + useEffect(() => setCursor({ key: null, index: 0 }), [query]) useEffect(() => { const el = listRef.current?.querySelector(`[data-search-idx="${active}"]`) @@ -89,6 +147,20 @@ export function SearchPalette(): JSX.Element { focusEditorNormalMode() } + // A block opens its note at the block's line, highlighted, and records the + // jump (Ctrl+O comes back); "+N more" opens the rest in the Tags view with + // the free text still filtering. + const openRow = async (row: SearchPaletteRow): Promise => { + if (row.kind === 'note') return open(row.note) + setSearchOpen(false) + if (row.kind === 'block') { + await openTaggedBlock(row.note.path, row.block.startLine) + focusEditorNormalMode() + return + } + await openTagViewFor(tagTokens, freeText) + } + // Same landing as `:e name` and the dead-wikilink flow: the new note opens // with the editor focused, because its name was settled in the form. const createFromForm = async (target: SearchCreateTarget): Promise => { @@ -109,14 +181,17 @@ export function SearchPalette(): JSX.Element { // search that ends in "this needs to go" used to mean opening the note or // hunting for it in the sidebar). Same confirmation and clean-up as every // other Move to Trash; the row disappears because search never lists trash. + // Note rows only: a block or "+N more" row is a place inside a note, and + // trashing the whole note from it would be a surprise. const trashSelected = async (): Promise => { - const note = results[active] - if (!note) return + const row = rows[active] + if (row?.kind !== 'note') return + const note = row.note const moved = await trashNote(note.path) inputRef.current?.focus() if (!moved) return useToastStore.getState().addToast(`Moved "${note.title}" to Trash`, 'success') - setActive((a) => Math.max(0, Math.min(a, results.length - 2))) + setCursor({ key: null, index: Math.max(0, Math.min(active, rowCount - 2)) }) } if (draft) { @@ -146,20 +221,20 @@ export function SearchPalette(): JSX.Element { if (isPaletteNextKey(e)) { e.preventDefault() e.stopPropagation() - setActive((a) => Math.max(0, Math.min(rowCount - 1, a + 1))) + setActive(Math.max(0, Math.min(rowCount - 1, active + 1))) } else if (isPalettePreviousKey(e)) { e.preventDefault() e.stopPropagation() - setActive((a) => Math.max(0, a - 1)) + setActive(Math.max(0, active - 1)) } else if (e.key === 'Enter' && e.shiftKey) { e.preventDefault() e.stopPropagation() if (createRow) setDraft(createRow) } else if (e.key === 'Enter') { e.preventDefault() - const note = results[active] - if (note) void open(note) - else if (createRow && active === results.length) setDraft(createRow) + const row = rows[active] + if (row) void openRow(row) + else if (createRow && active === createRowIndex) setDraft(createRow) } else if ( e.ctrlKey && !e.metaKey && @@ -198,17 +273,66 @@ export function SearchPalette(): JSX.Element { {rowCount === 0 ? (
No matches.
) : ( - results.map((n, i) => { + rows.map((row, i) => { + const isActive = i === active + if (row.kind === 'block') { + return ( + + ) + } + if (row.kind === 'more') { + return ( + + ) + } + const n = row.note const dir = noteFolderLabel(n, vaultSettings) return ( + ) + } + const { note } = row return (
) } - -function cssEscape(value: string): string { - if (typeof CSS !== 'undefined' && typeof CSS.escape === 'function') return CSS.escape(value) - return value.replace(/["\\]/g, '\\$&') -} diff --git a/packages/app-core/src/components/TaggedBlockText.tsx b/packages/app-core/src/components/TaggedBlockText.tsx new file mode 100644 index 00000000..d648b9a5 --- /dev/null +++ b/packages/app-core/src/components/TaggedBlockText.tsx @@ -0,0 +1,83 @@ +import { Fragment } from 'react' +import type { TagBlock } from '@shared/tag-blocks' + +// A `#tag` token where the tag scanner would read one: at the start of the +// text or after whitespace. The capture keeps the token in `split` output. +const TAG_TOKEN_SPLIT_RE = /((?<=^|\s)#\p{L}[\p{L}\d_/-]*)/u + +/** Split `text` around every case-insensitive occurrence of `needle`. */ +function splitOnMatch(text: string, needle: string): { text: string; match: boolean }[] { + if (!needle) return [{ text, match: false }] + const lower = text.toLowerCase() + const parts: { text: string; match: boolean }[] = [] + let from = 0 + let at = lower.indexOf(needle) + while (at !== -1) { + if (at > from) parts.push({ text: text.slice(from, at), match: false }) + parts.push({ text: text.slice(at, at + needle.length), match: true }) + from = at + needle.length + at = lower.indexOf(needle, from) + } + if (from < text.length) parts.push({ text: text.slice(from), match: false }) + return parts +} + +/** + * A tagged block's text (#837): the wanted tags picked out in the accent, the + * typed filter text marked, and a heading's own line in bold. Shared by the + * Tags view and the Search notes palette so a block reads the same in both. + */ +export function TaggedBlockText({ + block, + tags, + highlight = '', + clampClassName = 'line-clamp-3' +}: { + block: TagBlock + /** Tags to pick out, any case. */ + tags: readonly string[] + /** Text to mark wherever it occurs, any case. */ + highlight?: string + clampClassName?: string +}): JSX.Element { + const wanted = new Set(tags.map((t) => t.toLowerCase())) + const needle = highlight.trim().toLowerCase() + return ( + + {block.text.split('\n').map((line, li) => ( + + {li > 0 ? '\n' : null} + + {line.split(TAG_TOKEN_SPLIT_RE).map((part, pi) => + part.startsWith('#') && wanted.has(part.slice(1).toLowerCase()) ? ( + + {part} + + ) : ( + splitOnMatch(part, needle).map((piece, mi) => + piece.match ? ( + + {piece.text} + + ) : ( + {piece.text} + ) + ) + ) + )} + + + ))} + + ) +} diff --git a/packages/app-core/src/components/UnresolvedLinksView.tsx b/packages/app-core/src/components/UnresolvedLinksView.tsx new file mode 100644 index 00000000..b6e4d480 --- /dev/null +++ b/packages/app-core/src/components/UnresolvedLinksView.tsx @@ -0,0 +1,473 @@ +import { useCallback, useEffect, useMemo, useRef, useState } from 'react' +import type { NoteMeta } from '@shared/ipc' +import { + unresolvedOccurrencesIn, + type UnresolvedLinkGroup, + type WikilinkOccurrence +} from '@shared/unresolved-links' +import { isUnresolvedLinksViewActive, useStore } from '../store' +import { databaseLinkTargetsFor, vaultUnresolvedLinks } from '../lib/unresolved-links' +import { createNoteFromLinkNow } from '../lib/create-note-from-link' +import { requestLinkPopover } from '../lib/link-popover-open' +import { focusEditorNormalMode } from '../lib/editor-focus' +import { isAppOverlayOpen } from '../lib/overlay-open' +import { + advanceSequence, + getKeymapBinding, + getKeymapDisplay, + matchesSequenceToken, + matchesShortcut +} from '../lib/keymaps' +import { linkCreateDestination } from '../lib/link-popover' +import { getSystemFolderLabel } from '../lib/system-folder-labels' +import { Button } from './ui' +import { LinkIcon, SearchIcon } from './icons' + +/** + * The Unresolved Links view: every `[[wikilink]]` in the vault that names a + * note no one has written yet, with the notes and lines that link to it. + * Asked for by a user who links notes they mean to write later and then + * forgets to (uNyanda, Discord). Enter on a name creates the note (the `gD` + * path), Enter on a line opens the linking note there, and the link popover + * key writes the note in place without leaving the list. + * + * Which links are listed is the editor's own decision (`wikilinkReaches`): + * a link listed here is exactly a link the editor draws as unresolved. + * Grouping uses the vault index's per-note link lists; the lines come from + * reading the linking notes, which only happens while the view is open. + */ + +type Row = + | { kind: 'target'; id: string; group: UnresolvedLinkGroup } + | { + kind: 'mention' + id: string + group: UnresolvedLinkGroup + note: NoteMeta + occurrence: WikilinkOccurrence | null + /** The note was read; a null occurrence then means its saved text no + * longer has the link (an unsaved edit, or the index running ahead). */ + loaded: boolean + } + +interface LoadedBody { + updatedAt: number + body: string +} + +function cssEscape(value: string): string { + return value.replace(/["\\]/g, '\\$&') +} + +/** The linking line, trimmed to the neighborhood of the link. */ +function excerpt(occurrence: WikilinkOccurrence): { before: string; link: string; after: string } { + const text = occurrence.text + const start = occurrence.column + const end = start + (occurrence.to - occurrence.from) + const before = text.slice(0, start) + const clippedBefore = before.length > 48 ? `…${before.slice(-46).trimStart()}` : before.trimStart() + return { before: clippedBefore, link: text.slice(start, end), after: text.slice(end) } +} + +export function UnresolvedLinksView(): JSX.Element { + const notes = useStore((s) => s.notes) + const folders = useStore((s) => s.folders) + const vaultSettings = useStore((s) => s.vaultSettings) + const assetFiles = useStore((s) => s.assetFiles) + const keymapOverrides = useStore((s) => s.keymapOverrides) + const vimMode = useStore((s) => s.vimMode) + const amActive = useStore(isUnresolvedLinksViewActive) + const openNoteAtOffset = useStore((s) => s.openNoteAtOffset) + const selectNote = useStore((s) => s.selectNote) + const systemFolderLabels = useStore((s) => s.systemFolderLabels) + + const [filter, setFilter] = useState('') + const [cursor, setCursor] = useState(0) + const [bodies, setBodies] = useState>(() => new Map()) + const rootRef = useRef(null) + const filterRef = useRef(null) + const gPending = useRef(0) + const gTimer = useRef>() + + const groups = useMemo( + () => + vaultUnresolvedLinks(notes, { + databases: databaseLinkTargetsFor(folders, vaultSettings), + assets: assetFiles + }), + [notes, folders, vaultSettings, assetFiles] + ) + + // Read the linking notes for their lines. Keyed on each note's mtime so an + // edit elsewhere refreshes its lines, and nothing is read twice. + useEffect(() => { + if (!amActive) return + let cancelled = false + const wanted = new Map() + for (const group of groups) for (const note of group.sources) wanted.set(note.path, note) + const stale = [...wanted.values()].filter( + (note) => bodies.get(note.path)?.updatedAt !== note.updatedAt + ) + if (stale.length === 0) return + void (async () => { + const loaded: Array<[string, LoadedBody]> = [] + for (const note of stale) { + const cached = useStore.getState().noteContents[note.path]?.body + try { + const body = cached ?? (await window.zen.readNote(note.path)).body + loaded.push([note.path, { updatedAt: note.updatedAt, body }]) + } catch { + loaded.push([note.path, { updatedAt: note.updatedAt, body: '' }]) + } + if (cancelled) return + } + setBodies((prev) => { + const next = new Map(prev) + for (const [path, entry] of loaded) next.set(path, entry) + return next + }) + })() + return () => { + cancelled = true + } + // `bodies` is read, not tracked: tracking it would rerun the effect for + // the result it just stored. + // eslint-disable-next-line react-hooks/exhaustive-deps + }, [amActive, groups]) + + const rows = useMemo(() => { + const q = filter.trim().toLowerCase() + const out: Row[] = [] + for (const group of groups) { + const matches = + !q || + group.target.toLowerCase().includes(q) || + group.sources.some((note) => note.title.toLowerCase().includes(q)) + if (!matches) continue + out.push({ kind: 'target', id: `t:${group.key}`, group }) + for (const note of group.sources) { + const loaded = bodies.get(note.path) + const hits = loaded ? unresolvedOccurrencesIn(loaded.body, new Set([group.key])) : [] + if (hits.length === 0) { + out.push({ + kind: 'mention', + id: `m:${group.key}:${note.path}`, + group, + note, + occurrence: null, + loaded: !!loaded + }) + continue + } + for (const hit of hits) { + out.push({ + kind: 'mention', + id: `m:${group.key}:${note.path}:${hit.from}`, + group, + note, + occurrence: hit, + loaded: true + }) + } + } + } + return out + }, [groups, bodies, filter]) + + const safeCursor = Math.min(cursor, Math.max(0, rows.length - 1)) + const current = rows[safeCursor] ?? null + + useEffect(() => { + if (safeCursor !== cursor) setCursor(safeCursor) + }, [cursor, safeCursor]) + + useEffect(() => { + if (!current) return + rootRef.current + ?.querySelector(`[data-unresolved-row="${cssEscape(current.id)}"]`) + ?.scrollIntoView({ block: 'nearest' }) + }, [current]) + + // Take the keyboard when the view comes up with nothing else holding it. + useEffect(() => { + if (!amActive) return + const raf = requestAnimationFrame(() => { + const active = document.activeElement + if (!active || active === document.body) rootRef.current?.focus({ preventScroll: true }) + }) + return () => cancelAnimationFrame(raf) + }, [amActive]) + + const createNote = useCallback((group: UnresolvedLinkGroup) => { + void createNoteFromLinkNow(group.target) + }, []) + + const openMention = useCallback( + async (row: Extract) => { + if (row.occurrence) await openNoteAtOffset(row.note.path, row.occurrence.from) + else await selectNote(row.note.path) + focusEditorNormalMode() + }, + [openNoteAtOffset, selectNote] + ) + + const activate = useCallback( + (row: Row) => { + if (row.kind === 'target') createNote(row.group) + else void openMention(row) + }, + [createNote, openMention] + ) + + /** Write the missing note in the link popover, hanging off its row. */ + const writeInPopover = useCallback((row: Row) => { + const el = rootRef.current?.querySelector( + `[data-unresolved-row="${cssEscape(row.id)}"]` + ) + const rect = el?.getBoundingClientRect() + if (!rect) return + requestLinkPopover({ + target: row.group.target, + sourcePath: row.kind === 'mention' ? row.note.path : row.group.sources[0]?.path ?? null, + anchorRect: { + left: rect.left + 24, + top: rect.top, + right: rect.right, + bottom: rect.bottom, + width: rect.width, + height: rect.height + }, + mode: 'pinned', + focus: true + }) + }, []) + + useEffect(() => { + if (!amActive) return + const handler = (e: KeyboardEvent): void => { + if (isAppOverlayOpen()) return + const target = e.target instanceof HTMLElement ? e.target : null + if (target?.closest('[data-link-popover]')) return + const focusedPanel = useStore.getState().focusedPanel + if (focusedPanel !== null && focusedPanel !== 'editor') return + if (target) { + const tag = target.tagName + if (tag === 'INPUT' || tag === 'TEXTAREA' || target.isContentEditable) return + } + const overrides = keymapOverrides + const consume = (): void => { + e.preventDefault() + e.stopImmediatePropagation() + } + // The popover key works with Vim on or off; its Vim twin is `K`. + if ( + current && + (matchesShortcut(e, overrides, 'editor.linkPopover') || + (vimMode && matchesSequenceToken(e, overrides, 'vim.linkPopover'))) + ) { + consume() + writeInPopover(current) + return + } + if (e.metaKey || e.ctrlKey || e.altKey) return + // With Vim off, single-key shortcuts stay off: arrows, Enter, Escape. + const seq = (id: Parameters[2]): boolean => + vimMode && matchesSequenceToken(e, overrides, id) + const key = e.key + if (key === 'Escape') { + if (!filter) return + consume() + setFilter('') + return + } + if (seq('nav.filter')) { + consume() + filterRef.current?.focus() + filterRef.current?.select() + return + } + if (seq('nav.moveDown') || key === 'ArrowDown') { + consume() + setCursor((i) => Math.min(rows.length - 1, i + 1)) + return + } + if (seq('nav.moveUp') || key === 'ArrowUp') { + consume() + setCursor((i) => Math.max(0, i - 1)) + return + } + if (seq('nav.jumpBottom')) { + consume() + setCursor(Math.max(0, rows.length - 1)) + return + } + if ( + vimMode && + advanceSequence( + e, + getKeymapBinding(overrides, 'nav.jumpTop'), + gPending, + gTimer, + () => setCursor(0), + consume, + 500 + ) + ) { + return + } + if ((key === 'Enter' || seq('nav.openResult')) && current) { + consume() + activate(current) + } + } + window.addEventListener('keydown', handler, true) + return () => { + if (gTimer.current) clearTimeout(gTimer.current) + window.removeEventListener('keydown', handler, true) + } + }, [activate, amActive, current, filter, keymapOverrides, rows.length, vimMode, writeInPopover]) + + const popoverKey = vimMode + ? getKeymapDisplay(keymapOverrides, 'vim.linkPopover') + : getKeymapDisplay(keymapOverrides, 'editor.linkPopover') + const mentionCount = groups.reduce((sum, group) => sum + group.sources.length, 0) + + return ( +
+
+ +

Unresolved Links

+ + {groups.length} + +
+ + { + setFilter(e.target.value) + setCursor(0) + }} + onKeyDown={(e) => { + if (e.key === 'Escape' || e.key === 'Enter') { + e.preventDefault() + if (e.key === 'Escape') setFilter('') + rootRef.current?.focus({ preventScroll: true }) + } + }} + placeholder="Filter links or notes" + className="w-44 bg-transparent text-xs text-ink-900 outline-none placeholder:text-ink-400" + /> +
+
+

+ {groups.length === 0 + ? 'Links to notes that do not exist yet show up here.' + : `${groups.length} ${groups.length === 1 ? 'note' : 'notes'} linked but not written yet, from ${mentionCount} ${mentionCount === 1 ? 'link' : 'links'}. Enter on a name creates the note; Enter on a line opens it there${popoverKey ? `; ${popoverKey} writes the note in a popover` : ''}.`} +

+
+ {rows.length === 0 ? ( +
+ {groups.length === 0 + ? 'No unresolved links. Every [[wikilink]] in this vault points at a note that exists.' + : 'Nothing matches your filter.'} +
+ ) : ( +
    + {rows.map((row, index) => { + const selected = index === safeCursor + const base = [ + 'group flex cursor-pointer items-center gap-3 px-4 outline-none', + selected ? 'bg-paper-200/80' : 'hover:bg-paper-200/40' + ].join(' ') + if (row.kind === 'target') { + const count = row.group.sources.length + const destination = linkCreateDestination(row.group.target) + return ( +
  • setCursor(index)} + onDoubleClick={() => activate(row)} + > + +
    +
    {row.group.target}
    + {destination && ( +
    + {`New note in ${getSystemFolderLabel(destination.folder, systemFolderLabels)}${destination.subpath ? ` / ${destination.subpath}` : ''}`} +
    + )} +
    + + {count === 1 ? 'linked from 1 note' : `linked from ${count} notes`} + + +
    • + ) + } + const parts = row.occurrence ? excerpt(row.occurrence) : null + return ( +
  • { + setCursor(index) + void openMention(row) + }} + title={row.note.path} + > + + {row.note.title} + + + {row.occurrence ? `line ${row.occurrence.line}` : ''} + + + {parts ? ( + <> + {parts.before} + {parts.link} + {parts.after} + + ) : row.loaded ? ( + '' + ) : ( + 'Reading…' + )} + +
    • + ) + })} +
+ )} +
+
+ ) +} diff --git a/packages/app-core/src/components/VimNav.tsx b/packages/app-core/src/components/VimNav.tsx index 5ebbe3ae..20d64795 100644 --- a/packages/app-core/src/components/VimNav.tsx +++ b/packages/app-core/src/components/VimNav.tsx @@ -1,6 +1,12 @@ import { useCallback, useEffect, useRef, useState } from 'react' import { completionStatus } from '@codemirror/autocomplete' -import { isAtlasViewActive, isTagsViewActive, isTasksViewActive, useStore } from '../store' +import { + isAtlasViewActive, + isTagsViewActive, + isTasksViewActive, + isUnresolvedLinksViewActive, + useStore +} from '../store' import { HintOverlay } from './HintOverlay' import { WhichKeyOverlay, type WhichKeyItem } from './WhichKeyOverlay' import { @@ -339,6 +345,11 @@ export function VimNav(): JSX.Element | null { label: 'Note outline', detail: 'Jump to any heading in the active note.' }, + { + keyLabel: getKeymapDisplay(keymapOverrides, 'vim.leaderUnresolvedLinks'), + label: 'Unresolved links', + detail: 'Every link to a note that does not exist yet, with the lines that link to it.' + }, ...(canSwitchVaults ? [ { @@ -925,6 +936,17 @@ export function VimNav(): JSX.Element | null { ) { return } + // The Unresolved Links view stands where the editor would, so it holds + // the keyboard whenever the editor panel does, through its own + // capture handler. The leader still reaches the logic below. + if ( + isUnresolvedLinksViewActive(state) && + (state.focusedPanel == null || state.focusedPanel === 'editor') && + !leaderPending.current && + sequenceTokenFromEvent(e) !== leaderToken + ) { + return + } // ------- Global leader handling ----------------------------------- // Runs before per-panel routing so -prefixed shortcuts work @@ -1015,6 +1037,13 @@ export function VimNav(): JSX.Element | null { state.setOutlinePaletteOpen(true) return } + if (matchesSequenceToken(e, overrides, 'vim.leaderUnresolvedLinks')) { + e.preventDefault() + e.stopImmediatePropagation() + resetLeader() + void state.openUnresolvedLinksView() + return + } if (canSwitchVaults && matchesSequenceToken(e, overrides, 'vim.leaderSwitchVault')) { e.preventDefault() e.stopImmediatePropagation() @@ -2362,7 +2391,7 @@ export function VimNav(): JSX.Element | null { }) return } - if (type === 'missing' || type === 'attachment') { + if (type === 'missing' || type === 'attachment' || type === 'unresolved-all') { el.click() } } diff --git a/packages/app-core/src/lib/cm-table.test.ts b/packages/app-core/src/lib/cm-table.test.ts index 85e67272..3e443f35 100644 --- a/packages/app-core/src/lib/cm-table.test.ts +++ b/packages/app-core/src/lib/cm-table.test.ts @@ -18,6 +18,7 @@ import { findChar } from './cm-table' import { closeTableContextMenu } from './cm-table-menu' +import { getPromptRequest, settlePromptRequest } from './prompt-requests' import { isMacPlatform } from './keymaps' import { useStore } from '../store' import { Vim } from '@replit/codemirror-vim' @@ -892,6 +893,97 @@ describe('table cell link following (#445)', () => { }) }) +describe('unresolved wikilinks in table cells', () => { + const saved = { + notes: useStore.getState().notes, + selectNote: useStore.getState().selectNote, + selectedPath: useStore.getState().selectedPath, + vimMode: useStore.getState().vimMode + } + afterEach(() => { + const pending = getPromptRequest() + if (pending) settlePromptRequest(pending, null) + useStore.setState(saved) + vi.restoreAllMocks() + }) + + const existing = { path: 'Existing.md', title: 'Existing', folder: 'inbox' } + const DOC = [ + '| A | B |', + '| --- | --- |', + '| live | [[Existing]] |', + '| dead | [[Missing Note]] |', + '| alias | [[Missing Note\\|alias]] |', + '| code | `[[Missing Note]]` |' + ].join('\n') + + function setup(vimMode = false): ReturnType { + const selectNote = vi.fn(async () => {}) + useStore.setState({ vimMode, selectedPath: 'Doc.md', notes: [existing], selectNote } as never) + return selectNote + } + const cellLink = (view: EditorView, raw: string): HTMLAnchorElement | null => + [...view.dom.querySelectorAll('.cm-table-cell')] + .find((cell) => cell.dataset.raw === raw) + ?.querySelector('a.wikilink') ?? null + + it('marks a link to a note that does not exist broken, and leaves a live one alone', () => { + setup() + const view = mount(DOC) + expect(cellLink(view, '[[Existing]]')?.classList.contains('broken')).toBe(false) + expect(cellLink(view, '[[Missing Note]]')?.classList.contains('broken')).toBe(true) + // An alias is decided by its target, not its label. + const alias = cellLink(view, '[[Missing Note|alias]]') + expect(alias?.textContent).toBe('alias') + expect(alias?.classList.contains('broken')).toBe(true) + // Inside a code span `[[...]]` is text, not a link. + expect(cellLink(view, '`[[Missing Note]]`')).toBeNull() + view.destroy() + }) + + it('turns the link live in place once its note exists, without rebuilding the table', () => { + setup() + const view = mount(DOC) + const widget = view.dom.querySelector('.cm-table-widget') + expect(cellLink(view, '[[Missing Note]]')?.classList.contains('broken')).toBe(true) + useStore.setState({ + notes: [existing, { path: 'Missing Note.md', title: 'Missing Note', folder: 'inbox' }] + } as never) + expect(view.dom.querySelector('.cm-table-widget')).toBe(widget) + expect(cellLink(view, '[[Missing Note]]')?.classList.contains('broken')).toBe(false) + expect(cellLink(view, '[[Missing Note|alias]]')?.classList.contains('broken')).toBe(false) + // And back: the note going away (deleted, renamed) marks it broken again. + useStore.setState({ notes: [existing] } as never) + expect(cellLink(view, '[[Missing Note]]')?.classList.contains('broken')).toBe(true) + view.destroy() + }) + + it('re-decides a cell when it leaves editing', () => { + setup() + const view = mount(DOC) + const cell = [...view.dom.querySelectorAll('.cm-table-cell')].find( + (c) => c.dataset.raw === '[[Existing]]' + )! + cell.focus() + cell.textContent = '[[Nowhere]]' + cell.dispatchEvent(new Event('input', { bubbles: true })) + cell.blur() + expect(cell.querySelector('a.wikilink')?.classList.contains('broken')).toBe(true) + view.destroy() + }) + + it('still offers to create the note when a broken cell link is clicked', () => { + const selectNote = setup() + const view = mount(DOC) + const anchor = cellLink(view, '[[Missing Note]]') + expect(anchor?.classList.contains('broken')).toBe(true) + anchor?.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, button: 0 })) + expect(getPromptRequest()?.options.title).toBe('Create note for "Missing Note"?') + expect(selectNote).not.toHaveBeenCalled() + view.destroy() + }) +}) + describe('tableBlockAt — the fallback when the parse has not caught up (#485)', () => { const doc = (text: string) => Text.of(text.split('\n')) diff --git a/packages/app-core/src/lib/cm-table.ts b/packages/app-core/src/lib/cm-table.ts index b18304ec..0c538ed8 100644 --- a/packages/app-core/src/lib/cm-table.ts +++ b/packages/app-core/src/lib/cm-table.ts @@ -25,6 +25,7 @@ import { Decoration, type DecorationSet, EditorView, + ViewPlugin, WidgetType } from '@codemirror/view' import { @@ -50,6 +51,7 @@ import { useStore } from '../store' import { isMacPlatform, matchesSequenceToken, matchesShortcutBinding, type KeymapId } from './keymaps' import { writeClipboardText } from './clipboard-text' import { followLinkTarget } from './follow-link' +import { wikilinkResolves } from './cm-wikilink-render' import { TableCellLinkPicker, type CellTextEdit } from './cm-table-link-picker' import { linkRangeAtCursor, type LineLinkKind } from './internal-links' @@ -146,8 +148,14 @@ const INSERT_ESCAPE_TIMEOUT_MS = 1000 * parser as the reading view rather than adding an inline-only copy to keep in * sync, and `escapeCell` is the serializer's own escaping, so what the cell * shows is what its row will contain on disk. + * + * `linkResolves`, when given, decides each `[[wikilink]]` the way the editor + * does: a link that reaches nothing gets the reading view's `broken` class. */ -export function renderInlineCell(text: string): string { +export function renderInlineCell( + text: string, + linkResolves?: (target: string) => boolean +): string { const trimmed = text.trim() if (!trimmed) return '' // A newline would close the synthetic row; cells are single-line by @@ -158,12 +166,36 @@ export function renderInlineCell(text: string): string { const cell = parsed.content.querySelector('th, td') // Never swallow the text: if the pipeline returns something unexpected (its // error fallback, say), show the source rather than an empty cell. - if (cell) return cell.innerHTML + if (cell) { + if (linkResolves) markUnresolvedCellLinks(cell, linkResolves) + return cell.innerHTML + } const plain = document.createElement('span') plain.textContent = trimmed return plain.innerHTML } +/** Give every rendered `[[wikilink]]` under `root` the `broken` class when its + * target reaches nothing (a click would create the note), and take it off + * when it does. The editor draws those links muted with a dashed underline + * (`.cm-wikilink-broken`), and the reading view marks them `a.wikilink.broken`; + * a table cell used to draw every one as a live link. */ +function markUnresolvedCellLinks( + root: ParentNode, + linkResolves: (target: string) => boolean +): void { + root.querySelectorAll('a.wikilink').forEach((anchor) => { + const target = anchor.dataset.wikilink?.trim() + if (!target) return + anchor.classList.toggle('broken', !linkResolves(target)) + }) +} + +/** A cell's idle HTML, with its wikilinks decided against the vault. */ +function renderCellHtml(text: string): string { + return renderInlineCell(text, wikilinkResolves) +} + /** If a `` width marker sits on the line right after the * table ending at `tableTo`, return its parsed per-column widths and the end * offset of that line. The widget swallows the marker (so it never shows as @@ -654,7 +686,7 @@ class TableWidget extends WidgetType { editable.setAttribute('contenteditable', vimEnabled() ? 'false' : 'true') // Idle: show rendered inline markdown (code/bold/links). Editing: show the // raw source. `data-raw` stays authoritative for commits either way. - editable.innerHTML = renderInlineCell(text) + editable.innerHTML = renderCellHtml(text) editable.dataset.rendered = 'true' editable.addEventListener('focus', () => { @@ -717,7 +749,7 @@ class TableWidget extends WidgetType { if (editable.dataset.rendered === 'false') { const raw = editable.dataset.raw ?? editable.textContent ?? '' editable.dataset.raw = raw - editable.innerHTML = renderInlineCell(raw) + editable.innerHTML = renderCellHtml(raw) editable.dataset.rendered = 'true' } }) @@ -1735,7 +1767,7 @@ class TableWidget extends WidgetType { cell.querySelectorAll('.cm-table-cell-sel').forEach((overlay) => overlay.remove()) cell.classList.remove('is-vim-visual') if (!selected.has(cell) && cell !== active && cell.dataset.rendered === 'false') { - cell.innerHTML = renderInlineCell(cell.dataset.raw ?? '') + cell.innerHTML = renderCellHtml(cell.dataset.raw ?? '') cell.dataset.rendered = 'true' } }) @@ -1782,7 +1814,7 @@ class TableWidget extends WidgetType { cell.querySelectorAll('.cm-table-cell-sel').forEach((overlay) => overlay.remove()) cell.classList.remove('is-vim-visual') if (cell !== active && cell.dataset.rendered === 'false') { - cell.innerHTML = renderInlineCell(cell.dataset.raw ?? '') + cell.innerHTML = renderCellHtml(cell.dataset.raw ?? '') cell.dataset.rendered = 'true' } }) @@ -2498,6 +2530,39 @@ function buildDecorations(state: EditorState): DecorationSet { return builder.finish() } +/** + * Keeps the cells' `[[wikilink]]` look current while the note stays open. A + * link's fate depends on vault state that moves under the editor (the notes + * list arriving after mount, the missing note created from the link, the asset + * list), the same inputs the editor's own wikilinks recompute on. The table's + * source has not changed, so its widget is not rebuilt; instead the idle + * cells' anchors are re-decided in place, which leaves focus and a cell being + * edited alone (that one shows raw source and re-renders on blur anyway). + */ +const tableCellLinkStates = ViewPlugin.fromClass( + class { + private unsubscribe: () => void + constructor(view: EditorView) { + this.unsubscribe = useStore.subscribe((state, prev) => { + if ( + state.notes !== prev.notes || + state.assetFiles !== prev.assetFiles || + state.folders !== prev.folders || + state.vaultSettings !== prev.vaultSettings || + state.selectedPath !== prev.selectedPath + ) { + view.contentDOM + .querySelectorAll('.cm-table-widget .cm-table-cell') + .forEach((cell) => markUnresolvedCellLinks(cell, wikilinkResolves)) + } + }) + } + destroy(): void { + this.unsubscribe() + } + } +) + /** * Block widgets (and any decoration that replaces line breaks) must be * supplied through a StateField, not a ViewPlugin — CodeMirror needs to know @@ -2516,7 +2581,8 @@ export const tablePlugin = StateField.define({ }, provide: (field) => [ EditorView.decorations.from(field), - EditorView.atomicRanges.of((view) => view.state.field(field, false) ?? Decoration.none) + EditorView.atomicRanges.of((view) => view.state.field(field, false) ?? Decoration.none), + tableCellLinkStates ] }) diff --git a/packages/app-core/src/lib/cm-vim-default-keymap.test.ts b/packages/app-core/src/lib/cm-vim-default-keymap.test.ts index 0ec1b09a..7ee0ad22 100644 --- a/packages/app-core/src/lib/cm-vim-default-keymap.test.ts +++ b/packages/app-core/src/lib/cm-vim-default-keymap.test.ts @@ -224,6 +224,71 @@ describe('vimAwareMarkdownKeymap (Enter in Vim normal mode acts as )', () => }) }) +// #993: on Linux/Windows defaultKeymap's Mod-a (select all) is Ctrl+A, Vim's +// increment, and it ran ahead of the Vim plugin. jsdom's navigator is not +// a Mac, so CodeMirror reads Mod as Ctrl here, exactly as it does there. +describe('Ctrl+A reaches Vim where Mod is Ctrl (#993)', () => { + const views: EditorView[] = [] + afterEach(() => { + views.splice(0).forEach((v) => v.destroy()) + }) + + const mount = (doc: string): EditorView => { + const view = new EditorView({ + state: EditorState.create({ + doc, + // Keymap first: in the real editors CodeMirror's keymap handler runs + // before the Vim plugin's (measured in the app), which is the order + // that let select all win. + extensions: [keymap.of([...vimAwareDefaultKeymap(true, false)]), vim()] + }), + parent: document.body + }) + views.push(view) + view.focus() + return view + } + + const press = (view: EditorView, key: string, keyCode: number, ctrlKey = false): void => { + view.contentDOM.dispatchEvent( + new KeyboardEvent('keydown', { key, keyCode, ctrlKey, bubbles: true, cancelable: true }) + ) + } + + const selectAllRun = (mac: boolean): NonNullable => { + const binding = vimAwareDefaultKeymap(true, mac).find((b) => b.key === 'Mod-a') + if (!binding?.run) throw new Error('no Mod-a binding') + return binding.run + } + + it('increments the number on the line in normal mode instead of selecting the note', () => { + const view = mount('count 41 apples') + press(view, 'a', 65, true) + expect(view.state.doc.toString()).toBe('count 42 apples') + expect(view.state.selection.main.empty).toBe(true) + }) + + it('defers in visual mode too, and keeps select all in insert mode', () => { + const visual = mount('hello world') + press(visual, 'v', 86) + expect(selectAllRun(false)(visual)).toBe(false) + + const insert = mount('hello world') + press(insert, 'i', 73) + expect(selectAllRun(false)(insert)).toBe(true) + expect(insert.state.selection.main.from).toBe(0) + expect(insert.state.selection.main.to).toBe(11) + }) + + it('leaves Cmd+A on macOS and Ctrl+A with Vim off as plain select all', () => { + const mac = vimAwareDefaultKeymap(true, true).find((b) => b.key === 'Mod-a') + expect(mac?.preventDefault).toBeUndefined() + const view = mount('hello world') + expect(mac?.run?.(view)).toBe(true) // normal mode, and still selects + expect(vimAwareDefaultKeymap(false, false)).toBe(vimAwareDefaultKeymap(false, true)) + }) +}) + // #510: on Linux/Windows the search panel's Mod-f is Ctrl+F, which Vim wants // for page-forward; the keymap runs ahead of the Vim plugin, so the panel won. describe('vimAwareSearchKeymap', () => { diff --git a/packages/app-core/src/lib/cm-vim-default-keymap.ts b/packages/app-core/src/lib/cm-vim-default-keymap.ts index 9745cd9f..9b9177b9 100644 --- a/packages/app-core/src/lib/cm-vim-default-keymap.ts +++ b/packages/app-core/src/lib/cm-vim-default-keymap.ts @@ -159,15 +159,34 @@ const vimModeKeymap: readonly KeyBinding[] = deferEscapeToVim( deferKeysToVim(defaultKeymapWithoutMacEmacs, VIM_MOTION_KEYS) ) +/** + * Ctrl+A belongs to Vim where Mod is Ctrl (#993). `defaultKeymap` binds + * `Mod-a` to select all, which on Linux and Windows is Ctrl+A, Vim's + * `` increment; it ran ahead of the Vim plugin, so normal mode selected + * the whole note instead of bumping the number. (Ctrl+X, the decrement, has + * no binding here and always reached Vim.) Like the motion keys it defers to + * Vim outside insert mode, so insert mode keeps select all. macOS's Cmd+A + * never collided. + */ +const vimModeKeymapModIsCtrl: readonly KeyBinding[] = deferKeysToVim( + vimModeKeymap, + new Set(['Mod-a']) +) + /** * CodeMirror's `defaultKeymap`, made Vim-aware: in Vim mode the macOS * emacs-style control chords are stripped so Vim's ``/``/``/… * bindings work, the arrow keys defer to Vim in normal/visual mode so they - * move/extend like `hjkl`, and Escape defers to Vim in insert/visual mode so it - * leaves the mode; with Vim off the full keymap is used unchanged. + * move/extend like `hjkl`, Escape defers to Vim in insert/visual mode so it + * leaves the mode, and off macOS Ctrl+A defers to Vim outside insert mode; + * with Vim off the full keymap is used unchanged. */ -export function vimAwareDefaultKeymap(vimMode: boolean): readonly KeyBinding[] { - return vimMode ? vimModeKeymap : defaultKeymap +export function vimAwareDefaultKeymap( + vimMode: boolean, + mac: boolean = isMacPlatform() +): readonly KeyBinding[] { + if (!vimMode) return defaultKeymap + return mac ? vimModeKeymap : vimModeKeymapModIsCtrl } /** diff --git a/packages/app-core/src/lib/cm-wikilink-render.ts b/packages/app-core/src/lib/cm-wikilink-render.ts index 927dc281..f1b75fe3 100644 --- a/packages/app-core/src/lib/cm-wikilink-render.ts +++ b/packages/app-core/src/lib/cm-wikilink-render.ts @@ -24,8 +24,8 @@ import { isSameFileBlockLink, isSameFileHeadingLink, resolveWikilinkTarget } fro import { openDatabaseFromWikilink, openWikilinkTarget } from './wikilink-navigation' import { createNoteFromLinkNow, offerCreateNoteFromLink } from './create-note-from-link' import { openWikilinkAttachment } from './open-wikilink-attachment' -import { resolveAssetPathAmong } from './asset-path-resolution' -import { listDatabaseLinkTargets, resolveDatabaseWikilink } from './database-links' +import { listDatabaseLinkTargets } from './database-links' +import { wikilinkReaches } from './unresolved-links' import { setHoveredLink } from './hovered-link' // Same shape as the Preview pipeline (remarkWikilinks). @@ -41,10 +41,11 @@ const bracketMark = Decoration.mark({ class: 'cm-wikilink-bracket' }) const refreshWikilinksEffect = StateEffect.define() /** - * Whether a wikilink target reaches something: a note, a spot in this note, a - * `.base` database, or a file in the vault. Anything else would create a note - * when followed, and is drawn as unresolved (#768). Mirrors the reading view's - * `broken` decision in Preview.tsx. + * Whether a wikilink target reaches something (`wikilinkReaches`): a note, a + * spot in this note, a `.base` database, or a file in the vault. Anything else + * would create a note when followed, and is drawn as unresolved (#768). + * Mirrors the reading view's `broken` decision in Preview.tsx, and is the same + * call the Unresolved Links view makes for every link in the vault. * * Decorations rebuild on every selection change, and note resolution scans * the whole notes list, so answers are memoized until any input changes. @@ -60,7 +61,7 @@ interface ResolverCache { } let resolverCache: ResolverCache | null = null -function wikilinkResolves(target: string): boolean { +export function wikilinkResolves(target: string): boolean { const s = useStore.getState() // A surface that mounts the editor with a partial store (tests, the // standalone windows) has no vault lists to check against. A link there is @@ -98,12 +99,11 @@ function wikilinkResolves(target: string): boolean { if (cached != null) return cached let resolves = true try { - resolves = - resolveWikilinkTarget(notes, target) != null || - isSameFileHeadingLink(target) || - isSameFileBlockLink(target) || - resolveDatabaseWikilink(resolverCache.databases, target) != null || - resolveAssetPathAmong(assetFiles, selectedPath ?? '', target) != null + resolves = wikilinkReaches(target, selectedPath ?? '', { + notes, + databases: resolverCache.databases, + assets: assetFiles + }) } catch { resolves = true } @@ -116,7 +116,7 @@ function wikilinkResolves(target: string): boolean { * literal text, not a link, so it should render as code (matching the Preview * pipeline, whose remark transform never visits code nodes). (#248) */ -function isInsideCode(state: EditorView['state'], pos: number): boolean { +export function isInsideCode(state: EditorView['state'], pos: number): boolean { let node = syntaxTree(state).resolveInner(pos, 1) while (node) { const n = node.name diff --git a/packages/app-core/src/lib/commands.ts b/packages/app-core/src/lib/commands.ts index a00ff161..cac7d7e3 100644 --- a/packages/app-core/src/lib/commands.ts +++ b/packages/app-core/src/lib/commands.ts @@ -7,7 +7,14 @@ * sensitive commands like "Unarchive" only show up when applicable). */ import { requestAgentEditReview } from './agent-review-runtime' -import { isTagsViewActive, isTasksViewActive, isTrashViewActive, useStore } from '../store' +import { + isTagsViewActive, + isTasksViewActive, + isTrashViewActive, + isUnresolvedLinksViewActive, + useStore +} from '../store' +import { openLinkPopoverAtCursor } from './link-popover-open' import { confirmApp } from './confirm-requests' import { requestSettingsTarget } from './settings-navigation' import { hideWindowToTray, useTrayStore } from './tray-runtime' @@ -1006,6 +1013,25 @@ export function buildCommands(options?: { includeUnavailable?: boolean }): Comma await getState().cancelTaskFromList(task) } }, + { + id: 'editor.link-popover', + title: 'Open Link Popover', + category: 'Editor', + shortcut: getState().vimMode + ? [shortcut('vim.linkPopover'), shortcut('editor.linkPopover')].filter(Boolean).join(' / ') + : shortcut('editor.linkPopover'), + keywords: 'link popover hover preview edit create note wikilink peek floating in place', + when: () => !!getState().editorViewRef && !!getState().activeNote, + run: () => { + const view = getState().editorViewRef + if (!view) return + // The palette took focus; the cursor the popover reads is the + // editor's, which it kept. + if (!openLinkPopoverAtCursor(view)) { + window.alert('Put the cursor on a [[wikilink]] to open its note in the link popover.') + } + } + }, { id: 'task.toggle-checkbox', title: 'Toggle Checkbox', @@ -1307,6 +1333,16 @@ export function buildCommands(options?: { includeUnavailable?: boolean }): Comma when: () => getState().atlasEnabled, run: () => getState().openAtlasView() }, + { + id: 'view.unresolved-links', + title: 'Open Unresolved Links', + category: 'View', + shortcut: getState().vimMode ? leaderShortcut('vim.leaderUnresolvedLinks') : ':unresolved', + keywords: + 'unresolved links missing broken dangling wikilinks notes to write later create orphan dead', + when: () => !isUnresolvedLinksViewActive(getState()), + run: () => getState().openUnresolvedLinksView() + }, { id: 'view.tags', title: 'Open Tags', diff --git a/packages/app-core/src/lib/create-note-from-link.test.ts b/packages/app-core/src/lib/create-note-from-link.test.ts index c8c86d92..b47ddd83 100644 --- a/packages/app-core/src/lib/create-note-from-link.test.ts +++ b/packages/app-core/src/lib/create-note-from-link.test.ts @@ -13,6 +13,14 @@ const state = vi.hoisted(() => ({ openDailyNoteForDate: vi.fn((_date: Date) => Promise.resolve()), openWeeklyNoteForDate: vi.fn((_date: Date) => Promise.resolve()), openMonthlyNoteForDate: vi.fn((_date: Date) => Promise.resolve()), + createNoteInPlace: vi.fn((folder: string, subpath: string, title: string) => + Promise.resolve({ path: `${folder}/${subpath ? `${subpath}/` : ''}${title}.md` } as { + path: string + } | null) + ), + ensureDailyNoteForDate: vi.fn((_date: Date) => + Promise.resolve({ path: 'Daily Notes/2026-11-03.md' } as { path: string } | null) + ), setFocusedPanel: vi.fn(), editorViewRef: null })) @@ -23,7 +31,9 @@ vi.mock('../store', () => ({ useStore: { getState: () => state } })) vi.mock('./prompt-requests', () => ({ promptApp })) vi.mock('./confirm-requests', () => ({ confirmApp })) -const { createNoteFromLinkNow, offerCreateNoteFromLink } = await import('./create-note-from-link') +const { createNoteForLinkInPlace, createNoteFromLinkNow, offerCreateNoteFromLink } = await import( + './create-note-from-link' +) beforeEach(() => { promptApp.mockClear() @@ -34,6 +44,8 @@ beforeEach(() => { state.openDailyNoteForDate.mockClear() state.openWeeklyNoteForDate.mockClear() state.openMonthlyNoteForDate.mockClear() + state.createNoteInPlace.mockClear() + state.ensureDailyNoteForDate.mockClear() }) describe('createNoteFromLinkNow (#768)', () => { @@ -127,3 +139,63 @@ describe('a dead link that names a periodic note', () => { }) }) + +// uNyanda (Discord): hover a link and create or edit its note in a small +// floating window, without leaving the note. The link popover creates the +// note where gD would, but never opens it: the popover edits it in place. +describe('createNoteForLinkInPlace (link popover)', () => { + it('creates the note named after the link without opening or prompting', async () => { + const path = await createNoteForLinkInPlace('Garden Plan') + + expect(path).toBe('inbox/Garden Plan.md') + expect(state.createNoteInPlace).toHaveBeenCalledWith('inbox', '', 'Garden Plan') + expect(state.createAndOpen).not.toHaveBeenCalled() + expect(state.selectNote).not.toHaveBeenCalled() + expect(promptApp).not.toHaveBeenCalled() + }) + + it('drops a heading anchor and an alias-free path keeps its folders', async () => { + await createNoteForLinkInPlace('projects/Plan#Goals') + expect(state.createNoteInPlace).toHaveBeenLastCalledWith('inbox', 'projects', 'Plan') + + await createNoteForLinkInPlace('archive/Old idea') + expect(state.createNoteInPlace).toHaveBeenLastCalledWith('archive', '', 'Old idea') + }) + + it('answers with an existing note at that path instead of creating a second one', async () => { + const path = await createNoteForLinkInPlace('existing') + + expect(path).toBe('inbox/Existing.md') + expect(state.createNoteInPlace).not.toHaveBeenCalled() + expect(state.selectNote).not.toHaveBeenCalled() + }) + + it("makes a daily-note link that day's daily note, still without opening it", async () => { + state.vaultSettings = { + dailyNotes: { enabled: true, directory: 'Daily Notes' }, + weeklyNotes: { enabled: true, directory: 'Weekly Notes' } + } + const path = await createNoteForLinkInPlace('2026-11-03') + + expect(path).toBe('Daily Notes/2026-11-03.md') + expect(state.ensureDailyNoteForDate).toHaveBeenCalledTimes(1) + expect(state.openDailyNoteForDate).not.toHaveBeenCalled() + expect(state.createNoteInPlace).not.toHaveBeenCalled() + }) + + it('leaves a weekly note to the opening path, which runs its template', async () => { + state.vaultSettings = { + dailyNotes: { enabled: true, directory: 'Daily Notes' }, + weeklyNotes: { enabled: true, directory: 'Weekly Notes' } + } + expect(await createNoteForLinkInPlace('2026-W45')).toBeNull() + expect(state.createNoteInPlace).not.toHaveBeenCalled() + expect(state.openWeeklyNoteForDate).not.toHaveBeenCalled() + }) + + it('reports a failed create as null, and a name no file can carry the same way', async () => { + state.createNoteInPlace.mockResolvedValueOnce(null) + expect(await createNoteForLinkInPlace('Will fail')).toBeNull() + expect(await createNoteForLinkInPlace('bad|name?')).toBeNull() + }) +}) diff --git a/packages/app-core/src/lib/create-note-from-link.ts b/packages/app-core/src/lib/create-note-from-link.ts index 81752126..9e4ec2f8 100644 --- a/packages/app-core/src/lib/create-note-from-link.ts +++ b/packages/app-core/src/lib/create-note-from-link.ts @@ -92,6 +92,40 @@ export async function createNoteFromLinkNow(target: string): Promise { await createNoteAtPath(suggestCreateNotePath(target)) } +/** + * Create the note a dead link names without opening it, so the link popover + * can be the place it is written, over the note that links to it. Same + * destination as `createNoteFromLinkNow`: named after the link, in Inbox + * unless the link names a top folder, and a link named like a daily note + * makes that day's daily note (template included). + * + * Resolves to the note's path: the new note, or one already at that path. + * Null when only opening can make the note (a weekly or monthly note, which + * the calendar creates as it opens it) or when creating failed; the caller + * falls back to `createNoteFromLinkNow`. + */ +export async function createNoteForLinkInPlace(target: string): Promise { + const dateNote = dateNoteForLink(target) + if (dateNote) { + if (dateNote.info.kind !== 'daily') return null + const daily = await useStore.getState().ensureDailyNoteForDate(dateNote.info.date) + return daily?.path ?? null + } + let parsed: ReturnType + try { + parsed = parseCreateNotePath(suggestCreateNotePath(target)) + } catch { + return null + } + const state = useStore.getState() + const existing = state.notes.find( + (note) => note.folder !== 'trash' && note.path.toLowerCase() === parsed.relPath.toLowerCase() + ) + if (existing) return existing.path + const created = await state.createNoteInPlace(parsed.folder, parsed.subpath, parsed.title) + return created?.path ?? null +} + async function createNoteAtPath(value: string): Promise { const focusEditorSoon = (): void => { useStore.getState().setFocusedPanel('editor') diff --git a/packages/app-core/src/lib/help.ts b/packages/app-core/src/lib/help.ts index 3c6bf583..f141855d 100644 --- a/packages/app-core/src/lib/help.ts +++ b/packages/app-core/src/lib/help.ts @@ -156,6 +156,16 @@ export const HELP_HOW_TO_GUIDES: HelpCard[] = [ body: 'Switch the active pane to Split mode when you want markdown on one side and rendered output on the other. Use Preview when you only want the rendered view, or keep Edit when you want the least visual noise while writing.' }, + { + title: 'Find links to notes you have not written yet', + body: + 'Link a note before it exists, like `[[Garden Plan]]`, and the Unresolved Links view keeps it for you: every `[[wikilink]]` in the vault that points at a note that does not exist yet, grouped by the missing note with the most-linked first, and under each one the notes that link to it and the line each link sits on. Open it with `Space u` in Vim mode, `:unresolved`, Open Unresolved Links in the command palette, or the All unresolved links row under a note\'s missing links in the Connections panel. Enter on a name creates the note where `gD` would (in Inbox, named after the link) and opens it, and the name leaves the list; Enter on a line opens the linking note with the cursor on the link; `K` (Shift+Cmd+K, or Shift+Ctrl+K on Windows and Linux) writes the missing note in the link popover without leaving the list. In Vim mode j / k move, gg / G jump to the ends and / filters; with Vim mode off the arrows, Enter and Escape do the work. A link is listed exactly when the editor draws it as unresolved: a heading (`[[Note#Heading]]`), block (`[[Note^id]]`) or display-text (`[[Note|text]]`) link to an existing note resolves, so does a link to a file in the vault or to a `.base` database, and a `[[link]]` inside a code block or inline code is text, not a link.' + }, + { + title: 'Edit or create a linked note without leaving yours', + body: + 'Rest the pointer on a `[[wikilink]]` in the editor and the link popover opens: the note the link names, in a small floating editor over the note you are in. It is the note itself, not a preview: what you type there is saved to it like any other edit, and shows up in any tab that has it open. Move the pointer away and it closes; click or type in it and it stays until you press Escape or click outside it. A link to a note that does not exist yet offers Create note instead: press Enter (or click it) and the note is created where `gD` would put it, then opens in the popover, ready for its first line. From the keyboard, put the cursor on a link and press `K` in Vim mode, or Shift+Cmd+K (Shift+Ctrl+K on Windows and Linux) with Vim mode on or off. The popover takes the keyboard: `K` on a link inside it moves on to that note, Cmd+Enter (Ctrl+Enter) opens the note in a tab, and Escape closes it and puts you back on the link you came from, cursor where it was. In Vim mode the first Escape leaves insert mode as usual and the next one closes the popover. A `[[Note#Heading]]` link opens it on that heading. To keep the popover to the keyboard only, turn off Settings → Writing → Link popover on hover.' + }, { title: 'Search the right thing', body: @@ -284,6 +294,11 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [ body: 'Tasks scans every note for checkboxes and groups the open ones by when they are due: Today (due today or overdue), Upcoming, and No due date, then Waiting, Forwarded, Done, and Cancelled. A task written in a daily note counts as due on that note’s date while “Tasks are due on the note’s date” is on (Settings → Daily notes). Inside each group the list keeps the notes’ line order, or puts high priority first when its Order menu, above the list, says Priority (`s` in Vim mode). Tags lets you browse notes that carry all of the selected tags (toggle Match to Any for a union), Archive gives you a dedicated list of cold-storage notes, and Trash gives you a recovery surface for deleted notes without turning the left rail into a second browser. Selected tags accumulate so you can narrow across several at once; clear them with the Selected strip’s “Clear all”, the `c` key, or a right-click on any tag chip (which also offers “Unselect others” to keep just that one). A tag chip’s context menu also carries “Rename Tag…” and “Delete Tag…”, which rewrite or remove that hashtag across the whole vault. Tags work in any script (`#тест` and `#标签` are tags), while headings (`# x`) and hex colors (`#1971c2`) are not.' }, + { + title: 'Tags find the idea, not just the note', + body: + 'Open a tag (click it in the sidebar or in a note, or run `:tag idea`) and the Tags view lists each matching note with its tagged blocks under the title: every list item, paragraph, quote, or table row inside the note that carries the tag. Several unrelated ideas jotted into one note show up one by one instead of as one note you have to read through. A tagged list item brings its nested items along, and a tag on a heading tags its whole section: the row shows the heading with the first lines under it. Enter, `o`, or a click on a block opens the note at that line and highlights it; Enter on the note row opens the note at the top as before. The header counts both (“3 notes · 5 blocks”). The filter box narrows to the blocks whose text matches what you type, and keeps every block of a note whose title matches. With Vim mode on, `}` and `{` hop from note to note past the blocks. Tags in frontmatter tag the whole note, so a note tagged only there stays a plain row, and a `#tag` inside code is never a tag. A block you type into an open note lists right away.\n\nSearch notes shows the same blocks. Type `#idea` and each matching note lists up to two of its tagged blocks under it, then a “+N more tagged blocks” row that opens the rest in the Tags view; Enter on a block opens the note at that line. Words after the tag narrow the blocks to those containing them (marked in each block), and a note found by such a word deep in its body is listed too, while a note that matched only by its title stays a plain row. With several tags (`#idea #later`) notes still carry all of them, and the blocks carrying all of them come first. Without a `#tag` the palette lists notes as always. If the extra rows feel cluttered, turn off Settings → Editor → Search → **Show tagged blocks in note search** (`tagged_blocks` under `[search]` in config.toml).' + }, { title: 'Archiving a note retires its tasks', body: @@ -417,7 +432,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [ { title: 'Reference and connections support research-heavy work', body: - 'Pin a companion note or PDF in the reference pane, then toggle the connections panel to inspect backlinks and unresolved links while you draft. Connections count both `[[wikilinks]]` and standard Markdown links (`[text](Note.md)`), so incoming and outgoing associations show up even if you never use wikilinks. A wikilink at a file in the vault, such as an embedded image or a PDF, is listed as a file and opens in its own tab; the panel only offers to create a note for a wikilink that reaches nothing.' + 'Pin a companion note or PDF in the reference pane, then toggle the connections panel to inspect backlinks and unresolved links while you draft. Connections count both `[[wikilinks]]` and standard Markdown links (`[text](Note.md)`), so incoming and outgoing associations show up even if you never use wikilinks. A wikilink at a file in the vault, such as an embedded image or a PDF, is listed as a file and opens in its own tab; the panel only offers to create a note for a wikilink that reaches nothing, and under those missing links the All unresolved links in the vault row opens the Unresolved Links view, the same list for the whole vault.' }, { title: 'Zen mode removes chrome', @@ -427,7 +442,7 @@ export const HELP_CORE_CONCEPTS: HelpCard[] = [ { title: 'Links are actionable', body: - 'Use [[wikilinks]] or markdown links. Following a link (click it, Cmd/Ctrl-click it, or use the follow-link motion `gd` in normal mode) opens the note under the cursor and pins PDFs into the reference pane. If the note does not exist yet, following the link offers to create it (after you confirm) rather than leaving a dead link; hold Cmd (macOS) or Ctrl (Windows/Linux) while clicking the link, or use `gD` in normal mode, to create it at once at the suggested path: Inbox, named after the link text. A link named like one of your daily, weekly or monthly notes, such as `[[2026-11-03]]` while daily notes are on, creates that note instead, in its folder and from its template, the way the calendar does, so it shows up on that day; a link that names a folder (`[[journal/2026-11-03]]`) still makes a plain note there. A link at a note that does not exist yet is drawn muted with a dashed underline, in the editor and in the reading view, so you can tell live links from ones that would create a note. Prefix a wikilink with `!` to embed rather than link: `![[Note]]` inlines the target note content in the reading view and PDF export (recursively, with cycle protection), so a master note can pull in sub-notes and export to PDF as one document. `![[image.png]]` embeds an image and `![[drawing.excalidraw]]` embeds an Excalidraw drawing as a PNG preview; both take optional `|width` or `|WxH` size hints (`![[image.png|300]]`, `![[image.png|600x400]]`), and the markdown form carries the same hint after the alt text (`![caption|300](image.png)`). In the editor, drag the handle on a picture\'s right edge to resize it; the width is written back as that hint, so the reading view, exports and Obsidian all show the same size. Resize Image… in the command palette (or `:imgwidth 480` in Vim mode, `:imgw auto` to reset) sets it by number for the image under the cursor. Right-click a web link or an email address, in the editor or the reading view, to open it or copy it (the address itself, without `mailto:`); `gy` in normal mode, or Copy Link Under Cursor in the palette, copies the one under the caret.' + 'Use [[wikilinks]] or markdown links. Following a link (click it, Cmd/Ctrl-click it, or use the follow-link motion `gd` in normal mode) opens the note under the cursor and pins PDFs into the reference pane. If the note does not exist yet, following the link offers to create it (after you confirm) rather than leaving a dead link; hold Cmd (macOS) or Ctrl (Windows/Linux) while clicking the link, or use `gD` in normal mode, to create it at once at the suggested path: Inbox, named after the link text. A link named like one of your daily, weekly or monthly notes, such as `[[2026-11-03]]` while daily notes are on, creates that note instead, in its folder and from its template, the way the calendar does, so it shows up on that day; a link that names a folder (`[[journal/2026-11-03]]`) still makes a plain note there. A link at a note that does not exist yet is drawn muted with a dashed underline, in the editor and in the reading view, so you can tell live links from ones that would create a note; the Unresolved Links view (`Space u`) lists all of them in the vault. Rest the pointer on a wikilink, or press `K` on it in Vim mode, to edit or create its note in the link popover without leaving the note you are in. Prefix a wikilink with `!` to embed rather than link: `![[Note]]` inlines the target note content in the reading view and PDF export (recursively, with cycle protection), so a master note can pull in sub-notes and export to PDF as one document. `![[image.png]]` embeds an image and `![[drawing.excalidraw]]` embeds an Excalidraw drawing as a PNG preview; both take optional `|width` or `|WxH` size hints (`![[image.png|300]]`, `![[image.png|600x400]]`), and the markdown form carries the same hint after the alt text (`![caption|300](image.png)`). In the editor, drag the handle on a picture\'s right edge to resize it; the width is written back as that hint, so the reading view, exports and Obsidian all show the same size. Resize Image… in the command palette (or `:imgwidth 480` in Vim mode, `:imgw auto` to reset) sets it by number for the image under the cursor. Right-click a web link or an email address, in the editor or the reading view, to open it or copy it (the address itself, without `mailto:`); `gy` in normal mode, or Copy Link Under Cursor in the palette, copies the one under the caret.' }, { title: 'Open links in other applications', @@ -518,7 +533,8 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [ description: 'These work across the main app shell. With Vim mode on and the editor focused, an app shortcut on a Ctrl chord wins over Vim\u2019s own use of that chord, except the ones Vim mode keeps on purpose: Ctrl+W (the pane prefix), Ctrl+O and Ctrl+I (the jumplist), and Ctrl+D and Ctrl+U (half-page scroll). On macOS these shortcuts use Cmd and never collide.', items: [ { keys: 'Mod+P', action: 'Search notes', detail: 'Open the note search palette, from the editor too: on Linux and Windows this wins over Vim\u2019s Ctrl+P (cursor up).' }, - { keys: 'Ctrl+D (in Search notes)', action: 'Move the highlighted note to Trash', detail: 'Trash a note straight from the search results, with the usual confirmation; the palette stays open, so a clean-up pass is search, Ctrl+D, search, Ctrl+D.' }, + { keys: 'Ctrl+D (in Search notes)', action: 'Move the highlighted note to Trash', detail: 'Trash a note straight from the search results, with the usual confirmation; the palette stays open, so a clean-up pass is search, Ctrl+D, search, Ctrl+D. It acts on note rows only, never on a tagged block row.' }, + { keys: 'Enter on a tagged block (in Search notes)', action: 'Open the note at that block', detail: 'With a #tag in the query, notes list their tagged blocks; Enter opens the note at the block’s line, highlighted, and Ctrl+O comes back. Enter on “+N more tagged blocks” opens the rest in the Tags view, your words still filtering.' }, { keys: 'Shift+Enter (in Search notes)', action: 'Create a note named after your search', detail: 'The last row of the results offers to create the note you typed: Shift+Enter (or Enter on that row) opens a New note form with three fields. Name starts as your search text, selected so you can retype it. Folder starts empty (your Inbox) or as the path you typed, like projects/roadmap; landing in it lists every folder, typing narrows the list, Enter picks the highlighted one and ArrowUp keeps a folder that does not exist yet. Tags starts with any #tag words from your search; type to pick an existing tag or add a new one, Space or comma commits, Backspace on an empty field removes the last one. The line under the fields tells you what will happen. A note with the same name in that folder blocks Create until you change the name, and Shift+↵ opens the existing note instead; the same name elsewhere only warns. Enter in Name, or Ctrl/Cmd+Enter anywhere, creates the note and opens it; Escape goes back to the results.' }, { keys: 'Mod+F', action: 'Search notes (non-Vim mode)', detail: 'Open the note search palette directly when Vim mode is off.' }, { keys: 'Mod+F (in the editor)', action: 'Find and replace in the note', detail: 'In Edit and Split, open the editor’s find-and-replace bar: Tab moves between the Find and Replace fields, with match-case, whole-word, and regex toggles. Esc closes it. With Vim mode off, Mod+F in the main window opens note search instead (the row above); unbind or move Search notes in non-Vim mode under Settings \u2192 Keymap to give Mod+F to the bar, or use F3. With Vim mode on, Linux and Windows keep Ctrl+F as Vim\u2019s page-forward (search with / instead); macOS keeps Cmd+F for the bar. A floating window has no note search, so there Mod+F opens the bar with Vim mode off too.' }, @@ -546,6 +562,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [ { keys: 'Mod+O', action: 'Open file', detail: 'Desktop only: pick a Markdown file with the native dialog. A file inside a known vault opens against that vault; anything else opens in a standalone external-file window. Links in that window follow from the file\'s own folder: a relative link such as `../README.md` opens the file it names, and a `[[wikilink]]` finds a page of that name in the folder or below it, each in its own window (or in its vault, when the target lives in one).' }, { keys: 'Mod+4 / Mod+5 / Mod+6', action: 'Edit / Split / Preview mode', detail: 'Switch the active note between the raw editor, side-by-side split, and rendered preview. Preview opens at the line you were editing; Edit and Split open on the section you were reading when you scrolled away from the cursor in Preview, and keep the cursor where it was when you only peeked.' }, { keys: 'Mod+L', action: 'Toggle checkbox', detail: 'Turn the current line into a checkbox and toggle it on repeat. See the “Check off a task with ⌘L” card in Core concepts for the full state rules.' }, + { keys: 'Shift+Mod+K', action: 'Open link popover', detail: 'Open the link popover for the [[wikilink]] under the cursor, keyboard inside: edit the note it names in place, or create it when it does not exist yet. Escape closes it and returns to the link; Mod+Enter opens the note in a tab. Works with Vim mode on or off (Vim mode also has `K`). Remappable as editor.linkPopover.' }, { keys: 'Alt+Q (macOS: Ctrl+Q)', action: 'Reflow paragraph', detail: 'Join the hard-wrapped lines of the paragraph under the cursor (or every paragraph in the selection) into one line, so the editor wraps it to the pane. Headings, lists, tables, code, and explicit line breaks are untouched. See the “Reflow a hard-wrapped paragraph” card. Remappable as editor.reflowParagraph.' }, { keys: 'Shift+Mod+E', action: 'Export note as PDF', detail: 'Export the active note as a PDF file.' }, { keys: 'Mod+=', action: 'Zoom in', detail: 'Scale the whole app up, including chrome, editor, and preview.' }, @@ -586,6 +603,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [ { keys: 'gq{motion} / gw{motion}', action: 'Reflow paragraph', detail: 'Vim’s format operator, tuned for an editor that wraps to the pane: `gqip` joins the hard-wrapped lines of the paragraph into one line, `gqj` joins two lines, `Vgq` a visual selection. `gq` lands on the first formatted line like Vim; `gw` keeps the cursor where it was. Headings, list markers, tables, code, math, and explicit line breaks are left alone.' }, { keys: 'Ctrl+V', action: 'Visual block', detail: 'Select a rectangle across rows; `I`, `A` and `c` apply the edit to every row of the block, short rows included.' }, { keys: 'Space p', action: 'Note outline', detail: 'Jump to any heading in the active note via a searchable overlay.' }, + { keys: 'Space u', action: 'Unresolved links', detail: 'Open the Unresolved Links view: every link in the vault to a note that does not exist yet, with the notes and lines that link to it. Enter on a name creates the note, Enter on a line opens the note at the link, and K writes the missing note in the link popover. Also `:unresolved`.' }, { keys: 'Space v', action: 'Switch vault', detail: 'Open the command palette directly to the local vault switcher.' }, { keys: 'Space a', action: 'Open workflows', detail: 'Open the Workflows view, where saved pipelines over your notes are built and run. Workflows are off by default; turn them on under Settings → Workflows first.' }, { keys: 'Space r', action: 'Review Cloud conflicts', detail: 'Open whatever Cloud sync is waiting on: the queue of files two devices changed at once, one decision at a time, or the vault settings question, which lists each setting that differs with this device’s value beside the cloud’s and lets you pick a side per setting. When the open note is one of the waiting files, the queue starts on it. A waiting note also says so across its top, in Edit and Preview alike: sync is paused for it until you choose what to keep, and its Review button opens the queue on it. Choosing the other device’s version puts the file where that device left it; when this device already has a different file there, that file moves beside it under the next free name, such as Untitled 2.md. A notification with Review appears once when a new conflict arrives. When the Cloud vault this vault syncs with is deleted, on this device, another device or the website, the status bar says Cloud vault deleted and the binding opens Settings → Cloud instead, where This vault says what happened until you choose a cloud vault, start a new one, or dismiss the notice. If another device moved it into an end-to-end encrypted vault, the status bar says Cloud vault now encrypted instead, and This vault asks you to unlock this device if needed, then choose the encrypted vault. The binding and the command palette entry appear only while something is waiting, and open the same place as Review in the status bar.' }, @@ -696,9 +714,10 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [ title: 'Tasks, tags, and trash views', description: 'These virtual views each run their own keyboard loop in the main pane, and the Vim leader works here too (for example Space h for hint mode). The single keys below belong to Vim mode: with it off only the arrows, Enter and Escape stay live everywhere, plus Shift+J/K to reorder in the list, Tab to pick a task on the calendar and Space to toggle one on the board or the calendar; everything else sits in the right-click menu.', items: [ - { keys: 'j / k', action: 'Move row cursor', detail: 'Step through task rows, tagged notes, or trashed notes.' }, + { keys: 'j / k', action: 'Move row cursor', detail: 'Step through task rows, tagged notes and their tagged blocks, or trashed notes.' }, { keys: 'g g / G', action: 'Jump to top or bottom', detail: 'Move to the first or last visible result.' }, - { keys: 'Enter / o', action: 'Open current result', detail: 'Open the selected task source note, tagged note, or trashed note.' }, + { keys: 'Enter / o', action: 'Open current result', detail: 'Open the selected task source note, tagged note, or trashed note. On a tagged block, open its note at that line, highlighted.' }, + { keys: '} / {', action: 'Next or previous note', detail: 'Tags view only: hop to the next note past the current note\'s tagged blocks, or back to the previous note (from a block, to its own note).' }, { keys: 'x', action: 'Toggle task', detail: 'Tasks view only: check or uncheck the selected task. A checked task lingers in place for a couple of seconds before it drops into Done, so you can toggle it again to undo. Space also toggles unless Space is your Vim leader key, in which case it starts a leader sequence.' }, { keys: '>', action: 'Forward task', detail: 'Tasks list only: forward the selected task to another note. Opens a note picker that filters as you type and preselects the first match, so Enter forwards without reaching for an arrow key. The original becomes a forwarded record (`[>]`) linking to the target, and a fresh copy is added there, backlinked home, subtasks and all. Forwarded tasks live under a “Forwarded” group.' }, { keys: 'i', action: 'Mark task in progress', detail: 'Tasks list only: mark the selected task as started (`- [/]`), or set it back to open. In-progress tasks keep their group and their day on the calendar, so the row keeps its place.' }, @@ -708,7 +727,7 @@ export const HELP_SHORTCUT_SECTIONS: HelpShortcutSection[] = [ { keys: 's', action: 'Order the list', detail: 'Tasks list only: switch the order inside each group between the notes’ line order and priority (high, then medium, low, and none, ties by due date). Same as the Order menu above the list, `:order priority` / `:order note`, and `tasks_list_order` under `[view]` in config.toml.' }, { keys: 'r', action: 'Restore trashed note', detail: 'Trash view only: restore the selected trashed note.' }, { keys: 'x / d', action: 'Delete forever', detail: 'Trash view only: permanently delete the selected trashed note after confirmation.' }, - { keys: '/', action: 'Filter the view', detail: 'Focus the local filter box for tasks, tag matches, or trashed notes.' }, + { keys: '/', action: 'Filter the view', detail: 'Focus the local filter box for tasks, tag matches, or trashed notes. In Tags, a word from a tagged block narrows the list to that block.' }, { keys: 'F', action: 'Pick a saved Tasks filter', detail: 'Tasks view: open the list of saved filters and apply one. Save the current query with the Save filter… chip or `:savefilter `.' }, { keys: ':', action: 'Open local ex prompt', detail: 'Run the view-specific command line inside Tasks or Tags.' }, { keys: 'Esc', action: 'Clear the filter', detail: 'Clears an active filter. These views are tabs, so Esc no longer closes them. Close with :q or the ✕ in the tab header.' } @@ -969,6 +988,16 @@ export const HELP_VIM_COMMANDS: HelpExCommand[] = [ summary: 'Create the note for the link under the cursor', detail: 'Like `gd`, but a link at a note that does not exist yet creates it at once at the suggested path (Inbox, named after the link) instead of asking first. A link named like a daily, weekly or monthly note, such as `[[2026-11-03]]`, creates that note where the calendar would. The keyboard twin of Cmd/Ctrl-clicking an unresolved wikilink.' }, + { + command: 'K', + summary: 'Open the link popover for the link under the cursor', + detail: 'Opens the note the `[[wikilink]]` under the cursor names in a floating editor over this note, with the keyboard in it; a link to a note that does not exist yet offers Create note, and the new note opens there ready for typing. `K` on a link inside the popover moves on to that note. Escape in normal mode closes it and puts the cursor back on the link. Vim\'s own `K` looks up the word under the cursor; this one looks up the note. Rebind it as `vim.linkPopover`.' + }, + { + command: ':unresolved', + summary: 'Open the Unresolved Links view', + detail: 'Lists every `[[wikilink]]` in the vault that points at a note that does not exist yet, with the notes and lines that link to it. `:unres` for short; `Space u` does the same.' + }, { command: 'gy', summary: 'Copy the link under the cursor', @@ -1154,6 +1183,7 @@ export const HELP_SETTINGS: HelpSettingsSection[] = [ { label: 'Heading level labels', detail: 'Show H1 through H6 badges before headings. Heading fold arrows stay available whether labels are on or off.' }, { label: 'Tab size', detail: 'Choose how many spaces a tab occupies when rendered and when indenting in every Markdown editor surface. Nested list levels also render this many columns deep, whatever the note’s source spacing, so levels stay tellable apart on any monitor.' }, { label: 'Indent guides', detail: 'Draw a vertical guide line at each nested list level in the editor, at the Tab size columns. On by default; the raw markup is never changed either way.' }, + { label: 'Link popover on hover', detail: 'On by default. Resting the pointer on a `[[wikilink]]` in the editor opens the link popover, where the linked note can be edited, or created when it does not exist yet, without leaving the note you are in. Off, the popover opens only from the keyboard: `K` in Vim mode, or Shift+Cmd+K (Shift+Ctrl+K on Windows and Linux). `link_popover_on_hover` under `[editor]` in config.toml.' }, { label: 'Text replacements', detail: 'Enable or disable typed expansions and manage the trigger-to-text rules under the dedicated Text replacements tab.' }, { label: 'Note tabs and wrap tabs', detail: 'Enable or disable tab-based editing and split-friendly note workflows, and wrap the tab strip onto extra rows when it overflows.' }, { label: 'Word wrap', detail: 'Wrap long lines to the editor width or let them scroll horizontally.' }, diff --git a/packages/app-core/src/lib/keymaps.ts b/packages/app-core/src/lib/keymaps.ts index 40777e9c..f8e77892 100644 --- a/packages/app-core/src/lib/keymaps.ts +++ b/packages/app-core/src/lib/keymaps.ts @@ -76,6 +76,7 @@ export type KeymapId = | "vim.leaderWeeklyNote" | "vim.leaderMonthlyNote" | "vim.leaderCalendar" + | "vim.leaderUnresolvedLinks" | "vim.panePrefix" | "vim.paneFocusLeft" | "vim.paneFocusDown" @@ -91,6 +92,7 @@ export type KeymapId = | "vim.tabNext" | "vim.hintMode" | "vim.goToDefinition" + | "vim.linkPopover" | "vim.createNoteFromLink" | "vim.foldCurrent" | "vim.unfoldCurrent" @@ -129,6 +131,8 @@ export type KeymapId = | "tasks.moveTaskUp" | "tasks.moveTaskDown" | "tasks.savedFilters" + | "tags.nextNote" + | "tags.previousNote" | "editor.moveLineUp" | "editor.moveLineDown" | "editor.hopMarkerForward" @@ -137,6 +141,7 @@ export type KeymapId = | "editor.unfoldHeading" | "editor.toggleCheckbox" | "editor.reflowParagraph" + | "editor.linkPopover" | "editor.reviewNextChange" | "editor.reviewPreviousChange" | "editor.reviewAcceptChange" @@ -809,6 +814,19 @@ const KEYMAP_DEFINITIONS: KeymapDefinition[] = [ vimOnly: true, maxTokens: 1, }, + { + id: "vim.leaderUnresolvedLinks", + kind: "sequence", + scope: "leader", + group: "vim", + title: "Leader: unresolved links", + // `u` for unresolved: every link in the vault that names a note no one wrote yet. + description: + "Open the Unresolved Links view: every [[wikilink]] in the vault that points at a note that does not exist yet.", + defaultBinding: "u", + vimOnly: true, + maxTokens: 1, + }, { id: "vim.panePrefix", kind: "sequence", @@ -987,6 +1005,20 @@ const KEYMAP_DEFINITIONS: KeymapDefinition[] = [ vimOnly: true, maxTokens: 2, }, + { + id: "vim.linkPopover", + kind: "sequence", + scope: "vim-editor", + group: "vim", + title: "Link popover for link at cursor", + // Vim's own `K` looks up the word under the cursor; here the word is a + // note, and the lookup shows it. + description: + "Open the link popover for the [[wikilink]] under the cursor: edit the note it names in place, or create it when it does not exist yet. Escape in normal mode closes it and returns here.", + defaultBinding: "K", + vimOnly: true, + maxTokens: 1, + }, { id: "vim.foldCurrent", kind: "sequence", @@ -1347,6 +1379,30 @@ const KEYMAP_DEFINITIONS: KeymapDefinition[] = [ defaultBinding: "F", maxTokens: 1, }, + { + id: "tags.nextNote", + kind: "sequence", + scope: "views", + group: "view-actions", + title: "Next note in Tags view", + description: + "Move past the selected note's tagged blocks to the next note in the Tags view (Vim mode).", + defaultBinding: "}", + vimOnly: true, + maxTokens: 1, + }, + { + id: "tags.previousNote", + kind: "sequence", + scope: "views", + group: "view-actions", + title: "Previous note in Tags view", + description: + "Move to the previous note in the Tags view, or to the top of the current note's blocks (Vim mode).", + defaultBinding: "{", + vimOnly: true, + maxTokens: 1, + }, { id: "editor.hopMarkerForward", kind: "shortcut", @@ -1464,6 +1520,16 @@ const KEYMAP_DEFINITIONS: KeymapDefinition[] = [ defaultBinding: "Alt+Q", defaultBindingMac: "Ctrl+Q", }, + { + id: "editor.linkPopover", + kind: "shortcut", + scope: "vim-editor", + group: "view-actions", + title: "Open link popover", + description: + "Open the link popover for the [[wikilink]] under the cursor and move into it: edit the note it names in place, or create it when it does not exist yet. Escape closes it and returns to the note you were in. Works with Vim mode on or off; Vim mode also has it as `K`.", + defaultBinding: "Shift+Mod+K", + }, { id: "nav.localEx", kind: "sequence", diff --git a/packages/app-core/src/lib/link-label-style.test.ts b/packages/app-core/src/lib/link-label-style.test.ts new file mode 100644 index 00000000..917ac7a8 --- /dev/null +++ b/packages/app-core/src/lib/link-label-style.test.ts @@ -0,0 +1,51 @@ +import { readFileSync } from 'node:fs' +import { describe, expect, it } from 'vitest' + +const stylesSource = readFileSync(new URL('../styles/index.css', import.meta.url), 'utf8').replace( + /\/\*[\s\S]*?\*\//g, + '' +) + +// Every top-level rule that sets `color`, in source order. +const colorRules = [...stylesSource.matchAll(/([^{}]+)\{([^}]*)\}/g)] + .map((match, order) => ({ + order, + selectors: match[1].split(',').map((selector) => selector.trim()), + body: match[2] + })) + .filter((rule) => /(^|[\s;])color\s*:/.test(rule.body)) + +function rulesFor(selector: string) { + const found = colorRules.filter((rule) => rule.selectors.includes(selector)) + expect(found, `no color rule for ${selector}`).not.toEqual([]) + return found +} + +const LABEL = '.cm-editor :where(.tok-link) .tok-link-syntax' + +describe('link label color in the editor', () => { + it('gives the label inside a resolved link the accent', () => { + const [label] = rulesFor(LABEL) + expect(label.body).toMatch(/color:\s*rgb\(var\(--z-accent\)\)/) + }) + + it('beats the block tokens on the same span and yields to the link syntax tokens', () => { + // Inside a list item the label span is `tok-list tok-link-syntax`; its + // brackets add `tok-meta-code`. All three rules share one specificity, so + // source order decides: a link in a list once rendered as plain list text. + const label = rulesFor(LABEL)[0].order + for (const block of [ + '.cm-editor .tok-list', + '.cm-editor .tok-quote', + '.cm-editor .tok-heading2', + '.cm-editor .tok-heading6', + '.cm-editor .tok-emphasis', + '.cm-editor .tok-strong' + ]) { + for (const rule of rulesFor(block)) expect(rule.order, block).toBeLessThan(label) + } + for (const syntax of ['.cm-editor .tok-meta-code', '.cm-editor .tok-string', '.cm-editor .tok-label']) { + for (const rule of rulesFor(syntax)) expect(rule.order, syntax).toBeGreaterThan(label) + } + }) +}) diff --git a/packages/app-core/src/lib/link-popover-open.ts b/packages/app-core/src/lib/link-popover-open.ts new file mode 100644 index 00000000..cb54d71f --- /dev/null +++ b/packages/app-core/src/lib/link-popover-open.ts @@ -0,0 +1,198 @@ +import type { EditorView } from '@codemirror/view' +import { useStore, type LinkPopoverState, type PreviewAnchorRect } from '../store' +import { linkRangeAtCursor } from './internal-links' +import { + LINK_POPOVER_HOVER_DELAY_MS, + LINK_POPOVER_LEAVE_GRACE_MS, + linkPopoverTarget +} from './link-popover' +import { databaseLinkTargetsFor } from './unresolved-links' + +/** + * Opening the link popover: from the pointer resting on a `[[wikilink]]` + * (hover intent below), or from a key on the link under the cursor (`K`, the + * editor shortcut). Kept out of the component so the editor's handlers and + * Vim actions reach it without mounting anything. + */ + +/** Screen rect of the document range `from..to`, for placing the popover. */ +export function rangeRect(view: EditorView, from: number, to: number): PreviewAnchorRect | null { + const start = view.coordsAtPos(from, 1) + const end = view.coordsAtPos(to, -1) + if (!start || !end) return null + // A link wrapped onto a second line ends left of where it starts; its + // first line is where the eye is, so hang the popover off that. + const right = end.top > start.top + 2 ? start.left + 1 : Math.max(end.right, start.left + 1) + return { + left: start.left, + top: start.top, + right, + bottom: end.bottom, + width: right - start.left, + height: end.bottom - start.top + } +} + +/** + * Show the popover for `target`, written in the note at `sourcePath`, when + * the popover has something for it (a note, or a note to create). False for + * a link it leaves to other surfaces: a database, a file, an address, or a + * spot in the note being read. + */ +export function requestLinkPopover(args: { + target: string + sourcePath: string | null + anchorRect: PreviewAnchorRect + mode: LinkPopoverState['mode'] + focus: boolean +}): boolean { + const s = useStore.getState() + const shows = linkPopoverTarget(args.target, args.sourcePath ?? '', { + notes: s.notes, + databases: databaseLinkTargetsFor(s.folders, s.vaultSettings), + assets: s.assetFiles + }) + if (!shows) return false + void s.openLinkPopover({ + target: args.target.trim(), + path: shows.kind === 'note' ? shows.path : null, + anchorRect: args.anchorRect, + mode: args.mode, + focus: args.focus, + created: false + }) + return true +} + +/** The note an editor view shows: the popover's own editor shows the + * popover's note, so `K` inside it chains to the next link. */ +function notePathOfView(view: EditorView): string | null { + const s = useStore.getState() + if (view.dom.closest('[data-link-popover]')) return s.linkPopover?.path ?? null + return s.selectedPath ?? null +} + +/** + * `K` (Vim) and the editor shortcut: the popover for the wikilink under the + * cursor, with the keyboard moved into it. False when the cursor is not on a + * wikilink the popover can show, so the key falls through. + */ +export function openLinkPopoverAtCursor(view: EditorView): boolean { + const pos = view.state.selection.main.head + const line = view.state.doc.lineAt(pos) + const link = linkRangeAtCursor(line.text, pos - line.from) + if (!link || link.kind !== 'wikilink') return false + const anchorRect = rangeRect(view, line.from + link.from, line.from + link.to) + if (!anchorRect) return false + return requestLinkPopover({ + target: link.target, + sourcePath: notePathOfView(view), + anchorRect, + mode: 'pinned', + focus: true + }) +} + +// ---- Hover intent --------------------------------------------------------- +// +// The pointer has to rest on a link before its popover opens, and may cross +// the gap between link and popover without closing it. One link is "under +// the pointer" at a time; `shownKey` is the link whose popover the pointer +// opened, so coming back to it cancels a pending close instead of reopening. + +let pointerKey: string | null = null +let shownKey: string | null = null +// Moving from a link onto the popover fires the popover's pointerenter +// before the editor's mouseleave, so a close armed by the second must check +// where the pointer actually is. +let pointerOnPopover = false +let openTimer: ReturnType | null = null +let closeTimer: ReturnType | null = null + +function clearOpenTimer(): void { + if (openTimer) clearTimeout(openTimer) + openTimer = null +} + +function clearCloseTimer(): void { + if (closeTimer) clearTimeout(closeTimer) + closeTimer = null +} + +function scheduleHoverClose(): void { + clearCloseTimer() + closeTimer = setTimeout(() => { + closeTimer = null + const s = useStore.getState() + // A popover the user has worked in waits for Escape or a click outside. + if (s.linkPopover?.mode !== 'hover') return + if (pointerOnPopover) return + if (pointerKey !== null && pointerKey === shownKey) return + shownKey = null + s.closeLinkPopover() + }, LINK_POPOVER_LEAVE_GRACE_MS) +} + +/** + * The pointer is over the wikilink `target` in the note at `sourcePath`. + * Called on every pointer move over a link, so it does nothing new until the + * link changes. `rect` is read when the popover opens, after the rest. + */ +export function pointerOverWikilink( + target: string, + sourcePath: string | null, + rect: () => PreviewAnchorRect | null +): void { + const key = `${sourcePath ?? ''}\n${target.trim().toLowerCase()}` + if (key === pointerKey) return + pointerKey = key + clearOpenTimer() + const s = useStore.getState() + if (key === shownKey && s.linkPopover) { + clearCloseTimer() + return + } + // Moving onto another link starts the old popover's goodbye. + if (s.linkPopover?.mode === 'hover') scheduleHoverClose() + if (!s.linkPopoverOnHover) return + openTimer = setTimeout(() => { + openTimer = null + if (pointerKey !== key) return + const now = useStore.getState() + // Never swap out a popover the user is working in. + if (now.linkPopover?.mode === 'pinned' || !now.linkPopoverOnHover) return + const anchorRect = rect() + if (!anchorRect) return + if (requestLinkPopover({ target, sourcePath, anchorRect, mode: 'hover', focus: false })) { + shownKey = key + clearCloseTimer() + } + }, LINK_POPOVER_HOVER_DELAY_MS) +} + +/** The pointer left whatever link it was on. */ +export function pointerLeftWikilink(): void { + if (pointerKey === null) return + pointerKey = null + clearOpenTimer() + if (useStore.getState().linkPopover?.mode === 'hover') scheduleHoverClose() +} + +export function pointerEnteredLinkPopover(): void { + pointerOnPopover = true + clearCloseTimer() +} + +export function pointerLeftLinkPopover(): void { + pointerOnPopover = false + if (useStore.getState().linkPopover?.mode === 'hover') scheduleHoverClose() +} + +/** Forget any pending hover: the popover was closed some other way. */ +export function resetLinkPopoverHover(): void { + clearOpenTimer() + clearCloseTimer() + pointerKey = null + shownKey = null + pointerOnPopover = false +} diff --git a/packages/app-core/src/lib/link-popover.test.ts b/packages/app-core/src/lib/link-popover.test.ts new file mode 100644 index 00000000..dbd304e4 --- /dev/null +++ b/packages/app-core/src/lib/link-popover.test.ts @@ -0,0 +1,72 @@ +import { describe, expect, it } from 'vitest' +import { linkAnchorOffset, linkCreateDestination, linkPopoverTarget } from './link-popover' +import type { WikilinkReachContext } from './unresolved-links' + +// The link popover edits the note a wikilink opens, or offers to create the +// note it names. Everything else a wikilink can reach keeps its own surface. + +const context: WikilinkReachContext = { + notes: [ + { path: 'inbox/Current.md', title: 'Current', folder: 'inbox' }, + { path: 'inbox/Doc.md', title: 'Doc', folder: 'inbox' }, + { path: 'trash/Gone.md', title: 'Gone', folder: 'trash' } + ], + databases: [{ csvPath: 'Budget.base/data.csv', title: 'Budget' }], + assets: [{ path: 'assets/diagram.png' }] +} + +const at = (target: string) => linkPopoverTarget(target, 'inbox/Current.md', context) + +describe('linkPopoverTarget', () => { + it('shows the note a link opens, whatever the anchor or alias spelling', () => { + expect(at('Doc')).toEqual({ kind: 'note', path: 'inbox/Doc.md' }) + expect(at('doc#Heading')).toEqual({ kind: 'note', path: 'inbox/Doc.md' }) + expect(at('Doc^block')).toEqual({ kind: 'note', path: 'inbox/Doc.md' }) + }) + + it('offers to create a note no one has written yet, a trashed one included', () => { + expect(at('Garden Plan')).toEqual({ kind: 'missing' }) + expect(at('Gone')).toEqual({ kind: 'missing' }) + }) + + it('stays out of links into the note being read', () => { + expect(at('#Heading')).toBeNull() + expect(at('^block')).toBeNull() + expect(at('Current')).toBeNull() + }) + + it('stays out of databases, files and addresses outside the vault', () => { + expect(at('Budget')).toBeNull() + expect(at('assets/diagram.png')).toBeNull() + expect(at('https://example.com')).toBeNull() + expect(at('mailto:me@example.com')).toBeNull() + expect(at(' ')).toBeNull() + }) +}) + +describe('linkAnchorOffset', () => { + const body = '# Plan\n\nIntro.\n\n## Goals\n\nShip it. ^ship\n' + + it('lands a heading link on its heading and a block link on its block', () => { + expect(linkAnchorOffset(body, 'Plan#Goals')).toBe(body.indexOf('## Goals')) + expect(linkAnchorOffset(body, 'Plan#goals')).toBe(body.indexOf('## Goals')) + expect(linkAnchorOffset(body, 'Plan^ship')).toBe(body.indexOf('Ship it.')) + }) + + it('opens at the top for a plain link or an anchor the note lost', () => { + expect(linkAnchorOffset(body, 'Plan')).toBeNull() + expect(linkAnchorOffset(body, 'Plan#Gone')).toBeNull() + }) +}) + +describe('linkCreateDestination', () => { + it('names the folder creating the note would put it in', () => { + expect(linkCreateDestination('Garden Plan')).toEqual({ folder: 'inbox', subpath: '' }) + expect(linkCreateDestination('projects/Plan#Goals')).toEqual({ folder: 'inbox', subpath: 'projects' }) + expect(linkCreateDestination('archive/Old idea')).toEqual({ folder: 'archive', subpath: '' }) + }) + + it('has no destination for a name no file can carry', () => { + expect(linkCreateDestination('what?')).toBeNull() + }) +}) diff --git a/packages/app-core/src/lib/link-popover.ts b/packages/app-core/src/lib/link-popover.ts new file mode 100644 index 00000000..44281131 --- /dev/null +++ b/packages/app-core/src/lib/link-popover.ts @@ -0,0 +1,81 @@ +import { classifyApplicationLink } from '@shared/application-links' +import { externalUrlForLink } from './internal-links' +import { wikilinkReaches, type WikilinkReachContext } from './unresolved-links' +import { findBlockAnchor } from './block-anchors' +import { findHeadingForAnchor } from './heading-anchor' +import { parseOutline } from './outline' +import type { NoteFolder } from '@shared/ipc' +import { + isSameFileBlockLink, + isSameFileHeadingLink, + parseCreateNotePath, + resolveWikilinkTarget, + suggestCreateNotePath, + wikilinkBlockAnchor, + wikilinkHeadingAnchor +} from './wikilinks' + +/** How long the pointer rests on a link before its popover opens. Long + * enough that a pointer crossing the text on its way somewhere opens + * nothing. */ +export const LINK_POPOVER_HOVER_DELAY_MS = 500 + +/** How long a hover popover survives the pointer leaving the link or the + * popover, so the trip between the two does not close it. */ +export const LINK_POPOVER_LEAVE_GRACE_MS = 280 + +export type LinkPopoverTarget = { kind: 'note'; path: string } | { kind: 'missing' } + +/** + * What the link popover shows for a wikilink written in the note at + * `fromPath`: the note it opens, or an offer to create the note it names. + * Null for a link the popover has nothing to add to: one into the note + * being read (`[[#heading]]`, or the note's own name), a `.base` database, + * a file in the vault, or an address that opens outside the vault. + */ +export function linkPopoverTarget( + target: string, + fromPath: string, + context: WikilinkReachContext +): LinkPopoverTarget | null { + const name = target.trim() + if (!name) return null + if (externalUrlForLink(name, 'wikilink') || classifyApplicationLink(name)) return null + if (isSameFileHeadingLink(name) || isSameFileBlockLink(name)) return null + const note = resolveWikilinkTarget(context.notes, name) + if (note) return note.path === fromPath ? null : { kind: 'note', path: note.path } + // A database or a file: it has its own tab, and nothing to create. + if (wikilinkReaches(name, fromPath, context)) return null + return { kind: 'missing' } +} + +/** + * Where in `body` a link's anchor points: the heading of `[[Doc#Heading]]`, + * the block of `[[Doc^id]]`. Null for a plain link, or an anchor the note no + * longer carries; the popover then opens at the top, as following the link + * would. + */ +export function linkAnchorOffset(body: string, target: string): number | null { + const heading = wikilinkHeadingAnchor(target) + if (heading) return findHeadingForAnchor(parseOutline(body), heading)?.from ?? null + const block = wikilinkBlockAnchor(target) + if (block) return findBlockAnchor(body, block)?.from ?? null + return null +} + +/** + * Where creating the note a dead link names puts it: the top folder and the + * folders under it, as `gD` and the popover's Create would. Null for a link + * no file can be named after. Surfaces show the folder by its label, since a + * system folder can live under another directory name. + */ +export function linkCreateDestination( + target: string +): { folder: NoteFolder; subpath: string } | null { + try { + const parsed = parseCreateNotePath(suggestCreateNotePath(target)) + return { folder: parsed.folder, subpath: parsed.subpath } + } catch { + return null + } +} diff --git a/packages/app-core/src/lib/outline.test.ts b/packages/app-core/src/lib/outline.test.ts index a1adb392..e28178ba 100644 --- a/packages/app-core/src/lib/outline.test.ts +++ b/packages/app-core/src/lib/outline.test.ts @@ -67,6 +67,11 @@ describe('parseOutline — #249 code block with wikilinks', () => { expect(parseOutline(body).map((i) => i.text)).toEqual(['Real', 'Also real']) }) + it('skips headings inside a fence in a body with CRLF line endings', () => { + const body = ['# Real', '```sh', '# fake heading in code', '```', '# Also real', ''].join('\r\n') + expect(parseOutline(body).map((i) => i.text)).toEqual(['Real', 'Also real']) + }) + it('is unaffected by a single-backtick inline code span', () => { const body = ['# Section 1', '`[[Linux-Backup]]`', '# Section 2'].join('\n') expect(parseOutline(body).map((i) => i.text)).toEqual(['Section 1', 'Section 2']) diff --git a/packages/app-core/src/lib/pane-layout.test.ts b/packages/app-core/src/lib/pane-layout.test.ts index 696cd728..267d82f2 100644 --- a/packages/app-core/src/lib/pane-layout.test.ts +++ b/packages/app-core/src/lib/pane-layout.test.ts @@ -1,5 +1,6 @@ import { describe, expect, it } from 'vitest' import { + activeTabWasPicked, leafWithAddedTab, leafWithPinnedTab, leafWithPreviewTab, @@ -181,3 +182,40 @@ describe('preserveLayoutIfPruneEmptiesNoteTabs (#384)', () => { expect(preserveLayoutIfPruneEmptiesNoteTabs(prev, pruned, isVirtual)).toBe(pruned) }) }) + +describe('activeTabWasPicked', () => { + const only = (layout: ReturnType): PaneLeaf => { + if (layout.kind !== 'leaf') throw new Error('expected a leaf') + return layout + } + + it('marks a leaf whose active note was dropped', () => { + const base = leaf({ tabs: ['old.md', 'b.md', 'c.md'], activeTab: 'c.md' }) + const next = only(rewritePathsInTree(base, (p) => (p === 'c.md' ? null : p))) + expect(next.activeTab).toBe('old.md') + expect(activeTabWasPicked(next)).toBe(true) + }) + + it('marks a leaf that showed no tab (a phone on Home)', () => { + const base = leaf({ tabs: ['old.md', 'b.md'], activeTab: null }) + const next = only(rewritePathsInTree(base, (p) => p)) + expect(next.activeTab).toBe('old.md') + expect(activeTabWasPicked(next)).toBe(true) + }) + + it('does not mark a leaf whose active note was renamed or kept', () => { + const base = leaf({ tabs: ['old.md', 'b.md'], activeTab: 'b.md' }) + const renamed = only(rewritePathsInTree(base, (p) => (p === 'b.md' ? 'moved/b.md' : p))) + expect(renamed.activeTab).toBe('moved/b.md') + expect(activeTabWasPicked(renamed)).toBe(false) + const kept = only(rewritePathsInTree(base, (p) => (p === 'old.md' ? null : p))) + expect(kept.activeTab).toBe('b.md') + expect(activeTabWasPicked(kept)).toBe(false) + }) + + it('forgets the mark on the next change to the leaf', () => { + const base = leaf({ tabs: ['old.md', 'b.md'], activeTab: 'b.md' }) + const picked = only(rewritePathsInTree(base, (p) => (p === 'b.md' ? null : p))) + expect(activeTabWasPicked(leafWithAddedTab(picked, 'c.md'))).toBe(false) + }) +}) diff --git a/packages/app-core/src/lib/pane-layout.ts b/packages/app-core/src/lib/pane-layout.ts index 241120ae..408d78e2 100644 --- a/packages/app-core/src/lib/pane-layout.ts +++ b/packages/app-core/src/lib/pane-layout.ts @@ -257,6 +257,7 @@ export function rewritePathsInTree( nextActive = mappedActive } } + const picked = !nextActive if (!nextActive) nextActive = nextTabs[0] let nextPreview: string | null = null if (leaf.previewTab) { @@ -265,17 +266,32 @@ export function rewritePathsInTree( nextPreview = mappedPreview } } - return enforcePinnedPrefix({ + const next = enforcePinnedPrefix({ ...leaf, tabs: nextTabs, pinnedTabs: nextPinned, activeTab: nextActive, previewTab: nextPreview }) + if (picked) leavesWithPickedTab.add(next) + return next }) return result ?? makeLeaf() } +/** + * Leaves whose active tab `rewritePathsInTree` chose on its own, because the + * note they showed was dropped (trashed, archived, deleted) or because they + * showed none (a phone's Home). Desktop wants that choice: its tab strip shows + * where it landed. A shell that hides tabs reads this to show Home instead of + * a hidden tab the user never asked for (see `installHomeGuard`). + */ +const leavesWithPickedTab = new WeakSet() + +export function activeTabWasPicked(leaf: PaneLeaf): boolean { + return leavesWithPickedTab.has(leaf) +} + /** * Guard against a note-list refresh closing *every* open note tab at once. * diff --git a/packages/app-core/src/lib/search-palette-rows.test.ts b/packages/app-core/src/lib/search-palette-rows.test.ts new file mode 100644 index 00000000..224afa0a --- /dev/null +++ b/packages/app-core/src/lib/search-palette-rows.test.ts @@ -0,0 +1,160 @@ +import { describe, expect, it } from 'vitest' +import type { NoteMeta } from '@shared/ipc' +import { extractTagBlocks } from '@shared/tag-blocks' +import { buildSearchPaletteRows, type SearchPaletteRow } from './search-palette-rows' + +function note(path: string, title: string, updatedAt = 0): NoteMeta { + return { + path, + title, + folder: 'inbox', + siblingOrder: 0, + createdAt: 0, + updatedAt, + size: 0, + tags: [], + wikilinks: [], + assetEmbeds: [], + hasAttachments: false, + excerpt: '' + } +} + +const ideas = note('inbox/Ideas.md', 'Ideas', 3) +const journal = note('inbox/Journal.md', 'Journal', 2) +const deep = note('inbox/Deep.md', 'Deep', 1) +const plain = note('inbox/Plain.md', 'Plain', 0) + +const blocksByPath = new Map([ + [ + ideas.path, + extractTagBlocks( + [ + '- Recipe gallery #idea', + '- Plugin store #idea', + '- Dark mode #idea #later', + '- Zine #idea', + '- Groceries' + ].join('\n') + ) + ], + [journal.path, extractTagBlocks('Woke up.\n\nWrite a zine about walking #idea')], + [deep.path, extractTagBlocks('# Deep\n\nLots of prose.\n\n- Gallery wall for the hallway #idea')], + [plain.path, extractTagBlocks('---\ntags: [idea]\n---\nOnly frontmatter.')] +]) + +const shape = (rows: SearchPaletteRow[]): string[] => + rows.map((r) => + r.kind === 'note' + ? r.note.title + : r.kind === 'more' + ? ` +${r.hidden} more` + : ` L${r.block.startLine + 1} ${r.block.text}` + ) + +const base = { + tagged: [ideas, journal, deep, plain], + blocksByPath, + freeText: '', + enabled: true, + limit: 20 +} + +describe('buildSearchPaletteRows', () => { + it('lists two tagged blocks per note, then a row for the rest', () => { + const rows = buildSearchPaletteRows({ + ...base, + results: [ideas, journal, plain], + tagTokens: ['idea'] + }) + expect(shape(rows)).toEqual([ + 'Ideas', + ' L1 Recipe gallery #idea', + ' L2 Plugin store #idea', + ' +2 more', + 'Journal', + ' L3 Write a zine about walking #idea', + 'Plain' + ]) + }) + + it('puts blocks carrying every query tag first, then those carrying any', () => { + const rows = buildSearchPaletteRows({ + ...base, + results: [ideas], + tagTokens: ['idea', 'later'] + }) + expect(shape(rows)).toEqual(['Ideas', ' L3 Dark mode #idea #later', ' L1 Recipe gallery #idea', ' +2 more']) + }) + + it('narrows blocks to the free text and lists a note found by a deep block first', () => { + const rows = buildSearchPaletteRows({ + ...base, + // The search ranked Ideas (excerpt) and Plain (title); Deep matched neither. + results: [plain, ideas], + tagTokens: ['idea'], + freeText: 'gallery' + }) + expect(shape(rows)).toEqual([ + 'Ideas', + ' L1 Recipe gallery #idea', + 'Deep', + ' L5 Gallery wall for the hallway #idea', + 'Plain' + ]) + }) + + it('keeps a note that matched only by title as a plain row', () => { + const rows = buildSearchPaletteRows({ + ...base, + results: [journal], + tagTokens: ['idea'], + freeText: 'journal' + }) + expect(shape(rows)).toEqual(['Journal']) + }) + + it('counts the rest of the narrowed blocks, not every tagged block', () => { + const rows = buildSearchPaletteRows({ + ...base, + results: [ideas], + tagTokens: ['idea'], + // Three of the four tagged blocks contain an "r"; "Zine" does not. + freeText: 'r' + }) + expect(shape(rows).filter((r) => r.includes('more'))).toEqual([' +1 more']) + }) + + it('lists plain note rows without a tag in the query', () => { + const rows = buildSearchPaletteRows({ ...base, results: [ideas, journal], tagTokens: [] }) + expect(shape(rows)).toEqual(['Ideas', 'Journal']) + }) + + it('lists plain note rows, exactly the results, with the setting off', () => { + const rows = buildSearchPaletteRows({ + ...base, + results: [plain, ideas], + tagTokens: ['idea'], + freeText: 'gallery', + enabled: false + }) + expect(rows.map((r) => r.kind)).toEqual(['note', 'note']) + expect(shape(rows)).toEqual(['Plain', 'Ideas']) + }) + + it('caps the note rows at the limit', () => { + const rows = buildSearchPaletteRows({ + ...base, + results: [plain], + tagTokens: ['idea'], + freeText: 'a', + limit: 2 + }) + expect(rows.filter((r) => r.kind === 'note')).toHaveLength(2) + }) + + it('gives every row a distinct key', () => { + const rows = buildSearchPaletteRows({ ...base, results: [ideas, journal], tagTokens: ['idea'] }) + expect(new Set(rows.map((r) => r.key)).size).toBe(rows.length) + }) +}) diff --git a/packages/app-core/src/lib/search-palette-rows.ts b/packages/app-core/src/lib/search-palette-rows.ts new file mode 100644 index 00000000..6fbe2441 --- /dev/null +++ b/packages/app-core/src/lib/search-palette-rows.ts @@ -0,0 +1,104 @@ +import type { NoteMeta } from '@shared/ipc' +import type { TagBlock } from '@shared/tag-blocks' + +/** Tagged blocks listed under one note before the "+N more" row (#837). */ +export const SEARCH_BLOCKS_PER_NOTE = 2 + +/** + * A row of the Search notes palette. With a `#tag` in the query (and the + * "Show tagged blocks in note search" setting on), a note is followed by up to + * SEARCH_BLOCKS_PER_NOTE of its tagged blocks and, when it has more, a row + * that opens the rest in the Tags view. The create row stays last and is + * added by the palette itself. + */ +export type SearchPaletteRow = + | { kind: 'note'; key: string; note: NoteMeta } + | { kind: 'block'; key: string; note: NoteMeta; block: TagBlock } + | { kind: 'more'; key: string; note: NoteMeta; hidden: number } + +export interface SearchPaletteRowInput { + /** The ranked note results, as `searchNoteIndex` returns them. */ + results: readonly NoteMeta[] + /** Every listable note carrying all the query's tags. With free text, a note + * whose tagged block matches it is listed even when its title, path and + * excerpt do not, since the idea can sit anywhere in the body. */ + tagged: readonly NoteMeta[] + blocksByPath: ReadonlyMap + /** The query's `#tag` tokens, lowercased. */ + tagTokens: readonly string[] + freeText: string + /** The "Show tagged blocks in note search" setting. */ + enabled: boolean + /** Most note rows to list. */ + limit: number +} + +/** + * Build the palette's rows. + * + * Without a tag, or with the setting off, every result is a plain note row, + * exactly the list the palette always showed. With tags, notes must still + * carry all of them (the search already decided that); under each note the + * blocks carrying ANY of the tags are listed, those carrying all of them + * first, then in document order. + * + * Free text after the tags narrows the blocks to those whose text contains it + * (the Tags view filter's rule), and a note with a matching block is listed + * first. A note that matched only by its title, path or excerpt is a plain + * note row: its blocks did not match what was typed. + */ +export function buildSearchPaletteRows(input: SearchPaletteRowInput): SearchPaletteRow[] { + const { results, tagged, blocksByPath, tagTokens, enabled, limit } = input + if (!enabled || tagTokens.length === 0) { + return results.map((note) => ({ kind: 'note', key: note.path, note })) + } + + const wanted = new Set(tagTokens.map((t) => t.toLowerCase())) + const q = input.freeText.trim().toLowerCase() + + const blocksFor = (note: NoteMeta): TagBlock[] => { + const carrying = (blocksByPath.get(note.path) ?? []).filter((block) => + block.tags.some((tag) => wanted.has(tag.toLowerCase())) + ) + const narrowed = q ? carrying.filter((block) => block.text.toLowerCase().includes(q)) : carrying + const carriesAll = (block: TagBlock): boolean => { + const have = new Set(block.tags.map((tag) => tag.toLowerCase())) + for (const tag of wanted) if (!have.has(tag)) return false + return true + } + // Stable: blocks carrying every tag keep their document order, then the rest. + return [...narrowed.filter(carriesAll), ...narrowed.filter((b) => !carriesAll(b))] + } + + let notes: readonly NoteMeta[] = results + if (q) { + const rank = new Map(results.map((note, i) => [note.path, i])) + const withBlocks = tagged + .filter((note) => blocksFor(note).length > 0) + .sort( + (a, b) => + (rank.get(a.path) ?? Infinity) - (rank.get(b.path) ?? Infinity) || + b.updatedAt - a.updatedAt + ) + const listed = new Set(withBlocks.map((note) => note.path)) + notes = [...withBlocks, ...results.filter((note) => !listed.has(note.path))].slice(0, limit) + } + + const rows: SearchPaletteRow[] = [] + for (const note of notes) { + rows.push({ kind: 'note', key: note.path, note }) + const blocks = blocksFor(note) + for (const block of blocks.slice(0, SEARCH_BLOCKS_PER_NOTE)) { + rows.push({ kind: 'block', key: `${note.path}\0${block.startLine}`, note, block }) + } + if (blocks.length > SEARCH_BLOCKS_PER_NOTE) { + rows.push({ + kind: 'more', + key: `${note.path}\0more`, + note, + hidden: blocks.length - SEARCH_BLOCKS_PER_NOTE + }) + } + } + return rows +} diff --git a/packages/app-core/src/lib/self-keyed-surfaces.ts b/packages/app-core/src/lib/self-keyed-surfaces.ts index eded9841..9f9b4953 100644 --- a/packages/app-core/src/lib/self-keyed-surfaces.ts +++ b/packages/app-core/src/lib/self-keyed-surfaces.ts @@ -29,7 +29,10 @@ export const SELF_KEYED_SURFACES = [ '[data-workflow-list-pane]', '[data-workflow-canvas]', // Owns bracket region navigation before global Vim buffer prefixes. - '[data-atlas-view]' + '[data-atlas-view]', + // The link popover: its editor and its Create button own every key, and + // its Escape closes it rather than walking the sidebar. + '[data-link-popover]' ].join(', ') /** diff --git a/packages/app-core/src/lib/settings-navigation.ts b/packages/app-core/src/lib/settings-navigation.ts index dd5cf5e5..0012fc67 100644 --- a/packages/app-core/src/lib/settings-navigation.ts +++ b/packages/app-core/src/lib/settings-navigation.ts @@ -1,8 +1,15 @@ /** Settings pages other surfaces can open directly: the Cloud page from the * status bar, Space r and the palette (it lands on This vault, where what * they reported waits), the Keymaps page from `:unbind` when the action id - * is missing or unknown, the CLI page from Open CLI Settings. */ -export type SettingsNavigationTarget = "cloud" | "keymaps" | "external-links" | "about" | "cli"; + * is missing or unknown, the CLI page from Open CLI Settings, and Periodic + * notes from the phones' Calendar entry while daily notes are off. */ +export type SettingsNavigationTarget = + | "cloud" + | "keymaps" + | "external-links" + | "about" + | "cli" + | "periodic-notes"; let pendingSettingsTarget: SettingsNavigationTarget | null = null; diff --git a/packages/app-core/src/lib/settings-search.test.ts b/packages/app-core/src/lib/settings-search.test.ts index 22fa37d8..7aa2a4bd 100644 --- a/packages/app-core/src/lib/settings-search.test.ts +++ b/packages/app-core/src/lib/settings-search.test.ts @@ -1,5 +1,5 @@ import { describe, expect, it } from 'vitest' -import { getSettingsSearchResults } from './settings-search' +import { getSettingsSearchResults, inNavigationOrder } from './settings-search' const categories = [ { @@ -118,3 +118,32 @@ describe('getSettingsSearchResults', () => { }) }) }) + +// #993: Ctrl+J/K walk the results list, which with an empty search used to +// follow the definition order while the nav showed the section order. +describe('inNavigationOrder', () => { + const cat = (id: string) => ({ id, title: id, description: '', keywords: [] }) + const defined = ['appearance', 'editor', 'keymaps', 'tasks', 'typography', 'cloud', 'vault'].map(cat) + const nav = ['appearance', 'typography', 'editor', 'tasks', 'keymaps', 'vault', 'cloud'] + + it('puts the categories in the order the navigation shows them', () => { + expect(inNavigationOrder(defined, nav).map((c) => c.id)).toEqual(nav) + }) + + it('so the empty-search results Ctrl+J walks match the nav', () => { + const results = getSettingsSearchResults(inNavigationOrder(defined, nav), '') + expect(results.map((r) => r.category.id)).toEqual(nav) + }) + + it('keeps categories the order does not name, after the named ones', () => { + const ids = inNavigationOrder([cat('extra'), ...defined], ['vault', 'appearance']).map((c) => c.id) + expect(ids.slice(0, 2)).toEqual(['vault', 'appearance']) + expect(ids.slice(2)).toEqual(['extra', 'editor', 'keymaps', 'tasks', 'typography', 'cloud']) + }) + + it('leaves the input untouched', () => { + const input = [...defined] + inNavigationOrder(input, nav) + expect(input.map((c) => c.id)).toEqual(defined.map((c) => c.id)) + }) +}) diff --git a/packages/app-core/src/lib/settings-search.ts b/packages/app-core/src/lib/settings-search.ts index 70f3cd25..edbbc52b 100644 --- a/packages/app-core/src/lib/settings-search.ts +++ b/packages/app-core/src/lib/settings-search.ts @@ -85,6 +85,25 @@ function settingResult( } } +/** + * Categories in the order the navigation shows them, which groups them by + * section and so differs from the order they are defined in. The results + * list is built from this, and Ctrl+J/K (and the arrows) walk that list even + * while the search is empty, so a definition-order list sent the keys + * skipping back and forth through the categories on screen. (#993) + * Categories the order does not name follow, in their own order. + */ +export function inNavigationOrder( + categories: readonly TCategory[], + order: readonly string[] +): TCategory[] { + const rank = (id: string): number => { + const at = order.indexOf(id) + return at === -1 ? order.length : at + } + return [...categories].sort((a, b) => rank(a.id) - rank(b.id)) +} + export function getSettingsSearchResults( categories: TCategory[], query: string diff --git a/packages/app-core/src/lib/sidebar-cursor.test.ts b/packages/app-core/src/lib/sidebar-cursor.test.ts new file mode 100644 index 00000000..29679ad9 --- /dev/null +++ b/packages/app-core/src/lib/sidebar-cursor.test.ts @@ -0,0 +1,288 @@ +// @vitest-environment jsdom + +import { beforeEach, describe, expect, it } from 'vitest' +import { + anchorSidebarCursor, + findSidebarCursorRow, + sidebarCursorFallbackInDom, + sidebarCursorNeighbors, + sidebarRowIdentity +} from './sidebar-cursor' + +type Attrs = Record + +const noteKey = (path: string): string => `note:${encodeURIComponent(path)}` +const folderKey = (subpath: string): string => `folder:inbox:${encodeURIComponent(subpath)}` + +/** A tree note row, with the attributes NoteLeaf (and its placeholder) carry. */ +const note = (idx: number, path: string): [number, Attrs] => [ + idx, + { 'data-sidebar-type': 'note', 'data-sidebar-path': path, 'data-sidebar-select-key': noteKey(path) } +] +/** A tree folder row, with the attributes the folder row carries. */ +const folder = (idx: number, subpath: string): [number, Attrs] => [ + idx, + { + 'data-sidebar-type': 'folder', + 'data-sidebar-folder': 'inbox', + 'data-sidebar-subpath': subpath, + 'data-sidebar-key': `inbox:${subpath}`, + 'data-sidebar-expandable': 'false', + 'data-sidebar-collapsed': 'true', + 'data-sidebar-select-key': folderKey(subpath) + } +] +const plain = (idx: number, type: string): [number, Attrs] => [idx, { 'data-sidebar-type': type }] + +const escapeHtml = (value: string): string => + value.replace(/&/g, '&').replace(/"/g, '"').replace(/, hidden: number[] = []): void { + document.body.innerHTML = rows + .map(([idx, attrs]) => { + const rendered = Object.entries(attrs) + .map(([name, value]) => `${name}="${escapeHtml(value)}"`) + .join(' ') + return `` + }) + .join('') + document.querySelectorAll('[data-sidebar-idx]').forEach((el) => { + const idx = Number(el.dataset.sidebarIdx) + el.getClientRects = (() => + (hidden.includes(idx) ? [] : [{ width: 200, height: 24 }]) as unknown as DOMRectList) as never + }) +} + +const pathAt = (idx: number): string | null => + document.querySelector(`[data-sidebar-idx="${idx}"]`)?.getAttribute('data-sidebar-path') ?? + document.querySelector(`[data-sidebar-idx="${idx}"]`)?.getAttribute('data-sidebar-subpath') ?? + null + +beforeEach(() => { + document.body.innerHTML = '' +}) + +// The measured repro: a folder numbers its notes before the subfolders it +// shows above them, so a note written from outside the app renumbers rows +// the cursor sits on, and the cursor used to stay on the number. +describe('keeping the sidebar cursor on its row', () => { + const before: Array<[number, Attrs]> = [ + plain(0, 'vault'), + folder(9, ''), + folder(12, 'Areas'), + folder(13, 'Projects'), + folder(14, 'Reading'), + note(10, 'inbox/Another.md'), + note(11, 'inbox/Open note.md'), + plain(15, 'archive') + ] + const afterOutsideWrite: Array<[number, Attrs]> = [ + plain(0, 'vault'), + folder(9, ''), + folder(13, 'Areas'), + folder(14, 'Projects'), + folder(15, 'Reading'), + note(10, 'inbox/Another.md'), + note(11, 'inbox/Churn.md'), + note(12, 'inbox/Open note.md'), + plain(16, 'archive') + ] + + it('follows its row to the new number after an outside write renumbers it', () => { + renderRows(before) + const anchor = anchorSidebarCursor(document, 12) + expect(anchor).not.toBeNull() + renderRows(afterOutsideWrite) + // The old number now names another row; the anchor still finds Areas. + expect(pathAt(12)).toBe('inbox/Open note.md') + expect(findSidebarCursorRow(document, anchor!)).toBe(13) + expect(pathAt(13)).toBe('Areas') + }) + + it('stays on a row whose number did not change', () => { + renderRows(before) + const anchor = anchorSidebarCursor(document, 10)! + renderRows(afterOutsideWrite) + expect(findSidebarCursorRow(document, anchor)).toBe(10) + }) + + it('has no anchor for a number no row carries', () => { + renderRows(before) + expect(anchorSidebarCursor(document, 99)).toBeNull() + }) + + it('reads a folder by its identity, not its open or closed state', () => { + renderRows(before) + const anchor = anchorSidebarCursor(document, 12)! + renderRows( + before.map(([idx, attrs]) => + idx === 12 ? [idx, { ...attrs, 'data-sidebar-collapsed': 'false' }] : [idx, attrs] + ) + ) + expect(findSidebarCursorRow(document, anchor)).toBe(12) + }) + + it('tells a tree note from the same note pinned under Favorites', () => { + const favorite: [number, Attrs] = [ + 1, + { 'data-sidebar-type': 'note', 'data-sidebar-path': 'inbox/Open note.md' } + ] + renderRows([plain(0, 'vault'), favorite, note(11, 'inbox/Open note.md')]) + const tree = anchorSidebarCursor(document, 11)! + const pinned = anchorSidebarCursor(document, 1)! + expect(tree.identity).not.toBe(pinned.identity) + // A second favorite above both renumbers them. + renderRows([ + plain(0, 'vault'), + [1, { 'data-sidebar-type': 'note', 'data-sidebar-path': 'inbox/Another.md' }], + [2, favorite[1]], + note(12, 'inbox/Open note.md') + ]) + expect(findSidebarCursorRow(document, tree)).toBe(12) + expect(findSidebarCursorRow(document, pinned)).toBe(2) + }) + + it('tells twins apart by their order (Atlas shares Workflows type)', () => { + renderRows([plain(0, 'vault'), plain(1, 'tasks'), plain(2, 'workflows'), plain(3, 'workflows')]) + const atlas = anchorSidebarCursor(document, 3)! + const workflows = anchorSidebarCursor(document, 2)! + expect(atlas.occurrence).toBe(1) + expect(workflows.occurrence).toBe(0) + // A favorite above them moves both down one. + renderRows([ + plain(0, 'vault'), + note(1, 'inbox/Pinned.md'), + plain(2, 'tasks'), + plain(3, 'workflows'), + plain(4, 'workflows') + ]) + expect(findSidebarCursorRow(document, atlas)).toBe(4) + expect(findSidebarCursorRow(document, workflows)).toBe(3) + // With one twin left, either anchor lands on it: it is also the row next door. + renderRows([plain(0, 'vault'), plain(1, 'tasks'), plain(2, 'workflows')]) + expect(findSidebarCursorRow(document, atlas)).toBe(2) + }) + + it('treats a windowed placeholder and its full row as one row', () => { + document.body.innerHTML = `
` + const anchor = anchorSidebarCursor(document, 20)! + document.body.innerHTML = `` + expect(findSidebarCursorRow(document, anchor)).toBe(21) + }) + + it('copes with quotes and backslashes in a path', () => { + const odd = 'inbox/He said "hi" \\ there.md' + renderRows([note(4, 'inbox/a.md'), note(5, odd)]) + const anchor = anchorSidebarCursor(document, 5)! + renderRows([note(4, 'inbox/a.md'), note(5, 'inbox/b.md'), note(6, odd)]) + expect(findSidebarCursorRow(document, anchor)).toBe(6) + expect(sidebarRowIdentity(document.querySelector('[data-sidebar-idx="6"]')!)).toBe(anchor.identity) + }) +}) + +describe('when the cursor row is gone', () => { + it('reports it gone', () => { + renderRows([note(10, 'inbox/a.md'), note(11, 'inbox/b.md')]) + const anchor = anchorSidebarCursor(document, 11)! + renderRows([note(10, 'inbox/a.md')]) + expect(findSidebarCursorRow(document, anchor)).toBeNull() + }) + + it('takes the row that now sits where it sat', () => { + // Display order: Areas, Reading, a, b, c. Deleting `b` (ordinal 3) leaves `c` there. + renderRows([folder(12, 'Areas'), folder(13, 'Reading'), note(9, 'inbox/a.md'), note(10, 'inbox/b.md'), note(11, 'inbox/c.md')]) + const anchor = anchorSidebarCursor(document, 10)! + expect(anchor.ordinal).toBe(3) + renderRows([folder(11, 'Areas'), folder(12, 'Reading'), note(9, 'inbox/a.md'), note(10, 'inbox/c.md')]) + expect(findSidebarCursorRow(document, anchor)).toBeNull() + expect(sidebarCursorFallbackInDom(document, anchor)).toBe(10) + expect(pathAt(10)).toBe('inbox/c.md') + }) + + it('takes the renamed row when a rename keeps its place', () => { + renderRows([note(9, 'inbox/a.md'), note(10, 'inbox/b.md'), note(11, 'inbox/c.md')]) + const anchor = anchorSidebarCursor(document, 10)! + renderRows([note(9, 'inbox/a.md'), note(10, 'inbox/bb.md'), note(11, 'inbox/c.md')]) + expect(findSidebarCursorRow(document, anchor)).toBeNull() + expect(sidebarCursorFallbackInDom(document, anchor)).toBe(10) + }) + + it('takes the row before it when it was the last one', () => { + renderRows([note(9, 'inbox/a.md'), note(10, 'inbox/b.md')]) + const anchor = anchorSidebarCursor(document, 10)! + renderRows([note(9, 'inbox/a.md')]) + expect(sidebarCursorFallbackInDom(document, anchor)).toBe(9) + }) + + it('skips rows that are not laid out', () => { + renderRows([note(9, 'inbox/a.md'), note(10, 'inbox/b.md'), note(11, 'inbox/c.md'), note(12, 'inbox/d.md')]) + const anchor = anchorSidebarCursor(document, 10)! + renderRows([note(9, 'inbox/a.md'), note(11, 'inbox/c.md'), note(12, 'inbox/d.md')], [11]) + expect(sidebarCursorFallbackInDom(document, anchor)).toBe(12) + }) + + // The measured layout: the Inbox tree, then the System section. + function renderTree(): void { + document.body.innerHTML = ` +
+ +
+
+ +
+
+ + +
+
+
` + document.querySelectorAll('[data-sidebar-idx]').forEach((el) => { + el.getClientRects = (() => [{ width: 200, height: 24 }] as unknown as DOMRectList) as never + }) + } + const removeRow = (idx: number): void => document.querySelector(`[data-sidebar-idx="${idx}"]`)!.remove() + + it('stays in the folder when the gone row was its last one', () => { + // Deleting Inbox's last note used to hand the cursor to Archive, a section away. + renderTree() + const anchor = anchorSidebarCursor(document, 11)! + removeRow(11) + expect(sidebarCursorFallbackInDom(document, anchor)).toBe(10) + }) + + it('takes the row in its place from the middle of a folder', () => { + renderTree() + const anchor = anchorSidebarCursor(document, 10)! + removeRow(10) + expect(sidebarCursorFallbackInDom(document, anchor)).toBe(11) + }) + + it('goes up to the folder when its only note goes', () => { + renderTree() + const anchor = anchorSidebarCursor(document, 13)! + removeRow(13) + expect(sidebarCursorFallbackInDom(document, anchor)).toBe(12) + }) + + it('finds no neighbor in an empty or hidden sidebar', () => { + expect(sidebarCursorNeighbors([], 3)).toEqual({ after: -1, before: -1 }) + expect(sidebarCursorNeighbors([{ index: 4, rendered: false }], 0)).toEqual({ after: -1, before: -1 }) + renderRows([note(9, 'inbox/a.md')]) + const anchor = anchorSidebarCursor(document, 9)! + document.body.innerHTML = '' + expect(sidebarCursorFallbackInDom(document, anchor)).toBeNull() + }) + + it('looks back from past the end, and never lands on a row without a number', () => { + const rows = [ + { index: 2, rendered: true }, + { index: -1, rendered: true }, + { index: 7, rendered: false } + ] + expect(sidebarCursorNeighbors(rows, 9)).toEqual({ after: -1, before: 0 }) + expect(sidebarCursorNeighbors(rows, 1)).toEqual({ after: -1, before: 0 }) + expect(sidebarCursorNeighbors(rows, 0)).toEqual({ after: 0, before: -1 }) + }) +}) diff --git a/packages/app-core/src/lib/sidebar-cursor.ts b/packages/app-core/src/lib/sidebar-cursor.ts new file mode 100644 index 00000000..f0290011 --- /dev/null +++ b/packages/app-core/src/lib/sidebar-cursor.ts @@ -0,0 +1,177 @@ +/** + * The sidebar's Vim cursor is a row NUMBER: `sidebarCursorIndex` names the row + * whose `data-sidebar-idx` matches it. Sidebar hands those numbers out in + * render order on every render, and render order is not even display order (a + * folder numbers its notes before the subfolders it shows above them). So when + * the listing changes under the cursor (a note written from outside the app, a + * sync), every row numbered after the change moves up or down one, and the + * cursor silently lands on whichever row inherits its number. + * + * The number stays the cursor (VimNav, panel-rows and the windowed rows all + * speak it). What this adds is a note of which row the number named, taken + * from the DOM when the cursor moves, so that Sidebar can put the number back + * on that row after a render renumbers it. + */ + +export interface SidebarCursorAnchor { + /** The cursor's `data-sidebar-idx` when the anchor was taken. */ + index: number + /** What the row is, from its identifying attributes (see sidebarRowIdentity). */ + identity: string + /** Matches the row and any twin that shares its identity. */ + selector: string + /** Which of those twins it is, in document order. Atlas and Workflows are + * both `data-sidebar-type="workflows"` with nothing else to tell them apart. */ + occurrence: number + /** Its position among all sidebar rows in document order, to find the row + * that took its place when it goes away. */ + ordinal: number + /** Its ancestor elements, nearest first, to tell which neighbor shared its + * folder when it goes away. */ + ancestors: Element[] +} + +const ROW_SELECTOR = '[data-sidebar-idx]' + +/** The attributes that say which row a row is. Display state (collapsed, + * expandable, the number itself) is left out on purpose. */ +const IDENTITY_ATTRIBUTES = [ + 'data-sidebar-type', + 'data-sidebar-select-key', + 'data-sidebar-path', + 'data-sidebar-key', + 'data-sidebar-folder', + 'data-sidebar-subpath', + 'data-sidebar-tag', + 'data-sidebar-datenav-key', + 'data-sidebar-database' +] as const + +function escapeForAttr(value: string): string { + if (typeof CSS !== 'undefined' && typeof CSS.escape === 'function') return CSS.escape(value) + return value.replace(/["\\]/g, '\\$&') +} + +function rowIndex(row: Element): number { + const value = Number(row.getAttribute('data-sidebar-idx')) + return Number.isInteger(value) && value >= 0 ? value : -1 +} + +/** + * A row's identity. A tree note and the same note pinned under Favorites are + * different rows (only the tree row carries a select key), while a windowed + * placeholder carries the attributes of the full row it stands in for, so the + * two read as one row. + */ +export function sidebarRowIdentity(row: Element): string { + return JSON.stringify(IDENTITY_ATTRIBUTES.map((name) => row.getAttribute(name))) +} + +function sidebarRowSelector(row: Element): string { + let selector = ROW_SELECTOR + for (const name of IDENTITY_ATTRIBUTES) { + const value = row.getAttribute(name) + if (value !== null) selector += `[${name}="${escapeForAttr(value)}"]` + } + return selector +} + +function rowTwins(root: ParentNode, selector: string, identity: string): Element[] { + return [...root.querySelectorAll(selector)].filter((row) => sidebarRowIdentity(row) === identity) +} + +/** The anchor for the row numbered `index`, or null when no row has it. */ +export function anchorSidebarCursor(root: ParentNode, index: number): SidebarCursorAnchor | null { + const rows = [...root.querySelectorAll(ROW_SELECTOR)] + const ordinal = rows.findIndex((row) => rowIndex(row) === index) + if (ordinal < 0) return null + const row = rows[ordinal] + const identity = sidebarRowIdentity(row) + const selector = sidebarRowSelector(row) + const ancestors: Element[] = [] + for (let node = row.parentElement; node; node = node.parentElement) ancestors.push(node) + return { + index, + identity, + selector, + occurrence: Math.max(0, rowTwins(root, selector, identity).indexOf(row)), + ordinal, + ancestors + } +} + +/** + * The number the anchored row has now, or null when it is gone. A twin that + * went away takes its neighbor twin's place, which is also the row next to it. + */ +export function findSidebarCursorRow(root: ParentNode, anchor: SidebarCursorAnchor): number | null { + const twins = rowTwins(root, anchor.selector, anchor.identity) + if (twins.length === 0) return null + const index = rowIndex(twins[Math.min(anchor.occurrence, twins.length - 1)]) + return index >= 0 ? index : null +} + +/** + * The rows on either side of where a gone row sat, as positions in `rows` + * (-1 for none): the one that now sits in its place, and the one before it. + * Rows the browser does not lay out are skipped, the way the j/k row scan + * skips them, and so are rows without a number. + */ +export function sidebarCursorNeighbors( + rows: readonly { index: number; rendered: boolean }[], + ordinal: number +): { after: number; before: number } { + const usable = (i: number): boolean => rows[i].index >= 0 && rows[i].rendered + const start = Math.min(Math.max(ordinal, 0), rows.length) + let after = start + while (after < rows.length && !usable(after)) after++ + let before = start - 1 + while (before >= 0 && !usable(before)) before-- + return { after: after < rows.length ? after : -1, before } +} + +/** How far up from `row` the nearest ancestor it shares with the anchored + * row is; Infinity when it shares none. */ +function treeDistance(row: Element, ancestors: readonly Element[]): number { + for (let node = row.parentElement; node; node = node.parentElement) { + const at = ancestors.indexOf(node) + if (at >= 0) return at + } + return Infinity +} + +/** + * Where the cursor goes when its row is gone (deleted, moved away, renamed to + * another sort position): the row that now sits where it sat, so a note + * renamed without changing its place keeps the cursor. When the row before + * it is closer in the tree (the gone row was the last one in its folder, and + * the row in its place belongs to another folder or another sidebar section), + * the cursor stays in the folder and takes that one instead. + */ +export function sidebarCursorFallbackInDom( + root: ParentNode, + anchor: Pick +): number | null { + // Only reached when the cursor's row is gone, so the layout reads stay off + // the path every render takes. + const rows = [...root.querySelectorAll(ROW_SELECTOR)] + const { after, before } = sidebarCursorNeighbors( + rows.map((row) => ({ + index: rowIndex(row), + get rendered() { + return row.getClientRects().length > 0 + } + })), + anchor.ordinal + ) + if (after < 0 && before < 0) return null + const pick = + after < 0 + ? before + : before < 0 + ? after + : treeDistance(rows[before], anchor.ancestors) < treeDistance(rows[after], anchor.ancestors) + ? before + : after + return rowIndex(rows[pick]) +} diff --git a/packages/app-core/src/lib/sidebar-scroll.test.ts b/packages/app-core/src/lib/sidebar-scroll.test.ts index 0689384b..368a0480 100644 --- a/packages/app-core/src/lib/sidebar-scroll.test.ts +++ b/packages/app-core/src/lib/sidebar-scroll.test.ts @@ -1,9 +1,35 @@ import { describe, expect, it } from 'vitest' import { getScrollTopForPreservedSidebarAnchor, - isRecentSidebarPointerInteraction + isRecentSidebarPointerInteraction, + sidebarSelectionChanged } from './sidebar-scroll' +// #993: the reveal re-ran on every listing refresh and on the open note +// coming back after a folder selection, and each run pulled the Vim cursor +// onto the open note. +describe('sidebarSelectionChanged', () => { + const folderView = { kind: 'folder', folder: 'inbox', subpath: 'Projects' } + const tags: string[] = [] + + it('reveals the first time, after focus comes back (no previous selection)', () => { + expect(sidebarSelectionChanged(null, ['inbox/a.md', folderView, false, tags])).toBe(true) + }) + + it('stays put when nothing the person selects has changed', () => { + const selection = ['inbox/a.md', folderView, false, tags] + expect(sidebarSelectionChanged(selection, ['inbox/a.md', folderView, false, tags])).toBe(false) + }) + + it('follows a different note, a new view, or a toggled special view', () => { + const selection = ['inbox/a.md', folderView, false, tags] + expect(sidebarSelectionChanged(selection, ['inbox/b.md', folderView, false, tags])).toBe(true) + expect(sidebarSelectionChanged(selection, ['inbox/a.md', { ...folderView }, false, tags])).toBe(true) + expect(sidebarSelectionChanged(selection, ['inbox/a.md', folderView, true, tags])).toBe(true) + expect(sidebarSelectionChanged(selection, ['inbox/a.md', folderView, false, ['x']])).toBe(true) + }) +}) + describe('sidebar scroll anchoring', () => { it('keeps the interacted row at the same visual offset', () => { expect( diff --git a/packages/app-core/src/lib/sidebar-scroll.ts b/packages/app-core/src/lib/sidebar-scroll.ts index fd16378c..04cf3b9c 100644 --- a/packages/app-core/src/lib/sidebar-scroll.ts +++ b/packages/app-core/src/lib/sidebar-scroll.ts @@ -29,3 +29,18 @@ export function isRecentSidebarPointerInteraction( if (!Number.isFinite(now) || now < lastPointerAt) return false return now - lastPointerAt <= windowMs } + +/** + * Whether the sidebar's reveal has a new selection to follow. The parts are + * the things a person selects (the note, the view, the special views), and + * they compare by identity. A reveal that ran for the same parts already put + * the Vim cursor there, so re-running it can only pull the cursor back from + * where the keys have since moved it. (#993) + */ +export function sidebarSelectionChanged( + previous: readonly unknown[] | null, + next: readonly unknown[] +): boolean { + if (!previous || previous.length !== next.length) return true + return next.some((part, i) => !Object.is(part, previous[i])) +} diff --git a/packages/app-core/src/lib/tag-block-index.ts b/packages/app-core/src/lib/tag-block-index.ts new file mode 100644 index 00000000..6687080f --- /dev/null +++ b/packages/app-core/src/lib/tag-block-index.ts @@ -0,0 +1,227 @@ +import { useEffect, useMemo, useState } from 'react' +import type { NoteMeta } from '@shared/ipc' +import { extractTagBlocks, tagBlockJumpOffset, type TagBlock } from '@shared/tag-blocks' +import { useStore } from '../store' + +/** + * Block-level tag occurrences for the Tags view (#837), indexed on demand. + * + * The note-level index (`NoteMeta.tags`) already says which notes carry a tag, + * so this reads only those notes, through the `readNote` bridge every host + * implements (a local vault, a remote workspace, the web client), and keeps + * the blocks found in each one stamped with the note's `updatedAt` and `size`. + * A watcher update changes the stamp, so a stale entry is never served, and + * nothing is read at boot or while the Tags view is closed. A note open in the + * editor is read from its buffer instead, so a block typed a moment ago lists + * before it is saved. + */ + +type Scope = string + +interface CachedBlocks { + stamp: string + blocks: readonly TagBlock[] +} + +interface ReadJob { + id: string + scope: Scope + path: string + stamp: string +} + +const MAX_CONCURRENT_READS = 6 +const MAX_CACHED_NOTES = 6000 +const MAX_LIVE_BODIES = 64 +const NOTIFY_DELAY_MS = 40 +const EMPTY_BLOCKS: readonly TagBlock[] = [] + +let cacheScope: Scope | null = null +const cache = new Map() +const liveBodies = new Map() +const queue: ReadJob[] = [] +const queuedIds = new Set() +let activeReads = 0 +const listeners = new Set<() => void>() +let notifyTimer: ReturnType | null = null + +function stampOf(note: Pick): string { + return `${note.updatedAt}:${note.size}` +} + +function useScope(): Scope { + return useStore( + (s) => + `${s.workspaceMode}\0${s.vault?.root ?? ''}\0${s.remoteWorkspaceInfo?.baseUrl ?? ''}\0${ + s.remoteWorkspaceInfo?.profileId ?? '' + }` + ) +} + +/** A different vault or workspace: nothing cached for the old one applies. */ +function enterScope(scope: Scope): void { + if (cacheScope === scope) return + cacheScope = scope + cache.clear() + liveBodies.clear() + queue.length = 0 + queuedIds.clear() +} + +function remember(path: string, entry: CachedBlocks): void { + cache.delete(path) + cache.set(path, entry) + if (cache.size > MAX_CACHED_NOTES) { + const oldest = cache.keys().next().value + if (oldest !== undefined) cache.delete(oldest) + } +} + +function blocksFromLiveBody(path: string, body: string): readonly TagBlock[] { + const memo = liveBodies.get(path) + if (memo && memo.body === body) return memo.blocks + const blocks = extractTagBlocks(body) + liveBodies.delete(path) + liveBodies.set(path, { body, blocks }) + if (liveBodies.size > MAX_LIVE_BODIES) { + const oldest = liveBodies.keys().next().value + if (oldest !== undefined) liveBodies.delete(oldest) + } + return blocks +} + +function scheduleNotify(): void { + if (notifyTimer !== null) return + notifyTimer = setTimeout(() => { + notifyTimer = null + for (const listener of listeners) listener() + }, NOTIFY_DELAY_MS) +} + +function request(scope: Scope, note: NoteMeta): void { + const stamp = stampOf(note) + const id = `${note.path}\0${stamp}` + if (queuedIds.has(id)) return + queuedIds.add(id) + queue.push({ id, scope, path: note.path, stamp }) + pump() +} + +function pump(): void { + while (activeReads < MAX_CONCURRENT_READS && queue.length > 0) { + const job = queue.shift() as ReadJob + activeReads += 1 + // Through a promise, so a host without the call rejects instead of + // throwing inside the effect that asked. + void Promise.resolve() + .then(() => window.zen.readNote(job.path)) + .then( + (content) => { + if (cacheScope === job.scope) { + remember(job.path, { stamp: job.stamp, blocks: extractTagBlocks(content.body) }) + } + }, + () => { + // Unreadable right now (moved, mid-rename, offline remote): list the + // note without blocks until its stamp changes, rather than retrying + // the same read on every render. + if (cacheScope === job.scope) remember(job.path, { stamp: job.stamp, blocks: EMPTY_BLOCKS }) + } + ) + .finally(() => { + activeReads -= 1 + queuedIds.delete(job.id) + scheduleNotify() + pump() + }) + } +} + +export interface TagBlockIndex { + /** Blocks per note path, for every note whose body has been read. */ + blocksByPath: ReadonlyMap + /** Notes still waiting for their body. */ + pending: number +} + +/** + * The tagged blocks of `notes`, filling in as their bodies are read. Pass + * only the notes the Tags view lists: their count is the cost. + */ +export function useTagBlockIndex(notes: readonly NoteMeta[]): TagBlockIndex { + const scope = useScope() + const activeNote = useStore((s) => s.activeNote) + const noteContents = useStore((s) => s.noteContents) + const [revision, setRevision] = useState(0) + + useEffect(() => { + const listener = (): void => setRevision((r) => r + 1) + listeners.add(listener) + return () => { + listeners.delete(listener) + // The last Tags view closed: reads nobody waits for are dropped. Reads + // already in flight finish into the cache. + if (listeners.size === 0) { + for (const job of queue) queuedIds.delete(job.id) + queue.length = 0 + } + } + }, []) + + const { index, missing } = useMemo(() => { + enterScope(scope) + const blocksByPath = new Map() + const missing: NoteMeta[] = [] + for (const note of notes) { + const live = + activeNote && activeNote.path === note.path + ? activeNote.body + : noteContents[note.path]?.body + if (live != null) { + blocksByPath.set(note.path, blocksFromLiveBody(note.path, live)) + continue + } + const cached = cache.get(note.path) + if (cached && cached.stamp === stampOf(note)) { + blocksByPath.set(note.path, cached.blocks) + continue + } + missing.push(note) + } + return { index: { blocksByPath, pending: missing.length }, missing } + // `revision` is not read here: it re-runs this after a batch of reads + // lands in the cache. + }, [notes, activeNote, noteContents, scope, revision]) + + useEffect(() => { + for (const note of missing) request(scope, note) + }, [missing, scope]) + + return index +} + +/** + * Open a note at a tagged block's first line, highlighted, the way a task + * opens from the Tasks view. The offset comes from the body as it is now (the + * open buffer when there is one), so an edit since the list was built cannot + * send the caret to a stale position. Recorded as a jump, so Ctrl+O comes + * back. Resolves false when the note could not be read. + */ +export async function openTaggedBlock(path: string, startLine: number): Promise { + const state = useStore.getState() + let body = + state.activeNote?.path === path ? state.activeNote.body : state.noteContents[path]?.body + if (body == null) { + try { + body = (await window.zen.readNote(path)).body + } catch (err) { + console.error('open tagged block: readNote failed', err) + return false + } + } + await useStore.getState().openNoteAtOffset(path, tagBlockJumpOffset(body, startLine), { + scrollMode: 'center', + highlightLine: true + }) + return true +} diff --git a/packages/app-core/src/lib/tag-view-rows.test.ts b/packages/app-core/src/lib/tag-view-rows.test.ts new file mode 100644 index 00000000..41f322ce --- /dev/null +++ b/packages/app-core/src/lib/tag-view-rows.test.ts @@ -0,0 +1,123 @@ +import { describe, expect, it } from 'vitest' +import type { NoteMeta } from '@shared/ipc' +import { extractTagBlocks } from '@shared/tag-blocks' +import { buildTagViewRows, nextNoteRowIndex, previousNoteRowIndex } from './tag-view-rows' + +function note(path: string, title: string, excerpt = ''): NoteMeta { + return { + path, + title, + folder: 'inbox', + siblingOrder: 0, + createdAt: 0, + updatedAt: 0, + size: 0, + tags: [], + wikilinks: [], + assetEmbeds: [], + hasAttachments: false, + excerpt + } +} + +const ideas = note('inbox/Ideas.md', 'Ideas', 'A grab bag') +const journal = note('inbox/Journal.md', 'Journal', 'Monday') +const frontmatterOnly = note('inbox/Project.md', 'Project', 'Tagged up top') + +const blocksByPath = new Map([ + [ + ideas.path, + extractTagBlocks( + ['- Recipe gallery #idea', '- Groceries', '- Plugin store #Idea #later', '- Dark mode #later'].join( + '\n' + ) + ) + ], + [journal.path, extractTagBlocks('Woke up early.\n\nWrite the zine #idea')], + [frontmatterOnly.path, extractTagBlocks('---\ntags: idea\n---\nNo inline tags here')] +]) + +describe('buildTagViewRows', () => { + it('lists each note followed by its blocks that carry a selected tag', () => { + const { rows, noteCount, blockCount } = buildTagViewRows( + [ideas, journal, frontmatterOnly], + blocksByPath, + ['idea'], + '' + ) + expect(rows.map((r) => (r.kind === 'note' ? r.note.title : ` L${r.block.startLine + 1}`))).toEqual([ + 'Ideas', + ' L1', + ' L3', + 'Journal', + ' L3', + 'Project' + ]) + expect(noteCount).toBe(3) + expect(blockCount).toBe(3) + // A frontmatter-only note keeps today's plain note row. + expect(rows[5]).toMatchObject({ kind: 'note', blockCount: 0 }) + }) + + it('matches block tags case-insensitively and leaves out blocks with other tags only', () => { + const { rows } = buildTagViewRows([ideas], blocksByPath, ['IDEA'], '') + expect(rows.filter((r) => r.kind === 'block')).toHaveLength(2) + }) + + it('lists a note whose blocks are not read yet as a note row alone', () => { + const { rows } = buildTagViewRows([note('inbox/New.md', 'New')], blocksByPath, ['idea'], '') + expect(rows).toEqual([expect.objectContaining({ kind: 'note', blockCount: 0 })]) + }) + + it('keeps every block of a note whose title matches the filter', () => { + const { rows } = buildTagViewRows([ideas, journal], blocksByPath, ['idea'], 'ideas') + expect(rows.map((r) => r.kind)).toEqual(['note', 'block', 'block']) + }) + + it('narrows to the blocks whose text matches when only blocks match', () => { + const { rows, noteCount, blockCount } = buildTagViewRows( + [ideas, journal], + blocksByPath, + ['idea'], + 'plugin' + ) + expect(rows.map((r) => (r.kind === 'block' ? r.block.text : r.note.title))).toEqual([ + 'Ideas', + 'Plugin store #Idea #later' + ]) + expect([noteCount, blockCount]).toEqual([1, 1]) + }) + + it('narrows to matching blocks even when the excerpt also matches', () => { + const openingIdea = note('inbox/Ideas.md', 'Ideas', 'Recipe gallery Groceries Plugin store') + const { rows } = buildTagViewRows([openingIdea], blocksByPath, ['idea'], 'plugin') + expect(rows.map((r) => r.kind)).toEqual(['note', 'block']) + }) + + it('keeps a note found only by its excerpt as a note row alone', () => { + const { rows } = buildTagViewRows([ideas, journal], blocksByPath, ['idea'], 'grab bag') + expect(rows).toEqual([expect.objectContaining({ kind: 'note', note: ideas, blockCount: 0 })]) + }) + + it('gives each row a key that survives blocks filling in', () => { + const { rows } = buildTagViewRows([ideas], blocksByPath, ['idea'], '') + expect(new Set(rows.map((r) => r.key)).size).toBe(rows.length) + expect(rows[0]?.key).toBe(ideas.path) + }) +}) + +describe('note row hops', () => { + const { rows } = buildTagViewRows([ideas, journal, frontmatterOnly], blocksByPath, ['idea'], '') + + it('moves to the next note past the current note blocks', () => { + expect(nextNoteRowIndex(rows, 0)).toBe(3) + expect(nextNoteRowIndex(rows, 1)).toBe(3) + expect(nextNoteRowIndex(rows, 5)).toBe(-1) + }) + + it('moves from a block to its own note, and from a note to the one before', () => { + expect(previousNoteRowIndex(rows, 4)).toBe(3) + expect(previousNoteRowIndex(rows, 3)).toBe(0) + expect(previousNoteRowIndex(rows, 0)).toBe(-1) + }) +}) diff --git a/packages/app-core/src/lib/tag-view-rows.ts b/packages/app-core/src/lib/tag-view-rows.ts new file mode 100644 index 00000000..583a5116 --- /dev/null +++ b/packages/app-core/src/lib/tag-view-rows.ts @@ -0,0 +1,77 @@ +import type { NoteMeta } from '@shared/ipc' +import type { TagBlock } from '@shared/tag-blocks' + +/** + * The rows the Tags view lists (#837): each matching note, followed by the + * blocks inside it that carry one of the selected tags. A note tagged only in + * frontmatter, or one whose blocks have not been read yet, is a note row + * alone, which is exactly the list the view showed before block results. + */ +export type TagViewRow = + | { kind: 'note'; key: string; note: NoteMeta; blockCount: number } + | { kind: 'block'; key: string; note: NoteMeta; block: TagBlock } + +export interface TagViewRows { + rows: TagViewRow[] + /** Notes listed after the filter. */ + noteCount: number + /** Blocks listed after the filter. */ + blockCount: number +} + +/** + * Build the Tags view's rows. A block is listed when it carries any selected + * tag (case-insensitive): the note-level All/Any match already decided which + * notes appear, and inside a note every block holding one of the tags is a + * place the user may want to land. + * + * The filter keeps a note whose title or path matches together with all its + * blocks; otherwise the note with only the blocks whose text matches, so + * typing a word from an idea finds that idea; otherwise, when only the + * excerpt matches, the note row alone, as the list worked before blocks. The + * excerpt is the opening of the body, so letting it keep every block would + * undo the narrowing whenever the idea sits near the top. + */ +export function buildTagViewRows( + notes: readonly NoteMeta[], + blocksByPath: ReadonlyMap, + selectedTags: readonly string[], + filter: string +): TagViewRows { + const wanted = new Set(selectedTags.map((t) => t.toLowerCase())) + const q = filter.trim().toLowerCase() + const rows: TagViewRow[] = [] + let noteCount = 0 + let blockCount = 0 + for (const note of notes) { + let blocks = (blocksByPath.get(note.path) ?? []).filter((block) => + block.tags.some((tag) => wanted.has(tag.toLowerCase())) + ) + if (q && !note.title.toLowerCase().includes(q) && !note.path.toLowerCase().includes(q)) { + blocks = blocks.filter((block) => block.text.toLowerCase().includes(q)) + if (blocks.length === 0 && !note.excerpt.toLowerCase().includes(q)) continue + } + noteCount += 1 + blockCount += blocks.length + rows.push({ kind: 'note', key: note.path, note, blockCount: blocks.length }) + for (const block of blocks) { + rows.push({ kind: 'block', key: `${note.path}\0${block.startLine}`, note, block }) + } + } + return { rows, noteCount, blockCount } +} + +/** Index of the next note row after `index`, or -1. */ +export function nextNoteRowIndex(rows: readonly TagViewRow[], index: number): number { + for (let i = index + 1; i < rows.length; i++) if (rows[i]?.kind === 'note') return i + return -1 +} + +/** + * Index of the note row `{` moves to from `index`: from a block, its own + * note; from a note, the note before it. -1 when there is none. + */ +export function previousNoteRowIndex(rows: readonly TagViewRow[], index: number): number { + for (let i = index - 1; i >= 0; i--) if (rows[i]?.kind === 'note') return i + return -1 +} diff --git a/packages/app-core/src/lib/tags.test.ts b/packages/app-core/src/lib/tags.test.ts index 523cac15..5296bd00 100644 --- a/packages/app-core/src/lib/tags.test.ts +++ b/packages/app-core/src/lib/tags.test.ts @@ -24,6 +24,11 @@ describe('extractTags — code fences are never scanned for tags (#293)', () => expect(extractTags('- item\n ```\n #include\n ```\n #after')).toEqual(['after']) }) + it('ignores #tags inside a fence in a note saved with CRLF line endings', () => { + expect(extractTags('```c\r\n#include \r\n```\r\nreal #ok\r\n')).toEqual(['ok']) + expect(extractTags('- item\r\n ~~~\r\n #nope\r\n ~~~\r\n #after\r\n')).toEqual(['after']) + }) + it('includes first-class frontmatter tags', () => { expect(extractTags('---\ntags: [frontmatter, "#quoted", project/nested]\ntitle: #ignored\n---\n\n#inline')).toEqual([ 'frontmatter', diff --git a/packages/app-core/src/lib/tags.ts b/packages/app-core/src/lib/tags.ts index 7f59135c..069bc22c 100644 --- a/packages/app-core/src/lib/tags.ts +++ b/packages/app-core/src/lib/tags.ts @@ -1,77 +1,13 @@ /** - * Extract a note's tags from a markdown body: its frontmatter `tags` field - * plus every inline `#tag`. Mirrors the extraction the main process runs in - * `vault.ts` so the sidebar can update tag counts *live* as the user types, - * instead of waiting for the save + chokidar round-trip. - * - * Rules: - * - The hash must be preceded by start-of-line or whitespace (so - * `me#tag` and `url.com/#x` don't match). - * - The first tag character must be a letter in any script (Cyrillic, - * CJK, … — #205), the rest can be letters, digits, `_`, `-`, or `/`. - * - Fenced code blocks and inline code spans are stripped first. - * - Heading markers (`#`, `##`, …) are not a hashtag because the - * character after the hash is a space, not a letter. - * - The frontmatter block is read for `tags` and then excluded from the - * inline scan, so a `#` in some other field is never a tag (#444). + * Tag helpers for the vault's tag surfaces. The note-level scan itself, + * `extractTags`, lives in shared-domain's `tag-scan.ts` (next to the + * block-level scan that reads by the same rules, #837) and is re-exported here + * for the renderer's existing callers. */ -import { FRONTMATTER_BLOCK_RE, frontmatterTags } from '@shared/frontmatter' +import { extractTags } from '@shared/tag-scan' import { isTypstPreamblePath } from '@shared/typst-preamble-folder' -export function extractTags(body: string): string[] { - const seen = new Set() - for (const tag of frontmatterTags(body)) seen.add(tag) - - const markdownBody = body.replace(FRONTMATTER_BLOCK_RE, '') - const stripped = stripCodeContent(markdownBody) - const regex = /(?:^|\s)#(\p{L}[\p{L}\d_/-]*)/gu - let m: RegExpExecArray | null - while ((m = regex.exec(stripped)) !== null) { - seen.add(m[1]) - } - return [...seen] -} - -/** - * Blank out fenced and inline code so the tag scanner never reads code as a - * tag. Fence detection is line-based and indentation-tolerant: a fence nested - * under a list item is still a code block, so e.g. a C `#include` line inside - * it is not a tag (#293). Mirrors `stripCodeContent` in - * apps/desktop/src/main/vault.ts and internal/vault/parse.go in ZenNotes/znserver — - * keep the three in sync. - */ -function stripCodeContent(body: string): string { - if (!body.includes('`') && !body.includes('~')) return body - const lines = body.split('\n') - let inFence = false - let fenceChar = '' - let fenceLen = 0 - for (let i = 0; i < lines.length; i++) { - const line = lines[i] as string - const m = /^[ \t]*(`{3,}|~{3,})(.*)$/.exec(line) - if (m) { - const marker = m[1] as string - const char = marker[0] as string - const rest = m[2] as string - if (!inFence) { - // A backtick fence's info string may not contain a backtick (CommonMark). - if (char === '~' || !rest.includes('`')) { - inFence = true - fenceChar = char - fenceLen = marker.length - lines[i] = ' ' - continue - } - } else if (char === fenceChar && marker.length >= fenceLen && rest.trim() === '') { - inFence = false - lines[i] = ' ' - continue - } - } - if (inFence) lines[i] = ' ' - } - return lines.join('\n').replace(/`[^`\n]*`/g, ' ') -} +export { extractTags } /** * Does a note's tags satisfy the Tags-view selection? `all` = the note carries diff --git a/packages/app-core/src/lib/unresolved-links.test.ts b/packages/app-core/src/lib/unresolved-links.test.ts new file mode 100644 index 00000000..598282e7 --- /dev/null +++ b/packages/app-core/src/lib/unresolved-links.test.ts @@ -0,0 +1,147 @@ +import { describe, expect, it } from 'vitest' +import type { NoteFolder } from '@shared/ipc' +import { unresolvedOccurrencesIn } from '@shared/unresolved-links' +import { vaultUnresolvedLinks, wikilinkReaches, type WikilinkReachContext } from './unresolved-links' +import { extractWikilinkTargets } from './wikilinks' + +// uNyanda (Discord): "I sometimes create wiki links to notes I want to write +// later, but I forget to create the actual notes." The Unresolved Links view +// lists every such link, and must agree with the editor about which links are +// broken: same resolver, applied to every note in the vault. + +interface FixtureNote { + path: string + title: string + folder: NoteFolder + wikilinks: string[] + body: string +} + +function note(path: string, body: string, folder: NoteFolder = 'inbox'): FixtureNote { + const title = path.split('/').pop()!.replace(/\.md$/i, '') + // The vault index stores each note's wikilink targets, code masked. The + // renderer's scanner applies the same rules as the main process's. + return { path, title, folder, body, wikilinks: extractWikilinkTargets(body) } +} + +const context: Omit = { + databases: [{ csvPath: 'Budget.base/data.csv', title: 'Budget' }], + assets: [{ path: 'assets/diagram.png' }, { path: 'Papers/spec.pdf' }] +} + +function groupsOf(notes: FixtureNote[]) { + return vaultUnresolvedLinks(notes, context).map((g) => ({ + target: g.target, + sources: g.sources.map((n) => n.path) + })) +} + +describe('vaultUnresolvedLinks', () => { + it('lists a missing note with every note that links to it', () => { + const notes = [ + note('inbox/Ideas.md', 'Write up [[Garden Plan]] and see [[Reading]]'), + note('inbox/Reading.md', 'Back to [[Ideas]]. Also [[Garden Plan#Beds|the beds]].'), + note('inbox/Journal.md', 'Nothing linked here') + ] + expect(groupsOf(notes)).toEqual([ + { target: 'Garden Plan', sources: ['inbox/Ideas.md', 'inbox/Reading.md'] } + ]) + }) + + it('treats headings, blocks and aliases of an existing note as resolved', () => { + const notes = [ + note('inbox/Doc.md', '# Intro\ntext ^b1'), + note('inbox/A.md', '[[Doc#Intro]] [[Doc^b1]] [[Doc#^b1]] [[Doc|alias]] [[doc]] [[Doc.md]]') + ] + expect(groupsOf(notes)).toEqual([]) + }) + + it('treats same-note heading and block links as resolved', () => { + expect(groupsOf([note('inbox/A.md', '# H\n[[#H]] [[#Missing heading]] [[^blk]]')])).toEqual([]) + }) + + it('ignores links that only appear inside code', () => { + const body = [ + '`[[Inline Code]]`', + '```', + '[[Fenced]]', + '```', + '- list', + ' ~~~', + ' [[Nested Fence]]', + ' ~~~', + 'Real [[Later]]' + ].join('\n') + expect(groupsOf([note('inbox/A.md', body)])).toEqual([ + { target: 'Later', sources: ['inbox/A.md'] } + ]) + }) + + it('counts files in the vault and databases as resolved, wherever the note sits', () => { + const notes = [ + note('Projects/Deep/A.md', '[[assets/diagram.png]] [[spec.pdf]] [[Budget]] [[Budget#x]]') + ] + expect(groupsOf(notes)).toEqual([]) + }) + + it('lists a link to a trashed note, and never a trashed note as a source', () => { + const notes = [ + note('trash/Old.md', '[[Ghost]]', 'trash'), + note('inbox/A.md', 'See [[Old]]') + ] + expect(groupsOf(notes)).toEqual([{ target: 'Old', sources: ['inbox/A.md'] }]) + }) + + it('resolves through remapped system folders by title and by path', () => { + // Inbox mapped to `Notes/`, Archive to `Old Stuff/` (vault.json + // systemFolderPaths). Notes keep their logical folder; paths are on-disk. + const notes = [ + note('Notes/Plan.md', 'body'), + note('Old Stuff/Retro.md', 'body', 'archive'), + note('Notes/A.md', '[[Plan]] [[Notes/Plan]] [[Retro]] [[Old Stuff/Retro]] [[Notes/Nope]]') + ] + expect(groupsOf(notes)).toEqual([{ target: 'Notes/Nope', sources: ['Notes/A.md'] }]) + }) + + it('groups spellings of one missing note, case and anchors aside', () => { + const notes = [ + note('inbox/A.md', '[[Someday]] [[someday#When]]'), + note('inbox/B.md', '[[SOMEDAY|later]] [[Someday.md]]') + ] + expect(groupsOf(notes)).toEqual([ + { target: 'Someday', sources: ['inbox/A.md', 'inbox/B.md'] } + ]) + }) + + it('finds the line each source note mentions its missing targets on', () => { + const notes = [ + note('inbox/A.md', 'top\n```\n[[Later]]\n```\nwrite [[Later]] soon\n[[later#part]]') + ] + const [group] = vaultUnresolvedLinks(notes, context) + const hits = unresolvedOccurrencesIn(notes[0]!.body, new Set([group!.key])) + expect(hits.map((h) => [h.line, h.text])).toEqual([ + [5, 'write [[Later]] soon'], + [6, '[[later#part]]'] + ]) + }) +}) + +describe('wikilinkReaches', () => { + const reach: WikilinkReachContext = { + notes: [{ path: 'inbox/Doc.md', title: 'Doc', folder: 'inbox' }], + ...context + } + + it('resolves an embed relative to the note it sits in', () => { + // Two files share the basename, so only the note-relative reading can + // pick one. + const local = { ...reach, assets: [{ path: 'Projects/img/a.png' }, { path: 'Elsewhere/a.png' }] } + expect(wikilinkReaches('img/a.png', 'Projects/Note.md', local)).toBe(true) + expect(wikilinkReaches('img/a.png', 'Other/Note.md', local)).toBe(false) + }) + + it('says no for a name nothing answers', () => { + expect(wikilinkReaches('Nowhere', 'inbox/A.md', reach)).toBe(false) + expect(wikilinkReaches('Doc', 'inbox/A.md', reach)).toBe(true) + }) +}) diff --git a/packages/app-core/src/lib/unresolved-links.ts b/packages/app-core/src/lib/unresolved-links.ts new file mode 100644 index 00000000..bef4c971 --- /dev/null +++ b/packages/app-core/src/lib/unresolved-links.ts @@ -0,0 +1,67 @@ +import type { FolderEntry, NoteMeta, VaultSettings } from '@shared/ipc' +import { collectUnresolvedLinks, type UnresolvedLinkGroup } from '@shared/unresolved-links' +import { resolveAssetPathAmong, type AssetPathRef } from './asset-path-resolution' +import { + listDatabaseLinkTargets, + resolveDatabaseWikilink, + type DatabaseLinkTarget +} from './database-links' +import { isSameFileBlockLink, isSameFileHeadingLink, resolveWikilinkTarget } from './wikilinks' + +type NoteRef = Pick + +/** The vault lists a wikilink can reach into. */ +export interface WikilinkReachContext { + notes: NoteRef[] + databases: DatabaseLinkTarget[] + assets: ReadonlyArray +} + +/** + * Whether a wikilink target written in the note at `fromPath` reaches + * something: a note, a spot in this note, a `.base` database, or a file in + * the vault. Anything else would create a note when followed. + * + * The one decision behind both the editor's unresolved look (#768) and the + * Unresolved Links view, so a link the editor draws as broken is exactly a + * link the view lists. `fromPath` matters for files only: an embed resolves + * relative to the note it sits in. + */ +export function wikilinkReaches( + target: string, + fromPath: string, + context: WikilinkReachContext +): boolean { + return ( + resolveWikilinkTarget(context.notes, target) != null || + isSameFileHeadingLink(target) || + isSameFileBlockLink(target) || + resolveDatabaseWikilink(context.databases, target) != null || + resolveAssetPathAmong(context.assets, fromPath, target) != null + ) +} + +/** Database link targets for a vault, or none when its folders cannot be read. */ +export function databaseLinkTargetsFor( + folders: FolderEntry[] | null | undefined, + vaultSettings: VaultSettings | null | undefined +): DatabaseLinkTarget[] { + if (!Array.isArray(folders) || !vaultSettings) return [] + try { + return listDatabaseLinkTargets(folders, vaultSettings) + } catch { + return [] + } +} + +/** + * Every missing note the vault links to, grouped by the note each link names, + * from the index's per-note link lists. See `collectUnresolvedLinks`. + */ +export function vaultUnresolvedLinks>( + notes: N[], + context: Omit +): UnresolvedLinkGroup[] { + const reach: WikilinkReachContext = { ...context, notes } + return collectUnresolvedLinks(notes, (target, note) => wikilinkReaches(target, note.path, reach)) +} diff --git a/packages/app-core/src/lib/whats-new.ts b/packages/app-core/src/lib/whats-new.ts index 7ca057ac..40ff4c26 100644 --- a/packages/app-core/src/lib/whats-new.ts +++ b/packages/app-core/src/lib/whats-new.ts @@ -39,6 +39,27 @@ export const CLOUD_ANNOUNCEMENT = { } as const export const WHATS_NEW: readonly WhatsNewEntry[] = [ + { + version: '2.77.0', + highlights: [ + { + title: 'Links to notes you haven’t written yet', + body: 'Unresolved Links lists every [[link]] in your vault that points at no note, most linked first, with the lines that link to it. Open it from the command palette, or with Space u in Vim mode.' + }, + { + title: 'Edit a linked note in place', + body: 'Rest the pointer on a link and its note opens in a popover over yours: type, then Escape. A link to a missing note offers to create it right there. K in Vim mode, Shift+Cmd+K without.' + }, + { + title: 'Tags find the idea, not just the note', + body: 'The Tags view lists the tagged blocks inside each note: a list item, a paragraph, or a whole section under a tagged heading. In Search notes, #idea does the same, and Enter jumps to the line.' + }, + { + title: 'Steadier on slow networks', + body: 'ZenNotes Cloud retries a stalled request after 30 seconds instead of waiting five minutes, and a conflict review opens at once, even while a sync is running.' + } + ] + }, { version: '2.76.0', highlights: [ diff --git a/packages/app-core/src/lib/wikilinks.test.ts b/packages/app-core/src/lib/wikilinks.test.ts index b1f7cc9a..0ff9381a 100644 --- a/packages/app-core/src/lib/wikilinks.test.ts +++ b/packages/app-core/src/lib/wikilinks.test.ts @@ -21,6 +21,11 @@ describe('extractWikilinkTargets — code fences are not scanned (#293)', () => const body = '- item:\n\n ```\n see [[Secret Note]] here\n ```\n\n[[Real Link]]' expect(extractWikilinkTargets(body)).toEqual(['Real Link']) }) + + it('ignores [[links]] inside a fence in a note saved with CRLF line endings', () => { + const body = '```\r\nsee [[Secret Note]] here\r\n```\r\n\r\n[[Real Link]]\r\n' + expect(extractWikilinkTargets(body)).toEqual(['Real Link']) + }) }) const notes = [ diff --git a/packages/app-core/src/lib/wikilinks.ts b/packages/app-core/src/lib/wikilinks.ts index 66ac4a48..757abd81 100644 --- a/packages/app-core/src/lib/wikilinks.ts +++ b/packages/app-core/src/lib/wikilinks.ts @@ -8,7 +8,7 @@ const INVALID_NOTE_PATH_CHARS = /[\\:*?"<>|#^\[\]]/ * Blank out fenced and inline code so [[wikilink]] / mention scanning never * reads code as a link. Line-based and indentation-tolerant: a fence nested * under a list item is still a code block (#293). Mirrors `stripCodeContent` in - * tags.ts, apps/desktop/src/main/vault.ts, apps/desktop/src/mcp/vault-ops.ts, + * @shared/tag-scan, apps/desktop/src/main/vault.ts, apps/desktop/src/mcp/vault-ops.ts, * and internal/vault/parse.go in ZenNotes/znserver — keep all five in sync. */ function stripCodeContent(body: string): string { @@ -19,7 +19,8 @@ function stripCodeContent(body: string): string { let fenceLen = 0 for (let i = 0; i < lines.length; i++) { const line = lines[i] as string - const m = /^[ \t]*(`{3,}|~{3,})(.*)$/.exec(line) + // `.` never matches `\r`, so the `\r?` is what lets a CRLF-saved fence line match. + const m = /^[ \t]*(`{3,}|~{3,})(.*)\r?$/.exec(line) if (m) { const marker = m[1] as string const char = marker[0] as string diff --git a/packages/app-core/src/lib/workspace-tabs.ts b/packages/app-core/src/lib/workspace-tabs.ts index 10d4736e..ea76b7ff 100644 --- a/packages/app-core/src/lib/workspace-tabs.ts +++ b/packages/app-core/src/lib/workspace-tabs.ts @@ -8,6 +8,7 @@ import { isWorkflowsTabPath } from '@shared/workflows-view' import { isAtlasTabPath } from '@shared/atlas-view' import { isDatabaseTabPath } from '@shared/databases' import { isAssetsViewTabPath } from '@shared/assets-view' +import { isUnresolvedLinksTabPath } from '@shared/unresolved-links' import { isAssetTabPath } from './asset-tabs' import { isDiagramTabPath } from './diagram-tabs' import { allLeaves, type PaneLayout } from './pane-layout' @@ -23,6 +24,7 @@ export function isWorkspaceVirtualTabPath(path: string): boolean { isArchiveTabPath(path) || isTrashTabPath(path) || isAssetsViewTabPath(path) || + isUnresolvedLinksTabPath(path) || isAssetTabPath(path) || isDiagramTabPath(path) || isDatabaseTabPath(path) diff --git a/packages/app-core/src/navigation.test.ts b/packages/app-core/src/navigation.test.ts index bcd6e64f..d98cb33f 100644 --- a/packages/app-core/src/navigation.test.ts +++ b/packages/app-core/src/navigation.test.ts @@ -14,7 +14,7 @@ function meta(path: string, body: string) { return { path, title: path, - folder: 'inbox' as const, + folder: (path.startsWith('trash/') ? 'trash' : path.startsWith('archive/') ? 'archive' : 'inbox') as 'inbox', siblingOrder: 0, createdAt: 0, updatedAt: 1, @@ -27,6 +27,14 @@ function meta(path: string, body: string) { } } +function relocate(from: string, to: string) { + const body = vault.get(from) + if (body === undefined) throw new Error(`Missing note: ${from}`) + vault.delete(from) + vault.set(to, body) + return meta(to, body) +} + beforeEach(() => { vi.resetModules() localStorage.clear() @@ -51,6 +59,12 @@ beforeEach(() => { writeNote: async (path: string, body: string) => { vault.set(path, body) return meta(path, body) + }, + moveToTrash: async (path: string) => relocate(path, `trash/${path}`), + archiveNote: async (path: string) => relocate(path, `archive/${path}`), + restoreFromTrash: async (path: string) => relocate(path, path.slice('trash/'.length)), + deleteNote: async (path: string) => { + vault.delete(path) } } }) @@ -151,6 +165,86 @@ describe('public shell navigation', () => { }) }) +describe('Home after the open note leaves the workspace', () => { + async function phone(options: { guard?: boolean } = {}) { + vault.set('three.md', '# Third note\n') + const s = await setup() + const notes = await import('./notes') + const confirms = await import('./lib/confirm-requests') + if (options.guard !== false) disposers.push(s.installHomeGuard()) + s.useStore.setState({ vault: { root: '/phone', name: 'Phone' } }) + const host = { isCurrent: () => true } + const confirmNext = () => confirms.settleConfirmRequest(confirms.getConfirmRequest()!, true) + const leaf = () => { + const state = s.useStore.getState() + return findLeaf(state.paneLayout, state.activePaneId) + } + for (const path of ['one.md', 'two.md', 'three.md']) await s.openNote(path) + return { ...s, ...notes, host, confirmNext, leaf } + } + + it('shows Home after the open note moves to Trash, and Restore brings it back', async () => { + const s = await phone() + const trashing = s.requestTrashNote(s.host, 'three.md') + s.confirmNext() + expect(await trashing).toBe('completed') + expect(vault.get('trash/three.md')).toBe('# Third note\n') + // Not one.md: that is only the first note still open behind the scenes. + expect(s.useStore.getState().selectedPath).toBeNull() + expect(s.useStore.getState().activeNote).toBeNull() + expect(s.leaf()).toMatchObject({ tabs: ['one.md', 'two.md'], activeTab: null }) + expect(await s.restoreNote(s.host, 'trash/three.md')).toBe('completed') + expect(vault.get('three.md')).toBe('# Third note\n') + await s.openNote('three.md') + expect(s.useStore.getState().activeNote?.body).toBe('# Third note\n') + }) + + it('stays on Home when a note is moved to Trash from a list', async () => { + const s = await phone() + await s.openNote('two.md') + s.goHome() + vault.set('four.md', '# Fourth note\n') + await s.useStore.getState().refreshNotes() + const trashing = s.requestTrashNote(s.host, 'four.md') + s.confirmNext() + expect(await trashing).toBe('completed') + expect(s.useStore.getState().selectedPath).toBeNull() + expect(s.leaf()?.activeTab).toBeNull() + }) + + it('shows Home after the open note is archived or deleted for good', async () => { + const s = await phone() + expect(await s.requestArchiveNote(s.host, 'three.md')).toBe('completed') + expect(s.useStore.getState().selectedPath).toBeNull() + await s.openNote('two.md') + const trashing = s.requestTrashNote(s.host, 'two.md') + s.confirmNext() + await trashing + await s.openNote('trash/two.md') + const deleting = s.requestDeleteNotePermanently(s.host, 'trash/two.md') + s.confirmNext() + expect(await deleting).toBe('completed') + expect(vault.has('trash/two.md')).toBe(false) + expect(s.useStore.getState().selectedPath).toBeNull() + expect(s.leaf()?.tabs).toEqual(['one.md']) + }) + + it('still opens the first open note when the user asks for it', async () => { + const s = await phone() + s.goHome() + await s.openNote('one.md') + expect(s.useStore.getState().selectedPath).toBe('one.md') + }) + + it('leaves desktop on its remaining tab', async () => { + const s = await phone({ guard: false }) + const trashing = s.requestTrashNote(s.host, 'three.md') + s.confirmNext() + await trashing + expect(s.useStore.getState().selectedPath).toBe('one.md') + }) +}) + describe('navigation across workspace changes', () => { function gate() { let resolve!: (value: T) => void diff --git a/packages/app-core/src/navigation.ts b/packages/app-core/src/navigation.ts index d664bdc9..5729fb1f 100644 --- a/packages/app-core/src/navigation.ts +++ b/packages/app-core/src/navigation.ts @@ -1,6 +1,6 @@ import { captureNavigationContext } from './lib/navigation-context' import { useStore } from './store' -import { findLeaf, updateLeaf } from './lib/pane-layout' +import { activeTabWasPicked, findLeaf, updateLeaf } from './lib/pane-layout' import { paneModesWithPathMode, type PaneMode } from './lib/pane-mode' /** Open a note or app-generated page path through the normal save and history flow. */ @@ -56,27 +56,24 @@ export function goHome(): void { * Register before mounting React or adding other store subscribers. Call the * returned disposer when the host shell is torn down. * - * A rescan or vault mutation can promote the first tab while rewriting paths. - * Restore Home only for that transition. Deliberate note navigation does not - * replace the note index and must remain visible. + * A rescan or vault mutation can promote the first tab while rewriting paths, + * from Home or because the note on screen left the workspace (moved to Trash, + * archived, deleted). That tab is the oldest note still open behind Home, not + * one the user chose, so show Home for those transitions instead. Deliberate + * note navigation does not replace the note index and must remain visible. */ export function installHomeGuard(): () => void { return useStore.subscribe((state, previous) => { - if ( - state.notes === previous.notes || - state.paneLayout === previous.paneLayout - ) - return + if (state.paneLayout === previous.paneLayout) return const leaf = findLeaf(state.paneLayout, state.activePaneId) + if (!leaf || leaf.activeTab === null) return const before = findLeaf(previous.paneLayout, state.activePaneId) - if ( - !leaf || - !before || - before.activeTab !== null || - before.tabs.length === 0 - ) - return - if (leaf.activeTab === null || leaf.activeTab !== leaf.tabs[0]) return + const rescannedFromHome = + state.notes !== previous.notes && + before?.activeTab === null && + before.tabs.length > 0 && + leaf.activeTab === leaf.tabs[0] + if (!rescannedFromHome && !activeTabWasPicked(leaf)) return const next = updateLeaf(state.paneLayout, leaf.id, (pane) => ({ ...pane, activeTab: null diff --git a/packages/app-core/src/public-host-api.test.ts b/packages/app-core/src/public-host-api.test.ts index 97b09c06..e6d3dc92 100644 --- a/packages/app-core/src/public-host-api.test.ts +++ b/packages/app-core/src/public-host-api.test.ts @@ -69,6 +69,13 @@ describe('public host APIs', () => { s.settings.setSettingsVisible(true) expect(s.settings.getSettingsSnapshot().open).toBe(true) }) + it('opens Settings on the Periodic notes page for a host', async () => { + const s = await setup() + const navigation = await import('./lib/settings-navigation') + s.settings.showSettingsPage('periodic-notes') + expect(s.settings.getSettingsSnapshot().open).toBe(true) + expect(navigation.consumeSettingsTarget()).toBe('periodic-notes') + }) it('does not let a second host dialog replace an unresolved prompt', async () => { await setup() const dialogs = await import('./dialogs'), requests = await import('./lib/prompt-requests') diff --git a/packages/app-core/src/settings.ts b/packages/app-core/src/settings.ts index 4889e31c..fc50b3f3 100644 --- a/packages/app-core/src/settings.ts +++ b/packages/app-core/src/settings.ts @@ -1,5 +1,6 @@ import { useSyncExternalStore } from 'react' import { useStore } from './store' +import { requestSettingsTarget } from './lib/settings-navigation' export interface SettingsSnapshot { readonly themeId: string @@ -30,6 +31,11 @@ export function subscribeSettings(listener: (next: SettingsSnapshot, previous: S function subscribeReact(notify: () => void): () => void { return subscribeSettings(() => notify()) } export function useSettingsSnapshot(): SettingsSnapshot { return useSyncExternalStore(subscribeReact, getSettingsSnapshot, getSettingsSnapshot) } export function setSettingsVisible(open: boolean): void { useStore.getState().setSettingsOpen(open) } +/** Open Settings on one page: `periodic-notes` is Vault, Periodic notes, where daily notes are turned on. */ +export function showSettingsPage(page: 'periodic-notes'): void { + requestSettingsTarget(page) + useStore.getState().setSettingsOpen(true) +} export function setEditorFontSize(size: number, options?: { persist?: boolean }): void { if (!Number.isFinite(size)) return const clamped = Math.max(12, Math.min(28, Math.round(size))) diff --git a/packages/app-core/src/store.ts b/packages/app-core/src/store.ts index bd39a6b3..be2ce6a7 100644 --- a/packages/app-core/src/store.ts +++ b/packages/app-core/src/store.ts @@ -96,6 +96,7 @@ import { HELP_TAB_PATH, isHelpTabPath } from '@shared/help' import { ARCHIVE_TAB_PATH, isArchiveTabPath } from '@shared/archive' import { TRASH_TAB_PATH, isTrashTabPath } from '@shared/trash' import { ASSETS_VIEW_TAB_PATH } from '@shared/assets-view' +import { UNRESOLVED_LINKS_TAB_PATH } from '@shared/unresolved-links' import { QUICK_NOTES_TAB_PATH, isQuickNotesTabPath } from '@shared/quick-notes' import { isAssetTabPath, assetPathFromTab, assetTabPath } from './lib/asset-tabs' import { @@ -569,11 +570,16 @@ interface Prefs { ripgrepBinaryPath: string | null /** Optional explicit binary path for fzf. Blank uses PATH lookup. */ fzfBinaryPath: string | null + /** With a #tag in Search notes, list each note's tagged blocks under it (#837). */ + searchTaggedBlocks: boolean livePreview: boolean // hide markdown syntax on inactive lines /** Show an H1 through H6 badge before Markdown headings in the editor. */ showHeadingLevelLabels: boolean /** Vertical guide lines at each nested-list level in the editor (#491). */ listIndentGuides: boolean + /** Resting the pointer on a `[[wikilink]]` in the editor opens the link + * popover. Off leaves the popover to its keys (`K`, the editor shortcut). */ + linkPopoverOnHover: boolean /** Render Markdown tables as interactive WYSIWYG widgets in live preview. * Off keeps tables as plain editable markdown — full keyboard/Vim editing. */ renderTablesInLivePreview: boolean @@ -1105,9 +1111,11 @@ export const DEFAULT_PREFS: Prefs = { vaultTextSearchBackend: 'auto', ripgrepBinaryPath: null, fzfBinaryPath: null, + searchTaggedBlocks: true, livePreview: true, showHeadingLevelLabels: false, listIndentGuides: true, + linkPopoverOnHover: true, renderTablesInLivePreview: true, completedTaskStyle: 'none', mathRenderer: 'katex', @@ -1270,6 +1278,10 @@ function normalizePrefs(p: Partial): Prefs { typeof p.fzfBinaryPath === 'string' || p.fzfBinaryPath === null ? (p.fzfBinaryPath as string | null) : DEFAULT_PREFS.fzfBinaryPath, + searchTaggedBlocks: + typeof p.searchTaggedBlocks === 'boolean' + ? p.searchTaggedBlocks + : DEFAULT_PREFS.searchTaggedBlocks, livePreview: typeof p.livePreview === 'boolean' ? p.livePreview : DEFAULT_PREFS.livePreview, showHeadingLevelLabels: @@ -1280,6 +1292,10 @@ function normalizePrefs(p: Partial): Prefs { typeof p.listIndentGuides === 'boolean' ? p.listIndentGuides : DEFAULT_PREFS.listIndentGuides, + linkPopoverOnHover: + typeof p.linkPopoverOnHover === 'boolean' + ? p.linkPopoverOnHover + : DEFAULT_PREFS.linkPopoverOnHover, renderTablesInLivePreview: typeof p.renderTablesInLivePreview === 'boolean' ? p.renderTablesInLivePreview @@ -1815,6 +1831,29 @@ export interface ConnectionPreviewState { anchorRect: PreviewAnchorRect } +/** + * The link popover: the note a `[[wikilink]]` names, editable in place over + * the note that links to it (Logseq-style), or an offer to create it when no + * note answers the link yet. + */ +export interface LinkPopoverState { + /** The target as written, `Doc#Heading` included. */ + target: string + /** The note the link opens, or null while no note answers it. */ + path: string | null + /** Screen rect of the link the popover hangs off. */ + anchorRect: PreviewAnchorRect + /** 'hover' closes when the pointer leaves; 'pinned' waits for Escape, a + * click outside or the close button. Working in a hover popover pins it. */ + mode: 'hover' | 'pinned' + /** Take keyboard focus as it shows: it was opened from a key. */ + focus: boolean + /** The note was just created from the popover: start at its end, typing. */ + created: boolean + /** Bumped by every open, so reopening one link reruns the popover's setup. */ + serial: number +} + export interface CreateDatabaseOptions { /** Initial columns and rows (a converted Markdown table, #832). */ seed?: DatabaseSeed @@ -2398,9 +2437,11 @@ function collectPrefs(s: { vaultTextSearchBackend: VaultTextSearchBackendPreference ripgrepBinaryPath: string | null fzfBinaryPath: string | null + searchTaggedBlocks: boolean livePreview: boolean showHeadingLevelLabels: boolean listIndentGuides: boolean + linkPopoverOnHover: boolean renderTablesInLivePreview: boolean completedTaskStyle: CompletedTaskStyle mathRenderer: MathRenderer @@ -2513,9 +2554,11 @@ function collectPrefs(s: { vaultTextSearchBackend: s.vaultTextSearchBackend, ripgrepBinaryPath: s.ripgrepBinaryPath, fzfBinaryPath: s.fzfBinaryPath, + searchTaggedBlocks: s.searchTaggedBlocks, livePreview: s.livePreview, showHeadingLevelLabels: s.showHeadingLevelLabels, listIndentGuides: s.listIndentGuides, + linkPopoverOnHover: s.linkPopoverOnHover, renderTablesInLivePreview: s.renderTablesInLivePreview, completedTaskStyle: s.completedTaskStyle, mathRenderer: s.mathRenderer, @@ -2937,6 +2980,15 @@ export function isArchiveViewActive(state: { return leaf?.activeTab === ARCHIVE_TAB_PATH } +/** True when the active pane's active tab is the Unresolved Links view. */ +export function isUnresolvedLinksViewActive(state: { + paneLayout: PaneLayout + activePaneId: string +}): boolean { + const leaf = findLeaf(state.paneLayout, state.activePaneId) + return leaf?.activeTab === UNRESOLVED_LINKS_TAB_PATH +} + /** True when the active pane's active tab is the built-in Assets view. */ export function isAssetsViewActive(state: { paneLayout: PaneLayout @@ -3046,9 +3098,11 @@ interface Store { vaultTextSearchBackend: VaultTextSearchBackendPreference ripgrepBinaryPath: string | null fzfBinaryPath: string | null + searchTaggedBlocks: boolean livePreview: boolean showHeadingLevelLabels: boolean listIndentGuides: boolean + linkPopoverOnHover: boolean renderTablesInLivePreview: boolean completedTaskStyle: CompletedTaskStyle mathRenderer: MathRenderer @@ -3284,6 +3338,10 @@ interface Store { /** Whether multiple selected tags combine with AND (`all`, the default — * narrows) or OR (`any` — widens). */ tagMatchMode: TagMatchMode + /** Text for the Tags view to put in its filter the next time it renders, + * then clear: how the Search notes palette hands over a "+N more" row with + * its free text still applied (#837). */ + tagViewFilterSeed: string | null /** Vim navigation: which panel is keyboard-focused. */ focusedPanel: Panel | null @@ -3316,6 +3374,7 @@ interface Store { * pane navigation can restore where you were. (#477) */ outlineCursorIndex: number connectionPreview: ConnectionPreviewState | null + linkPopover: LinkPopoverState | null editorViewRef: EditorView | null editorCursorPosition: EditorCursorPosition | null pendingTitleFocusPath: string | null @@ -3396,6 +3455,10 @@ interface Store { * open + focused. If `tag` is omitted, just opens the tab with the * current selection. First open with a tag starts a fresh selection. */ openTagView: (tag?: string) => Promise + /** Open the Tags view on exactly these tags, matching all of them, with + * `filter` in its filter box: the rest of a Search notes result, one + * keystroke away. */ + openTagViewFor: (tags: string[], filter?: string) => Promise /** Open the Workflows canvas as a tab in the active pane. */ openWorkflowsView: () => Promise /** Open the Atlas map as a tab in the active pane. */ @@ -3409,6 +3472,8 @@ interface Store { /** Open the built-in Archive tab in the active pane. */ openArchiveView: () => Promise openAssetsView: () => Promise + /** Open the built-in Unresolved Links view in the active pane. */ + openUnresolvedLinksView: () => Promise /** Open the built-in Trash tab in the active pane. */ openTrashView: () => Promise /** Read a CSV database (CSV + sidecar) into `databases` if not already loaded. */ @@ -3537,7 +3602,7 @@ interface Store { openNoteAtOffset: ( relPath: string, offset: number, - options?: { scrollMode?: 'center' | 'start' } + options?: { scrollMode?: 'center' | 'start'; highlightLine?: boolean } ) => Promise /** Reload the vault's Typst preamble notes (tag-driven math definitions). */ refreshTypstPreambles: () => Promise @@ -3675,9 +3740,11 @@ interface Store { setVaultTextSearchBackend: (backend: VaultTextSearchBackendPreference) => void setRipgrepBinaryPath: (path: string | null) => void setFzfBinaryPath: (path: string | null) => void + setSearchTaggedBlocks: (enabled: boolean) => void setLivePreview: (on: boolean) => void setShowHeadingLevelLabels: (on: boolean) => void setListIndentGuides: (on: boolean) => void + setLinkPopoverOnHover: (on: boolean) => void setRenderTablesInLivePreview: (on: boolean) => void setCompletedTaskStyle: (style: CompletedTaskStyle) => void setMathRenderer: (renderer: MathRenderer) => void @@ -3879,6 +3946,18 @@ interface Store { setConnectionsCursorIndex: (idx: number) => void setOutlineCursorIndex: (idx: number) => void setConnectionPreview: (preview: ConnectionPreviewState | null) => void + /** Show the link popover. An existing note is read into the shared content + * cache first, so the popover edits the same buffer as every pane. */ + openLinkPopover: (popover: Omit) => Promise + /** Keep a hover popover open once the user works in it. */ + pinLinkPopover: () => void + /** Point the open popover at a note it just created, and focus it. */ + showNoteInLinkPopover: (path: string) => Promise + /** Close the popover; its note is saved first when it has unsaved edits. */ + closeLinkPopover: () => void + /** Create a note without opening it, for the link popover to edit in place. + * Resolves to the new note, or null when it could not be made. */ + createNoteInPlace: (folder: NoteFolder, subpath: string, title: string) => Promise setEditorViewRef: (view: EditorView | null) => void setEditorCursorPosition: (position: EditorCursorPosition | null) => void @@ -4642,6 +4721,7 @@ function rewriteFolderWorkspace( pendingJumpLocation: pendingPath ? { ...s.pendingJumpLocation!, path: pendingPath } : null, pendingTitleFocusPath: s.pendingTitleFocusPath ? rewrite(s.pendingTitleFocusPath) : null, pinnedRefPath: s.pinnedRefPath ? rewrite(s.pinnedRefPath) : null, + linkPopover: rewriteLinkPopover(s.linkPopover, rewrite), ...activeFieldsFrom(ensured.layout, ensured.activePaneId, contents, dirty) } } @@ -4862,6 +4942,69 @@ function rememberPrefetchedPath(path: string): void { prefetchedNotePaths.push(path) } +/** + * Notes whose cached content the link popover still needs. The popover edits + * a note through `noteContents`, like any pane, but no pane may have that + * note open, and every cache prune drops unreferenced paths. A closed + * popover keeps its note held until the last edit is saved: dropping the + * cache first would leave the debounced save nothing to write. + */ +const closingLinkPopoverPaths = new Set() + +function linkPopoverHeldPaths(s: Pick): string[] { + const held = [...closingLinkPopoverPaths] + if (s.linkPopover?.path) held.push(s.linkPopover.path) + return held +} + +function linkPopoverHolds(s: Pick, path: string): boolean { + return s.linkPopover?.path === path || closingLinkPopoverPaths.has(path) +} + +function rewriteLinkPopover( + popover: LinkPopoverState | null, + rewrite: (path: string) => string | null +): LinkPopoverState | null { + if (!popover?.path) return popover + const path = rewrite(popover.path) + if (path === null) return null + return path === popover.path ? popover : { ...popover, path } +} + +/** + * Let go of a note the link popover stopped showing (closed, or replaced by + * another link's note): save its last edit, then drop the cached copy unless + * something else shows it, so a later open reads it fresh from disk, as + * closing a tab does. The caller adds `path` to `closingLinkPopoverPaths` + * before clearing the popover, which keeps the cache alive until the save. + */ +async function releaseLinkPopoverNote(path: string): Promise { + const store = useStore + try { + if (store.getState().noteDirty[path]) await store.getState().persistNote(path) + } finally { + closingLinkPopoverPaths.delete(path) + store.setState((s) => { + const referenced = + s.selectedPath === path || + s.pinnedRefPath === path || + linkPopoverHolds(s, path) || + allLeaves(s.paneLayout).some((leaf) => leaf.tabs.includes(path)) + if (referenced || s.noteDirty[path] || !s.noteContents[path]) return {} + const { [path]: _drop, ...contents } = s.noteContents + const { [path]: _d, ...dirty } = s.noteDirty + void _drop + void _d + return { noteContents: contents, noteDirty: dirty } + }) + } +} + +/** Bumped by every popover open and close, so a slow note read that loses + * the race to a close (the pointer left first) does not reopen it. */ +let linkPopoverRequest = 0 +let linkPopoverSerial = 0 + function prunePrefetchedContents(s: Store): Partial { if (prefetchedNotePaths.length <= MAX_PREFETCHED_NOTE_CONTENTS) return {} @@ -4873,6 +5016,7 @@ function prunePrefetchedContents(s: Store): Partial { const referenced = s.selectedPath === path || s.pinnedRefPath === path || + linkPopoverHolds(s, path) || allLeaves(s.paneLayout).some((leaf) => leaf.tabs.includes(path)) if (referenced || dirty[path]) continue delete contents[path] @@ -4947,6 +5091,7 @@ function withoutNoteInWorkspace(s: Store, path: string): Partial { noteDirty: dirty, pendingJumpLocation: null, pinnedRefPath: s.pinnedRefPath === path ? null : s.pinnedRefPath, + linkPopover: s.linkPopover?.path === path ? null : s.linkPopover, ...activeFieldsFrom(ensured.layout, ensured.activePaneId, contents, dirty) } } @@ -5895,9 +6040,11 @@ export const useStore = create((set, get) => { vaultTextSearchBackend: loadPrefs().vaultTextSearchBackend, ripgrepBinaryPath: loadPrefs().ripgrepBinaryPath, fzfBinaryPath: loadPrefs().fzfBinaryPath, + searchTaggedBlocks: loadPrefs().searchTaggedBlocks, livePreview: loadPrefs().livePreview, showHeadingLevelLabels: loadPrefs().showHeadingLevelLabels, listIndentGuides: loadPrefs().listIndentGuides, + linkPopoverOnHover: loadPrefs().linkPopoverOnHover, renderTablesInLivePreview: loadPrefs().renderTablesInLivePreview, completedTaskStyle: loadPrefs().completedTaskStyle, mathRenderer: loadPrefs().mathRenderer, @@ -6009,6 +6156,7 @@ export const useStore = create((set, get) => { databasesLoading: {}, selectedTags: [], tagMatchMode: 'all', + tagViewFilterSeed: null, focusedPanel: null, sidebarCursorIndex: 0, dateNavExpanded: [], @@ -6020,6 +6168,7 @@ export const useStore = create((set, get) => { connectionsCursorIndex: 0, outlineCursorIndex: 0, connectionPreview: null, + linkPopover: null, editorViewRef: null, editorCursorPosition: null, pendingTitleFocusPath: null, @@ -6229,6 +6378,12 @@ export const useStore = create((set, get) => { // itself, which also moves focus off the sidebar row this was blurring. }, + openTagViewFor: async (tags, filter) => { + get().setSelectedTags(tags) + set({ tagMatchMode: 'all', tagViewFilterSeed: filter ?? '' }) + await get().openTagView() + }, + openTagView: async (tag) => { const state = get() const trimmed = tag?.trim() ?? '' @@ -6295,6 +6450,15 @@ export const useStore = create((set, get) => { set({ focusedPanel: 'editor' }) }, + openUnresolvedLinksView: async () => { + // A link at a file in the vault is not missing, so the scan needs the + // asset list; it is read lazily and may not be there yet. + if (!get().assetFilesListed) await get().refreshAssets() + await get().openNoteInPane(get().activePaneId, UNRESOLVED_LINKS_TAB_PATH) + ;(document.activeElement as HTMLElement | null)?.blur?.() + set({ focusedPanel: 'editor' }) + }, + openAssetsView: async () => { // Refresh both: assets for the list, notes for fresh assetEmbeds (usage). await Promise.all([get().refreshAssets(), get().refreshNotes()]) @@ -7603,7 +7767,8 @@ export const useStore = create((set, get) => { editorSelectionHead: anchor, editorScrollTop: 0, previewScrollTop: 0, - editorScrollMode: options?.scrollMode ?? 'center' + editorScrollMode: options?.scrollMode ?? 'center', + ...(options?.highlightLine ? { highlightLine: true } : {}) } set({ pendingJumpLocation, @@ -7739,6 +7904,8 @@ export const useStore = create((set, get) => { for (const tab of leaf.tabs) referenced.add(tab) } if (pinnedRefPath) referenced.add(pinnedRefPath) + // The link popover edits a cached note no pane may have open. + for (const held of linkPopoverHeldPaths(s)) referenced.add(held) const contents: Record = {} const dirty: Record = {} for (const [path, content] of Object.entries(s.noteContents)) { @@ -7916,6 +8083,7 @@ export const useStore = create((set, get) => { noteContents: contents, noteDirty: dirty, pinnedRefPath: s.pinnedRefPath === notePath ? null : s.pinnedRefPath, + linkPopover: s.linkPopover?.path === notePath ? null : s.linkPopover, ...activeFieldsFrom(ensured.layout, ensured.activePaneId, contents, dirty) } }) @@ -9146,6 +9314,10 @@ export const useStore = create((set, get) => { set({ fzfBinaryPath: path }) savePrefs(collectPrefs(get())) }, + setSearchTaggedBlocks: (enabled) => { + set({ searchTaggedBlocks: enabled }) + savePrefs(collectPrefs(get())) + }, setLivePreview: (on) => { set({ livePreview: on }) savePrefs(collectPrefs(get())) @@ -9158,6 +9330,10 @@ export const useStore = create((set, get) => { set({ listIndentGuides: on }) savePrefs(collectPrefs(get())) }, + setLinkPopoverOnHover: (on) => { + set({ linkPopoverOnHover: on }) + savePrefs(collectPrefs(get())) + }, setRenderTablesInLivePreview: (on) => { set({ renderTablesInLivePreview: on }) savePrefs(collectPrefs(get())) @@ -9351,6 +9527,11 @@ export const useStore = create((set, get) => { contents[s.pinnedRefPath] = s.noteContents[s.pinnedRefPath] dirty[s.pinnedRefPath] = s.noteDirty[s.pinnedRefPath] ?? false } + for (const held of linkPopoverHeldPaths(s)) { + if (!s.noteContents[held]) continue + contents[held] = s.noteContents[held] + dirty[held] = s.noteDirty[held] ?? false + } return { tabsEnabled: false, paneLayout: onlyLeaf, @@ -10291,6 +10472,67 @@ export const useStore = create((set, get) => { setConnectionsCursorIndex: (idx) => set({ connectionsCursorIndex: idx }), setOutlineCursorIndex: (idx) => set({ outlineCursorIndex: idx }), setConnectionPreview: (preview) => set({ connectionPreview: preview }), + openLinkPopover: async (popover) => { + const request = ++linkPopoverRequest + const path = popover.path + if (path && !get().noteContents[path]) { + let content: NoteContent + try { + content = await readNoteContent(path, get()) + } catch (err) { + console.error('openLinkPopover readNote failed', err) + return + } + if (request !== linkPopoverRequest) return + set((s) => + s.noteContents[path] + ? {} + : { + noteContents: { ...s.noteContents, [path]: content }, + noteDirty: { ...s.noteDirty, [path]: false } + } + ) + } + if (request !== linkPopoverRequest) return + const replaced = get().linkPopover?.path + if (replaced && replaced !== path) closingLinkPopoverPaths.add(replaced) + set({ linkPopover: { ...popover, serial: ++linkPopoverSerial } }) + if (replaced && replaced !== path) void releaseLinkPopoverNote(replaced) + }, + pinLinkPopover: () => { + const popover = get().linkPopover + if (!popover || popover.mode === 'pinned') return + set({ linkPopover: { ...popover, mode: 'pinned' } }) + }, + showNoteInLinkPopover: async (path) => { + const popover = get().linkPopover + if (!popover) return + await get().openLinkPopover({ ...popover, path, mode: 'pinned', focus: true, created: true }) + }, + closeLinkPopover: () => { + linkPopoverRequest++ + const popover = get().linkPopover + if (!popover) return + const path = popover.path + if (path) closingLinkPopoverPaths.add(path) + set({ linkPopover: null }) + if (path) void releaseLinkPopoverNote(path) + }, + createNoteInPlace: trackNoteWrite(null, async (folder, subpath, title) => { + try { + const meta = await window.zen.createNote(folder, title, subpath) + rememberEditModeForCreatedNote(meta.path) + emitNoteEvent('note-created', meta.path) + set((s) => ({ + notes: s.notes.some((n) => n.path === meta.path) ? s.notes : [...s.notes, meta] + })) + await get().refreshNotes() + return get().notes.find((n) => n.path === meta.path) ?? meta + } catch (err) { + console.error('createNoteInPlace failed', err) + return null + } + }), setEditorViewRef: (view) => set({ editorViewRef: view, @@ -10586,6 +10828,7 @@ export const useStore = create((set, get) => { const ensured = ensureActivePane(nextLayout, s.activePaneId) const stillOpen = s.pinnedRefPath === path || + linkPopoverHolds(s, path) || allLeaves(nextLayout).some((l) => l.tabs.includes(path)) const contents = { ...s.noteContents } const dirty = { ...s.noteDirty } @@ -10658,6 +10901,7 @@ export const useStore = create((set, get) => { // including the pinned-reference pane. const stillOpen = cur.pinnedRefPath === path || + linkPopoverHolds(cur, path) || allLeaves(layout).some((l) => l.tabs.includes(path)) const nextContents = { ...contents } const nextDirty = { ...dirty } @@ -10715,6 +10959,7 @@ export const useStore = create((set, get) => { layout = splitLeaf(layout, targetPaneId, edge, newLeaf) const stillOpen = cur.pinnedRefPath === path || + linkPopoverHolds(cur, path) || allLeaves(layout).some((l) => l.tabs.includes(path)) const nextContents = { ...contents } const nextDirty = { ...dirty } diff --git a/packages/app-core/src/styles/index.css b/packages/app-core/src/styles/index.css index 1ff1fb03..f876a304 100644 --- a/packages/app-core/src/styles/index.css +++ b/packages/app-core/src/styles/index.css @@ -2291,6 +2291,16 @@ html[data-completed-task-style="gray-strikethrough"] .cm-editor .cm-task-done * color: rgb(var(--z-accent)); text-decoration: none; } +/* `tok-link` is a mark around the highlight spans (cm-markdown-links.ts), so a + label inside a list, heading, or emphasis sits in a span whose own body color + (`.tok-list` and friends above) beats the color the mark passes down. The + label span takes the accent back here. `:where()` keeps the specificity of + the `.tok-link` class this span carried before 2.50.3, so the tokens declared + after this rule (link brackets, titles, labels) keep their own colors, and an + undefined `[ref]`, which gets no mark, stays prose. */ +.cm-editor :where(.tok-link) .tok-link-syntax { + color: rgb(var(--z-accent)); +} .cm-editor .tok-monospace { font-family: var( --z-mono-font, @@ -3827,6 +3837,37 @@ html[data-completed-task-style="gray-strikethrough"] .prose-zen li.task-list-ite text-decoration-color: rgb(var(--z-accent)); } +/* The link popover's editor. The main editor's 20vh bottom runway, centered + measure and 32px gutter are sized for a whole pane; in a floating card they + only push the note out of sight. */ +.zn-link-popover .cm-editor { + height: auto; + max-height: 100%; + font-size: calc(var(--z-editor-font-size, 16px) * 0.875); +} +/* A card a few lines tall cannot spend most of them on a 2em title. */ +.zn-link-popover .cm-editor .tok-heading1 { + font-size: 1.45em; +} +.zn-link-popover .cm-editor .tok-heading2 { + font-size: 1.3em; +} +.zn-link-popover .cm-editor .tok-heading3 { + font-size: 1.15em; +} +.zn-link-popover .cm-editor .cm-scroller { + padding: 8px 0 12px 0; +} +.zn-link-popover .cm-editor .cm-content { + max-width: none; + margin: 0; + padding: 0 14px; +} +.zn-link-popover [data-link-popover-editor] { + display: flex; + flex-direction: column; +} + .prose-hover-preview { font-size: 13px; line-height: var(--z-editor-line-height, 1.7); @@ -5671,6 +5712,14 @@ html[data-completed-task-style="gray-strikethrough"] .prose-zen li.task-list-ite text-decoration: underline; text-decoration-color: rgb(var(--z-accent) / 0.4); } +/* A [[wikilink]] whose note does not exist yet: the editor's + `.cm-wikilink-broken` look, muted with a dashed underline, so a cell link + that would create a note reads apart from one that opens a note. */ +.cm-table-widget .cm-table-cell a.wikilink.broken { + color: theme("colors.ink.500"); + text-decoration-style: dashed; + text-decoration-color: theme("colors.ink.400"); +} .cm-table-widget td[align="center"] .cm-table-cell, .cm-table-widget th[align="center"] .cm-table-cell { text-align: center; diff --git a/packages/bridge-contract/package.json b/packages/bridge-contract/package.json index a08bf33c..7b4b0758 100644 --- a/packages/bridge-contract/package.json +++ b/packages/bridge-contract/package.json @@ -1,7 +1,7 @@ { "name": "@zennotes/bridge-contract", "private": true, - "version": "2.76.0", + "version": "2.77.0", "type": "module", "exports": { "./bridge": "./src/bridge.ts", diff --git a/packages/bridge-contract/src/app-config.ts b/packages/bridge-contract/src/app-config.ts index ac7120c6..e936c9d5 100644 --- a/packages/bridge-contract/src/app-config.ts +++ b/packages/bridge-contract/src/app-config.ts @@ -22,10 +22,12 @@ export const PORTABLE_PREF_KEYS = [ 'vaultTextSearchBackend', 'ripgrepBinaryPath', 'fzfBinaryPath', + 'searchTaggedBlocks', // editor 'livePreview', 'showHeadingLevelLabels', 'listIndentGuides', + 'linkPopoverOnHover', 'renderTablesInLivePreview', 'completedTaskStyle', 'mathRenderer', diff --git a/packages/shared-domain/package.json b/packages/shared-domain/package.json index e523638a..0dffe2c1 100644 --- a/packages/shared-domain/package.json +++ b/packages/shared-domain/package.json @@ -1,7 +1,7 @@ { "name": "@zennotes/shared-domain", "private": true, - "version": "2.76.0", + "version": "2.77.0", "type": "module", "exports": { "./*": "./src/*.ts" diff --git a/packages/shared-domain/src/app-config.ts b/packages/shared-domain/src/app-config.ts index 3e8a9abe..8dfbde57 100644 --- a/packages/shared-domain/src/app-config.ts +++ b/packages/shared-domain/src/app-config.ts @@ -87,9 +87,11 @@ export const PORTABLE_DEFAULTS: Record = { vaultTextSearchBackend: 'auto', ripgrepBinaryPath: null, fzfBinaryPath: null, + searchTaggedBlocks: true, livePreview: true, showHeadingLevelLabels: false, listIndentGuides: true, + linkPopoverOnHover: true, renderTablesInLivePreview: true, completedTaskStyle: 'none', mathRenderer: 'katex', diff --git a/packages/shared-domain/src/block-anchors.test.ts b/packages/shared-domain/src/block-anchors.test.ts index c47b10fa..22f34990 100644 --- a/packages/shared-domain/src/block-anchors.test.ts +++ b/packages/shared-domain/src/block-anchors.test.ts @@ -27,6 +27,12 @@ describe('stripBlockAnchorMarkers (#601 review)', () => { expect(stripBlockAnchorMarkers(fm)).toBe(fm) }) + it('never touches a code fence in a body with CRLF line endings', () => { + const code = '```bash\r\nkill %1 ^Z2\r\n```\r\nafter\r\n' + expect(stripBlockAnchorMarkers(code)).toBe(code) + expect(parseBlockAnchors(code)).toEqual([]) + }) + it('blanks a standalone marker line without changing the line count', () => { const src = 'A paragraph.\n\n^tag\n\nNext.' const out = stripBlockAnchorMarkers(src) diff --git a/packages/shared-domain/src/cloud-e2ee-vault.test.ts b/packages/shared-domain/src/cloud-e2ee-vault.test.ts index b952c6fe..f7a6ac89 100644 --- a/packages/shared-domain/src/cloud-e2ee-vault.test.ts +++ b/packages/shared-domain/src/cloud-e2ee-vault.test.ts @@ -22,7 +22,13 @@ import { } from './cloud-e2ee-account' import { CloudE2eeError, fromBase64, sha256Hex, toBase64 } from './cloud-e2ee' import { CLOUD_E2EE_HEADER, CloudE2eeLockedError } from './cloud-e2ee-vault' -import { CloudSyncApiClient, type CloudSyncHttpRequest, type CloudSyncHttpTransport } from './cloud-sync-api' +import { + CloudSyncApiClient, + CloudSyncRateLimitCoordinator, + type CloudSyncHttpRequest, + type CloudSyncHttpTransport +} from './cloud-sync-api' +import { CloudSyncTransportError } from './cloud-sync-stall' import { validateCloudSyncContentReference, validateCloudSyncDownloadInstruction } from './cloud-sync-content' const PASSPHRASE = 'quiet harbor lantern orbit' @@ -295,6 +301,38 @@ describe('encrypted vault sync through the API client', () => { ).rejects.toThrow(/needs the file details/) }, 20_000) + it('replays a stalled encrypted push with the same sealed bytes, never sealing it again', async () => { + const { cloud, keyring, vault } = await encryptedSetup() + const sent: Array<{ body: string; header: string | undefined }> = [] + let stalls = 1 + const flaky: CloudSyncHttpTransport = { + request: async (request: CloudSyncHttpRequest): Promise => { + if (request.path.endsWith('/mutations')) { + sent.push({ body: JSON.stringify(request.body), header: request.headers?.[CLOUD_E2EE_HEADER] }) + if (stalls-- > 0) throw new CloudSyncTransportError('timeout', { stalled: true }) + } + return cloud.request(request) + } + } + const transport = new CloudSyncRateLimitCoordinator().wrap(flaky, { + baseUrl: 'https://cloud.example.test', accountId: 'account', transportRetryDelaysMs: [0] + }) + const client = new CloudSyncApiClient(transport, { endToEndEncryption: true, vaultCiphers: keyring }) + const note = await utf8Content('# Secret\n\nMeet at noon.') + await client.mutate(vault.id, { + mutations: [{ type: 'upsert', operation_id: 'op-1', item_id: 'item-1', base_revision: null, path: 'Secret.md', kind: 'text', content: note }] + }) + + // Sealing uses fresh nonces, so a second seal would be a different + // request under the same operation id, which the service refuses. + expect(sent).toHaveLength(2) + expect(sent[1].body).toBe(sent[0].body) + expect(sent[0].header).toBeDefined() + expect(sent[1].header).toBe(sent[0].header) + expect(sent[0].body).not.toContain('Meet at noon') + expect((await client.manifest(vault.id, { includeContent: true })).data).toMatchObject([{ path: 'Secret.md', content: note }]) + }, 20_000) + it('leaves readable vaults byte for byte as before, minus the client-only hints', async () => { const { cloud, client, readable } = await encryptedSetup() const note = await utf8Content('plain') diff --git a/packages/shared-domain/src/cloud-error-copy.test.ts b/packages/shared-domain/src/cloud-error-copy.test.ts index d6417e11..cb52117d 100644 --- a/packages/shared-domain/src/cloud-error-copy.test.ts +++ b/packages/shared-domain/src/cloud-error-copy.test.ts @@ -16,6 +16,7 @@ import { } from './cloud-error-copy' import { CLOUD_VAULT_REMOVED_MESSAGE } from './cloud-vault-availability' import { CloudE2eeError } from './cloud-e2ee' +import { CloudSyncTransportError } from './cloud-sync-stall' /** The shape both the desktop client and the phone shells throw. */ function serviceError( @@ -60,6 +61,17 @@ describe('describeCloudError', () => { expect(describeCloudError(overIpc('cloud-vault:sync', timeout)).message).toBe(CLOUD_TIMEOUT_MESSAGE) }) + it('words a phone request that stalled or never connected, keeping the host\'s words as details', () => { + const stalled = new CloudSyncTransportError('timeout', { stalled: true, code: 'SocketTimeoutException' }) + expect(describeCloudError(stalled)).toEqual({ + message: CLOUD_TIMEOUT_MESSAGE, + detail: 'SocketTimeoutException · timeout', + kind: 'offline' + }) + const refused = new CloudSyncTransportError('Unable to resolve host', { code: 'UnknownHostException' }) + expect(describeCloudError(refused)).toMatchObject({ message: CLOUD_OFFLINE_MESSAGE, kind: 'offline' }) + }) + it('treats a refused sign-in as signed out, whatever the server says', () => { for (const error of [ serviceError('Authentication is required.', 401, 'UNAUTHENTICATED'), diff --git a/packages/shared-domain/src/cloud-error-copy.ts b/packages/shared-domain/src/cloud-error-copy.ts index 5c01ec28..ad4d1eef 100644 --- a/packages/shared-domain/src/cloud-error-copy.ts +++ b/packages/shared-domain/src/cloud-error-copy.ts @@ -224,6 +224,7 @@ interface RawCloudError { causeCode: string | null issue: CloudIssue | null path: string | null + stalled: boolean } /** @@ -249,6 +250,11 @@ export function describeCloudError(error: unknown, fallback = CLOUD_UNEXPECTED_M if (raw.issue) return worded(issueMessage(raw.issue, raw.path)) if (raw.name === 'AbortError') return worded(STOPPED) + // A phone request that got no answer, after its retries: the host already + // knows whether the connection went quiet or failed outright. + if (raw.name === 'CloudSyncTransportError') { + return worded(raw.stalled ? CLOUD_TIMEOUT_MESSAGE : CLOUD_OFFLINE_MESSAGE, 'offline') + } if (isTimeout(raw)) return worded(CLOUD_TIMEOUT_MESSAGE, 'offline') if (isNetworkFailure(raw)) return worded(CLOUD_OFFLINE_MESSAGE, 'offline') @@ -501,6 +507,7 @@ function rawCloudError(error: unknown): RawCloudError { issue?: unknown path?: unknown relPath?: unknown + stalled?: unknown } const message = typeof error === 'string' ? error : typeof value.message === 'string' ? value.message : error == null ? '' : String(error) @@ -519,7 +526,8 @@ function rawCloudError(error: unknown): RawCloudError { : null, causeCode: cause && typeof cause === 'object' && typeof cause.code === 'string' ? cause.code : null, issue: ownName === 'CloudIssueError' && typeof value.issue === 'string' ? (value.issue as CloudIssue) : null, - path: typeof value.path === 'string' ? value.path : typeof value.relPath === 'string' ? value.relPath : null + path: typeof value.path === 'string' ? value.path : typeof value.relPath === 'string' ? value.relPath : null, + stalled: value.stalled === true } } diff --git a/packages/shared-domain/src/cloud-sync-api.test.ts b/packages/shared-domain/src/cloud-sync-api.test.ts index 06e617f6..abccf0c6 100644 --- a/packages/shared-domain/src/cloud-sync-api.test.ts +++ b/packages/shared-domain/src/cloud-sync-api.test.ts @@ -121,6 +121,7 @@ describe('CloudSyncApiClient', () => { method: 'POST', path: '/api/v1/vaults/vault%2F1/uploads/upload%2F1/complete', timeoutMs: 300_000, + retryOnTransportFailure: false, retryOnRateLimit: true }, { diff --git a/packages/shared-domain/src/cloud-sync-api.ts b/packages/shared-domain/src/cloud-sync-api.ts index 7292b83d..94024cb4 100644 --- a/packages/shared-domain/src/cloud-sync-api.ts +++ b/packages/shared-domain/src/cloud-sync-api.ts @@ -86,8 +86,13 @@ export interface CloudSyncHttpRequest { timeoutMs?: number signal?: AbortSignal /** Only for explicitly idempotent JSON operations with stable operation/session IDs. - * GETs are replayable by default. Other requests are never retried implicitly. */ + * GETs are replayable by default. Other requests are never retried implicitly. + * A replayable request is also sent again after a transport failure where the + * host opts in (CloudSyncRateLimitOptions.transportRetryDelaysMs). */ retryOnRateLimit?: boolean + /** False where the service may still be working on a request that got no + * answer, so sending it again would race the first attempt. */ + retryOnTransportFailure?: boolean /** Extra request headers; transports forward them. */ headers?: Record } @@ -431,6 +436,9 @@ export class CloudSyncApiClient { method: 'POST', path: `${this.uploadPath(vaultId, uploadId)}/complete`, timeoutMs: 300_000, + // The service hashes the whole object before it answers; a second + // completion sent while that runs is refused. Hosts retry it themselves. + retryOnTransportFailure: false, ...(uploadId ? { retryOnRateLimit: true } : {}) }) if (!cipher) return response diff --git a/packages/shared-domain/src/cloud-sync-coordinator.test.ts b/packages/shared-domain/src/cloud-sync-coordinator.test.ts index 792a111e..25ba7c6f 100644 --- a/packages/shared-domain/src/cloud-sync-coordinator.test.ts +++ b/packages/shared-domain/src/cloud-sync-coordinator.test.ts @@ -2032,6 +2032,131 @@ describe('CloudSyncCoordinator: catching up on a file this device never touched' expect(server.mutations).toEqual([]) }) + it('saves only what landed when a change fails while a coalesced revision is still owed', async () => { + // Fresh.md lands on its own. Plan.md v2 is then skipped in favour of v3, + // and New.md lands while v3 is still owed, so the newest state that can + // stand on its own is the one right after Fresh.md. The failing move must + // not save Plan.md as v2, nor New.md as tracked. + const fs = memoryFileSystem({ [path]: 'v1', 'Other.md': 'other' }) + const rename = fs.rename + let refuse = true + fs.rename = async (from, to) => { + if (refuse) throw new Error('rename failed: Already exists') + return rename(from, to) + } + const states = memoryState({ + version: 1, + vault_id: 'vault-1', + cursor: 1, + items: { + plan: tracked('plan', path, 1, 'v1'), + other: tracked('other', 'Other.md', 1, 'other') + } + }) + const server = remote({ + changes: [ + upsert(2, 'fresh', 'Fresh.md', 'fresh'), + upsert(3, 'plan', path, 'v2'), + upsert(4, 'new', 'New.md', 'new'), + { + sequence: 5, + item_id: 'other', + type: 'move', + path: 'archive/Other.md', + previous_path: 'Other.md', + revision: 5 + }, + upsert(6, 'plan', path, 'v3') + ] + }) + const coordinator = new CloudSyncCoordinator( + 'vault-1', + server, + new PortableCloudSyncRepository(fs), + states, + ids() + ) + + await expect(coordinator.sync()).rejects.toThrow('Already exists') + expect(states.current).toEqual({ + version: 1, + vault_id: 'vault-1', + cursor: 2, + items: { + plan: tracked('plan', path, 1, 'v1'), + other: tracked('other', 'Other.md', 1, 'other'), + fresh: tracked('fresh', 'Fresh.md', 2, 'fresh') + } + }) + + refuse = false + const retry = await coordinator.sync() + + expect(retry.localConflicts).toEqual([]) + expect([...fs.files.keys()].sort()).toEqual(['Fresh.md', 'New.md', 'archive/Other.md', path]) + expect(fs.files.get(path)).toBe('v3') + expect(states.current?.cursor).toBe(6) + expect(states.current?.items.new).toEqual(tracked('new', 'New.md', 4, 'new')) + expect(states.current?.pending_conflicts ?? {}).toEqual({}) + expect(server.mutations).toEqual([]) + }) + + it('pulls each change at the same cost in a large vault as in a small one', async () => { + // Every pulled change used to copy the whole tracked state, so a phone + // catching up on a big vault paid for its size on every file: 1.7 ms a + // change at 10,000 notes against 0.18 ms at 600 (18 µs at both now). + async function perChange(vaultSize: number, arriving: number): Promise { + const items: CloudSyncState['items'] = {} + const files = new Map() + for (let index = 0; index < vaultSize; index++) { + const notePath = `inbox/Note ${index}.md` + const body = content(`note ${index}`) + items[`note-${index}`] = { + item_id: `note-${index}`, path: notePath, kind: 'text', revision: 1, + sha256: body.sha256, byte_length: body.byte_length, media_type: body.media_type + } + files.set(notePath, { path: notePath, kind: 'text', content: body }) + } + const changes = Array.from({ length: arriving }, (_, index): CloudSyncChange => ({ + sequence: vaultSize + index + 1, + item_id: `new-${index}`, + type: 'upsert', + path: `inbox/New ${index}.md`, + previous_path: null, + revision: 1, + content: content(`new ${index}`) + })) + // Timed from the first file written to the last, so the run's one scan + // and one save, which do grow with the vault, are left out. + let first = 0 + let last = 0 + const repository: CloudSyncRepository = { + async scan() { + return [...files.values()] + }, + async apply(change) { + last = performance.now() + first ||= last + if (change.content) files.set(change.path, { path: change.path, kind: 'text', content: change.content }) + } + } + const result = await new CloudSyncCoordinator( + 'vault-1', + remote({ changes }), + repository, + memoryState({ version: 1, vault_id: 'vault-1', cursor: vaultSize, items }), + ids() + ).sync() + expect(result.pulled).toBe(arriving) + return (last - first) / (arriving - 1) + } + + await perChange(200, 2000) + const small = await perChange(200, 2000) + const large = await perChange(20_000, 2000) + expect(large).toBeLessThan(small * 5) + }) + it('queues a real local edit without creating a note beside it', async () => { const fs = memoryFileSystem({ [path]: 'edited here while offline' }) const states = memoryState({ diff --git a/packages/shared-domain/src/cloud-sync-coordinator.ts b/packages/shared-domain/src/cloud-sync-coordinator.ts index cc5db432..c53a5290 100644 --- a/packages/shared-domain/src/cloud-sync-coordinator.ts +++ b/packages/shared-domain/src/cloud-sync-coordinator.ts @@ -29,7 +29,7 @@ import { import { emptyCloudSyncState, planCloudSyncMutations, - reduceCloudSyncChange, + reduceCloudSyncChangeInto, resolveCloudSyncMutations, type CloudSyncIdSource, type CloudSyncLocalItem, @@ -108,6 +108,10 @@ export interface CloudSyncRepository { applyStagedCloudContent?(change: CloudSyncChange, previous: CloudSyncTrackedItem | undefined, file: CloudSyncStagedFile): Promise resolveStagedCloudConflict?(input: CloudSyncStagedConflict): Promise scan(): Promise + /** The file scan() would list at exactly this path and spelling, or null + * when none is there. Reviewing a conflict needs only its own file, and a + * phone hashes every file a scan lists. */ + readLocalItem?(path: string): Promise /** Finish filesystem work an earlier run was stopped in the middle of. Runs * first in every sync run, before anything is pulled or scanned. */ recoverInterruptedWork?(): Promise @@ -888,6 +892,12 @@ export class CloudSyncCoordinator { // revision still waiting for the change that lands it) and save that // before the error escapes, so a retry resumes at the failing change. let landed = initialState + // Tracked items change in place, in one copy this pull owns: copying all + // of them for every change made each pulled file cost more the bigger the + // vault was. What an item held when `landed` was taken is kept until the + // next landing, so `landed` can still be saved exactly as it was. + let items: Record | null = null + const sinceLanded = new Map() let hydratedPage = -1 let pageBodies = new Map() try { @@ -944,12 +954,19 @@ export class CloudSyncCoordinator { } pulled++ } - state = reduceCloudSyncChange(state, change) - if (onDisk.size === 0) landed = state + if (change.sequence > state.cursor) { + items ??= { ...state.items } + if (!sinceLanded.has(change.item_id)) sinceLanded.set(change.item_id, items[change.item_id]) + state = { ...state, cursor: reduceCloudSyncChangeInto(items, state.cursor, change), items } + } + if (onDisk.size === 0) { + landed = state + sinceLanded.clear() + } } throwIfCloudSyncCancelled(this.remote.downloadSignal) } catch (error) { - if (landed !== initialState) await this.states.save(landed) + if (landed !== initialState) await this.states.save(asLanded(landed, sinceLanded)) throw error } if (changes.length > 0) await this.states.save(state) @@ -1234,8 +1251,15 @@ export class CloudSyncCoordinator { private async currentLocalSnapshot( conflict: CloudSyncStoredConflict ): Promise { - const items = await this.repository.scan() const expectedPath = conflict.local.path ?? conflict.base.path + // Opening one conflict scanned the whole vault, and a phone reads and + // hashes every file it lists: on a vault just pulled from a computer the + // review waited on that for as long as the vault was big. Only a file + // that is no longer at its path (moved, renamed by case) needs the scan. + const direct = expectedPath && this.repository.readLocalItem + ? await this.repository.readLocalItem(expectedPath) + : null + const items = direct ? [direct] : await this.repository.scan() const exact = expectedPath ? items.find((item) => cloudSyncPathKey(item.path) === cloudSyncPathKey(expectedPath)) : undefined @@ -1999,6 +2023,21 @@ function withConflict(state: CloudSyncState, conflict: CloudSyncStoredConflict): return { ...state, pending_conflicts: { ...state.pending_conflicts, [conflict.id]: conflict } } } +/** A pull's landed state as it was taken, undoing what its items have + * changed in place since (pullChanges). */ +function asLanded( + landed: CloudSyncState, + sinceLanded: ReadonlyMap +): CloudSyncState { + if (sinceLanded.size === 0) return landed + const items = { ...landed.items } + for (const [id, item] of sinceLanded) { + if (item) items[id] = item + else delete items[id] + } + return { ...landed, items } +} + /** * A conflict for a file this device never had (no base) whose Cloud copy no * longer sits on the local file it met: Cloud moved or deleted it since. diff --git a/packages/shared-domain/src/cloud-sync-engine.test.ts b/packages/shared-domain/src/cloud-sync-engine.test.ts index 589dbd1b..b5b7137f 100644 --- a/packages/shared-domain/src/cloud-sync-engine.test.ts +++ b/packages/shared-domain/src/cloud-sync-engine.test.ts @@ -1,9 +1,10 @@ import { describe, expect, it } from 'vitest' -import type { CloudSyncContent, CloudSyncMutationResponse } from '@zennotes/bridge-contract/cloud-sync' +import type { CloudSyncChange, CloudSyncContent, CloudSyncMutationResponse } from '@zennotes/bridge-contract/cloud-sync' import { emptyCloudSyncState, planCloudSyncMutations, reduceCloudSyncChange, + reduceCloudSyncChangeInto, resolveCloudSyncMutations, type CloudSyncIdSource, type CloudSyncState @@ -274,3 +275,43 @@ describe('reduceCloudSyncChange', () => { ).toThrow('Expected sync sequence 2') }) }) + +describe('reduceCloudSyncChangeInto', () => { + it('changes the caller’s items in place exactly as reduceCloudSyncChange would', () => { + const changes: CloudSyncChange[] = [ + { sequence: 1, item_id: 'a', type: 'upsert', path: 'a.md', previous_path: null, revision: 1, content: content('a1') }, + { sequence: 2, item_id: 'b', type: 'upsert', path: 'b.md', previous_path: null, revision: 1, content: content('b1') }, + { sequence: 3, item_id: 'a', type: 'move', path: 'archive/a.md', previous_path: 'a.md', revision: 2 }, + { sequence: 4, item_id: 'b', type: 'delete', path: 'b.md', previous_path: null, revision: 2 }, + { sequence: 5, item_id: 'a', type: 'upsert', path: 'archive/a.md', previous_path: null, revision: 3, content: content('a3') } + ] + let reduced = emptyCloudSyncState('vault-1') + const items: CloudSyncState['items'] = {} + let cursor = 0 + for (const change of changes) { + reduced = reduceCloudSyncChange(reduced, change) + cursor = reduceCloudSyncChangeInto(items, cursor, change) + expect({ cursor, items }).toEqual({ cursor: reduced.cursor, items: reduced.items }) + } + // A change the cursor already covers is left out, as before. + expect(reduceCloudSyncChangeInto(items, cursor, changes[1]!)).toBe(5) + expect(items).toEqual(reduced.items) + }) + + it('leaves the items untouched when a change cannot be reduced', () => { + const items = { + a: { item_id: 'a', path: 'a.md', kind: 'text' as const, revision: 1, sha256: 'hash:a1', byte_length: 2, media_type: 'text/markdown' } + } + const before = structuredClone(items) + expect(() => reduceCloudSyncChangeInto(items, 1, { + sequence: 3, item_id: 'a', type: 'delete', path: 'a.md', previous_path: null, revision: 2 + })).toThrow('Expected sync sequence 2') + expect(() => reduceCloudSyncChangeInto(items, 1, { + sequence: 2, item_id: 'missing', type: 'move', path: 'b.md', previous_path: 'a.md', revision: 2 + })).toThrow('Received a move for unknown item missing') + expect(() => reduceCloudSyncChangeInto(items, 1, { + sequence: 2, item_id: 'a', type: 'upsert', path: 'a.md', previous_path: null, revision: 2 + })).toThrow('did not include content') + expect(items).toEqual(before) + }) +}) diff --git a/packages/shared-domain/src/cloud-sync-engine.ts b/packages/shared-domain/src/cloud-sync-engine.ts index de88d007..c3a89f4e 100644 --- a/packages/shared-domain/src/cloud-sync-engine.ts +++ b/packages/shared-domain/src/cloud-sync-engine.ts @@ -262,11 +262,26 @@ export function reduceCloudSyncChange( change: CloudSyncChange ): CloudSyncState { if (change.sequence <= state.cursor) return state - if (change.sequence !== state.cursor + 1) { - throw cloudProtocolError(`Expected sync sequence ${state.cursor + 1}, received ${change.sequence}`) + const items = { ...state.items } + const cursor = reduceCloudSyncChangeInto(items, state.cursor, change) + return { ...state, cursor, items } +} + +/** + * reduceCloudSyncChange on tracked items the caller owns, changed in place, + * so one change costs the same in a vault of any size. Returns the new + * cursor, and leaves `items` as it was when it throws. + */ +export function reduceCloudSyncChangeInto( + items: Record, + cursor: number, + change: CloudSyncChange +): number { + if (change.sequence <= cursor) return cursor + if (change.sequence !== cursor + 1) { + throw cloudProtocolError(`Expected sync sequence ${cursor + 1}, received ${change.sequence}`) } - const items = { ...state.items } if (change.type === 'delete') { delete items[change.item_id] } else if (change.type === 'move') { @@ -294,7 +309,7 @@ export function reduceCloudSyncChange( } } - return { ...state, cursor: change.sequence, items } + return change.sequence } function inferItemKind(content: CloudSyncContentMetadata): CloudSyncItemKind { diff --git a/packages/shared-domain/src/cloud-sync-host-service.test.ts b/packages/shared-domain/src/cloud-sync-host-service.test.ts index 29d6961b..9c721c2a 100644 --- a/packages/shared-domain/src/cloud-sync-host-service.test.ts +++ b/packages/shared-domain/src/cloud-sync-host-service.test.ts @@ -360,6 +360,65 @@ describe('CloudSyncHostService', () => { }) }) + // Discord, 2026-10-26: queued behind a run waiting on a dropped connection, + // a phone's review showed "Loading the versions kept for you" until that + // request timed out minutes later. + it('opens a waiting conflict without waiting for a sync that is stuck', async () => { + const remoteVault: CloudSyncVault = { + id: 'vault-1', + name: 'Notes', + cursor: 1, + created_at: '2026-08-10T12:00:00.000Z', + updated_at: '2026-08-10T12:00:00.000Z' + } + const local = textContent('latest local edit') + const cloud = textContent('older cloud edit') + const { client, hostVault, service } = setup( + [remoteVault], + [{ path: 'Note.md', kind: 'text', content: local }] + ) + client.manifest.mockResolvedValue({ + data: [ + { + item_id: 'item-remote', + path: 'Note.md', + kind: 'text', + revision: 3, + sha256: cloud.sha256, + byte_length: cloud.byte_length, + media_type: cloud.media_type, + content: cloud + } + ], + cursor: 1, + next_page: null + }) + await service.link(hostVault, remoteVault.id) + const conflict = (await service.sync(hostVault)).pending_conflicts![0]! + + let releaseChanges!: (value: { data: []; cursor: number; has_more: false }) => void + client.changes.mockReset().mockImplementationOnce( + () => + new Promise((resolve) => { + releaseChanges = resolve + }) + ) + const syncing = service.sync(hostVault) + await vi.waitFor(() => expect(client.changes).toHaveBeenCalledOnce()) + + const opened = await Promise.race([ + service.getConflict(hostVault, conflict.id), + new Promise<'still waiting'>((resolve) => setTimeout(() => resolve('still waiting'), 500)) + ]) + expect(opened).toMatchObject({ + local: { text: 'latest local edit' }, + cloud: { text: 'older cloud edit' } + }) + + releaseChanges({ data: [], cursor: 1, has_more: false }) + await syncing + }) + it('does not start a sync while a conflict decision is being saved', async () => { const remoteVault: CloudSyncVault = { id: 'vault-1', diff --git a/packages/shared-domain/src/cloud-sync-host-service.ts b/packages/shared-domain/src/cloud-sync-host-service.ts index 77dd1cad..dda11c1e 100644 --- a/packages/shared-domain/src/cloud-sync-host-service.ts +++ b/packages/shared-domain/src/cloud-sync-host-service.ts @@ -372,16 +372,21 @@ export class CloudSyncHostService { vault: CloudSyncHostVault, conflictId: string ): Promise { - return await this.exclusive(vault.key, async () => { - const { account, client, link } = await this.linkedConnection(vault) - return await new CloudSyncCoordinator( - link.vault_id, - client, - vault.repository, - this.stateStore(vault.key, account.base_url, link.vault_id), - this.ids - ).getConflict(conflictId) - }) + // Reading a waiting conflict changes nothing, so it does not queue behind + // the vault's other work. Queued, the review waited out whatever sync was + // running: a phone's long first sync, or a request on a dropped + // connection that holds a run for minutes until it times out (Discord, + // 2026-10-26: "Loading the versions kept for you" never finished). A + // draft or a decision still waits its turn, and a choice made on what + // this read showed is checked again when it is saved. + const { account, client, link } = await this.linkedConnection(vault) + return await new CloudSyncCoordinator( + link.vault_id, + client, + vault.repository, + this.stateStore(vault.key, account.base_url, link.vault_id), + this.ids + ).getConflict(conflictId) } async saveConflictDraft( diff --git a/packages/shared-domain/src/cloud-sync-portable-filesystem.test.ts b/packages/shared-domain/src/cloud-sync-portable-filesystem.test.ts index f0b63a9f..c69b72fe 100644 --- a/packages/shared-domain/src/cloud-sync-portable-filesystem.test.ts +++ b/packages/shared-domain/src/cloud-sync-portable-filesystem.test.ts @@ -875,6 +875,103 @@ describe('PortableCloudSyncRepository: an interrupted case-only rename', () => { }) }) +/** Counts the files read, the way a phone pays for each one in native work. */ +class CountingMemoryFileSystem extends MemoryFileSystem { + readonly reads: string[] = [] + + override async readBase64(path: string): Promise { + this.reads.push(path) + return super.readBase64(path) + } +} + +// Discord, 2026-10-26: on a phone that had just pulled a computer's vault, +// opening one first-sync conflict read and hashed every note in the vault. +describe('PortableCloudSyncRepository: opening one waiting conflict', () => { + async function firstSyncWithConflict() { + const statePath = 'zennotes-cloud-sync/state.json' + const notes: Record = {} + for (let index = 1; index <= 200; index++) notes[`inbox/Note ${index}.md`] = `note ${index}` + const fs = new CountingMemoryFileSystem({ ...notes, 'inbox/Shopping.md': 'Eggs (from the phone)' }) + const cloudFiles = { ...notes, 'inbox/Shopping.md': 'Coffee (from the PC)' } + const items = await Promise.all(Object.entries(cloudFiles).map(async ([path, text], index) => { + const content = await textContent(text) + return { item_id: `item-${index}`, path, kind: 'text' as const, revision: 1, sha256: content.sha256, + byte_length: content.byte_length, media_type: content.media_type, content } + })) + const remote: CloudSyncRemote = { + manifest: async () => ({ data: items, cursor: items.length, next_page: null }), + changes: async () => ({ data: [], cursor: items.length, has_more: false }), + mutate: async () => { throw new Error('nothing should be pushed') } + } + let id = 0 + const coordinator = new CloudSyncCoordinator('vault-1', remote, new PortableCloudSyncRepository(fs), { + load: async () => (fs.text(statePath) ? JSON.parse(fs.text(statePath)!) as CloudSyncState : null), + save: async (state) => fs.writeText(statePath, JSON.stringify(state)) + }, { itemId: () => `new-${++id}`, operationId: () => `operation-${++id}` }) + const run = await coordinator.sync() + expect(run.pendingConflicts.map((conflict) => conflict.path)).toEqual(['inbox/Shopping.md']) + fs.reads.length = 0 + return { fs, coordinator, conflictId: run.pendingConflicts[0]!.id } + } + + it('reads only that file, not the whole vault', async () => { + const { fs, coordinator, conflictId } = await firstSyncWithConflict() + + await expect(coordinator.getConflict(conflictId)).resolves.toMatchObject({ + local: { path: 'inbox/Shopping.md', text: 'Eggs (from the phone)' }, + cloud: { path: 'inbox/Shopping.md', text: 'Coffee (from the PC)' } + }) + expect(fs.reads).toEqual(['inbox/Shopping.md']) + }) + + it('still finds this device\'s version after it moved', async () => { + const { fs, coordinator, conflictId } = await firstSyncWithConflict() + await fs.rename('inbox/Shopping.md', 'Errands/Shopping.md') + + await expect(coordinator.getConflict(conflictId)).resolves.toMatchObject({ + local: { path: 'Errands/Shopping.md', text: 'Eggs (from the phone)' } + }) + expect(fs.reads.length).toBeGreaterThan(200) + }) +}) + +describe('PortableCloudSyncRepository.readLocalItem', () => { + it('reads the file at exactly that path', async () => { + const repository = new PortableCloudSyncRepository(new MemoryFileSystem({ 'inbox/Plan.md': 'plan' })) + + await expect(repository.readLocalItem('inbox/Plan.md')).resolves.toMatchObject({ + path: 'inbox/Plan.md', kind: 'text', content: { data: 'plan' } + }) + }) + + // The scan reports the spelling stored on disk, so any other spelling is + // left to it rather than read under the asked-for name. + it('leaves a name stored in other letter case to the scan', async () => { + const repository = new PortableCloudSyncRepository( + new CaseInsensitiveMemoryFileSystem({ 'inbox/plan.md': 'plan' }) + ) + + await expect(repository.readLocalItem('inbox/Plan.md')).resolves.toBeNull() + await expect(repository.readLocalItem('Inbox/plan.md')).resolves.toBeNull() + await expect(repository.readLocalItem('inbox/plan.md')).resolves.toMatchObject({ path: 'inbox/plan.md' }) + }) + + it('finds nothing where the scan would list nothing', async () => { + const repository = new PortableCloudSyncRepository(new MemoryFileSystem({ + 'inbox/Plan.md/inside.md': 'a folder named like a note', + '.zennotes/sync/downloads/staged.md': 'sync work', + 'zennotes-cloud-sync/state.json': '{}' + })) + + await expect(repository.readLocalItem('inbox/Plan.md')).resolves.toBeNull() + await expect(repository.readLocalItem('inbox/Missing.md')).resolves.toBeNull() + await expect(repository.readLocalItem('Missing/Plan.md')).resolves.toBeNull() + await expect(repository.readLocalItem('.zennotes/sync/downloads/staged.md')).resolves.toBeNull() + await expect(repository.readLocalItem('zennotes-cloud-sync/state.json')).resolves.toBeNull() + }) +}) + async function tracked(path: string, data: string) { const content = await textContent(data) return { diff --git a/packages/shared-domain/src/cloud-sync-portable-filesystem.ts b/packages/shared-domain/src/cloud-sync-portable-filesystem.ts index 6838756c..12e908bb 100644 --- a/packages/shared-domain/src/cloud-sync-portable-filesystem.ts +++ b/packages/shared-domain/src/cloud-sync-portable-filesystem.ts @@ -142,6 +142,33 @@ export class PortableCloudSyncRepository implements CloudSyncRepository { return items.sort((left, right) => left.path.localeCompare(right.path)) } + /** + * The file at exactly this path, read as scan() reads it, found with one + * listing per folder on the way down. Every name must match its listing + * exactly; a case-only difference anywhere is left to the scan, which + * reports the spelling on disk. + */ + async readLocalItem(path: string): Promise { + const normalized = this.path(path) + if (!shouldSyncVaultPath(normalized)) return null + const segments = normalized.split('/') + let directory = '' + for (const [index, segment] of segments.entries()) { + const last = index === segments.length - 1 + let entries: CloudSyncFileEntry[] + try { + entries = await this.fs.readdir(directory) + } catch { + return null + } + const entry = entries.find((candidate) => candidate.name.normalize('NFC') === segment) + if (!entry || entry.type !== (last ? 'file' : 'directory')) return null + directory = directory ? `${directory}/${segment}` : segment + if (!last && !shouldTraverseCloudSyncDirectory(directory)) return null + } + return this.readItem(normalized) + } + async pendingConflictPaths(): Promise { return (await this.fs.stat(CLOUD_SYNC_SETTINGS_CONFLICT_PATH)) === 'file' ? [CLOUD_SYNC_VAULT_SETTINGS_PATH] diff --git a/packages/shared-domain/src/cloud-sync-rate-limit.test.ts b/packages/shared-domain/src/cloud-sync-rate-limit.test.ts index f40f9bbc..681e6709 100644 --- a/packages/shared-domain/src/cloud-sync-rate-limit.test.ts +++ b/packages/shared-domain/src/cloud-sync-rate-limit.test.ts @@ -7,6 +7,7 @@ import { type CloudSyncHttpTransport } from './cloud-sync-api' import { CloudAutoSyncController } from './cloud-auto-sync' +import { CloudSyncTransportError } from './cloud-sync-stall' const scope = { baseUrl: 'https://cloud.example.test', accountId: 'account-one' } const read: CloudSyncHttpRequest = { method: 'GET', path: '/api/v1/vaults/one/manifest?page=3' } @@ -411,3 +412,127 @@ describe('account-scoped Cloud request recovery', () => { ) }) }) + +describe('replaying a request that got no answer', () => { + const stalled = () => new CloudSyncTransportError('timeout', { stalled: true, code: 'SocketTimeoutException' }) + const phone = (coordinator = new CloudSyncRateLimitCoordinator()) => { + const send = vi.fn().mockResolvedValue({ ok: true }) + const transport: CloudSyncHttpTransport = { request: send as CloudSyncHttpTransport['request'] } + return { coordinator, send, client: coordinator.wrap(transport, { ...scope, transportRetryDelaysMs: [1_000, 4_000, 15_000] }) } + } + beforeEach(() => { + vi.spyOn(Math, 'random').mockReturnValue(0.999_999) + }) + + it('sends a stalled read again on a fresh attempt instead of failing the sync', async () => { + const f = phone() + f.send.mockRejectedValueOnce(stalled()).mockRejectedValueOnce(stalled()) + const result = f.client.request(read) + await vi.advanceTimersByTimeAsync(999) + expect(f.send).toHaveBeenCalledTimes(1) + await vi.advanceTimersByTimeAsync(1) + expect(f.send).toHaveBeenCalledTimes(2) + await vi.advanceTimersByTimeAsync(4_000) + await expect(result).resolves.toEqual({ ok: true }) + expect(f.send).toHaveBeenCalledTimes(3) + expect(f.send.mock.calls.map(([request]) => request.path)).toEqual([read.path, read.path, read.path]) + }) + + it('gives up after the last wait with the failure the host saw', async () => { + const f = phone() + const failures = [stalled(), stalled(), stalled(), stalled()] + for (const failure of failures) f.send.mockRejectedValueOnce(failure) + const result = f.client.request(read) + const settled = expect(result).rejects.toBe(failures[3]) + await vi.advanceTimersByTimeAsync(20_000) + await settled + expect(f.send).toHaveBeenCalledTimes(4) + }) + + it('stays off for a host that does not opt in (the desktop)', async () => { + const f = fixture() + const failure = stalled() + f.send.mockRejectedValueOnce(failure) + await expect(f.client.request(read)).rejects.toBe(failure) + expect(f.send).toHaveBeenCalledTimes(1) + }) + + it('never sends a request again that the service might apply twice', async () => { + const f = phone() + const failure = stalled() + f.send.mockRejectedValueOnce(failure) + await expect(f.client.request({ method: 'POST', path: '/api/v1/vaults', body: { name: 'New' } })).rejects.toBe(failure) + expect(f.send).toHaveBeenCalledTimes(1) + }) + + it('leaves an upload completion to its caller, since the service may still be hashing the object', async () => { + const f = phone() + const failure = stalled() + f.send.mockRejectedValueOnce(failure) + await expect(new CloudSyncApiClient(f.client).completeUpload('vault', 'upload-1')).rejects.toBe(failure) + expect(f.send).toHaveBeenCalledTimes(1) + expect(f.send.mock.calls[0][0]).toMatchObject({ timeoutMs: 300_000, retryOnTransportFailure: false }) + }) + + it('does not retry an answer the service gave, only a missing one', async () => { + const f = phone() + const refused = Object.assign(new Error('Server error'), { status: 503 }) + f.send.mockRejectedValueOnce(refused) + await expect(f.client.request(read)).rejects.toBe(refused) + expect(f.send).toHaveBeenCalledTimes(1) + }) + + it('replays a mutation with the same operation ids and bytes, so the service applies it once', async () => { + const f = phone() + const body = { + mutations: [{ type: 'delete' as const, item_id: 'item', operation_id: 'op-1', base_revision: 1 }] + } + const seen: string[] = [] + f.send + .mockImplementationOnce(async (request) => { + seen.push(JSON.stringify(request.body)) + ;(request.body as typeof body).mutations[0].operation_id = 'transport-change' + throw stalled() + }) + .mockImplementationOnce(async (request) => { + seen.push(JSON.stringify(request.body)) + return { acknowledged: [], conflicts: [], cursor: 1 } as never + }) + const result = new CloudSyncApiClient(f.client).mutate('vault', body) + await vi.advanceTimersByTimeAsync(1_000) + await result + expect(seen).toHaveLength(2) + expect(seen[1]).toBe(seen[0]) + expect(JSON.parse(seen[0]).mutations[0].operation_id).toBe('op-1') + }) + + it('keeps 429 retries and stall retries on separate allowances', async () => { + const f = phone() + f.send.mockRejectedValueOnce(stalled()).mockRejectedValueOnce(limited('2')).mockRejectedValueOnce(stalled()) + const result = f.client.request(read) + await vi.advanceTimersByTimeAsync(1_000 + 2_000 + 4_000) + await expect(result).resolves.toEqual({ ok: true }) + expect(f.send).toHaveBeenCalledTimes(4) + }) + + it('stops waiting to retry when the client is cancelled', async () => { + const controller = new AbortController() + const coordinator = new CloudSyncRateLimitCoordinator() + const send = vi.fn().mockRejectedValue(stalled()) + const client = coordinator.wrap({ request: send as CloudSyncHttpTransport['request'] }, { + ...scope, signal: controller.signal, transportRetryDelaysMs: [60_000] + }) + const result = client.request(read) + const settled = expect(result).rejects.toMatchObject({ name: 'AbortError' }) + await vi.advanceTimersByTimeAsync(100) + controller.abort() + await settled + expect(send).toHaveBeenCalledTimes(1) + }) + + it('refuses a retry schedule it cannot keep', () => { + const coordinator = new CloudSyncRateLimitCoordinator() + const transport: CloudSyncHttpTransport = { request: vi.fn() as CloudSyncHttpTransport['request'] } + expect(() => coordinator.wrap(transport, { ...scope, transportRetryDelaysMs: [-1] })).toThrow(/retry delays/) + }) +}) diff --git a/packages/shared-domain/src/cloud-sync-rate-limit.ts b/packages/shared-domain/src/cloud-sync-rate-limit.ts index c81c3721..f17850d7 100644 --- a/packages/shared-domain/src/cloud-sync-rate-limit.ts +++ b/packages/shared-domain/src/cloud-sync-rate-limit.ts @@ -1,4 +1,9 @@ import type { CloudSyncHttpRequest, CloudSyncHttpTransport } from './cloud-sync-api' +import { + assertCloudTransportRetryDelays, + cloudTransportRetryDelayMs, + isCloudSyncTransportError +} from './cloud-sync-stall' export type CloudSyncResponseHeaders = | Readonly> @@ -14,6 +19,13 @@ export interface CloudSyncRateLimitOptions extends CloudSyncRateLimitScope { signal?: AbortSignal /** Additional attempts for one request, 0 through 10. Defaults to 3. */ maxRetries?: number + /** + * The wait before sending a replayable request again after it got no answer + * at all (a CloudSyncTransportError), one retry per entry. Off by default: + * only a host whose transport gives up on a stalled connection soon should + * opt in, or each retry repeats a long wait (see cloud-sync-stall.ts). + */ + transportRetryDelaysMs?: readonly number[] } interface AccountCooldown { @@ -58,6 +70,8 @@ export class CloudSyncRateLimitCoordinator { if (!Number.isInteger(maxRetries) || maxRetries < 0 || maxRetries > 10) { throw new Error('Cloud rate-limit retries must be an integer from 0 through 10.') } + const transportRetryDelays = options.transportRetryDelaysMs ?? [] + assertCloudTransportRetryDelays(transportRetryDelays) const key = scopeKey(options) let account = this.accounts.get(key) if (!account) { @@ -75,6 +89,7 @@ export class CloudSyncRateLimitCoordinator { request, cooldown, maxRetries, + transportRetryDelays, combined.signal ).finally(combined.dispose) } @@ -102,16 +117,21 @@ export class CloudSyncRateLimitCoordinator { request: CloudSyncHttpRequest, account: AccountCooldown, maxRetries: number, + transportRetryDelays: readonly number[], signal: AbortSignal ): Promise { throwIfCancelled(signal) const replayable = request.method === 'GET' || request.retryOnRateLimit === true + // A replay is the same request, byte for byte: an encrypted vault's body + // was sealed above this layer, so the service sees the same operation. + const resendable = replayable && request.retryOnTransportFailure !== false const snapshot = { ...request, ...(replayable && request.body !== undefined ? { body: cloneReplayBody(request.body) } : {}), signal } let retries = 0 + let transportFailures = 0 for (;;) { while (account.until > Date.now()) { await wait(Math.min(account.until - Date.now(), MAX_TIMER_DELAY_MS), signal) @@ -130,6 +150,13 @@ export class CloudSyncRateLimitCoordinator { ) } catch (error) { throwIfCancelled(signal) + const pause = resendable && isCloudSyncTransportError(error) + ? cloudTransportRetryDelayMs(transportFailures++, transportRetryDelays) + : null + if (pause !== null) { + await wait(pause, signal) + continue + } if (!error || typeof error !== 'object' || !('status' in error) || error.status !== 429) { throw error } diff --git a/packages/shared-domain/src/cloud-sync-stall.test.ts b/packages/shared-domain/src/cloud-sync-stall.test.ts new file mode 100644 index 00000000..2199c122 --- /dev/null +++ b/packages/shared-domain/src/cloud-sync-stall.test.ts @@ -0,0 +1,130 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { + CLOUD_TRANSPORT_RETRY_DELAYS_MS, + CloudSyncTransportError, + cloudSendTimeoutMs, + cloudTransportRetryDelayMs, + isCloudSyncTransportError, + retryCloudTransfer +} from './cloud-sync-stall' + +const stalled = () => new CloudSyncTransportError('timeout', { stalled: true, code: 'SocketTimeoutException' }) + +beforeEach(() => { + vi.useFakeTimers() +}) +afterEach(() => { + vi.restoreAllMocks() + vi.useRealTimers() +}) + +describe('cloudTransportRetryDelayMs', () => { + it('waits between half and all of each listed delay, then has none left', () => { + expect(cloudTransportRetryDelayMs(0, [1_000, 4_000], () => 0)).toBe(500) + expect(cloudTransportRetryDelayMs(0, [1_000, 4_000], () => 0.999_999)).toBe(1_000) + expect(cloudTransportRetryDelayMs(1, [1_000, 4_000], () => 0.5)).toBe(3_000) + expect(cloudTransportRetryDelayMs(2, [1_000, 4_000], () => 0.5)).toBeNull() + }) + + it('retries three times by default, the longest wait 15 seconds', () => { + expect(CLOUD_TRANSPORT_RETRY_DELAYS_MS).toEqual([1_000, 4_000, 15_000]) + }) +}) + +describe('cloudSendTimeoutMs', () => { + it('gives a body the time it takes at 8 KiB a second on top of the stall bound', () => { + expect(cloudSendTimeoutMs(0)).toBe(30_000) + expect(cloudSendTimeoutMs(4 * 1024)).toBe(30_500) + expect(cloudSendTimeoutMs(1024 * 1024)).toBe(158_000) + // A note at the 5 MiB inline cap, base64 in JSON: never less than the + // 300 seconds every iOS request used to get. + expect(cloudSendTimeoutMs(Math.ceil((5 * 1024 * 1024 * 4) / 3))).toBeGreaterThan(300_000) + expect(cloudSendTimeoutMs(-1)).toBe(30_000) + }) +}) + +describe('isCloudSyncTransportError', () => { + it('knows the error by name too, for a copy from another bundle', () => { + expect(isCloudSyncTransportError(stalled())).toBe(true) + expect(isCloudSyncTransportError(Object.assign(new Error('timeout'), { name: 'CloudSyncTransportError' }))).toBe(true) + expect(isCloudSyncTransportError(Object.assign(new Error('Not found'), { status: 404 }))).toBe(false) + expect(isCloudSyncTransportError(new DOMException('Stopped', 'AbortError'))).toBe(false) + expect(isCloudSyncTransportError(null)).toBe(false) + }) +}) + +describe('retryCloudTransfer', () => { + it('runs a stalled transfer again after each wait until it lands', async () => { + vi.spyOn(Math, 'random').mockReturnValue(0.999_999) + const transfer = vi.fn<() => Promise>() + .mockRejectedValueOnce(stalled()) + .mockRejectedValueOnce(stalled()) + .mockResolvedValueOnce('landed') + const result = retryCloudTransfer(transfer) + await vi.advanceTimersByTimeAsync(0) + expect(transfer).toHaveBeenCalledTimes(1) + await vi.advanceTimersByTimeAsync(999) + expect(transfer).toHaveBeenCalledTimes(1) + await vi.advanceTimersByTimeAsync(1) + expect(transfer).toHaveBeenCalledTimes(2) + await vi.advanceTimersByTimeAsync(4_000) + expect(transfer).toHaveBeenCalledTimes(3) + await expect(result).resolves.toBe('landed') + }) + + it('throws the last failure once the waits run out', async () => { + const failures = [stalled(), stalled(), stalled(), stalled()] + const transfer = vi.fn<() => Promise>() + for (const failure of failures) transfer.mockRejectedValueOnce(failure) + const result = retryCloudTransfer(transfer) + const settled = expect(result).rejects.toBe(failures[3]) + await vi.advanceTimersByTimeAsync(20_000) + await settled + expect(transfer).toHaveBeenCalledTimes(4) + }) + + it('never repeats an answer the service gave', async () => { + const refused = Object.assign(new Error('Forbidden'), { status: 403 }) + const transfer = vi.fn<() => Promise>().mockRejectedValueOnce(refused) + await expect(retryCloudTransfer(transfer)).rejects.toBe(refused) + expect(transfer).toHaveBeenCalledTimes(1) + }) + + it('takes the host\'s word for what counts as a transport failure', async () => { + const nativeFailure = Object.assign(new Error('Cloud object download failed.'), { code: 'DIRECT_DOWNLOAD_FAILED' }) + const transfer = vi.fn<() => Promise>().mockRejectedValueOnce(nativeFailure).mockResolvedValueOnce('landed') + const result = retryCloudTransfer(transfer, { + isTransportFailure: (error) => (error as { code?: string }).code === 'DIRECT_DOWNLOAD_FAILED', + delaysMs: [10] + }) + await vi.advanceTimersByTimeAsync(10) + await expect(result).resolves.toBe('landed') + }) + + it('stops waiting when the sync is cancelled, and sends nothing more', async () => { + const controller = new AbortController() + const transfer = vi.fn<() => Promise>().mockRejectedValue(stalled()) + const result = retryCloudTransfer(transfer, { signal: controller.signal }) + const settled = expect(result).rejects.toMatchObject({ name: 'AbortError' }) + await vi.advanceTimersByTimeAsync(100) + controller.abort() + await settled + await vi.advanceTimersByTimeAsync(60_000) + expect(transfer).toHaveBeenCalledTimes(1) + }) + + it('does not retry a transfer that failed because the sync was cancelled', async () => { + const controller = new AbortController() + const transfer = vi.fn<() => Promise>().mockImplementation(async () => { + controller.abort() + throw stalled() + }) + await expect(retryCloudTransfer(transfer, { signal: controller.signal })).rejects.toBeInstanceOf(CloudSyncTransportError) + expect(transfer).toHaveBeenCalledTimes(1) + }) + + it('refuses a schedule it cannot keep', async () => { + await expect(retryCloudTransfer(async () => 'x', { delaysMs: [Number.NaN] })).rejects.toThrow(/retry delays/) + await expect(retryCloudTransfer(async () => 'x', { delaysMs: new Array(11).fill(1) })).rejects.toThrow(/retry delays/) + }) +}) diff --git a/packages/shared-domain/src/cloud-sync-stall.ts b/packages/shared-domain/src/cloud-sync-stall.ts new file mode 100644 index 00000000..378bcc16 --- /dev/null +++ b/packages/shared-domain/src/cloud-sync-stall.ts @@ -0,0 +1,151 @@ +/** + * How a phone notices a ZenNotes Cloud request that stopped moving, and what + * it does next. + * + * A phone's HTTP stack measures idle time, not total time: Android's socket + * read timeout and an iOS URLRequest's timeout both start over whenever bytes + * arrive. One short bound therefore drops a connection that went quiet (a + * filtering network that holds a connection open and passes nothing is the + * usual cause) while a large download that keeps moving runs as long as it + * needs. Phones used to wait 300 seconds there, and the rest of the sync + * waited behind it. A request dropped that way never got an answer, so one + * that is safe to send twice goes out again on a fresh connection instead of + * failing the whole sync. + * + * Sending is the exception. Bytes going out do not restart the iOS timeout, + * and URLSession reports a body as sent once it holds it, long before the + * bytes leave, so on iOS a request with a body gets cloudSendTimeoutMs. + * Android's read timeout does not run while it sends; its native uploader + * watches the bytes it writes instead. + */ + +/** + * No bytes for this long and a request is stalled. The desktop gives a whole + * request 30 seconds, so 30 seconds without a single byte never treats a slow + * but moving connection worse than the desktop does. + */ +export const CLOUD_STALL_TIMEOUT_MS = 30_000 + +/** A connection that has not opened in this long is not going to. */ +export const CLOUD_CONNECT_TIMEOUT_MS = 15_000 + +/** + * The slowest upload a phone still waits out. URLSession on iOS restarts a + * request's timeout only when data arrives, so while a body goes out the + * timeout keeps running from the start (Android's runs only while it reads). + * 8 KiB a second is a weak mobile signal; slower than that, retrying later + * serves better than waiting. + */ +export const CLOUD_SLOWEST_UPLOAD_BYTES_PER_SECOND = 8 * 1024 + +/** + * The timeout for a request that sends `bodyBytes`, on a host whose timeout + * keeps running while it sends (iOS): the stall bound, which also covers the + * service's answer, plus the time the body takes at the slowest upload rate. + */ +export function cloudSendTimeoutMs(bodyBytes: number): number { + return CLOUD_STALL_TIMEOUT_MS + Math.ceil((Math.max(0, bodyBytes) / CLOUD_SLOWEST_UPLOAD_BYTES_PER_SECOND) * 1000) +} + +/** + * The wait before each new attempt at a request that got no answer, one entry + * per retry. Each is shortened by up to half at random, so devices behind the + * same unsteady link do not all come back at once. + */ +export const CLOUD_TRANSPORT_RETRY_DELAYS_MS: readonly number[] = [1_000, 4_000, 15_000] + +/** + * A request that got no HTTP answer at all: it stalled, its connection was + * reset, or the connection never opened. Hosts wrap their native failures in + * it so a retry can tell them from an answer the service gave. The message is + * the host's own, so the words a person sees do not change. + */ +export class CloudSyncTransportError extends Error { + /** The connection went quiet, as opposed to failing outright. */ + readonly stalled: boolean + /** The host's own name for the failure, for the details line. */ + readonly code: string | null + + constructor(message: string, options: { stalled?: boolean; code?: string | null; cause?: unknown } = {}) { + super(message, { cause: options.cause }) + this.name = 'CloudSyncTransportError' + this.stalled = options.stalled === true + this.code = options.code ?? null + } +} + +export function isCloudSyncTransportError(error: unknown): error is CloudSyncTransportError { + return error instanceof CloudSyncTransportError || + (typeof error === 'object' && error !== null && (error as { name?: unknown }).name === 'CloudSyncTransportError') +} + +/** How long to wait before retry number `attempt` (0 first), or null when none is left. */ +export function cloudTransportRetryDelayMs( + attempt: number, + delays: readonly number[] = CLOUD_TRANSPORT_RETRY_DELAYS_MS, + random: () => number = Math.random +): number | null { + const base = delays[attempt] + if (base === undefined) return null + return Math.round(base * (0.5 + random() * 0.5)) +} + +/** Throws unless `delays` is a usable retry schedule. */ +export function assertCloudTransportRetryDelays(delays: readonly number[]): void { + if (delays.length > 10 || delays.some((delay) => !Number.isFinite(delay) || delay < 0)) { + throw new Error('Cloud transport retry delays must be at most 10 non-negative numbers.') + } +} + +/** + * Runs `transfer`, and runs it again after each failure `isTransportFailure` + * recognizes, waiting out the delays in between; anything else is thrown at + * once, and so is the last failure. Only for work that is safe to repeat: a + * GET, or a PUT of the same bytes to the same object. + */ +export async function retryCloudTransfer( + transfer: () => Promise, + options: { + signal?: AbortSignal + isTransportFailure?: (error: unknown) => boolean + delaysMs?: readonly number[] + } = {} +): Promise { + const isTransportFailure = options.isTransportFailure ?? isCloudSyncTransportError + const delays = options.delaysMs ?? CLOUD_TRANSPORT_RETRY_DELAYS_MS + assertCloudTransportRetryDelays(delays) + for (let attempt = 0; ; attempt++) { + throwIfAborted(options.signal) + try { + return await transfer() + } catch (error) { + if (options.signal?.aborted) throw error + const delay = isTransportFailure(error) ? cloudTransportRetryDelayMs(attempt, delays) : null + if (delay === null) throw error + await pause(delay, options.signal) + } + } +} + +function abortReason(signal: AbortSignal): unknown { + return signal.reason ?? new DOMException('The Cloud request was aborted.', 'AbortError') +} + +function throwIfAborted(signal: AbortSignal | undefined): void { + if (signal?.aborted) throw abortReason(signal) +} + +function pause(milliseconds: number, signal: AbortSignal | undefined): Promise { + throwIfAborted(signal) + return new Promise((resolve, reject) => { + const abort = () => { + clearTimeout(timer) + reject(abortReason(signal!)) + } + const timer = setTimeout(() => { + signal?.removeEventListener('abort', abort) + resolve() + }, milliseconds) + signal?.addEventListener('abort', abort, { once: true }) + }) +} diff --git a/packages/shared-domain/src/keymaps-catalog.ts b/packages/shared-domain/src/keymaps-catalog.ts index 4ccb0daf..cd067205 100644 --- a/packages/shared-domain/src/keymaps-catalog.ts +++ b/packages/shared-domain/src/keymaps-catalog.ts @@ -108,6 +108,7 @@ export const KEYMAP_CATALOG: KeymapCatalogEntry[] = [ { id: "vim.leaderWeeklyNote", group: "vim", defaultBinding: "w", title: "Leader: this week's note" }, { id: "vim.leaderMonthlyNote", group: "vim", defaultBinding: "m", title: "Leader: this month's note" }, { id: "vim.leaderCalendar", group: "vim", defaultBinding: "c", title: "Leader: toggle calendar" }, + { id: "vim.leaderUnresolvedLinks", group: "vim", defaultBinding: "u", title: "Leader: unresolved links" }, { id: "vim.panePrefix", group: "vim", defaultBinding: "Ctrl+W", title: "Pane command prefix" }, { id: "vim.paneFocusLeft", group: "vim", defaultBinding: "h", title: "Pane: focus left" }, { id: "vim.paneFocusDown", group: "vim", defaultBinding: "j", title: "Pane: focus down" }, @@ -124,6 +125,7 @@ export const KEYMAP_CATALOG: KeymapCatalogEntry[] = [ { id: "vim.hintMode", group: "vim", defaultBinding: "h", title: "Leader: hint mode" }, { id: "vim.goToDefinition", group: "vim", defaultBinding: "g d", title: "Follow link at cursor" }, { id: "vim.createNoteFromLink", group: "vim", defaultBinding: "g D", title: "Create note for link at cursor" }, + { id: "vim.linkPopover", group: "vim", defaultBinding: "K", title: "Link popover for link at cursor" }, { id: "vim.foldCurrent", group: "vim", defaultBinding: "z c", title: "Fold heading or list item at cursor" }, { id: "vim.unfoldCurrent", group: "vim", defaultBinding: "z o", title: "Unfold heading or list item at cursor" }, { id: "vim.foldAll", group: "vim", defaultBinding: "z M", title: "Fold all headings and lists" }, @@ -158,6 +160,8 @@ export const KEYMAP_CATALOG: KeymapCatalogEntry[] = [ { id: "tasks.moveTaskUp", group: "view-actions", defaultBinding: "K", title: "Move task up" }, { id: "tasks.moveTaskDown", group: "view-actions", defaultBinding: "J", title: "Move task down" }, { id: "tasks.savedFilters", group: "view-actions", defaultBinding: "F", title: "Pick a saved Tasks filter" }, + { id: "tags.nextNote", group: "view-actions", defaultBinding: "}", title: "Next note in Tags view" }, + { id: "tags.previousNote", group: "view-actions", defaultBinding: "{", title: "Previous note in Tags view" }, { id: "editor.hopMarkerForward", group: "view-actions", defaultBinding: "Alt+]", defaultBindingMac: "Ctrl+.", title: "Hop past next marker" }, { id: "editor.hopMarkerBackward", group: "view-actions", defaultBinding: "Alt+[", defaultBindingMac: "Ctrl+,", title: "Hop before previous marker" }, { id: "editor.foldHeading", group: "view-actions", defaultBinding: "Alt+Mod+F", title: "Fold heading or list item" }, @@ -166,6 +170,7 @@ export const KEYMAP_CATALOG: KeymapCatalogEntry[] = [ { id: "editor.moveLineDown", group: "view-actions", defaultBinding: "Alt+ArrowDown", title: "Move line down" }, { id: "editor.toggleCheckbox", group: "view-actions", defaultBinding: "Mod+L", title: "Toggle checkbox" }, { id: "editor.reflowParagraph", group: "view-actions", defaultBinding: "Alt+Q", defaultBindingMac: "Ctrl+Q", title: "Reflow paragraph" }, + { id: "editor.linkPopover", group: "view-actions", defaultBinding: "Shift+Mod+K", title: "Open link popover" }, { id: "editor.reviewNextChange", group: "view-actions", defaultBinding: "Alt+Mod+ArrowDown", title: "Next change to review" }, { id: "editor.reviewPreviousChange", group: "view-actions", defaultBinding: "Alt+Mod+ArrowUp", title: "Previous change to review" }, { id: "editor.reviewAcceptChange", group: "view-actions", defaultBinding: "Shift+Mod+Enter", title: "Accept change" }, diff --git a/packages/shared-domain/src/markdown-lines.ts b/packages/shared-domain/src/markdown-lines.ts index 32e1f159..bf9e0fb3 100644 --- a/packages/shared-domain/src/markdown-lines.ts +++ b/packages/shared-domain/src/markdown-lines.ts @@ -7,11 +7,14 @@ // export) can consume the same rules as the renderer. // A fenced code block opens with a run of >=3 backticks or tildes; the second -// group is the rest of the line (the info string). -export const FENCE_OPEN_RE = /^\s*(`{3,}|~{3,})(.*)$/ +// group is the rest of the line (the info string). Callers split at `\n` +// only, so a CRLF body hands both patterns lines that still end in `\r`, which +// neither `.` nor `[ \t]` matches: the `\r?` before `$` lets those fences open +// and close. +export const FENCE_OPEN_RE = /^\s*(`{3,}|~{3,})(.*)\r?$/ // A closing fence is a run of fence characters alone on its line, save for // trailing whitespace (no info string). -export const FENCE_CLOSE_RE = /^\s*(`{3,}|~{3,})[ \t]*$/ +export const FENCE_CLOSE_RE = /^\s*(`{3,}|~{3,})[ \t]*\r?$/ /** * A YAML frontmatter fence: `---` alone on its line, surrounding whitespace @@ -51,11 +54,23 @@ export interface MarkdownLine { from: number } +export interface ScanMarkdownLinesOptions { + /** + * Also yield the lines of a leading YAML frontmatter block (its fences + * included). Outline and anchor grammars never want them; a link scanner + * does, because `related: "[[Doc]]"` is a link the vault index counts. + */ + includeFrontmatter?: boolean +} + /** * Walk the lines of a note body that markdown owns, skipping leading YAML * frontmatter and the inside of fenced code blocks. */ -export function scanMarkdownLines(body: string): MarkdownLine[] { +export function scanMarkdownLines( + body: string, + options: ScanMarkdownLinesOptions = {} +): MarkdownLine[] { const scanned: MarkdownLine[] = [] if (!body) return scanned @@ -77,7 +92,12 @@ export function scanMarkdownLines(body: string): MarkdownLine[] { // Skip the leading frontmatter block wholesale: its fences and `key: value` // lines are YAML, not markdown, and must never surface as outline entries. - if (i <= frontmatterEnd) continue + if (i <= frontmatterEnd) { + if (options.includeFrontmatter) { + scanned.push({ text: raw, next: lines[i + 1], line: i + 1, from: lineStart }) + } + continue + } if (fence) { const close = raw.match(FENCE_CLOSE_RE) diff --git a/packages/shared-domain/src/tag-blocks.test.ts b/packages/shared-domain/src/tag-blocks.test.ts new file mode 100644 index 00000000..5de71826 --- /dev/null +++ b/packages/shared-domain/src/tag-blocks.test.ts @@ -0,0 +1,261 @@ +import { describe, expect, it } from 'vitest' +import { extractTagBlocks, tagBlockJumpOffset } from './tag-blocks' +import { extractTags } from './tag-scan' + +const lines = (...rows: string[]): string => rows.join('\n') + +describe('extractTagBlocks', () => { + it('returns nothing for a note without inline tags', () => { + expect(extractTagBlocks('')).toEqual([]) + expect(extractTagBlocks('Just prose, no hashes.')).toEqual([]) + expect(extractTagBlocks('# A heading\n\nText')).toEqual([]) + }) + + it('lists each list item that carries a tag, with its own line', () => { + const body = lines( + '# Ideas', + '', + '- Unrelated thought', + '- Build a recipe gallery #idea', + '- Another idea #idea #later', + '- Last item' + ) + const blocks = extractTagBlocks(body) + expect(blocks).toEqual([ + { + kind: 'list-item', + startLine: 3, + endLine: 3, + tags: ['idea'], + text: 'Build a recipe gallery #idea' + }, + { + kind: 'list-item', + startLine: 4, + endLine: 4, + tags: ['idea', 'later'], + text: 'Another idea #idea #later' + } + ]) + }) + + it('takes a list item with its nested children and wrapped lines', () => { + const body = lines( + '- Parent idea #idea', + ' wrapped onto a second line', + ' - child one', + ' - grandchild', + '- Sibling' + ) + const [block] = extractTagBlocks(body) + expect(block?.kind).toBe('list-item') + expect(block?.startLine).toBe(0) + expect(block?.endLine).toBe(3) + expect(block?.text).toBe('Parent idea #idea\nwrapped onto a second line\nchild one\ngrandchild') + }) + + it('gives a nested item its own block, apart from its parent', () => { + const body = lines('- Parent #a', ' - Child #b', ' - Other child', '- Next') + const blocks = extractTagBlocks(body) + expect(blocks.map((b) => [b.startLine, b.endLine, b.tags])).toEqual([ + [0, 2, ['a']], + [1, 1, ['b']] + ]) + }) + + it('credits a tag on a continuation line to the item it belongs to', () => { + const body = lines( + '1. First step', + ' more about it #todo', + '', + ' a loose paragraph of the step', + '2. Second step' + ) + const [block] = extractTagBlocks(body) + expect(block).toMatchObject({ kind: 'list-item', startLine: 0, endLine: 3, tags: ['todo'] }) + }) + + it('keeps a loose paragraph under a nested item with the outer item', () => { + const body = lines('- Parent', ' - child', '', ' parent paragraph #x', '- Next') + expect(extractTagBlocks(body)).toMatchObject([{ kind: 'list-item', startLine: 0, endLine: 3 }]) + }) + + it('treats a task line as a list item and strips its box from the text', () => { + const body = lines('- [ ] Ship the gallery #idea', '- [x] Done thing #idea') + expect(extractTagBlocks(body).map((b) => b.text)).toEqual([ + 'Ship the gallery #idea', + 'Done thing #idea' + ]) + }) + + it('takes the whole paragraph a tag sits in', () => { + const body = lines( + 'First paragraph, not tagged.', + '', + 'An idea that spans', + 'several lines #idea', + 'and keeps going.', + '', + 'Another paragraph.' + ) + expect(extractTagBlocks(body)).toEqual([ + { + kind: 'paragraph', + startLine: 2, + endLine: 4, + tags: ['idea'], + text: 'An idea that spans\nseveral lines #idea\nand keeps going.' + } + ]) + }) + + it('does not pull a paragraph after a list into the list', () => { + const body = lines('- item', '', 'Paragraph after the list #idea') + expect(extractTagBlocks(body)).toMatchObject([{ kind: 'paragraph', startLine: 2, endLine: 2 }]) + }) + + it('does not pull a column-0 paragraph into an earlier list across a blank line', () => { + const body = lines('- item', '', 'Para A', '', ' indented para #x') + expect(extractTagBlocks(body)).toMatchObject([{ kind: 'paragraph', startLine: 4 }]) + }) + + it('tags a heading with its whole section, down to the next heading at its level', () => { + const body = lines( + '# Note', + '## Gallery idea #idea', + 'Why it matters.', + '### Sub detail', + 'More.', + '', + '## Next section', + 'Other.' + ) + expect(extractTagBlocks(body)).toEqual([ + { + kind: 'heading', + startLine: 1, + endLine: 4, + tags: ['idea'], + text: 'Gallery idea #idea\nWhy it matters.\nSub detail\nMore.' + } + ]) + }) + + it('lists a tagged block inside a tagged section as a block of its own', () => { + const body = lines('## Ideas #idea', '- one #idea', '- two') + expect(extractTagBlocks(body).map((b) => [b.kind, b.startLine, b.endLine])).toEqual([ + ['heading', 0, 2], + ['list-item', 1, 1] + ]) + }) + + it('ignores tags inside fenced and inline code', () => { + const body = lines( + '```c', + '#include ', + '```', + '', + '- item with `#notatag` code #real', + ' ```', + ' #alsonot', + ' ```', + '', + '~~~', + '#nope', + '~~~' + ) + const blocks = extractTagBlocks(body) + expect(blocks).toHaveLength(1) + expect(blocks[0]).toMatchObject({ kind: 'list-item', startLine: 4, endLine: 7, tags: ['real'] }) + // The fenced child is part of the item's extent but not of its text. + expect(blocks[0]?.text).toBe('item with `#notatag` code #real') + }) + + it('never treats a `#` line inside a fence as a heading that ends a section', () => { + const body = lines('## Section #s', '```sh', '# a shell comment', '```', 'after', '## Next') + expect(extractTagBlocks(body)).toMatchObject([{ kind: 'heading', startLine: 0, endLine: 4 }]) + }) + + it('leaves frontmatter tags note-level and counts lines from the top of the file', () => { + const body = lines('---', 'tags: [project, idea]', 'title: "#notatag"', '---', '', 'Body line #inline') + const blocks = extractTagBlocks(body) + expect(blocks).toEqual([ + { kind: 'paragraph', startLine: 5, endLine: 5, tags: ['inline'], text: 'Body line #inline' } + ]) + // The note-level scan still sees the frontmatter tags. + expect(extractTags(body)).toEqual(['project', 'idea', 'inline']) + }) + + it('produces no block for a note tagged only in frontmatter', () => { + expect(extractTagBlocks(lines('---', 'tags: idea', '---', 'Plain body'))).toEqual([]) + }) + + it('takes a whole quote or callout', () => { + const body = lines('Intro', '', '> [!note] Callout title', '> idea inside #idea', '', 'After') + expect(extractTagBlocks(body)).toEqual([ + { + kind: 'quote', + startLine: 2, + endLine: 3, + tags: ['idea'], + text: 'Callout title\nidea inside #idea' + } + ]) + }) + + it('takes a single table row', () => { + const body = lines('| Idea | Status |', '| --- | --- |', '| Gallery #idea | open |', '| Other | done |') + expect(extractTagBlocks(body)).toEqual([ + { kind: 'table-row', startLine: 2, endLine: 2, tags: ['idea'], text: 'Gallery #idea · open' } + ]) + }) + + it('merges tags from several lines of one block', () => { + const body = lines('First line #a', 'second line #b #a') + expect(extractTagBlocks(body)).toMatchObject([{ startLine: 0, endLine: 1, tags: ['a', 'b'] }]) + }) + + it('agrees with the note-level scan on which tags are inline', () => { + const body = lines( + '# Heading', + 'me#nottag url.com/#nottag #Ünïcode #тег #nested/tag-1', + '`#code` #after-code' + ) + const blockTags = extractTagBlocks(body).flatMap((b) => b.tags) + expect(blockTags).toEqual(['Ünïcode', 'тег', 'nested/tag-1', 'after-code']) + expect(extractTags(body)).toEqual(blockTags) + }) + + it('reads CRLF bodies without shifting lines', () => { + const body = ['- one', '- two #idea', '- three'].join('\r\n') + expect(extractTagBlocks(body)).toMatchObject([{ startLine: 1, endLine: 1, text: 'two #idea' }]) + }) + + it('drops a trailing block id from the text', () => { + expect(extractTagBlocks('- An idea #idea ^gallery')[0]?.text).toBe('An idea #idea') + }) + + it('caps long blocks', () => { + const body = ['## Long #idea', ...Array.from({ length: 20 }, (_, i) => `line ${i}`)].join('\n') + const text = extractTagBlocks(body)[0]?.text ?? '' + expect(text.split('\n')).toHaveLength(6) + expect(text.endsWith('…')).toBe(true) + }) +}) + +describe('tagBlockJumpOffset', () => { + const body = lines('# Title', '', '- [ ] task #idea', ' > quoted', '## Head #x', 'plain #y') + + it('lands after list markers and task boxes', () => { + expect(tagBlockJumpOffset(body, 2)).toBe(body.indexOf('task #idea')) + }) + + it('lands after heading hashes', () => { + expect(tagBlockJumpOffset(body, 4)).toBe(body.indexOf('Head #x')) + }) + + it('lands at the start of a plain line, and clamps past the end', () => { + expect(tagBlockJumpOffset(body, 5)).toBe(body.indexOf('plain #y')) + expect(tagBlockJumpOffset(body, 99)).toBe(body.indexOf('plain #y')) + }) +}) diff --git a/packages/shared-domain/src/tag-blocks.ts b/packages/shared-domain/src/tag-blocks.ts new file mode 100644 index 00000000..7278e919 --- /dev/null +++ b/packages/shared-domain/src/tag-blocks.ts @@ -0,0 +1,340 @@ +/** + * Block-level tag occurrences (#837). A note's tags stay a flat list on + * `NoteMeta.tags`; this finds where each inline `#tag` sits and which block + * carries it (a list item, a paragraph, a heading's section, a quote, a table + * row), so the Tags view can list the idea itself under its note and jump to + * its line. + * + * Tags are read exactly as `extractTags` reads them (the same frontmatter cut, + * the same `stripCodeContent` mask, the same pattern), so a block is listed + * for a tag only when the note-level scan counted that tag from that line. + * Frontmatter tags tag the whole note and produce no block. + * + * Block structure is read from the lines markdown owns (`scanMarkdownLines`: + * outside frontmatter and fenced code), so a fence inside a list item stays + * part of the item and a `#` line inside a fence is never a heading. + */ +import { trailingBlockIdRange } from './block-anchors' +import { FRONTMATTER_BLOCK_RE } from './frontmatter' +import { FENCE_OPEN_RE, frontmatterEndIndex, scanMarkdownLines } from './markdown-lines' +import { INLINE_TAG_RE, stripCodeContent } from './tag-scan' + +export type TagBlockKind = 'heading' | 'list-item' | 'paragraph' | 'quote' | 'table-row' + +export interface TagBlock { + kind: TagBlockKind + /** 0-based first line of the block in the whole body, frontmatter counted. + * This is the line a jump lands on. */ + startLine: number + /** 0-based last line of the block, inclusive. A heading's block runs to the + * next heading at the same or a higher level. */ + endLine: number + /** The inline tags on the block's own lines, as written, first seen first. + * A nested list item or a paragraph inside a heading's section is a block + * of its own and keeps its own tags. */ + tags: string[] + /** The block as readable text: markers stripped, blank lines and code + * dropped, capped at a few lines. */ + text: string +} + +const HEADING_RE = /^ {0,3}(#{1,6})(?:[ \t]|$)/ +const LIST_MARKER_RE = /^[ \t]*(?:[-+*]|\d{1,9}[.)])(?:[ \t]+|$)/ +const THEMATIC_BREAK_RE = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/ +const QUOTE_RE = /^[ \t]{0,3}>/ +const TABLE_ROW_RE = /^[ \t]*\|/ + +const MAX_TEXT_LINES = 6 +const MAX_TEXT_CHARS = 400 + +/** Every block in `body` that carries an inline tag, in document order. */ +export function extractTagBlocks(body: string): TagBlock[] { + if (!body.includes('#')) return [] + // CRLF bodies: drop the CR so every line rule below sees the same text an LF + // body would. Only a CR before LF goes, so line numbers do not move. + const text = body.includes('\r') ? body.replace(/\r(?=\n)/g, '') : body + + const tagLines = inlineTagLines(text) + if (tagLines.size === 0) return [] + + const lines = text.split('\n') + const owned = new Array(lines.length).fill(false) + for (const { line } of scanMarkdownLines(text)) owned[line - 1] = true + const ctx: LineContext = { lines, owned, frontmatterEnd: frontmatterEndIndex(lines) } + + const byStart = new Map() + for (const [lineIndex, tags] of tagLines) { + const { kind, start, end } = blockAt(ctx, lineIndex) + const existing = byStart.get(start) + if (existing) { + for (const tag of tags) if (!existing.tags.includes(tag)) existing.tags.push(tag) + } else { + byStart.set(start, { kind, end, tags: [...tags] }) + } + } + + return [...byStart.entries()] + .sort((a, b) => a[0] - b[0]) + .map(([start, block]) => ({ + kind: block.kind, + startLine: start, + endLine: block.end, + tags: block.tags, + text: blockText(ctx, block.kind, start, block.end) + })) +} + +/** + * The 0-based char offset a jump to a block should land on: the start of the + * line plus its indentation, quote and list markers, task box and heading + * hashes, so the caret sits on the block's first word. Clamped to the body. + */ +export function tagBlockJumpOffset(body: string, line: number): number { + const lines = body.split('\n') + const target = Math.max(0, Math.min(line, lines.length - 1)) + let offset = 0 + for (let i = 0; i < target; i++) offset += (lines[i] as string).length + 1 + const lineText = lines[target] ?? '' + const marker = /^[ \t]*(?:>[ \t]?)*(?:(?:[-+*]|\d{1,9}[.)])[ \t]+(?:\[[ xX>/-]\][ \t]*)?|#{1,6}[ \t]+)?/.exec(lineText) + return offset + (marker ? marker[0].length : 0) +} + +interface LineContext { + lines: string[] + owned: boolean[] + /** Index of the frontmatter's closing fence, or -1. */ + frontmatterEnd: number +} + +/** Line index (whole body) → the inline tags on that line, scanned the way + * `extractTags` scans them. */ +function inlineTagLines(text: string): Map { + const out = new Map() + const frontmatter = FRONTMATTER_BLOCK_RE.exec(text) + const markdownBody = frontmatter ? text.slice(frontmatter[0].length) : text + // The frontmatter cut removes whole lines, so lines below it shift by the + // number of newlines it swallowed. + const shift = frontmatter ? countNewlines(frontmatter[0]) : 0 + if (!markdownBody.includes('#')) return out + const masked = stripCodeContent(markdownBody).split('\n') + for (let i = 0; i < masked.length; i++) { + const line = masked[i] as string + if (!line.includes('#')) continue + const tags: string[] = [] + for (const m of line.matchAll(INLINE_TAG_RE)) { + const tag = m[1] as string + if (!tags.includes(tag)) tags.push(tag) + } + if (tags.length > 0) out.set(i + shift, tags) + } + return out +} + +function countNewlines(s: string): number { + let n = 0 + for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) === 10) n++ + return n +} + +function blockAt( + ctx: LineContext, + index: number +): { kind: TagBlockKind; start: number; end: number } { + const { lines, owned } = ctx + // A line the structure walk does not own (a fence variant only the tag mask + // disagrees about) is still a counted tag: list it as its own line. + if (!owned[index]) return { kind: 'paragraph', start: index, end: index } + const line = lines[index] as string + + const level = headingLevel(ctx, index) + if (level > 0) return { kind: 'heading', start: index, end: sectionEnd(ctx, index, level) } + + if (QUOTE_RE.test(line)) { + let start = index + while (start - 1 > ctx.frontmatterEnd && owned[start - 1] && QUOTE_RE.test(lines[start - 1] as string)) start-- + let end = index + while (end + 1 < lines.length && owned[end + 1] && QUOTE_RE.test(lines[end + 1] as string)) end++ + return { kind: 'quote', start, end } + } + + const item = owningListItem(ctx, index) + if (item >= 0) return { kind: 'list-item', start: item, end: listItemEnd(ctx, item) } + + if (TABLE_ROW_RE.test(line)) return { kind: 'table-row', start: index, end: index } + + let start = index + while (start - 1 > ctx.frontmatterEnd && isParagraphLine(ctx, start - 1)) start-- + let end = index + while (end + 1 < lines.length && isParagraphLine(ctx, end + 1)) end++ + return { kind: 'paragraph', start, end } +} + +function isBlank(line: string): boolean { + return line.trim() === '' +} + +function indentOf(line: string): number { + let width = 0 + for (const ch of line) { + if (ch === ' ') width++ + else if (ch === '\t') width += 4 - (width % 4) + else break + } + return width +} + +function headingLevel(ctx: LineContext, index: number): number { + if (!ctx.owned[index]) return 0 + const m = HEADING_RE.exec(ctx.lines[index] as string) + return m ? (m[1] as string).length : 0 +} + +function isThematicBreak(line: string): boolean { + return THEMATIC_BREAK_RE.test(line) +} + +function isListMarker(ctx: LineContext, index: number): boolean { + const line = ctx.lines[index] as string + return ctx.owned[index] === true && LIST_MARKER_RE.test(line) && !isThematicBreak(line) +} + +function isParagraphLine(ctx: LineContext, index: number): boolean { + const line = ctx.lines[index] as string + return ( + ctx.owned[index] === true && + !isBlank(line) && + headingLevel(ctx, index) === 0 && + !isThematicBreak(line) && + !isListMarker(ctx, index) && + !QUOTE_RE.test(line) && + !TABLE_ROW_RE.test(line) + ) +} + +/** A heading's section: down to the line before the next heading at the same + * or a higher level, trailing blank lines left out. */ +function sectionEnd(ctx: LineContext, start: number, level: number): number { + let end = start + for (let i = start + 1; i < ctx.lines.length; i++) { + const next = headingLevel(ctx, i) + if (next > 0 && next <= level) break + end = i + } + while (end > start && isBlank(ctx.lines[end] as string)) end-- + return end +} + +/** + * The list item whose content includes line `index`, as the index of the + * item's marker line, or -1 when the line is not inside a list. A line belongs + * to the nearest marker above it that is less indented than every non-blank + * line in between, or to the marker it continues without a blank line (a lazy + * continuation). A column-0 line of other text after a blank line, a heading, + * or a thematic break closes the search. + */ +function owningListItem(ctx: LineContext, index: number): number { + if (isListMarker(ctx, index)) return index + const { lines, owned } = ctx + let minIndent = indentOf(lines[index] as string) + let sawBlank = false + for (let j = index - 1; j > ctx.frontmatterEnd; j--) { + const line = lines[j] as string + if (isBlank(line)) { + sawBlank = true + continue + } + if (owned[j]) { + if (headingLevel(ctx, j) > 0 || isThematicBreak(line)) return -1 + if (isListMarker(ctx, j)) { + const markerIndent = indentOf(line) + if (minIndent > markerIndent || !sawBlank) return j + // A sibling item at this depth: only a shallower item can still hold + // the line. + if (markerIndent === 0) return -1 + minIndent = Math.min(minIndent, markerIndent) + continue + } + } + minIndent = Math.min(minIndent, indentOf(line)) + if (minIndent === 0 && sawBlank) return -1 + } + return -1 +} + +/** Where a list item ends: the last line indented under it (children, wrapped + * text, loose paragraphs, fenced code), or a lazy continuation of its text. */ +function listItemEnd(ctx: LineContext, start: number): number { + const { lines, owned } = ctx + const indent = indentOf(lines[start] as string) + let end = start + for (let i = start + 1; i < lines.length; i++) { + const line = lines[i] as string + if (isBlank(line)) continue + if (indentOf(line) > indent) { + end = i + continue + } + const lazy = + i === end + 1 && + owned[i] === true && + owned[end] === true && + isParagraphLine(ctx, i) && + !isBlank(lines[end] as string) + if (lazy) { + end = i + continue + } + break + } + return end +} + +/** The readable text of a block, for listing it. Code lines are dropped: the + * idea is the prose around them. */ +function blockText(ctx: LineContext, kind: TagBlockKind, start: number, end: number): string { + const out: string[] = [] + let chars = 0 + let truncated = false + for (let i = start; i <= end; i++) { + if (!ctx.owned[i]) continue + const raw = ctx.lines[i] as string + if (FENCE_OPEN_RE.test(raw)) continue + const clean = displayLine(raw, kind === 'heading' && i === start) + if (!clean) continue + if (out.length === MAX_TEXT_LINES || chars + clean.length > MAX_TEXT_CHARS) { + const room = MAX_TEXT_CHARS - chars + if (out.length < MAX_TEXT_LINES && room > 20) out.push(clean.slice(0, room).trimEnd()) + truncated = true + break + } + out.push(clean) + chars += clean.length + } + if (truncated && out.length > 0) out[out.length - 1] = `${out[out.length - 1]}…` + return out.join('\n') +} + +function displayLine(raw: string, isHeadingLine: boolean): string { + let line = raw + const anchor = trailingBlockIdRange(line) + if (anchor) line = line.slice(0, anchor.from) + if (isHeadingLine) { + line = line.replace(/^ {0,3}#{1,6}[ \t]*/, '').replace(/[ \t]+#+[ \t]*$/, '') + } else if (TABLE_ROW_RE.test(line)) { + line = line + .trim() + .replace(/^\||\|$/g, '') + .split('|') + .map((cell) => cell.trim()) + .filter(Boolean) + .join(' · ') + } else { + line = line + .replace(/^[ \t]*(?:>[ \t]?)+/, '') + .replace(/^\[![^\]]+\][+-]?[ \t]*/, '') + .replace(/^[ \t]*(?:[-+*]|\d{1,9}[.)])[ \t]+/, '') + .replace(/^\[[ xX>/-]\][ \t]+/, '') + .replace(/^ {0,3}#{1,6}[ \t]+/, '') + } + return line.trim() +} diff --git a/packages/shared-domain/src/tag-scan.ts b/packages/shared-domain/src/tag-scan.ts new file mode 100644 index 00000000..2852e67f --- /dev/null +++ b/packages/shared-domain/src/tag-scan.ts @@ -0,0 +1,81 @@ +/** + * Extract a note's tags from a markdown body: its frontmatter `tags` field + * plus every inline `#tag`. Mirrors the extraction the main process runs in + * `vault.ts` so the sidebar can update tag counts *live* as the user types, + * instead of waiting for the save + chokidar round-trip. + * + * Rules: + * - The hash must be preceded by start-of-line or whitespace (so + * `me#tag` and `url.com/#x` don't match). + * - The first tag character must be a letter in any script (Cyrillic, + * CJK, and so on: #205), the rest can be letters, digits, `_`, `-`, or `/`. + * - Fenced code blocks and inline code spans are stripped first. + * - Heading markers (`#`, `##`, …) are not a hashtag because the + * character after the hash is a space, not a letter. + * - The frontmatter block is read for `tags` and then excluded from the + * inline scan, so a `#` in some other field is never a tag (#444). + * + * Lives in shared-domain (it was app-core's `lib/tags.ts` copy) so the + * block-level tag scan in `tag-blocks.ts` reads tags by exactly these rules + * instead of carrying a sixth copy of the code mask (#837). + */ +import { FRONTMATTER_BLOCK_RE, frontmatterTags } from './frontmatter' + +/** An inline `#tag`. Global, so callers reset `lastIndex` or use `matchAll`. */ +export const INLINE_TAG_RE = /(?:^|\s)#(\p{L}[\p{L}\d_/-]*)/gu + +export function extractTags(body: string): string[] { + const seen = new Set() + for (const tag of frontmatterTags(body)) seen.add(tag) + + const markdownBody = body.replace(FRONTMATTER_BLOCK_RE, '') + const stripped = stripCodeContent(markdownBody) + for (const m of stripped.matchAll(INLINE_TAG_RE)) { + seen.add(m[1] as string) + } + return [...seen] +} + +/** + * Blank out fenced and inline code so the tag scanner never reads code as a + * tag. Fence detection is line-based and indentation-tolerant: a fence nested + * under a list item is still a code block, so e.g. a C `#include` line inside + * it is not a tag (#293). Line-preserving: a code line becomes a single space, + * so line N of the result is line N of the input. Mirrors `stripCodeContent` + * in apps/desktop/src/main/vault.ts, apps/desktop/src/mcp/vault-ops.ts, + * packages/app-core/src/lib/wikilinks.ts and internal/vault/parse.go in + * ZenNotes/znserver: keep all five in sync. + */ +export function stripCodeContent(body: string): string { + if (!body.includes('`') && !body.includes('~')) return body + const lines = body.split('\n') + let inFence = false + let fenceChar = '' + let fenceLen = 0 + for (let i = 0; i < lines.length; i++) { + const line = lines[i] as string + // `.` never matches `\r`, so the `\r?` is what lets a CRLF-saved fence line match. + const m = /^[ \t]*(`{3,}|~{3,})(.*)\r?$/.exec(line) + if (m) { + const marker = m[1] as string + const char = marker[0] as string + const rest = m[2] as string + if (!inFence) { + // A backtick fence's info string may not contain a backtick (CommonMark). + if (char === '~' || !rest.includes('`')) { + inFence = true + fenceChar = char + fenceLen = marker.length + lines[i] = ' ' + continue + } + } else if (char === fenceChar && marker.length >= fenceLen && rest.trim() === '') { + inFence = false + lines[i] = ' ' + continue + } + } + if (inFence) lines[i] = ' ' + } + return lines.join('\n').replace(/`[^`\n]*`/g, ' ') +} diff --git a/packages/shared-domain/src/unresolved-links.test.ts b/packages/shared-domain/src/unresolved-links.test.ts new file mode 100644 index 00000000..1b2a4452 --- /dev/null +++ b/packages/shared-domain/src/unresolved-links.test.ts @@ -0,0 +1,197 @@ +import { describe, expect, it } from 'vitest' +import { + UNRESOLVED_LINKS_TAB_PATH, + collectUnresolvedLinks, + findWikilinkOccurrences, + isUnresolvedLinksTabPath, + unresolvedLinkKey, + unresolvedOccurrencesIn, + wikilinkNoteName, + type UnresolvedLinkSource +} from './unresolved-links' +import { scanMarkdownLines } from './markdown-lines' + +describe('findWikilinkOccurrences', () => { + it('reports each link with its 1-based line and body offsets', () => { + const body = 'intro\nsee [[Alpha]] and [[Beta|the beta]]\n![[Gamma]]' + const found = findWikilinkOccurrences(body) + expect(found.map((o) => [o.target, o.line])).toEqual([ + ['Alpha', 2], + ['Beta', 2], + ['Gamma', 3] + ]) + expect(body.slice(found[0]!.from, found[0]!.to)).toBe('[[Alpha]]') + expect(body.slice(found[1]!.from, found[1]!.to)).toBe('[[Beta|the beta]]') + expect(body.slice(found[2]!.from, found[2]!.to)).toBe('![[Gamma]]') + expect(found[1]!.text).toBe('see [[Alpha]] and [[Beta|the beta]]') + expect(found[1]!.column).toBe('see [[Alpha]] and '.length) + }) + + it('ignores links inside fenced code blocks, tilde fences and nested list fences', () => { + const body = [ + '[[Real]]', + '```md', + '[[In Fence]]', + '```', + '~~~', + '[[In Tilde]]', + '~~~', + '- item', + ' ```', + ' [[In List Fence]]', + ' ```', + 'after [[After]]' + ].join('\n') + expect(findWikilinkOccurrences(body).map((o) => o.target)).toEqual(['Real', 'After']) + }) + + it('ignores links inside inline code spans and keeps later columns exact', () => { + const body = 'a `[[Code]]` b [[Prose]]' + const found = findWikilinkOccurrences(body) + expect(found.map((o) => o.target)).toEqual(['Prose']) + expect(body.slice(found[0]!.from, found[0]!.to)).toBe('[[Prose]]') + }) + + it('treats a backtick run with a backtick in its info string as inline code, not a fence', () => { + const body = '```[[Inline]]```\n[[Next]]' + expect(findWikilinkOccurrences(body).map((o) => o.target)).toEqual(['Next']) + }) + + it('does not let a longer closer requirement leak a fence open', () => { + const body = '````\n```\n[[Still Code]]\n````\n[[Out]]' + expect(findWikilinkOccurrences(body).map((o) => o.target)).toEqual(['Out']) + }) + + it('scans frontmatter lines, as the vault index does', () => { + const body = '---\nrelated: "[[Front]]"\n---\nbody [[Body]]' + expect(findWikilinkOccurrences(body).map((o) => [o.target, o.line])).toEqual([ + ['Front', 2], + ['Body', 4] + ]) + }) + + it('counts a CRLF break as one character, like the editor', () => { + const body = 'one\r\ntwo [[Link]]' + const [hit] = findWikilinkOccurrences(body) + expect(hit!.line).toBe(2) + expect(hit!.from).toBe('one\ntwo '.length) + }) + + it('skips empty targets', () => { + expect(findWikilinkOccurrences('[[ ]] [[|alias]]')).toEqual([]) + }) +}) + +describe('scanMarkdownLines includeFrontmatter', () => { + it('still skips frontmatter by default', () => { + const body = '---\na: b\n---\ntext' + expect(scanMarkdownLines(body).map((l) => l.text)).toEqual(['text']) + expect(scanMarkdownLines(body, { includeFrontmatter: true }).map((l) => l.text)).toEqual([ + '---', + 'a: b', + '---', + 'text' + ]) + }) +}) + +describe('unresolvedLinkKey', () => { + it('folds case, anchors, the .md extension and a leading slash into one note', () => { + for (const spelling of ['Doc', 'doc', 'Doc#Intro', 'Doc^block', 'Doc.md', '/Doc', ' Doc ']) { + expect(unresolvedLinkKey(spelling)).toBe('doc') + } + }) + + it('keeps folders: a path spelling names a different file', () => { + expect(unresolvedLinkKey('ideas/Doc')).toBe('ideas/doc') + expect(unresolvedLinkKey('ideas\\Doc#h')).toBe('ideas/doc') + }) + + it('names the note part of an anchored target', () => { + expect(wikilinkNoteName('Doc#Heading')).toBe('Doc') + expect(wikilinkNoteName('#Heading')).toBe('') + }) +}) + +describe('collectUnresolvedLinks', () => { + const note = (path: string, wikilinks: string[], folder = 'inbox'): UnresolvedLinkSource => ({ + path, + folder, + wikilinks + }) + const existing = new Set(['alpha']) + const resolves = (target: string): boolean => existing.has(unresolvedLinkKey(target)) + + it('groups spellings of one missing note and lists each source note once', () => { + const a = note('inbox/a.md', ['Missing', 'missing#Part', 'Alpha']) + const b = note('inbox/b.md', ['Missing|alias'.split('|')[0]!]) + const groups = collectUnresolvedLinks([a, b], resolves) + expect(groups).toHaveLength(1) + expect(groups[0]!.target).toBe('Missing') + expect(groups[0]!.sources.map((n) => n.path)).toEqual(['inbox/a.md', 'inbox/b.md']) + }) + + it('drops the anchor from the name it would create', () => { + const groups = collectUnresolvedLinks([note('inbox/a.md', ['Later#Plan'])], resolves) + expect(groups[0]!.target).toBe('Later') + }) + + it('ignores trashed source notes and targets the resolver accepts', () => { + const groups = collectUnresolvedLinks( + [note('trash/t.md', ['Gone'], 'trash'), note('inbox/a.md', ['Alpha'])], + resolves + ) + expect(groups).toEqual([]) + }) + + it('asks the resolver with the note the link was written in', () => { + const seen: Array<[string, string]> = [] + collectUnresolvedLinks([note('inbox/a.md', ['Sibling#Local'])], (target, from) => { + seen.push([target, from.path]) + return true + }) + expect(seen).toEqual([['Sibling#Local', 'inbox/a.md']]) + }) + + it('skips a target that names no note at all', () => { + let asked = 0 + const groups = collectUnresolvedLinks([note('inbox/a.md', ['#heading', '^block'])], () => { + asked++ + return false + }) + expect(groups).toEqual([]) + expect(asked).toBe(0) + }) + + it('puts the most-linked missing note first, then sorts by name', () => { + const groups = collectUnresolvedLinks( + [ + note('inbox/a.md', ['beta', 'Zeta']), + note('inbox/b.md', ['Zeta', 'alpha 2']), + note('inbox/c.md', ['alpha 10']) + ], + () => false + ) + expect(groups.map((g) => g.target)).toEqual(['Zeta', 'alpha 2', 'alpha 10', 'beta']) + }) +}) + +describe('unresolvedOccurrencesIn', () => { + it('returns only the lines that link to the requested missing notes', () => { + const body = '[[Alpha]]\n[[Later#Plan]] and `[[Later]]`\n```\n[[Later]]\n```\n[[later]]' + const hits = unresolvedOccurrencesIn(body, new Set(['later'])) + expect(hits.map((h) => [h.target, h.line, h.key])).toEqual([ + ['Later#Plan', 2, 'later'], + ['later', 6, 'later'] + ]) + }) +}) + +describe('Unresolved Links tab path', () => { + it('is a zen:// virtual path', () => { + expect(UNRESOLVED_LINKS_TAB_PATH.startsWith('zen://')).toBe(true) + expect(isUnresolvedLinksTabPath(UNRESOLVED_LINKS_TAB_PATH)).toBe(true) + expect(isUnresolvedLinksTabPath('inbox/unresolved-links.md')).toBe(false) + expect(isUnresolvedLinksTabPath(null)).toBe(false) + }) +}) diff --git a/packages/shared-domain/src/unresolved-links.ts b/packages/shared-domain/src/unresolved-links.ts new file mode 100644 index 00000000..108a2611 --- /dev/null +++ b/packages/shared-domain/src/unresolved-links.ts @@ -0,0 +1,181 @@ +/** + * Unresolved wikilinks: `[[targets]]` no note in the vault answers, the notes + * someone meant to write later. The Unresolved Links view lists them + * vault-wide with the lines that mention them. + * + * What counts as "resolved" is the editor's decision, not this module's: the + * renderer resolves titles, paths, headings, assets and databases with rules + * that live in app-core, so `collectUnresolvedLinks` takes that answer as a + * callback and owns only the grouping. The line scan masks code the way the + * vault index does (a `[[link]]` inside a fence or an inline code span is + * text, not a link) through `scanMarkdownLines`, the shared fence walker, + * instead of another copy of `stripCodeContent`. + */ +import { scanMarkdownLines } from './markdown-lines' + +/** Virtual tab path of the Unresolved Links view. */ +export const UNRESOLVED_LINKS_TAB_PATH = 'zen://unresolved-links' + +/** True when `path` is the Unresolved Links view tab. */ +export function isUnresolvedLinksTabPath(path: string | null | undefined): boolean { + return path === UNRESOLVED_LINKS_TAB_PATH +} + +/** One `[[wikilink]]` as it sits in a note body. */ +export interface WikilinkOccurrence { + /** The target as written, before any `|alias`, trimmed. */ + target: string + /** 1-based line number. */ + line: number + /** Offset of the link within its line. */ + column: number + /** Body offset of the opening `[[` (or the `!` of an embed). */ + from: number + /** Body offset just past the closing `]]`. */ + to: number + /** The line the link sits on, as written. */ + text: string +} + +// Same shape as the vault index's scanner (`extractWikilinks` in the desktop +// main process): an optional embed bang, the target up to `|` or `]`, and an +// optional alias. +const WIKILINK_RE = /(!?)\[\[([^\]|]+?)(?:\|[^\]]+)?\]\]/g + +// Inline code spans as the vault index masks them (`[^`\n]*` between single +// backticks), blanked to spaces of the same length so the columns of every +// link after the span stay where the editor has them. +const INLINE_CODE_RE = /`[^`\n]*`/g + +function maskInlineCode(line: string): string { + if (!line.includes('`')) return line + return line.replace(INLINE_CODE_RE, (span) => ' '.repeat(span.length)) +} + +/** + * Every wikilink in a note body, in reading order, with its line and offsets. + * Links inside fenced code blocks and inline code spans are skipped. Lines of + * a leading frontmatter block are scanned, as the vault index scans them. + * + * Offsets count a CRLF line break as one character, the way CodeMirror counts + * them, so `from` places the editor cursor on the link in either encoding. + */ +export function findWikilinkOccurrences(body: string): WikilinkOccurrence[] { + if (!body.includes('[[')) return [] + const normalized = body.includes('\r') ? body.replace(/\r\n?/g, '\n') : body + const found: WikilinkOccurrence[] = [] + for (const line of scanMarkdownLines(normalized, { includeFrontmatter: true })) { + if (!line.text.includes('[[')) continue + const masked = maskInlineCode(line.text) + for (const m of masked.matchAll(WIKILINK_RE)) { + const target = (m[2] ?? '').trim() + if (!target) continue + const start = m.index ?? 0 + found.push({ + target, + line: line.line, + column: start, + from: line.from + start, + to: line.from + start + m[0].length, + text: line.text + }) + } + } + return found +} + +/** + * The part of a wikilink target that names a note: `Doc#Heading` and + * `Doc^block` both point into `Doc`. Note names cannot contain `#` or `^`, + * so the first one always starts the anchor. + */ +export function wikilinkNoteName(target: string): string { + const anchor = target.search(/[#^]/) + return (anchor === -1 ? target : target.slice(0, anchor)).trim() +} + +/** + * Identity of a missing note across its spellings. `[[Doc]]`, `[[doc]]`, + * `[[Doc#Intro]]` and `[[Doc.md]]` all name one note that does not exist, so + * the view lists it once. A path spelling keeps its folders: `[[ideas/Doc]]` + * names a different file than `[[Doc]]`. + */ +export function unresolvedLinkKey(target: string): string { + return wikilinkNoteName(target) + .replace(/\\/g, '/') + .replace(/\/+/g, '/') + .replace(/^\/+|\/+$/g, '') + .replace(/\.md$/i, '') + .trim() + .toLowerCase() +} + +/** The note fields the scan reads: the vault index's per-note link list. */ +export interface UnresolvedLinkSource { + path: string + folder: string + wikilinks?: readonly string[] +} + +export interface UnresolvedLinkGroup { + /** See {@link unresolvedLinkKey}. */ + key: string + /** The note name as first written, anchor dropped: what creating it names the file. */ + target: string + /** The notes that link to it, in vault order, each once. */ + sources: N[] +} + +/** + * Group every unresolved wikilink in the vault by the note it names, from the + * index's per-note link lists (no file reads). `isResolved(target, note)` + * answers for one target as written in `note`, so relative paths and + * same-note `[[#heading]]` links resolve against the right note. + * + * Trashed notes are not sources: their links are not part of the vault. Most + * linked first, then by name, so the note the vault asks for most is on top. + */ +export function collectUnresolvedLinks( + notes: readonly N[], + isResolved: (target: string, note: N) => boolean +): UnresolvedLinkGroup[] { + const groups = new Map>() + for (const note of notes) { + if (note.folder === 'trash' || !note.wikilinks?.length) continue + for (const raw of note.wikilinks) { + const target = raw.trim() + if (!target) continue + const key = unresolvedLinkKey(target) + if (!key) continue + if (isResolved(target, note)) continue + const group = groups.get(key) + if (!group) { + groups.set(key, { key, target: wikilinkNoteName(target), sources: [note] }) + } else if (group.sources[group.sources.length - 1] !== note) { + group.sources.push(note) + } + } + } + return [...groups.values()].sort( + (a, b) => + b.sources.length - a.sources.length || + a.target.localeCompare(b.target, undefined, { sensitivity: 'base', numeric: true }) + ) +} + +/** + * The lines of `body` that link to any of the missing notes in `keys`, in + * reading order. Used to show where each source note mentions a missing + * target once its body has been read. + */ +export function unresolvedOccurrencesIn( + body: string, + keys: ReadonlySet +): Array { + const out: Array = [] + for (const occurrence of findWikilinkOccurrences(body)) { + const key = unresolvedLinkKey(occurrence.target) + if (keys.has(key)) out.push({ ...occurrence, key }) + } + return out +} diff --git a/packages/shared-domain/src/workflows/apply-ops.ts b/packages/shared-domain/src/workflows/apply-ops.ts index 7a8b51c4..160d0d71 100644 --- a/packages/shared-domain/src/workflows/apply-ops.ts +++ b/packages/shared-domain/src/workflows/apply-ops.ts @@ -231,8 +231,8 @@ interface CodeMap { /** * Which lines are fenced code. * - * The state machine is lifted from `stripCodeContent` (packages/app-core/src/ - * lib/tags.ts, apps/desktop/src/main/vault.ts, apps/desktop/src/mcp/vault-ops.ts + * The state machine is lifted from `stripCodeContent` (packages/shared-domain/ + * src/tag-scan.ts, apps/desktop/src/main/vault.ts, apps/desktop/src/mcp/vault-ops.ts * and internal/vault/parse.go in ZenNotes/znserver all carry a copy) so that a `#tag` * this module writes, and a `#tag` the vault's indexer reads, can never disagree * about what is code. It returns per-line flags instead of a blanked string diff --git a/packages/shared-ui/package.json b/packages/shared-ui/package.json index e907f529..604c2d25 100644 --- a/packages/shared-ui/package.json +++ b/packages/shared-ui/package.json @@ -1,7 +1,7 @@ { "name": "@zennotes/shared-ui", "private": true, - "version": "2.76.0", + "version": "2.77.0", "type": "module", "exports": { ".": "./src/index.ts" diff --git a/tooling/scripts/pack-app-core.mjs b/tooling/scripts/pack-app-core.mjs index 4f3fe704..e8d8340e 100644 --- a/tooling/scripts/pack-app-core.mjs +++ b/tooling/scripts/pack-app-core.mjs @@ -58,6 +58,7 @@ export async function packAppCore() { const exports = { './main': { types: './dist/main.d.ts', import: './dist/main.js' }, './navigation': { types: './dist/navigation.d.ts', import: './dist/navigation.js' }, + './calendar': { types: './dist/calendar.d.ts', import: './dist/calendar.js' }, './notes': { types: './dist/notes.d.ts', import: './dist/notes.js' }, './shell': { types: './dist/shell.d.ts', import: './dist/shell.js' }, './browse': { types: './dist/browse.d.ts', import: './dist/browse.js' }, diff --git a/tooling/scripts/sidebar-vim-smoke.mjs b/tooling/scripts/sidebar-vim-smoke.mjs index 1cbc0f00..69ff752c 100644 --- a/tooling/scripts/sidebar-vim-smoke.mjs +++ b/tooling/scripts/sidebar-vim-smoke.mjs @@ -12,6 +12,7 @@ * and drives it over the Chrome DevTools Protocol: * - windowing is actually active (most rows are placeholders), * - j / k move the cursor one real row at a time, + * - a note written from outside above the cursor leaves it on its row, * - G / gg scroll to the ends and the end rows render as full rows, * - every row exposes a selection key (range-select sees the whole list), * - clicking an off-screen placeholder opens its note, @@ -284,6 +285,26 @@ async function main() { } check('k moves up one real row at a time', kOk, kDetail) + // 5b. A note written from outside the app lands above the cursor, and every + // row after it is renumbered. The cursor follows its row, not its number. + const cursorRow = `(() => { + const el = [...document.querySelectorAll('[data-sidebar-idx]')].find(e => /(^|\\s)vim-cursor/.test(e.className)); + return el ? { idx: Number(el.getAttribute('data-sidebar-idx')), path: el.getAttribute('data-sidebar-path') } : null; + })()` + const beforeWrite = await evaluate(client, cursorRow) + const outsideFile = '00000a - outside.md' + await writeFile(join(vaultRoot, 'inbox', outsideFile), '# Outside\n\nWritten while the sidebar had focus.\n') + const outsideIdx = await until(client, `(() => { + const el = document.querySelector('[data-sidebar-path$=${JSON.stringify(outsideFile)}]'); + return el ? Number(el.getAttribute('data-sidebar-idx')) : null; + })()`, 8000, 100) + await sleep(150) + const afterWrite = await evaluate(client, cursorRow) + check('an outside write above the cursor leaves it on its row', + !!beforeWrite && outsideIdx != null && outsideIdx < beforeWrite.idx && + afterWrite?.path === beforeWrite.path && afterWrite?.idx === beforeWrite.idx + 1, + JSON.stringify({ beforeWrite, outsideIdx, afterWrite })) + // 6. G scrolls to the bottom and the last note (a placeholder until now) renders full. await pressKey(client, 'G', true) const gOk = await until(client, `(() => { diff --git a/tooling/scripts/tag-blocks-smoke.mjs b/tooling/scripts/tag-blocks-smoke.mjs new file mode 100644 index 00000000..53a8ca12 --- /dev/null +++ b/tooling/scripts/tag-blocks-smoke.mjs @@ -0,0 +1,828 @@ +#!/usr/bin/env node +/** + * Block-level tag results smoke test (#837). + * + * Seeds a vault with tagged list items, a tagged heading section, a tagged + * paragraph, a `#tag` inside fenced code, and a note tagged only in + * frontmatter, launches the real desktop build twice (Vim on, then Vim off) + * with its own userData and config dir, and drives the Tags view over the + * Chrome DevTools Protocol: + * - a sidebar tag click opens the Tags view with each note's tagged blocks + * listed under it, code ignored, the frontmatter-only note a plain row, + * - j / } / { move over block rows and between notes, + * - Enter on a block opens the note with the caret and highlight on that line, + * - the filter narrows to the blocks whose text matches, + * - a block typed into an open note lists right away, + * - with Vim off, } is inert and the arrows and Enter still work, + * - Search notes with a #tag lists two blocks per note and a "+N more" row: + * Ctrl+J / the arrows reach the blocks, Enter opens one at its line, free + * text narrows and marks them, "+N more" opens the Tags view with the + * text still filtering, and the Settings toggle (saved to config.toml) + * turns the blocks off, + * - a tag on ZEN_TAG_BLOCKS_BULK notes (default 500) fills in, timed, + * - no console errors fire. + * + * Usage: + * node tooling/scripts/tag-blocks-smoke.mjs + * ZEN_TAG_BLOCKS_SKIP_BUILD=1 node tooling/scripts/tag-blocks-smoke.mjs # reuse out/main + * ZEN_TAG_BLOCKS_SHOTS= ... # keep screenshots + */ +import { execFileSync, spawn } from 'node:child_process' +import { createRequire } from 'node:module' +import { constants } from 'node:fs' +import { access, mkdir, mkdtemp, readFile, rm, utimes, writeFile } from 'node:fs/promises' +import http from 'node:http' +import net from 'node:net' +import { tmpdir } from 'node:os' +import { dirname, join, resolve } from 'node:path' +import { fileURLToPath } from 'node:url' +import WebSocket from 'ws' +import { testWindowState } from './test-window-state.mjs' + +const scriptDir = dirname(fileURLToPath(import.meta.url)) +const repoRoot = resolve(scriptDir, '..', '..') +const requireDesktop = createRequire(resolve(repoRoot, 'apps/desktop/package.json')) +const electronPath = requireDesktop('electron') +const desktopOutMain = resolve(repoRoot, 'apps/desktop/out/main/index.js') +const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm' + +const skipBuild = process.env.ZEN_TAG_BLOCKS_SKIP_BUILD === '1' +const shotsDir = process.env.ZEN_TAG_BLOCKS_SHOTS?.trim() || null +const BULK_NOTES = Number.parseInt(process.env.ZEN_TAG_BLOCKS_BULK ?? '500', 10) || 0 + +const sleep = (ms) => new Promise((r) => setTimeout(r, ms)) + +const IDEAS = [ + '# Ideas', + '', + 'Some thoughts I keep in one place.', + '', + '- Groceries for the week', + '- Recipe gallery for the website #idea', + ' - start with ten recipes', + '- Plugin store with reviews #idea #later', + '', + '## Dark mode schedule #idea', + 'Switch themes at sunset.', + 'Needs a setting.', + '', + '## Notes', + '', + 'A paragraph about the zine', + 'that spans lines #idea and continues.', + '', + '```js', + '// #idea inside code must not list', + "const tag = '#idea'", + '```', + '' +].join('\n') + +const JOURNAL = ['# Journal', '', 'Woke up early.', '', 'Write a zine about walking #idea', ''].join('\n') +const PROJECT = ['---', 'tags: [idea]', '---', '# Project', '', 'Only frontmatter tags here.', ''].join('\n') +const LATER = ['# Later', '', '- Something for later #later', ''].join('\n') + +async function fileExists(p) { + try { + await access(p, constants.F_OK) + return true + } catch { + return false + } +} + +function run(command, args) { + return new Promise((res, rej) => { + const child = spawn(command, args, { cwd: repoRoot, stdio: 'inherit', shell: process.platform === 'win32' }) + child.on('exit', (code) => (code === 0 ? res() : rej(new Error(`${command} ${args.join(' ')} exited ${code}`)))) + child.on('error', rej) + }) +} + +async function seedVault(root) { + const inbox = join(root, 'inbox') + await mkdir(inbox, { recursive: true }) + await Promise.all(['quick', 'archive', 'trash'].map((d) => mkdir(join(root, d), { recursive: true }))) + const now = Date.now() / 1000 + const notes = [ + ['Ideas.md', IDEAS, now], + ['Journal.md', JOURNAL, now - 60], + ['Project.md', PROJECT, now - 120], + ['Later.md', LATER, now - 180] + ] + for (const [name, body, mtime] of notes) { + const p = join(inbox, name) + await writeFile(p, body) + await utimes(p, mtime, mtime) + } + if (BULK_NOTES > 0) { + const bulk = join(inbox, 'bulk') + await mkdir(bulk, { recursive: true }) + const filler = Array.from({ length: 40 }, (_, i) => `Filler line ${i} of plain prose.`).join('\n') + const files = [] + for (let i = 0; i < BULK_NOTES; i++) { + files.push([ + join(bulk, `bulk-${String(i).padStart(4, '0')}.md`), + `# Bulk ${i}\n\n${filler}\n\n- first item\n- idea number ${i} #bulk\n- last item\n\n${filler}\n` + ]) + } + for (let i = 0; i < files.length; i += 100) { + await Promise.all(files.slice(i, i + 100).map(([p, b]) => writeFile(p, b))) + } + } +} + +async function seedUserData(userDataRoot, configRoot, vaultRoot, vim) { + await Promise.all([mkdir(userDataRoot, { recursive: true }), mkdir(configRoot, { recursive: true })]) + await writeFile( + join(userDataRoot, 'zennotes.config.json'), + JSON.stringify( + { + workspaceMode: 'local', + vaultRoot, + remoteWorkspace: null, + remoteWorkspaceProfileId: null, + remoteWorkspaceProfiles: [], + windowState: testWindowState(1280, 860), + zoomFactor: 1, + quickCaptureHotkey: '' + }, + null, + 2 + ) + ) + await writeFile(join(configRoot, 'config.toml'), `[vim]\nenabled = ${vim}\n`) +} + +function getFreePort() { + return new Promise((res, rej) => { + const s = net.createServer() + s.listen(0, '127.0.0.1', () => { + const a = s.address() + s.close(() => res(a.port)) + }) + s.on('error', rej) + }) +} + +function httpGetJson(url) { + return new Promise((res, rej) => { + const req = http.get(url, (r) => { + let b = '' + r.on('data', (c) => (b += c)) + r.on('end', () => { + try { + res(JSON.parse(b)) + } catch (e) { + rej(e) + } + }) + }) + req.on('error', rej) + req.setTimeout(1000, () => req.destroy(new Error('timeout'))) + }) +} + +class Cdp { + constructor(url) { + this.url = url + this.id = 1 + this.pending = new Map() + this.listeners = new Map() + } + connect() { + return new Promise((res, rej) => { + this.ws = new WebSocket(this.url) + this.ws.on('open', res) + this.ws.on('error', rej) + this.ws.on('close', () => { + for (const { reject } of this.pending.values()) reject(new Error('CDP socket closed')) + this.pending.clear() + }) + this.ws.on('message', (raw) => { + const m = JSON.parse(String(raw)) + if (m.id && this.pending.has(m.id)) { + const { resolve: ok, reject } = this.pending.get(m.id) + this.pending.delete(m.id) + if (m.error) reject(new Error(m.error.message)) + else ok(m.result ?? {}) + } else if (m.method) { + for (const l of this.listeners.get(m.method) ?? []) l(m.params ?? {}) + } + }) + }) + } + send(method, params = {}) { + const id = this.id++ + return new Promise((res, rej) => { + this.pending.set(id, { resolve: res, reject: rej }) + this.ws.send(JSON.stringify({ id, method, params })) + }) + } + on(method, l) { + const a = this.listeners.get(method) ?? [] + a.push(l) + this.listeners.set(method, a) + } + close() { + this.ws?.terminate?.() + } +} + +async function connectPage(port) { + const deadline = Date.now() + 30000 + let lastErr = null + while (Date.now() < deadline) { + try { + const targets = await httpGetJson(`http://127.0.0.1:${port}/json/list`) + const page = targets.find( + (t) => t.type === 'page' && t.webSocketDebuggerUrl && (String(t.url).startsWith('file:') || String(t.url).includes('index.html')) + ) + if (page) { + const c = new Cdp(page.webSocketDebuggerUrl) + await c.connect() + return c + } + } catch (e) { + lastErr = e + } + await sleep(100) + } + throw new Error(`no CDP page: ${lastErr?.message ?? 'timeout'}`) +} + +async function evaluate(client, expression) { + const r = await client.send('Runtime.evaluate', { expression, awaitPromise: true, returnByValue: true }) + if (r.exceptionDetails) throw new Error(r.exceptionDetails.exception?.description ?? r.exceptionDetails.text) + return r.result?.value +} + +async function until(client, expression, timeoutMs = 4000, intervalMs = 60) { + const deadline = Date.now() + timeoutMs + while (Date.now() < deadline) { + const v = await evaluate(client, expression) + if (v) return v + await sleep(intervalMs) + } + return null +} + +const KEY_CODES = { + '}': ['BracketRight', 221, true], + '{': ['BracketLeft', 219, true], + '/': ['Slash', 191, false], + ':': ['Semicolon', 186, true], + '#': ['Digit3', 51, true], + ' ': ['Space', 32, false], + '-': ['Minus', 189, false], + G: ['KeyG', 71, true] +} + +/** A real key press through CDP: keyDown (with text for printable keys) + keyUp. */ +async function press(client, key) { + const named = { Enter: 13, Escape: 27, ArrowDown: 40, ArrowUp: 38, Backspace: 8 } + let code + let keyCode + let shift = false + if (named[key]) { + code = key + keyCode = named[key] + } else if (KEY_CODES[key]) { + ;[code, keyCode, shift] = KEY_CODES[key] + } else if (/^[a-z]$/.test(key)) { + code = `Key${key.toUpperCase()}` + keyCode = key.toUpperCase().charCodeAt(0) + } else if (/^[A-Z]$/.test(key)) { + code = `Key${key}` + keyCode = key.charCodeAt(0) + shift = true + } else if (/^[0-9]$/.test(key)) { + code = `Digit${key}` + keyCode = key.charCodeAt(0) + } else { + code = '' + keyCode = 0 + } + const text = key.length === 1 ? key : key === 'Enter' ? '\r' : undefined + const modifiers = shift ? 8 : 0 + await client.send('Input.dispatchKeyEvent', { + type: text ? 'keyDown' : 'rawKeyDown', + key, + code, + windowsVirtualKeyCode: keyCode, + nativeVirtualKeyCode: keyCode, + modifiers, + ...(text ? { text, unmodifiedText: text } : {}) + }) + await client.send('Input.dispatchKeyEvent', { type: 'keyUp', key, code, windowsVirtualKeyCode: keyCode, modifiers }) + await sleep(40) +} + +/** Ctrl plus a letter, as a real key press (no text: a chord types nothing). */ +async function pressCtrl(client, letter) { + const code = `Key${letter.toUpperCase()}` + const keyCode = letter.toUpperCase().charCodeAt(0) + for (const type of ['rawKeyDown', 'keyUp']) { + await client.send('Input.dispatchKeyEvent', { type, key: letter, code, windowsVirtualKeyCode: keyCode, modifiers: 2 }) + } + await sleep(60) +} + +/** Mod (Cmd on macOS, Ctrl elsewhere) plus a key, as a real key press. */ +async function pressMod(client, key, code, keyCode) { + const modifiers = process.platform === 'darwin' ? 4 : 2 + for (const type of ['rawKeyDown', 'keyUp']) { + await client.send('Input.dispatchKeyEvent', { type, key, code, windowsVirtualKeyCode: keyCode, modifiers }) + } + await sleep(80) +} + +/** A real mouse click at the centre of the first element matching `selector`. */ +async function clickAt(client, selector) { + const rect = await evaluate( + client, + `(() => { const r = document.querySelector(${JSON.stringify(selector)})?.getBoundingClientRect(); return r ? { x: r.left + r.width / 2, y: r.top + r.height / 2 } : null })()` + ) + if (!rect) return false + for (const type of ['mousePressed', 'mouseReleased']) { + await client.send('Input.dispatchMouseEvent', { type, x: rect.x, y: rect.y, button: 'left', clickCount: 1 }) + } + await sleep(60) + return true +} + +async function typeText(client, text) { + for (const ch of text) await press(client, ch) +} + +async function screenshot(client, name) { + if (!shotsDir) return + await mkdir(shotsDir, { recursive: true }) + const { data } = await client.send('Page.captureScreenshot', { format: 'png' }) + const file = join(shotsDir, `${name}.png`) + await writeFile(file, Buffer.from(data, 'base64')) + console.log(` screenshot ${file}`) +} + +async function dismissWhatsNew(client) { + if (!(await until(client, `!!document.querySelector('[data-whats-new]')`, 4000))) return + await evaluate(client, `document.querySelector('[data-whats-new-close]')?.click()`) + await until(client, `!document.querySelector('[data-whats-new]')`, 2000) +} + +/** What the Tags view lists, row by row, and where the cursor is. */ +function tagRows(client) { + return evaluate( + client, + `(() => [...document.querySelectorAll('[data-tag-view-index]')].map((el) => ({ + index: Number(el.getAttribute('data-tag-view-index')), + note: el.getAttribute('data-tag-row'), + block: el.getAttribute('data-tag-block-row'), + text: (el.textContent || '').trim(), + cursor: /(^|\\s)vim-cursor(\\s|$)/.test(el.className) + })))()` + ) +} + +function cursorRow(rows) { + return rows.find((r) => r.cursor) ?? null +} + +function devInstanceRunning() { + try { + // Anchored on the binary path, so a shell whose command line merely + // mentions the pattern (a wrapper script, a watcher) never matches. + const out = execFileSync('pgrep', ['-fl', '^[^ ]*Electron[.]app/Contents/MacOS/Electron --remote-debugging-port'], { + encoding: 'utf8' + }) + return out + .split('\n') + .filter((l) => l.trim() && !/zsh -c|pgrep/.test(l)) + .join('\n') + } catch { + return '' + } +} + +async function launch(label, vim, body) { + const live = devInstanceRunning() + if (live) throw new Error(`another dev ZenNotes is running; not starting a second one:\n${live}`) + const tempRoot = await mkdtemp(join(tmpdir(), 'zennotes-tag-blocks-')) + const vaultRoot = join(tempRoot, 'vault') + const userDataRoot = join(tempRoot, 'user-data') + const configRoot = join(tempRoot, 'config') + await seedVault(vaultRoot) + await seedUserData(userDataRoot, configRoot, vaultRoot, vim) + const port = await getFreePort() + const child = spawn(electronPath, [`--remote-debugging-port=${port}`, desktopOutMain], { + cwd: repoRoot, + env: { + ...process.env, + ELECTRON_DISABLE_SECURITY_WARNINGS: '1', + ZENNOTES_USER_DATA_PATH: userDataRoot, + ZENNOTES_CONFIG_DIR: configRoot + }, + stdio: ['ignore', 'pipe', 'pipe'] + }) + const exited = new Promise((res) => child.once('exit', res)) + const killChild = () => { + if (child.exitCode == null) child.kill('SIGKILL') + } + process.once('exit', killChild) + let log = '' + child.stdout.on('data', (c) => (log += c)) + child.stderr.on('data', (c) => (log += c)) + const errors = [] + let client + try { + client = await connectPage(port) + client.on('Runtime.consoleAPICalled', (e) => { + if (e.type === 'error') errors.push(e.args?.map((a) => a.value ?? a.description ?? '').join(' ')) + }) + client.on('Runtime.exceptionThrown', (e) => errors.push(e.exceptionDetails?.exception?.description ?? 'exception')) + await Promise.all([client.send('Page.enable'), client.send('Runtime.enable')]) + console.log(`\n${label}\n`) + const ready = await until(client, `!!document.querySelector('[data-sidebar-tag]')`, 35000, 200) + if (!ready) throw new Error(`notes never rendered; log tail: ${log.slice(-400)}`) + await dismissWhatsNew(client) + await sleep(300) + await body(client, errors, { configRoot }) + } finally { + client?.close() + if (child.exitCode == null) child.kill('SIGTERM') + const timer = setTimeout(killChild, 5000) + await exited + clearTimeout(timer) + process.removeListener('exit', killChild) + await rm(tempRoot, { recursive: true, force: true }) + } +} + +const failures = [] +function check(name, ok, detail) { + if (ok) console.log(` PASS ${name}`) + else { + failures.push(name) + console.error(` FAIL ${name}${detail ? `: ${detail}` : ''}`) + } +} + +async function openTagFromSidebar(client, tag) { + return evaluate( + client, + `(() => { + const row = document.querySelector('[data-sidebar-tag="${tag}"]'); + if (!row) return false; + const chip = row.tagName === 'BUTTON' ? row : row.querySelector('button[title="#${tag}"]'); + chip?.click(); + return !!chip; + })()` + ) +} + +async function vimOnScenario(client, errors) { + const clicked = await openTagFromSidebar(client, 'idea') + check('a sidebar tag chip for #idea exists and opens the Tags view', !!clicked) + const listed = await until( + client, + `document.querySelectorAll('[data-tag-block-row]').length >= 5 && !/Finding tagged blocks/.test(document.body.textContent)`, + 6000 + ) + const rows = await tagRows(client) + check('the Tags view lists block rows under the notes', !!listed, JSON.stringify(rows)) + + const shape = rows.map((r) => r.note ?? ` ${r.block}`) + check( + 'blocks sit under their notes; code ignored; frontmatter-only note is a plain row', + JSON.stringify(shape) === + JSON.stringify([ + 'inbox/Ideas.md', + ' inbox/Ideas.md:6', + ' inbox/Ideas.md:8', + ' inbox/Ideas.md:10', + ' inbox/Ideas.md:16', + 'inbox/Journal.md', + ' inbox/Journal.md:5', + 'inbox/Project.md' + ]), + JSON.stringify(shape) + ) + const header = await evaluate(client, `document.querySelector('h1')?.parentElement?.textContent ?? ''`) + check('the header counts notes and blocks', /3 notes · 5 blocks/.test(header), header) + const sectionText = rows.find((r) => r.block === 'inbox/Ideas.md:10')?.text ?? '' + check( + 'a tagged heading lists its section', + /Dark mode schedule #idea/.test(sectionText) && /Switch themes at sunset/.test(sectionText), + sectionText + ) + const listText = rows.find((r) => r.block === 'inbox/Ideas.md:6')?.text ?? '' + check('a tagged list item lists its child item', /start with ten recipes/.test(listText), listText) + await screenshot(client, '01-tags-view-blocks') + + // Keyboard: the cursor starts on the first note row. + check('the cursor starts on the first note row', cursorRow(await tagRows(client))?.note === 'inbox/Ideas.md') + await press(client, 'j') + check('j moves onto the first block row', cursorRow(await tagRows(client))?.block === 'inbox/Ideas.md:6') + await press(client, '}') + check('} hops past the blocks to the next note', cursorRow(await tagRows(client))?.note === 'inbox/Journal.md') + await press(client, '{') + check('{ hops back to the previous note', cursorRow(await tagRows(client))?.note === 'inbox/Ideas.md') + await press(client, 'j') + await press(client, 'j') + await press(client, 'j') + check('j walks the blocks in order', cursorRow(await tagRows(client))?.block === 'inbox/Ideas.md:10') + await screenshot(client, '02-cursor-on-section-block') + + // Enter opens the note at the block's line, highlighted. + await press(client, 'Enter') + const landed = await until( + client, + `(() => { + const line = document.querySelector('.cm-editor .cm-activeLine'); + const hl = document.querySelector('.cm-editor .cm-line.cm-task-jump-highlight'); + return line && /Dark mode schedule/.test(line.textContent) ? { active: line.textContent, highlighted: hl?.textContent ?? null } : null; + })()`, + 4000 + ) + check('Enter opens the note with the caret on the block line', !!landed, JSON.stringify(landed)) + check('the jumped-to line is highlighted', !!landed?.highlighted && /Dark mode schedule/.test(landed.highlighted), JSON.stringify(landed)) + await screenshot(client, '03-jumped-to-section') + + // The jump is recorded: Ctrl+O from the note comes back to the Tags view. + await pressCtrl(client, 'o') + const back = await until(client, `!!document.querySelector('[data-tag-view-index]')`, 3000) + check('Ctrl+O from the note comes back to the Tags view', !!back) + await clickAt(client, '[data-tab-path="inbox/Ideas.md"]') + await until(client, `!!document.querySelector('.cm-editor .cm-content')`, 3000) + await evaluate(client, `document.querySelector('.cm-editor .cm-content')?.focus(), true`) + + // A block typed into the open note lists before it is saved. + await press(client, 'G') + await press(client, 'o') + await typeText(client, '- Fresh idea typed just now #idea') + await press(client, 'Escape') + await clickAt(client, '[data-tab-path="zen://tags"]') + const fresh = await until( + client, + `[...document.querySelectorAll('[data-tag-block-row]')].some((el) => /Fresh idea typed just now/.test(el.textContent))`, + 4000 + ) + check('a block typed into the open note lists right away', !!fresh, JSON.stringify(await tagRows(client))) + + // The filter narrows to blocks whose text matches. + await press(client, '/') + await typeText(client, 'plugin') + const filtered = await until( + client, + `(() => { const rows = [...document.querySelectorAll('[data-tag-view-index]')]; return rows.length === 2 && rows[1].getAttribute('data-tag-block-row') === 'inbox/Ideas.md:8' ? rows.length : null })()`, + 3000 + ) + check('the filter narrows to the matching block under its note', !!filtered, JSON.stringify(await tagRows(client))) + await screenshot(client, '04-filtered-to-block') + await press(client, 'Escape') + await press(client, 'Escape') + + // Bulk fill timing: a tag carried by BULK_NOTES notes, none open. + if (BULK_NOTES > 0) { + await press(client, ':') + await typeText(client, 'tag bulk') + const t0 = Date.now() + await press(client, 'Enter') + const filled = await until( + client, + `document.querySelectorAll('[data-tag-block-row]').length === ${BULK_NOTES} && !/Finding tagged blocks/.test(document.body.textContent)`, + 30000, + 20 + ) + const ms = Date.now() - t0 + check(`a tag on ${BULK_NOTES} notes fills in all ${BULK_NOTES} blocks`, !!filled, `after ${ms} ms`) + console.log(` ${BULK_NOTES}-note tag: blocks listed ${ms} ms after Enter`) + const longTask = await evaluate( + client, + `(() => { const t0 = performance.now(); document.querySelector('[data-tag-view-index]')?.getBoundingClientRect(); return Math.round(performance.now() - t0) })()` + ) + console.log(` layout read after fill: ${longTask} ms`) + await screenshot(client, '05-bulk-tag') + } + + check('no console errors with Vim on', errors.length === 0, errors.slice(0, 3).join(' | ')) +} + +async function vimOffScenario(client, errors) { + await openTagFromSidebar(client, 'idea') + await until(client, `document.querySelectorAll('[data-tag-block-row]').length >= 5`, 6000) + check('Vim off: the cursor starts on the first note row', cursorRow(await tagRows(client))?.note === 'inbox/Ideas.md') + await press(client, '}') + await press(client, 'j') + check('Vim off: } and j do nothing', cursorRow(await tagRows(client))?.note === 'inbox/Ideas.md') + await press(client, 'ArrowDown') + await press(client, 'ArrowDown') + check('Vim off: ArrowDown walks the block rows', cursorRow(await tagRows(client))?.block === 'inbox/Ideas.md:8') + const hint = await evaluate( + client, + `[...document.querySelectorAll('div')].map((d) => d.textContent ?? '').filter((t) => /^\\S+ move · Enter open/.test(t)).pop() ?? ''` + ) + check('Vim off: the footer hint names no single-key shortcut', /↑\/↓ move · Enter open note or block/.test(hint) && !/[{}]/.test(hint), hint) + await screenshot(client, '06-vim-off') + await press(client, 'Enter') + const landed = await until( + client, + `(() => { const line = document.querySelector('.cm-editor .cm-activeLine'); return line && /Plugin store/.test(line.textContent) ? line.textContent : null })()`, + 4000 + ) + check('Vim off: Enter opens the block line', !!landed, String(landed)) + check('no console errors with Vim off', errors.length === 0, errors.slice(0, 3).join(' | ')) +} + +/** The Search notes rows, as text: a note's title, an indented block, "+N more". */ +function paletteRows(client) { + return evaluate( + client, + `(() => [...document.querySelectorAll('[data-search-idx]')].map((el) => ({ + label: el.dataset.searchBlock ? ' ' + el.dataset.searchBlock + : el.dataset.searchMore ? ' ' + (el.textContent || '').replace('open in Tags', '').trim() + : el.dataset.searchCreate !== undefined ? 'create' + : (el.querySelector('span')?.textContent || '').trim(), + active: el.className.split(/\\s+/).includes('bg-paper-200') + })))()` + ) +} + +async function openPalette(client, text) { + await pressMod(client, 'p', 'KeyP', 80) + const open = await until(client, `!!document.querySelector('input[placeholder^="Search notes"]')`, 3000) + if (!open) return false + await evaluate(client, `document.querySelector('input[placeholder^="Search notes"]').focus(), true`) + await typeText(client, text) + return true +} + +/** Clear the palette's query with real Backspaces, then type `text`. */ +async function retypePalette(client, text) { + const len = await evaluate(client, `document.querySelector('input[placeholder^="Search notes"]')?.value.length ?? 0`) + for (let i = 0; i < len; i++) await press(client, 'Backspace') + await typeText(client, text) +} + +async function moveToPaletteRow(client, label, nextKey) { + for (let i = 0; i < 20; i++) { + const rows = await paletteRows(client) + if (rows.find((r) => r.active)?.label === label) return true + await nextKey() + } + return false +} + +async function paletteScenario(client, errors) { + const opened = await openPalette(client, '#idea') + check('Mod+P opens Search notes', opened) + await until(client, `document.querySelectorAll('[data-search-block]').length >= 3`, 4000) + let rows = (await paletteRows(client)).map((r) => r.label) + const at = rows.indexOf('Ideas') + check( + 'a #tag query lists two blocks under the note, then "+N more"', + JSON.stringify(rows.slice(at, at + 4)) === + JSON.stringify(['Ideas', ' inbox/Ideas.md:6', ' inbox/Ideas.md:8', ' +3 more tagged blocks']), + JSON.stringify(rows) + ) + const j = rows.indexOf('Journal') + check('every tagged note lists its own blocks', rows[j + 1] === ' inbox/Journal.md:5', JSON.stringify(rows)) + const pr = rows.indexOf('Project') + check( + 'a note tagged only in frontmatter is a plain row in the palette', + pr >= 0 && !(rows[pr + 1] ?? '').startsWith(' '), + JSON.stringify(rows) + ) + await screenshot(client, '07-palette-tag-blocks') + + const reached = await moveToPaletteRow(client, ' inbox/Ideas.md:6', () => pressCtrl(client, 'j')) + check('Ctrl+J walks onto a block row', reached, JSON.stringify(await paletteRows(client))) + await press(client, 'Enter') + const landed = await until( + client, + `(() => { + if (document.querySelector('input[placeholder^="Search notes"]')) return null; + const line = document.querySelector('.cm-editor .cm-activeLine'); + const hl = document.querySelector('.cm-editor .cm-line.cm-task-jump-highlight'); + return line && /Recipe gallery/.test(line.textContent) && hl && /Recipe gallery/.test(hl.textContent) ? line.textContent : null; + })()`, + 4000 + ) + check('Enter on a palette block opens the note at that line, highlighted', !!landed, String(landed)) + + await openPalette(client, '#idea zine') + await until(client, `document.querySelectorAll('[data-search-block]').length === 2`, 4000) + rows = (await paletteRows(client)).map((r) => r.label) + check( + 'free text narrows the blocks, across notes', + rows.filter((r) => r.startsWith(' ')).sort().join('|') === ' inbox/Ideas.md:16| inbox/Journal.md:5', + JSON.stringify(rows) + ) + const marks = await evaluate(client, `[...document.querySelectorAll('[data-block-match]')].map((m) => m.textContent.toLowerCase())`) + check('the typed text is marked inside the blocks', marks.length >= 2 && marks.every((m) => m === 'zine'), JSON.stringify(marks)) + await screenshot(client, '08-palette-narrowed') + + await retypePalette(client, '#idea the') + await until(client, `!!document.querySelector('[data-search-more]')`, 4000) + rows = (await paletteRows(client)).map((r) => r.label) + const more = rows.find((r) => r.startsWith(' +')) + check('"+N more" counts the narrowed blocks', more === ' +1 more tagged block', JSON.stringify(rows)) + await moveToPaletteRow(client, more, () => press(client, 'ArrowDown')) + await press(client, 'Enter') + const tags = await until( + client, + `(() => { + const filter = document.querySelector('input[placeholder^="Filter"]'); + const rows = document.querySelectorAll('[data-tag-block-row]').length; + return filter && rows > 0 ? { filter: filter.value, rows } : null; + })()`, + 4000 + ) + check('"+N more" opens the Tags view with the text still filtering', tags?.filter === 'the' && tags.rows === 3, JSON.stringify(tags)) + await screenshot(client, '09-more-opens-tags') + check('no console errors in the palette', errors.length === 0, errors.slice(0, 3).join(' | ')) +} + +async function paletteVimOffScenario(client, errors, { configRoot }) { + await openPalette(client, '#idea') + await until(client, `document.querySelectorAll('[data-search-block]').length >= 3`, 4000) + const reached = await moveToPaletteRow(client, ' inbox/Ideas.md:8', () => press(client, 'ArrowDown')) + check('Vim off: the arrows walk onto a palette block', reached, JSON.stringify(await paletteRows(client))) + await press(client, 'Enter') + const landed = await until( + client, + `(() => { const line = document.querySelector('.cm-editor .cm-activeLine'); return line && /Plugin store/.test(line.textContent) ? line.textContent : null })()`, + 4000 + ) + check('Vim off: Enter on a palette block opens its line', !!landed, String(landed)) + + // Settings → Search → Show tagged blocks in note search, off. + await pressMod(client, ',', 'Comma', 188) + const search = await until(client, `!!document.querySelector('input[placeholder="Search settings…"]')`, 3000) + check('Settings opens', !!search) + await evaluate(client, `document.querySelector('input[placeholder="Search settings…"]').focus(), true`) + await typeText(client, 'tagged blocks') + const sw = '[data-settings-search-id="search-tagged-blocks"] [role="switch"]' + if (!(await until(client, `!!document.querySelector('${sw}')`, 1500))) await press(client, 'Enter') + const found = await until(client, `!!document.querySelector('${sw}')`, 3000) + check('Settings search finds "Show tagged blocks in note search"', !!found) + await evaluate(client, `document.querySelector('${sw}')?.scrollIntoView({ block: 'center' }), true`) + await screenshot(client, '10-setting-on') + await clickAt(client, sw) + const off = await until(client, `document.querySelector('${sw}')?.getAttribute('aria-checked') === 'false'`, 2000) + check('the toggle turns off', !!off) + const toml = await (async () => { + for (let i = 0; i < 30; i++) { + const text = await readFile(join(configRoot, 'config.toml'), 'utf8').catch(() => '') + if (/tagged_blocks\s*=\s*false/.test(text)) return text + await sleep(100) + } + return '' + })() + check('the setting is saved to config.toml as tagged_blocks = false', !!toml) + await press(client, 'Escape') + await until(client, `!document.querySelector('input[placeholder="Search settings…"]')`, 2000) + + await openPalette(client, '#idea') + await sleep(400) + const rows = await paletteRows(client) + check( + 'with the setting off, a #tag query lists notes only', + rows.length > 0 && rows.every((r) => !r.label.startsWith(' ')), + JSON.stringify(rows) + ) + await screenshot(client, '11-setting-off-plain-rows') + await press(client, 'Escape') + check('no console errors in the palette with Vim off', errors.length === 0, errors.slice(0, 3).join(' | ')) +} + +async function main() { + if (!skipBuild || !(await fileExists(desktopOutMain))) { + console.log('Building @zennotes/desktop (set ZEN_TAG_BLOCKS_SKIP_BUILD=1 to reuse the current build)…') + await run(npmCommand, ['run', 'build', '--workspace', '@zennotes/desktop']) + } + await launch('Tag blocks smoke test, Vim on', true, async (client, errors, ctx) => { + await vimOnScenario(client, errors) + console.log('\n Search notes, Vim on\n') + await paletteScenario(client, errors, ctx) + }) + await launch('Tag blocks smoke test, Vim off', false, async (client, errors, ctx) => { + await vimOffScenario(client, errors) + console.log('\n Search notes, Vim off\n') + await paletteVimOffScenario(client, errors, ctx) + }) + console.log('') + if (failures.length === 0) { + console.log('All tag-block checks passed.') + process.exit(0) + } + console.error(`${failures.length} check(s) failed: ${failures.join(', ')}`) + process.exit(1) +} + +process.once('SIGINT', () => process.exit(130)) +process.once('SIGTERM', () => process.exit(143)) +main().catch((err) => { + console.error(err) + process.exit(1) +})