\u2764BR\u2764';
+ });
// tinyMCE appends a trailing
to every non-empty block. Strip before conversion
// so it doesn't become a spurious newline. Do NOT strip from
(blank lines).
html=html.replace(/((?:[^<]|<(?!\/p>))+?)\s*<\/p>/gi,'$1
');
+ html=_protectInlineLeadingSpace(html);
// Convert
(line breaks within paragraphs and blank-line divs) to a
// sentinel Turndown won't touch. Restore as \n after conversion.
// For md-blank-line divs the blankLine rule matches the sentinel text.
@@ -3950,8 +4036,23 @@ function tinymceToMarkdown(html){
md=_applyHeadingSpacing(md);
// Normalise blank-line sentinels (md-blank-line divs + empty paragraphs)
md=md.replace(/\n*(?:\x00BL\x00\n*)+/g,function(m){var count=(m.match(/\x00BL\x00/g)||[]).length;return nl+nl+Array(count+1).join(nl)});
- // Restore line-break sentinels as \n (soft breaks within paragraphs)
- md=md.split('\u2764BR\u2764').join(nl);
+ // Restore line-break sentinels as \n (soft breaks within paragraphs).
+ // Inside a blockquote the sentinel must also re-apply the quote prefix:
+ // Turndown prefixes the lines it emits, but these newlines are injected
+ // afterwards, so '> b
c' would come back as '> b\nc' — the second line
+ // escaping the blockquote entirely (real content corruption, and a permanent
+ // dirty-on-open diff). Carry the leading '>' run of the line across the break.
+ md=md.split(nl).map(function(lineText){
+ if(lineText.indexOf('\u2764BR\u2764')<0)return lineText;
+ var qm=lineText.match(/^((?:[ \t]*>)+[ \t]?)/);
+ return lineText.split('\u2764BR\u2764').join(nl+(qm?qm[1]:''));
+ }).join(nl);
+ md=_restoreProtectedSpace(md);
+ // Turndown prefixes every line of a blockquote with '> ', including the empty
+ // lines between paragraphs, yielding '> ' where the source had a bare '>'.
+ // Trailing whitespace on a quote-only line is insignificant in CommonMark, so
+ // strip it — otherwise the note is reported dirty on every open.
+ md=md.replace(/^([ \t]*>+)[ \t]+$/gm,'$1');
var out='';
for(var i=0;i {
diff --git a/tests/appRuntime.test.js b/tests/appRuntime.test.js
index 1ca5bc6..2b25f83 100644
--- a/tests/appRuntime.test.js
+++ b/tests/appRuntime.test.js
@@ -59,6 +59,14 @@ function runWithDeps(ctx, ...fns) {
fns = [...fns];
fns.splice(fns.indexOf('getTurndown') >= 0 ? fns.indexOf('getTurndown') + 1 : 0, 0, '_applyHeadingSpacing');
}
+ if (fns.includes('tinymceToMarkdown') && !fns.includes('_protectInlineLeadingSpace')) {
+ fns = [...fns];
+ // _protectInlineLeadingSpace needs the shared inline-tag list plus the
+ // encode/restore pair that round-trips the exact whitespace characters.
+ vm.runInContext("var _INLINE_TAGS_RE_SRC='a|abbr|b|bdi|bdo|cite|code|del|em|i|ins|kbd|label|mark|q|s|small|span|strong|sub|sup|time|u|var';", ctx);
+ const at = fns.indexOf('getTurndown') >= 0 ? fns.indexOf('getTurndown') + 1 : 0;
+ fns.splice(at, 0, '_encodeProtectedSpace', '_protectInlineLeadingSpace', '_restoreProtectedSpace');
+ }
for (const fn of fns) vm.runInContext(extractFn(fn), ctx);
}
@@ -143,6 +151,181 @@ test('tinymceToMarkdown returns empty string for empty input', () => {
assert.equal(result.trim(), '');
});
+test('tinymceToMarkdown does not duplicate space after inline image in link', () => {
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const nbsp = '\u00a0'.repeat(12);
+ const imageId = 'a'.repeat(32);
+ const html = '++' + nbsp + '
Label++
';
+ const result = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(html) + ')', ctx);
+ assert.equal(result, '++' + nbsp + '[ Label](https://e.com)++');
+ const whitespace = result.match(/^\+\+([^\[]*)\[/);
+ assert.ok(whitespace, `expected link after opening markers, got: ${JSON.stringify(result)}`);
+ assert.equal(whitespace[1].length, 12);
+});
+
+test('tinymceToMarkdown is idempotent for rendered inline image link', () => {
+ const { renderMarkdown } = require('../app/templates');
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const md = '++' + '\u00a0'.repeat(12) + '[ Hybrid Savings commercials.xlsx](https://example.com/x.xlsx)++';
+ const results = [];
+ let current = md;
+ for (let i = 0; i < 5; i += 1) {
+ const html = renderMarkdown(current);
+ current = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(html) + ')', ctx);
+ results.push(current);
+ }
+ assert.equal(results[0], md);
+ assert.equal(results[4], md);
+ for (const result of results) {
+ const whitespace = result.match(/^\+\+([^\[]*)\[/);
+ assert.ok(whitespace, `expected link after opening markers, got: ${JSON.stringify(result)}`);
+ assert.equal(whitespace[1].length, 12);
+ }
+});
+
+test('tinymceToMarkdown keeps genuine leading link whitespace outside brackets', () => {
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const html = ' Label';
+ const result = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(html) + ')', ctx);
+ assert.equal(result, '[Label](https://e.com)');
+});
+
+test('tinymceToMarkdown restores an NBSP (not a plain space) after an inline image', () => {
+ // The real-world shape (Outlook-pasted link with an inline xlsx icon) separates
+ // the image from the label with a NON-BREAKING space, not an ASCII space.
+ // Turndown's edgeWhitespace uses \s, which matches NBSP, so the NBSP was expelled
+ // and duplicated. Restoring the sentinel as a generic ' ' would also change the
+ // body (NBSP -> space) and keep the phantom-edit loop alive, so the exact
+ // character must come back.
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const imageId = 'b'.repeat(32);
+ const html = '\u00a0Label
';
+ const result = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(html) + ')', ctx);
+ assert.equal(result, '[\u00a0Label](https://e.com)');
+ assert.ok(result.indexOf('\u00a0') !== -1, 'NBSP must survive as NBSP');
+});
+
+test('tinymceToMarkdown is idempotent for the real NBSP-separated icon link over 5 opens', () => {
+ // Regression for the reported bug: opening the note flashed "Edited" and fired a
+ // useless autosave because the whitespace run grew by one character per open
+ // (12 -> 13 -> 14 ...). Mirrors the stored body of the affected note.
+ const { renderMarkdown } = require('../app/templates');
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const md = '++' + '\u00a0'.repeat(12)
+ + '[\u00a0Hybrid Savings commercials.xlsx](https://example.com/x.xlsx)++';
+ let current = md;
+ for (let i = 0; i < 5; i += 1) {
+ current = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(renderMarkdown(current)) + ')', ctx);
+ assert.equal(current, md, `round-trip ${i + 1} must be byte-identical, got: ${JSON.stringify(current)}`);
+ }
+});
+
+test('tinymceToMarkdown keeps text typed INTO a blank-line marker (data-loss regression)', () => {
+ // A is a real, focusable paragraph in the TinyMCE
+ // iframe, so clicking the empty space between two blocks puts the caret inside
+ // it and typing puts the new text there. The blank-line normalisation used to
+ // rewrite the paragraph's content unconditionally, which silently DESTROYED
+ // that text: type a line after a checklist, leave the note, come back, gone.
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const shapes = [
+ '
hello there
', // typed over the
+ 'hello there
', // typed, TinyMCE re-added
+ 'hello there
', // with inline markup
+ ];
+ for (const p of shapes) {
+ const html = ' GPU
\n' + p + '\nApril
';
+ const result = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(html) + ')', ctx);
+ assert.ok(result.indexOf('hello') !== -1,
+ `text typed into a blank-line marker must survive, lost with ${p} -> ${JSON.stringify(result)}`);
+ assert.ok(result.indexOf('- [ ] GPU') !== -1, 'the checklist item must still convert');
+ }
+});
+
+test('tinymceToMarkdown still collapses a genuinely blank blank-line marker', () => {
+ // The counterpart guard: an untouched marker (or one whose
TinyMCE stripped)
+ // must still become a real blank line, otherwise spacing collapses.
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ for (const p of ['
', '', '
']) {
+ const html = ' GPU
\n' + p + '\nApril
';
+ const result = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(html) + ')', ctx);
+ assert.equal(result, '- [ ] GPU\n\n\n## April',
+ `blank marker ${p} must still produce a blank line, got: ${JSON.stringify(result)}`);
+ }
+});
+
+test('typing after a checklist survives a full render -> edit -> markdown -> reopen cycle', () => {
+ // End-to-end shape of the reported bug, including stability on reopen.
+ const { renderMarkdown } = require('../app/templates');
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const body = '- [ ] GPU\n- [ ] Do not include AI\n\n\n## April\n';
+ let html = renderMarkdown(body);
+ const marker = '
';
+ const at = html.indexOf(marker);
+ assert.ok(at !== -1, 'expected a blank-line marker between the checklist and the heading');
+ html = html.slice(0, at) + 'hello there
' + html.slice(at + marker.length);
+ const saved = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(html) + ')', ctx);
+ assert.ok(saved.indexOf('hello there') !== -1, `typed text must be saved, got: ${JSON.stringify(saved)}`);
+ assert.ok(/- \[ \] Do not include AI/.test(saved), 'checklist must be intact');
+ // Reopening must not change it again (no phantom edit, no further loss).
+ const reopened = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(renderMarkdown(saved)) + ')', ctx);
+ assert.equal(reopened, saved, 'the saved body must be stable on reopen');
+});
+
+test('tinymceToMarkdown does not add a trailing space to a bare > blockquote line', () => {
+ // Turndown prefixes every blockquote line with '> ', so the empty line between
+ // two quoted paragraphs came back as '> ' where the source had a bare '>'.
+ // Trailing whitespace there is insignificant in CommonMark, and leaving it in
+ // made the note look dirty on every open.
+ const { renderMarkdown } = require('../app/templates');
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const md = '> quote\n>\n> more';
+ const result = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(renderMarkdown(md)) + ')', ctx);
+ assert.equal(result, md);
+ assert.ok(!/>[ \t]+$/m.test(result), `no quote line may end in whitespace, got: ${JSON.stringify(result)}`);
+});
+
+test('tinymceToMarkdown keeps the > prefix on soft-wrapped blockquote lines', () => {
+ // '> b\n> c' is ONE quoted paragraph with a soft break, so the renderer emits
+ // 'b
c
'. The
sentinel is restored to a
+ // newline AFTER Turndown has prefixed its own lines, so without carrying the
+ // quote prefix across the break the second line came back as bare 'c' —
+ // escaping the blockquote entirely on the next render.
+ const { renderMarkdown } = require('../app/templates');
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ for (const md of ['> b\n> c', '> a\n>\n> b\n> c']) {
+ const result = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(renderMarkdown(md)) + ')', ctx);
+ assert.equal(result, md, `blockquote must round-trip, got: ${JSON.stringify(result)}`);
+ }
+});
+
+test('tinymceToMarkdown still turns a plain paragraph soft break into a bare newline', () => {
+ // Guard: the quote-prefix carry must not leak into non-quoted paragraphs.
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const result = vm.runInContext('tinymceToMarkdown("a
b
")', ctx);
+ assert.equal(result, 'a\nb');
+});
+
+test('tinymceToMarkdown does not duplicate whitespace before a trailing inline image', () => {
+ // Symmetric case: whitespace immediately before an ![]()
that closes the link.
+ const ctx = makeTurndownCtx();
+ runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
+ const imageId = 'c'.repeat(32);
+ const html = 'Label\u00a0
';
+ const result = vm.runInContext('tinymceToMarkdown(' + JSON.stringify(html) + ')', ctx);
+ assert.equal(result, '[Label\u00a0](https://e.com)');
+});
+
test('tinymceToMarkdown preserves a blank line INSIDE a code block (C #include is not a heading)', () => {
const ctx = makeTurndownCtx();
runWithDeps(ctx, 'getTurndown', 'tinymceToMarkdown');
diff --git a/tests/tinymceOnEditSync.test.js b/tests/tinymceOnEditSync.test.js
index 4880997..6984133 100644
--- a/tests/tinymceOnEditSync.test.js
+++ b/tests/tinymceOnEditSync.test.js
@@ -382,3 +382,107 @@ test('app.js: _tinymceFirstBlockText / autoTitleFromTinyMCE exist and are DOM-on
'autoTitleFromTinyMCE must read via _tinymceFirstBlockText');
});
+
+// ---------------------------------------------------------------------------
+// Post-load reconcile: load normalisation must NOT be mistaken for a user edit
+// ---------------------------------------------------------------------------
+
+// Build a context that runs _setTinyMCEContent's reconcile with controllable timers.
+function makeReconcileCtx({ userTyped, normalisedDiffers }) {
+ const dom = new JSDOM('');
+ const timers = [];
+ const editor = {
+ setContent() {},
+ undoManager: { clear() {} },
+ getBody: () => dom.window.document.body,
+ };
+ const ctx = vm.createContext({
+ document: dom.window.document,
+ window: dom.window,
+ Date,
+ _tinymceEditor: editor,
+ _tinymceSuppressEdits: false,
+ _tinymceReadonly: false,
+ _tinymcePostLoad: false,
+ _tinymcePostLoadUntil: 0,
+ _tinymceUserTypedSinceLoad: false,
+ _pendingSearchHighlight: false,
+ _savedHash: 111,
+ _edited: 0,
+ _saved: 0,
+ _snapshots: 0,
+ _logs: [],
+ setTimeout: (fn, ms) => { timers.push({ fn, ms }); return timers.length; },
+ });
+ vm.runInContext(`
+ function activeEditorForm(){return document.getElementById('note-editor-form')}
+ function _dbgline(){_logs.push(Array.from(arguments).join(' '))}
+ function _log(){}
+ function markEdited(){_edited++}
+ function scheduleSave(){_saved++}
+ function snapshotHash(){_snapshots++; _savedHash=formHash()}
+ function formHash(){return ${normalisedDiffers ? 222 : 111}}
+ function _lazyTinyMCESyncBeforeSave(){return true}
+ function ensureTinyMCEEditableAfterPre(){}
+ function initTinyMCECodeCopyButtons(){}
+ function _applyTinyMCESpellcheck(){}
+ function activeSearchTerm(){return ''}
+ function applySearchHighlight(){}
+ `, ctx);
+ vm.runInContext(extractFn('_setTinyMCEContent'), ctx);
+ vm.runInContext('_setTinyMCEContent("x
")', ctx);
+ if (userTyped) vm.runInContext('_tinymceUserTypedSinceLoad=true', ctx);
+ // Run the 820ms reconcile callback (the last scheduled timer).
+ const reconcile = timers.find(t => t.ms === 820);
+ assert.ok(reconcile, 'expected a 820ms reconcile timer to be scheduled');
+ reconcile.fn();
+ return {
+ edited: vm.runInContext('_edited', ctx),
+ saved: vm.runInContext('_saved', ctx),
+ snapshots: vm.runInContext('_snapshots', ctx),
+ logs: vm.runInContext('_logs.join("|")', ctx),
+ };
+}
+
+test('post-load reconcile: pure load normalisation re-baselines instead of flashing Edited', () => {
+ // Reported bug: opening a note whose markdown is not round-trip identical
+ // (indented ``` fence loses its indent, blank line after an ATX heading is
+ // collapsed) flashed "Edited" and fired a useless autosave EVERY open.
+ const r = makeReconcileCtx({ userTyped: false, normalisedDiffers: true });
+ assert.equal(r.edited, 0, 'markEdited must not fire for load normalisation');
+ assert.equal(r.saved, 0, 'no autosave may be scheduled for load normalisation');
+ assert.equal(r.snapshots, 1, 'the normalised content must become the new clean baseline');
+});
+
+test('post-load reconcile: a real edit during the quiet window still saves', () => {
+ // The reconcile exists so an edit absorbed by the 800ms post-load window is
+ // not silently lost. That safety net must survive the fix above.
+ const r = makeReconcileCtx({ userTyped: true, normalisedDiffers: true });
+ assert.equal(r.edited, 1, 'a genuine edit must still mark the note edited');
+ assert.equal(r.saved, 1, 'a genuine edit must still schedule a save');
+});
+
+test('post-load reconcile: identical content does nothing at all', () => {
+ const r = makeReconcileCtx({ userTyped: false, normalisedDiffers: false });
+ assert.equal(r.edited, 0);
+ assert.equal(r.saved, 0);
+ assert.equal(r.snapshots, 0);
+});
+
+test('app.js: user-typed flag is wired to keydown/paste/cut/drop, never to input/SetContent', () => {
+ // editor.setContent() fires 'input' and 'SetContent', so those events cannot
+ // be used to detect real user interaction — using them would reintroduce the
+ // phantom "Edited" on open.
+ const idx = appSrc.indexOf('_tinymceUserTypedSinceLoad=true');
+ assert.ok(idx !== -1, '_tinymceUserTypedSinceLoad must be set somewhere');
+ for (const evt of ['keydown', 'paste', 'cut', 'drop']) {
+ assert.ok(new RegExp(`editor\\.on\\('${evt}'`).test(appSrc),
+ `expected an editor.on('${evt}') handler to exist`);
+ }
+ const setLine = appSrc.slice(appSrc.lastIndexOf('\n', idx - 200), idx + 40);
+ assert.ok(!/editor\.on\('(?:input|SetContent)'[^)]*\)\s*\{[^}]*_tinymceUserTypedSinceLoad=true/.test(setLine),
+ '_tinymceUserTypedSinceLoad must not be set from input/SetContent handlers');
+ assert.ok(extractFn('_setTinyMCEContent').includes('_tinymceUserTypedSinceLoad=false'),
+ '_setTinyMCEContent must reset the user-typed flag on every programmatic load');
+});