diff --git a/packages/desktop/src/main/app/env.ts b/packages/desktop/src/main/app/env.ts index 2f88613959..aa5d2f0962 100644 --- a/packages/desktop/src/main/app/env.ts +++ b/packages/desktop/src/main/app/env.ts @@ -1,18 +1,8 @@ -import path from 'path' import AppPaths, { ensureAppDirectoriesSync } from './paths' +import { patchEnvPath } from './envPath' let envId = 0 -const patchEnvPath = (): void => { - if (process.platform === 'darwin') { - const currentPath = process.env.PATH ?? '' - process.env.PATH = - currentPath + - (currentPath.endsWith(path.delimiter) ? '' : path.delimiter) + - '/Library/TeX/texbin' - } -} - export interface AppEnvironmentOptions { userDataPath?: string debug?: boolean diff --git a/packages/desktop/src/main/app/envPath.ts b/packages/desktop/src/main/app/envPath.ts new file mode 100644 index 0000000000..69f0299227 --- /dev/null +++ b/packages/desktop/src/main/app/envPath.ts @@ -0,0 +1,21 @@ +import path from 'path' + +// GUI-launched apps on macOS/Linux don't inherit the user's login-shell PATH, +// so Homebrew (/opt/homebrew/bin, /usr/local/bin) and standard bin dirs are +// absent and CLI tools like pandoc can't be found (#2751). These mirror the +// picgo uploader's PATH handling (ipc/uploader.ts). +const EXTRA_PATH_DIRS: Record = { + darwin: ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin', '/Library/TeX/texbin'], + linux: ['/usr/local/bin', '/usr/bin', '/bin'] +} + +export const patchEnvPath = (): void => { + const extras = EXTRA_PATH_DIRS[process.platform] + if (!extras) return + + const current = (process.env.PATH ?? '').split(path.delimiter).filter(Boolean) + for (const dir of extras) { + if (!current.includes(dir)) current.push(dir) + } + process.env.PATH = current.join(path.delimiter) +} diff --git a/packages/desktop/src/main/menu/actions/file.ts b/packages/desktop/src/main/menu/actions/file.ts index 4f2393d689..e91b9b97d5 100644 --- a/packages/desktop/src/main/menu/actions/file.ts +++ b/packages/desktop/src/main/menu/actions/file.ts @@ -106,7 +106,15 @@ const handleResponseForExport = async(e: IpcMainEvent, payload: ExportPayload): if (filePath && !canceled) { try { if (type === 'pdf') { - const options: Electron.PrintToPDFOptions = { printBackground: true } + // Build a clickable bookmark/outline tree from the document's h1-h6 + // headings so exported PDFs have a navigation pane (#2989). The outline + // is derived from the tagged-PDF structure tree, so generateTaggedPDF is + // required — generateDocumentOutline alone produces no outline. + const options: Electron.PrintToPDFOptions = { + printBackground: true, + generateTaggedPDF: true, + generateDocumentOutline: true + } Object.assign(options, getPdfPageOptions(pageOptions)) const data = await win.webContents.printToPDF(options) removePrintServiceFromWindow(win) diff --git a/packages/desktop/src/main/menu/index.ts b/packages/desktop/src/main/menu/index.ts index db818946cd..cd80af460e 100644 --- a/packages/desktop/src/main/menu/index.ts +++ b/packages/desktop/src/main/menu/index.ts @@ -511,6 +511,18 @@ class AppMenu { updateSelectionMenus(this.getWindowMenuById(windowId), changes) }) + // In source-code mode the Paragraph and Format commands act on the hidden + // WYSIWYG engine, so grey them out; on return to WYSIWYG they are re-enabled + // and the next selection change refines them (#3531). + ipcMain.on('mt::set-editor-format-menus-enabled', (_e, windowId: number, enabled: boolean) => { + if (!this.has(windowId)) return + const menu = this.getWindowMenuById(windowId) + for (const id of ['paragraphMenuEntry', 'formatMenuItem']) { + const entry = menu.getMenuItemById(id) + entry?.submenu?.items.forEach((item) => (item.enabled = enabled)) + } + }) + onInternalChannel('menu-add-recently-used', (pathname: string) => { this.addRecentlyUsedDocument(pathname) }) diff --git a/packages/desktop/src/main/menu/templates/edit.ts b/packages/desktop/src/main/menu/templates/edit.ts index 4a461421a6..a0bb30fdeb 100755 --- a/packages/desktop/src/main/menu/templates/edit.ts +++ b/packages/desktop/src/main/menu/templates/edit.ts @@ -159,7 +159,10 @@ export default function(keybindings: Keybindings): MenuItemConstructorOptions { } }, { - type: 'separator' + // Screenshot is macOS-only; hide its trailing separator too so + // Windows/Linux don't show a doubled divider here (#2997). + type: 'separator', + visible: isOsx }, { // TODO: Remove this menu entry and add it to the command palette (#1408). diff --git a/packages/desktop/src/renderer/src/components/editorWithTabs/editor.vue b/packages/desktop/src/renderer/src/components/editorWithTabs/editor.vue index 7a0ad03e49..de80df4eae 100644 --- a/packages/desktop/src/renderer/src/components/editorWithTabs/editor.vue +++ b/packages/desktop/src/renderer/src/components/editorWithTabs/editor.vue @@ -546,6 +546,25 @@ watch(focus, (value) => { } }) +// In source-code mode the Paragraph and Format menus operate on the hidden +// WYSIWYG engine, so grey them out. On return to WYSIWYG, re-apply the menu +// state for the CURRENT cursor context (a code block/table still disables some +// items) rather than blanket-enabling everything (#3531). +watch(sourceCode, (isSource) => { + const windowId = window.marktext?.env?.windowId ?? -1 + if (isSource) { + window.electron.ipcRenderer.send('mt::set-editor-format-menus-enabled', windowId, false) + return + } + nextTick(() => { + if (selectionChange.value) { + pushSelectionMenuState(selectionChange.value as MuyaChange) + } else { + window.electron.ipcRenderer.send('mt::set-editor-format-menus-enabled', windowId, true) + } + }) +}) + watch(fontSize, (value, oldValue) => { if (value !== oldValue && editor.value) { editor.value.setOptions({ fontSize: value }) @@ -1371,6 +1390,12 @@ const pushSelectionMenuState = (changes: MuyaChange) => { } const handleEditParagraph = (type: unknown) => { + // These commands act on the hidden WYSIWYG engine, so block them in + // source-code mode (mirrors handleUndo/handleSelectAll) — otherwise e.g. the + // Insert Table wizard opens and writes to the invisible editor (#3531). + if (sourceCode.value) { + return + } if (type === 'table') { tableChecker.rows = 4 tableChecker.columns = 3 @@ -1391,6 +1416,9 @@ const handleEditParagraph = (type: unknown) => { // handle `duplicate`, `delete`, `create paragraph below` const handleParagraph = (type: unknown) => { + if (sourceCode.value) { + return + } if (editor.value) { switch (type) { case 'duplicate': { @@ -1409,6 +1437,9 @@ const handleParagraph = (type: unknown) => { } const handleInlineFormat = (type: unknown) => { + if (sourceCode.value) { + return + } editor.value && editor.value.format(type) } diff --git a/packages/desktop/src/renderer/src/components/search/index.vue b/packages/desktop/src/renderer/src/components/search/index.vue index 6ae87b26cc..a9f5d5624c 100644 --- a/packages/desktop/src/renderer/src/components/search/index.vue +++ b/packages/desktop/src/renderer/src/components/search/index.vue @@ -249,6 +249,9 @@ const listenFind = () => { type.value = 'search' nextTick(() => { search.value?.focus() + // Select the existing term so re-opening Find types over it instead of + // appending to the previous query (#3458). + search.value?.select() if (searchValue.value) { searchFn() } diff --git a/packages/desktop/src/renderer/src/components/sideBar/treeFolder.vue b/packages/desktop/src/renderer/src/components/sideBar/treeFolder.vue index 04f035fe3d..422d4f1433 100644 --- a/packages/desktop/src/renderer/src/components/sideBar/treeFolder.vue +++ b/packages/desktop/src/renderer/src/components/sideBar/treeFolder.vue @@ -91,13 +91,17 @@ const { activeItem } = storeToRefs(projectStore) const { clipboard } = storeToRefs(projectStore) const handleInputFocus = (): void => { + // Only the folder that is the create target reacts. Expand it FIRST so the + // create input renders even when the folder was collapsed, then focus it on + // the next tick — previously the expand sat behind `if (input.value)`, which + // is null while collapsed, so New File on a collapsed folder did nothing + // (#3439). + if (createCache.value.dirname !== props.folder.pathname) return + isCollapsed.value = false nextTick(() => { if (input.value) { input.value.focus() createName.value = '' - if (props.folder) { - isCollapsed.value = false - } } }) } diff --git a/packages/desktop/src/renderer/src/prefComponents/common/fontTextBox/bundledFonts.ts b/packages/desktop/src/renderer/src/prefComponents/common/fontTextBox/bundledFonts.ts new file mode 100644 index 0000000000..b10c9229da --- /dev/null +++ b/packages/desktop/src/renderer/src/prefComponents/common/fontTextBox/bundledFonts.ts @@ -0,0 +1,11 @@ +// Fonts MarkText bundles via @font-face (packages/muya/src/assets/styles/index.css). +// They are the editor/code defaults but are NOT installed system fonts, so the +// OS font-list IPC never returns them and the picker couldn't reselect them (#3021). +export const BUNDLED_PROPORTIONAL_FONTS = ['Open Sans'] +export const BUNDLED_MONOSPACE_FONTS = ['DejaVu Sans Mono'] + +export const withBundledFonts = (systemFonts: string[], onlyMonospace = false): string[] => { + const bundled = onlyMonospace ? BUNDLED_MONOSPACE_FONTS : BUNDLED_PROPORTIONAL_FONTS + const missing = bundled.filter(font => !systemFonts.includes(font)) + return [...missing, ...systemFonts] +} diff --git a/packages/desktop/src/renderer/src/prefComponents/common/fontTextBox/index.vue b/packages/desktop/src/renderer/src/prefComponents/common/fontTextBox/index.vue index 3844c2a9a9..9d3ccd3087 100644 --- a/packages/desktop/src/renderer/src/prefComponents/common/fontTextBox/index.vue +++ b/packages/desktop/src/renderer/src/prefComponents/common/fontTextBox/index.vue @@ -43,6 +43,7 @@ import { ArrowDown } from '@element-plus/icons-vue' import LinkIcon from '@/components/icons/LinkIcon.vue' import { useI18n } from 'vue-i18n' import type { PrefControlProps } from '../types' +import { withBundledFonts } from './bundledFonts' const { t } = useI18n() @@ -96,7 +97,10 @@ const handleMoreClick = () => { onMounted(async () => { // font-list is a native module; it runs in the main process and is reached via IPC. const fonts = await window.fonts.list() - fontFamilies.value = (fonts || []).map((f) => f.replace(/"/g, '').trim()) + const systemFonts = (fonts || []).map((f) => f.replace(/"/g, '').trim()) + // System fonts don't include the bundled defaults (Open Sans / DejaVu Sans + // Mono), so surface them in the picker too (#3021). + fontFamilies.value = withBundledFonts(systemFonts, props.onlyMonospace) }) diff --git a/packages/desktop/src/renderer/src/util/exportHtml.ts b/packages/desktop/src/renderer/src/util/exportHtml.ts index 053aefa30b..1c9eab6680 100644 --- a/packages/desktop/src/renderer/src/util/exportHtml.ts +++ b/packages/desktop/src/renderer/src/util/exportHtml.ts @@ -81,26 +81,36 @@ const styledClass = (value: boolean | undefined): string => { return value ? ' styled' : ' simple' } +// Header/footer left/center/right are user-supplied, so sanitize them here. +// The article body is NOT sanitized again (it was already sanitized by the +// engine during render); re-sanitizing it strips diagram +// labels and drops mermaid content from the export (#3359). +const hf = (value: string): string => sanitize(value, EXPORT_DOMPURIFY_CONFIG) as string + const createTableHeader = (header: HeaderFooterPart, headerFooterStyled?: boolean): string => { const { type, left = '', center = '', right = '' } = header - const headerClass = (type === 1 ? 'single' : '') + styledClass(headerFooterStyled) - return ` + const headerClass = `page-header ${(type === 1 ? 'single' : '') + styledClass(headerFooterStyled)}` + .replace(/\s+/g, ' ') + .trim() + return `
-
${left}
-
${center}
-
${right}
+
${hf(left)}
+
${hf(center)}
+
${hf(right)}
` } const createRealFooter = (footer: HeaderFooterPart, headerFooterStyled?: boolean): string => { const { type, left = '', center = '', right = '' } = footer - const footerClass = (type === 1 ? 'single' : '') + styledClass(headerFooterStyled) - return `
+ const footerClass = `page-footer ${(type === 1 ? 'single' : '') + styledClass(headerFooterStyled)}` + .replace(/\s+/g, ' ') + .trim() + return `
-
${left}
-
${center}
-
${right}
+
${hf(left)}
+
${hf(center)}
+
${hf(right)}
` } @@ -216,7 +226,7 @@ export const exportStyledHTML = async( } output += createTableBody(`
${article}
`) output += HF_TABLE_END - bodyHtml = sanitize(output, EXPORT_DOMPURIFY_CONFIG) as string + bodyHtml = output } // Re-emit the engine document shell with the (possibly augmented) body. diff --git a/packages/desktop/src/renderer/src/util/pdf.ts b/packages/desktop/src/renderer/src/util/pdf.ts index 247b4df4fe..6d84cb108c 100644 --- a/packages/desktop/src/renderer/src/util/pdf.ts +++ b/packages/desktop/src/renderer/src/util/pdf.ts @@ -48,6 +48,9 @@ export const getCssForOptions = async(options: PdfCssOptions): Promise = if (isPrintable) { output += `@media print{@page{ margin: ${pageMarginTop}mm ${pageMarginRight}mm ${pageMarginBottom}mm ${pageMarginLeft}mm;}` + // Keep a heading with the content that follows it, so a page never breaks + // immediately after a heading, and never split a multi-line heading (#3039). + output += 'h1,h2,h3,h4,h5,h6{break-after:avoid;break-inside:avoid;}' } // Auto numbering headings via CSS diff --git a/packages/desktop/src/shared/types/ipc.ts b/packages/desktop/src/shared/types/ipc.ts index 6aee9e9519..43fd0d003d 100644 --- a/packages/desktop/src/shared/types/ipc.ts +++ b/packages/desktop/src/shared/types/ipc.ts @@ -132,6 +132,7 @@ export interface IpcSendChannels { 'mt::open-setting-window': [] 'mt::rename': [payload: { id: string; pathname: string; newPathname: string; currentFile?: unknown }] 'mt::request-keybindings': [] + 'mt::set-editor-format-menus-enabled': [windowId: number, enabled: boolean] 'mt::response-export': [ payload: { type: ExportType diff --git a/packages/desktop/test/e2e/find-reopen-select-3458.spec.ts b/packages/desktop/test/e2e/find-reopen-select-3458.spec.ts new file mode 100644 index 0000000000..772e6de2cb --- /dev/null +++ b/packages/desktop/test/e2e/find-reopen-select-3458.spec.ts @@ -0,0 +1,54 @@ +import { expect, test } from '@playwright/test' +import type { ElectronApplication, Page } from 'playwright' +import { launchWithMarkdown, sendIpcToRenderer, focusEditor } from './helpers' + +// #3458 — re-pressing Find (Cmd/Ctrl-F) while the bar is already open just +// re-focused the input without selecting it, so the caret landed after the +// existing term and the next keystroke appended ("accretion"). Re-opening +// should highlight the current term so it can be typed over. + +const FIND_INPUT = '.search-bar .search input' + +test.describe('Find bar reopen selects the existing term (#3458)', () => { + let app: ElectronApplication + let page: Page + + test.beforeAll(async() => { + const launched = await launchWithMarkdown('apple banana apple cherry\n') + app = launched.app + page = launched.page + await focusEditor(page) + }) + + test.afterAll(async() => { + if (app) await app.close() + }) + + test('re-opening Find highlights the existing query so it can be typed over', async() => { + await sendIpcToRenderer(app, 'mt::editor-edit-action', 'find') + await expect(page.locator('.search-bar')).toBeVisible({ timeout: 5000 }) + await page.locator(FIND_INPUT).fill('apple') + // Let the search settle (active match selected) before re-opening. + await expect.poll(() => page.locator('.search-bar .search-result').innerText()) + .toContain('/ 2') + + // Re-trigger Find while the bar is already open with a term present. + await sendIpcToRenderer(app, 'mt::editor-edit-action', 'find') + + // The whole term must be selected (so a keystroke replaces it), not left + // with a collapsed caret at the end. + await expect + .poll(() => + page.evaluate((sel) => { + const el = document.querySelector(sel) as HTMLInputElement | null + if (!el) return null + return { start: el.selectionStart, end: el.selectionEnd, len: el.value.length } + }, FIND_INPUT) + ) + .toEqual({ start: 0, end: 5, len: 5 }) + + // Typing over the selection replaces the term rather than appending to it. + await page.keyboard.type('cherry') + await expect.poll(() => page.locator(FIND_INPUT).inputValue()).toBe('cherry') + }) +}) diff --git a/packages/desktop/test/e2e/new-file-collapsed-folder-3439.spec.ts b/packages/desktop/test/e2e/new-file-collapsed-folder-3439.spec.ts new file mode 100644 index 0000000000..5414768977 --- /dev/null +++ b/packages/desktop/test/e2e/new-file-collapsed-folder-3439.spec.ts @@ -0,0 +1,90 @@ +import { expect, test } from '@playwright/test' +import type { ElectronApplication, Page } from 'playwright' +import { launchElectron } from './helpers' + +// #3439 — invoking "New File" (sidebar context menu) on a COLLAPSED folder did +// nothing: the create only renders inside the folder's expanded +// contents, and handleInputFocus guarded the expand behind `if (input.value)`, +// which is null while collapsed — so the folder never expanded and no input +// appeared. + +// A collapsed sidebar folder's create-input is visible once the folder expands. +const visibleNewInput = (page: Page): Promise => + page.evaluate( + () => + Array.from( + document.querySelectorAll('.side-bar-folder .folder-contents input.new-input') + ).filter((el) => (el as HTMLElement).offsetParent !== null).length + ) + +test.describe('New File on a collapsed folder (#3439)', () => { + let app: ElectronApplication + let page: Page + + test.beforeAll(async() => { + // launchElectron opens the desktop package folder in the sidebar (its + // sub-folders render as collapsed tree-folders). + const launched = await launchElectron() + app = launched.app + page = launched.page + await page.waitForSelector('.side-bar-folder .folder-name', { timeout: 10000 }) + + // Replace the sidebar context-menu popup handler so it does NOT open a real + // native menu (which would hang the headless run); instead resolve the + // template to the "New File" item and dispatch its click straight back to + // the renderer, driving the real context-menu → bus → store → tree-folder + // path. + await app.evaluate(({ ipcMain }) => { + const findId = (items: Array<{ id?: string, submenu?: unknown }>): string | null => { + for (const it of items || []) { + if (it?.id && String(it.id).startsWith('newFileMenuItem')) return it.id + if (it?.submenu) { + const r = findId(it.submenu as Array<{ id?: string }>) + if (r) return r + } + } + return null + } + ipcMain.removeAllListeners('mt::menu::popup') + ipcMain.on('mt::menu::popup', (event, template) => { + const id = findId(template as Array<{ id?: string }>) + if (id) { + setTimeout(() => { + try { + event.sender.send('mt::menu::click', { id }) + } catch { /* window gone */ } + }, 30) + } + }) + }) + }) + + test.afterAll(async() => { + if (app) await app.close() + }) + + test('the create input appears when New File targets a collapsed folder', async() => { + // No tree-folder create input is rendered initially. + expect(await visibleNewInput(page)).toBe(0) + + // Right-click the first (collapsed) sub-folder → sets it active + pops the + // context menu, which the main-side hook resolves to "New File". + await page.evaluate(() => { + const fn = document.querySelector('.side-bar-folder .folder-name') as HTMLElement | null + if (!fn) throw new Error('no sub-folder in sidebar') + const r = fn.getBoundingClientRect() + fn.dispatchEvent( + new MouseEvent('contextmenu', { + bubbles: true, + clientX: r.left + 5, + clientY: r.top + 5 + }) + ) + }) + + // The targeted folder must expand and reveal its create input. + await expect.poll(() => visibleNewInput(page), { timeout: 6000 }).toBeGreaterThanOrEqual(1) + + await page.keyboard.press('Escape') + }) +}) diff --git a/packages/desktop/test/e2e/source-mode-menu-disabled-3531.spec.ts b/packages/desktop/test/e2e/source-mode-menu-disabled-3531.spec.ts new file mode 100644 index 0000000000..7d536e8370 --- /dev/null +++ b/packages/desktop/test/e2e/source-mode-menu-disabled-3531.spec.ts @@ -0,0 +1,84 @@ +import { expect, test } from '@playwright/test' +import type { ElectronApplication, Page } from 'playwright' +import { launchWithMarkdown, focusEditor, enterSourceMode, exitSourceMode } from './helpers' + +// #3531 — Paragraph and Format menu commands act on the hidden WYSIWYG engine, +// so they must be greyed out in source-code mode and re-enabled on return. + +const readEnabled = (app: ElectronApplication) => + app.evaluate(({ Menu }) => { + const m = Menu.getApplicationMenu() + const get = (id: string) => { + const i = m?.getMenuItemById(id) + return i ? i.enabled : null + } + return { + table: get('tableMenuItem'), + heading1: get('heading1MenuItem'), + strong: get('strongMenuItem'), + emphasis: get('emphasisMenuItem') + } + }) + +test.describe('paragraph/format menus disabled in source mode (#3531)', () => { + let app: ElectronApplication + let page: Page + + test.beforeAll(async() => { + const launched = await launchWithMarkdown('# Doc\n\nhello world\n', { suppressErrorDialog: true }) + app = launched.app + page = launched.page + await focusEditor(page) + }) + + test.afterAll(async() => { + if (app) await app.close() + }) + + test('menus are enabled in WYSIWYG, disabled in source mode, restored on exit', async() => { + await expect.poll(() => readEnabled(app)).toEqual({ + table: true, heading1: true, strong: true, emphasis: true + }) + + await enterSourceMode(page, app) + await expect.poll(() => readEnabled(app)).toEqual({ + table: false, heading1: false, strong: false, emphasis: false + }) + + await exitSourceMode(page, app) + await expect.poll(() => readEnabled(app)).toEqual({ + table: true, heading1: true, strong: true, emphasis: true + }) + }) +}) + +test.describe('menus reflect cursor context after exiting source mode (#3531)', () => { + let app: ElectronApplication + let page: Page + + test.beforeAll(async() => { + const launched = await launchWithMarkdown('```js\nconst x = 1\n```\n\n# Heading\n', { + suppressErrorDialog: true + }) + app = launched.app + page = launched.page + await focusEditor(page) + }) + + test.afterAll(async() => { + if (app) await app.close() + }) + + test('a cursor in a code block keeps Format items disabled after a source-mode round-trip', async() => { + // Put the caret inside the fenced code block; its context disables the Format menu. + await page.locator('.editor-component pre.mu-code-block .mu-codeblock-content').first().click() + await expect.poll(() => readEnabled(app).then((s) => s.strong)).toBe(false) + + await enterSourceMode(page, app) + await expect.poll(() => readEnabled(app).then((s) => s.strong)).toBe(false) + + await exitSourceMode(page, app) + // The fix: the menu is re-applied for the code-block cursor, NOT blanket-enabled. + await expect.poll(() => readEnabled(app).then((s) => s.strong)).toBe(false) + }) +}) diff --git a/packages/desktop/test/e2e/source-mode-table-wizard-3531.spec.ts b/packages/desktop/test/e2e/source-mode-table-wizard-3531.spec.ts new file mode 100644 index 0000000000..30414eca7d --- /dev/null +++ b/packages/desktop/test/e2e/source-mode-table-wizard-3531.spec.ts @@ -0,0 +1,52 @@ +import { expect, test } from '@playwright/test' +import type { ElectronApplication, Page } from 'playwright' +import { + launchWithMarkdown, + focusEditor, + enterSourceMode, + exitSourceMode, + sendIpcToRenderer +} from './helpers' + +// #3531 — the paragraph edit commands (e.g. the "Insert Table" wizard) still +// fired in source-code mode, where they operate on the hidden WYSIWYG engine +// instead of the visible CodeMirror source. Like undo/redo/selectAll, these +// must be blocked while in source mode. + +const TABLE_DIALOG = '.ag-insert-table-dialog' + +test.describe('paragraph edit commands are suppressed in source mode (#3531)', () => { + let app: ElectronApplication + let page: Page + + test.beforeAll(async() => { + const launched = await launchWithMarkdown('# Doc\n\nsome text\n', { + suppressErrorDialog: true + }) + app = launched.app + page = launched.page + await focusEditor(page) + }) + + test.afterAll(async() => { + if (app) await app.close() + }) + + test('the Insert Table wizard does not open while in source-code mode', async() => { + await enterSourceMode(page, app) + + // Fire the "insert table" paragraph action (menu / shortcut path). + await sendIpcToRenderer(app, 'mt::editor-paragraph-action', { type: 'table' }) + await page.waitForTimeout(400) + + // The table wizard dialog must NOT appear in source mode. + await expect(page.locator(TABLE_DIALOG)).toHaveCount(0) + + await exitSourceMode(page, app) + + // Sanity: in WYSIWYG mode the same action DOES open the wizard. + await focusEditor(page) + await sendIpcToRenderer(app, 'mt::editor-paragraph-action', { type: 'table' }) + await expect(page.locator(TABLE_DIALOG)).toBeVisible({ timeout: 5000 }) + }) +}) diff --git a/packages/desktop/test/unit/specs/bundled-fonts.spec.ts b/packages/desktop/test/unit/specs/bundled-fonts.spec.ts new file mode 100644 index 0000000000..5b46d59163 --- /dev/null +++ b/packages/desktop/test/unit/specs/bundled-fonts.spec.ts @@ -0,0 +1,29 @@ +import { describe, expect, it } from 'vitest' +import { + BUNDLED_MONOSPACE_FONTS, + BUNDLED_PROPORTIONAL_FONTS, + withBundledFonts +} from '@/prefComponents/common/fontTextBox/bundledFonts' + +describe('withBundledFonts (#3021)', () => { + it('prepends the bundled proportional font when the system list lacks it', () => { + const result = withBundledFonts(['Arial', 'Times New Roman'], false) + expect(result).toContain('Open Sans') + expect(result.indexOf('Open Sans')).toBeLessThan(result.indexOf('Arial')) + }) + + it('prepends the bundled monospace font for the code-font picker', () => { + const result = withBundledFonts(['Menlo', 'Consolas'], true) + expect(result).toContain('DejaVu Sans Mono') + }) + + it('does not duplicate a bundled font already installed on the system', () => { + const result = withBundledFonts(['Open Sans', 'Arial'], false) + expect(result.filter(f => f === 'Open Sans')).toHaveLength(1) + }) + + it('exposes the bundled names so they stay in sync with @font-face', () => { + expect(BUNDLED_PROPORTIONAL_FONTS).toContain('Open Sans') + expect(BUNDLED_MONOSPACE_FONTS).toContain('DejaVu Sans Mono') + }) +}) diff --git a/packages/desktop/test/unit/specs/edit-menu-separator.spec.ts b/packages/desktop/test/unit/specs/edit-menu-separator.spec.ts new file mode 100644 index 0000000000..fbf7b8b17a --- /dev/null +++ b/packages/desktop/test/unit/specs/edit-menu-separator.spec.ts @@ -0,0 +1,46 @@ +import { describe, expect, it, vi } from 'vitest' + +// The Edit menu's screenshot entry is macOS-only (`visible: isOsx`). On +// Windows/Linux it was hidden but its surrounding separators stayed, leaving +// two adjacent separators (a doubled divider) between "Find in Folder" and +// "Line Ending" (#2997). Build the template per-platform and assert no two +// visible separators are adjacent. + +vi.mock('electron', () => ({})) +vi.mock('main_renderer/menu/actions/edit', () => ({})) +vi.mock('main_renderer/i18n', () => ({ t: (key: string) => key })) +vi.mock('main_renderer/commands', () => ({ + COMMANDS: new Proxy({}, { get: () => 'cmd' }) +})) + +const keybindings = { getAccelerator: () => undefined } as never + +interface Item { type?: string, visible?: boolean, id?: string } + +async function buildEditSubmenu(isOsx: boolean): Promise { + vi.resetModules() + vi.doMock('main_renderer/config', () => ({ isOsx })) + const mod = await import('main_renderer/menu/templates/edit') + return (mod.default(keybindings).submenu as Item[]) +} + +const hasAdjacentVisibleSeparators = (items: Item[]): boolean => { + const visible = items.filter(i => i.visible !== false) + return visible.some((item, i) => + item.type === 'separator' && visible[i + 1]?.type === 'separator' + ) +} + +describe('Edit menu separators (#2997)', () => { + it('has no doubled separator on Windows/Linux', async() => { + const submenu = await buildEditSubmenu(false) + expect(submenu.find(i => i.id === 'screenshot')?.visible).toBe(false) + expect(hasAdjacentVisibleSeparators(submenu)).toBe(false) + }) + + it('keeps the screenshot entry and its separators on macOS', async() => { + const submenu = await buildEditSubmenu(true) + expect(submenu.find(i => i.id === 'screenshot')?.visible).toBe(true) + expect(hasAdjacentVisibleSeparators(submenu)).toBe(false) + }) +}) diff --git a/packages/desktop/test/unit/specs/export-header-footer-diagram.spec.ts b/packages/desktop/test/unit/specs/export-header-footer-diagram.spec.ts new file mode 100644 index 0000000000..c303b3e1ca --- /dev/null +++ b/packages/desktop/test/unit/specs/export-header-footer-diagram.spec.ts @@ -0,0 +1,49 @@ +import { describe, expect, it, vi } from 'vitest' + +// #3359 — exporting with Header & Footer enabled dropped diagram (mermaid) +// content. The header/footer branch re-sanitized the WHOLE already-rendered +// article with the export DOMPurify config, which strips the +// that mermaid renders its node labels into; the no-header/footer branch never +// re-sanitized, so the same document exported fine without header/footer. + +const FULL_DOC = + '' + + '
' + + '
' + + '
' + + '

DiagramLabel

' + + '
' + + '
' + +vi.mock('@muyajs/core', () => ({ + MarkdownToHtml: class { + async generate(): Promise { + return FULL_DOC + } + } +})) + +vi.mock('@/util/resolveImageSrc', () => ({ resolveLocalImageSrc: (s: string) => s })) +vi.mock('@/util/resolveLinkHref', () => ({ resolveLocalLinkHref: (s: string) => s })) + +const { exportStyledHTML } = await import('@/util/exportHtml') + +const fakeMuya = {} as never + +describe('export with Header & Footer preserves diagram content (#3359)', () => { + it('keeps the mermaid foreignObject label when a header is present', async() => { + const html = await exportStyledHTML(fakeMuya, '```mermaid\ngraph LR\n```', { + header: { type: 0, left: '', center: 'My Title', right: '' } + }) + expect(html).toContain('DiagramLabel') + expect(html).toContain('My Title') + }) + + it('still strips unsafe markup from the user-supplied header text', async() => { + const html = await exportStyledHTML(fakeMuya, 'x', { + header: { type: 0, left: '', center: 'Safe', right: '' } + }) + expect(html).toContain('Safe') + expect(html).not.toContain('