latex-stickies 1.3.8 → 1.4.0

package/README.md

@@ -29,7 +29,8 @@ keeps a copy of the runtime carrying this app's name and icon in
 `~/Library/Application Support/latex-stickies/` -- on APFS that is a
 copy-on-write clone, so it costs almost no disk. On a Mac you can
 download a `.dmg` from [Releases](https://github.com/kev-nj/latex-stickies/releases)
-instead and skip Node entirely.
+instead and skip Node entirely. It is not signed by Apple, so the first launch
+needs a right-click on the app and **Open** rather than a double-click.
 
 ## Writing in a note
 
@@ -91,7 +92,7 @@ Use `Ctrl` in place of `Cmd` on Windows and Linux.
 | | |
 |---|---|
 | `Cmd+N` | New note |
-| `Cmd+W` | Close note (it stays closed until you reopen it) |
+| `Cmd+W` | Close note (it stays closed until you reopen it; an empty one is discarded) |
 | `Cmd+Shift+Backspace` | Delete note, permanently |
 | `Cmd+B` / `Cmd+I` / `Cmd+E` | Bold / italic / code |
 | `Cmd+K` | Link |
@@ -162,6 +163,7 @@ node scripts/smoke.js --lifecycle # closing every note behaves per platform
 node scripts/render-check.js      # the first-run note renders correctly
 node scripts/ghost-check.js       # autocomplete suggests, and Tab accepts
 node scripts/snapshot-check.js    # a long note is captured whole
+node scripts/conflict-check.js    # the changed-on-disk banner behaves
 node scripts/verify-install.js    # the install path, end to end (macOS)
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "latex-stickies",
-  "version": "1.3.8",
+  "version": "1.4.0",
   "description": "Sticky notes for your desktop that render LaTeX and Markdown.",
   "main": "src/main.js",
   "scripts": {
@@ -30,7 +30,8 @@
         "zip"
       ],
       "icon": "build/icon.icns"
-    }
+    },
+    "afterPack": "scripts/after-pack.js"
   },
   "devDependencies": {
     "@codemirror/commands": "^6.11.0",

package/src/main.js

@@ -68,7 +68,13 @@ async function deleteFocusedNote() {
 
   const note = store.get(id);
   if (note && note.body.trim()) {
-    const { response } = await dialog.showMessageBox(win, {
+    // Deliberately not attached to the note's window. A sheet hangs off a
+    // title bar, and these windows are frameless, transparent and often on
+    // top -- so the prompt rendered invisibly and the app sat waiting for an
+    // answer nobody could give. Delete Note looked like it did nothing at all.
+    // The same trap took window.confirm() out of use here.
+    win.show();
+    const { response } = await dialog.showMessageBox({
       type: 'warning',
       buttons: ['Delete', 'Cancel'],
       defaultId: 1,
@@ -163,7 +169,22 @@ function openNote(note) {
     // Closing a note is a decision that should survive a restart. Quitting is
     // not: an app that shuts down closes every window, and treating that as
     // "the user closed them all" would greet them with an empty desk.
-    if (!quitting) store.upsert({ id: note.id, open: false });
+    // Nothing to record if the note is already gone: this fires during a
+    // delete too, and writing "open: false" for an id the store no longer
+    // knows created a fresh empty note in its place -- the note came straight
+    // back as "Untitled note".
+    if (!quitting && store.get(note.id)) {
+      const closed = store.get(note.id);
+      if (closed && !(closed.body || '').trim()) {
+        // An emptied note closed is a note thrown away, as in Stickies.
+        // Otherwise clearing a note's text leaves an "Untitled note" in the
+        // list for ever, with no way to be rid of it short of opening it
+        // again to delete it -- which is not where anyone looks.
+        store.remove(note.id);
+      } else {
+        store.upsert({ id: note.id, open: false });
+      }
+    }
 
     // macOS apps outlive their windows; the Dock icon is the way back.
     // Elsewhere there is no way back, so an app with no windows is just an
@@ -493,11 +514,16 @@ function prepareToExit() {
 }
 
 function watchNotesFolder() {
-  stopWatchingNotes = store.watch((changed) => {
-    for (const note of changed) {
+  stopWatchingNotes = store.watch((changes) => {
+    for (const { note, body, conflict } of changes) {
       const win = windows.get(note.id);
-      if (win && !win.isDestroyed()) win.webContents.send('note-changed', note.body);
+      if (!win || win.isDestroyed()) continue;
+      // A note with unsaved edits is never overwritten from disk. The window
+      // is told there is a conflict and offers the choice, because only the
+      // person typing knows which copy they want.
+      win.webContents.send(conflict ? 'note-conflict' : 'note-changed', body);
     }
+    refreshNoteTitles();
   });
 }
 

package/src/preload.js

@@ -43,7 +43,8 @@ contextBridge.exposeInMainWorld('sticky', {
   on: (channel, fn) => {
     const allowed = [
       'font-size', 'always-on-top-changed',
-      'copy-note-image', 'ai-settings-changed', 'note-changed', 'find-in-note', 'describe-latex',
+      'copy-note-image', 'ai-settings-changed', 'note-changed', 'note-conflict',
+      'find-in-note', 'describe-latex',
     ];
     if (!allowed.includes(channel)) return;
     ipcRenderer.on(channel, (_e, payload) => fn(payload));

package/src/renderer/note.css

@@ -362,3 +362,38 @@ body.capturing-note #preview [data-math].capturing {
 
 ::-webkit-scrollbar { width: 8px; }
 ::-webkit-scrollbar-thumb { background: rgba(0, 0, 0, 0.16); border-radius: 4px; }
+
+/* The file changed underneath unsaved edits. Sits over the note rather than
+   interrupting it: the text stays editable while the choice is on screen. */
+#conflict {
+  /* Fixed to the window, not the scrolling content: the choice has to stay
+     visible while you scroll the note it is about. */
+  position: fixed;
+  left: 8px;
+  right: 8px;
+  bottom: 8px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 7px 10px;
+  border-radius: 7px;
+  background: rgba(0, 0, 0, 0.82);
+  color: #fff;
+  font-size: 12px;
+  z-index: 5;
+}
+/* An author display rule beats the [hidden] attribute, which only sets
+   display:none in the browser's own stylesheet -- so without this the banner
+   is on screen from launch and cannot be dismissed. */
+#conflict[hidden] { display: none; }
+#conflict span { flex: 1; }
+#conflict button {
+  font: inherit;
+  color: inherit;
+  padding: 3px 9px;
+  border: 1px solid rgba(255, 255, 255, 0.35);
+  border-radius: 5px;
+  background: transparent;
+  cursor: pointer;
+}
+#conflict button:hover { background: rgba(255, 255, 255, 0.16); }

package/src/renderer/note.html

@@ -21,6 +21,13 @@
   </header>
   <main id="surface">
     <div id="host"></div>
+    <!-- Shown only when the file changed underneath unsaved edits. Not a
+         modal: the note stays editable while the choice is on screen. -->
+    <div id="conflict" hidden>
+      <span>Changed on disk.</span>
+      <button class="reload" type="button">Use theirs</button>
+      <button class="mine" type="button">Keep mine</button>
+    </div>
   </main>
   <script src="vendor/katex.min.js"></script>
   <script src="vendor/codemirror.js"></script>

package/src/renderer/note.js

@@ -14,12 +14,41 @@ let view = null;
 
 /* ---------- state ---------- */
 
+// Trailing debounce, but with a ceiling. A debounce that resets on every
+// keystroke never fires while you are typing, so the file could trail the
+// screen by as long as the burst lasted -- and anything that then read the
+// file got text seconds out of date. VS Code's autosave delay is 1s; this
+// keeps the quick 250ms settle and caps the wait at 1s.
+const SAVE_SETTLE_MS = 250;
+const SAVE_MAX_MS = 1000;
+
 let saveTimer = null;
+let pendingSince = 0;
+
+function saveNow() {
+  clearTimeout(saveTimer);
+  saveTimer = null;
+  pendingSince = 0;
+  if (note) window.sticky.update({ body: note.body });
+}
+
 function scheduleSave() {
+  if (!pendingSince) pendingSince = Date.now();
+  if (Date.now() - pendingSince >= SAVE_MAX_MS) {
+    saveNow();
+    return;
+  }
   clearTimeout(saveTimer);
-  saveTimer = setTimeout(() => window.sticky.update({ body: note.body }), 250);
+  saveTimer = setTimeout(saveNow, SAVE_SETTLE_MS);
 }
 
+// Losing focus is the moment to be certain: the file is what another editor,
+// or a sync engine, is about to read. VS Code ships the same behaviour as
+// files.autoSave onFocusChange.
+window.addEventListener('blur', () => {
+  if (saveTimer) saveNow();
+});
+
 // Typing is saved on a debounce, which Cmd+W would otherwise outrun: the window
 // is closed from the main process, so the pending timer dies with the renderer
 // and the last few words typed are lost. beforeunload is the last point the
@@ -114,16 +143,73 @@ window.sticky.on('describe-latex', async () => {
 // The file changed underneath us -- another editor, Dropbox, a git checkout.
 // Replace the text but keep the caret where it was, so a sync landing while
 // you are typing does not throw you back to the top of the note.
-window.sticky.on('note-changed', (body) => {
-  if (!view || body === view.state.doc.toString()) return;
-  const caret = Math.min(view.state.selection.main.head, body.length);
+/**
+ * Applies an edit that happened outside this window.
+ *
+ * As a splice of the part that actually differs, not a replacement of the
+ * whole document. Replacing everything maps every position to the end of the
+ * insertion, so the caret jumps, the selection is lost and the undo history
+ * becomes one opaque blob -- CodeMirror maps positions through a change set
+ * for you, but only if the change describes what really changed.
+ *
+ * Common prefix and suffix is enough here: an outside edit is nearly always
+ * one contiguous region, and it costs no dependency.
+ */
+function applyExternal(body) {
+  const doc = view.state.doc.toString();
+  if (body === doc) return;
+
+  let start = 0;
+  const max = Math.min(doc.length, body.length);
+  while (start < max && doc[start] === body[start]) start += 1;
+
+  let end = 0;
+  while (
+    end < max - start
+    && doc[doc.length - 1 - end] === body[body.length - 1 - end]
+  ) end += 1;
+
   note.body = body;
   view.dispatch({
-    changes: { from: 0, to: view.state.doc.length, insert: body },
-    selection: { anchor: caret },
+    changes: { from: start, to: doc.length - end, insert: body.slice(start, body.length - end) },
   });
+}
+
+window.sticky.on('note-changed', (body) => {
+  if (!view) return;
+  applyExternal(body);
+});
+
+/**
+ * The file changed while this note had edits that were not saved yet.
+ *
+ * Nothing is overwritten: the two versions are offered as a choice, because
+ * only the person typing knows which one they want. Silently reloading over
+ * unsaved input is the one thing every editor of this kind refuses to do.
+ */
+window.sticky.on('note-conflict', (body) => {
+  if (!view) return;
+  showConflict(body);
 });
 
+const conflict = document.getElementById('conflict');
+
+function showConflict(body) {
+  conflict.hidden = false;
+  conflict.querySelector('.reload').onclick = () => {
+    applyExternal(body);
+    saveNow();
+    conflict.hidden = true;
+  };
+  conflict.querySelector('.mine').onclick = () => {
+    // Writing our copy over theirs is what makes this stick: the next save
+    // carries it, and the file stops disagreeing.
+    note.body = view.state.doc.toString();
+    saveNow();
+    conflict.hidden = true;
+  };
+}
+
 // Right-click a rendered equation to copy it as an image or as LaTeX.
 host.addEventListener('contextmenu', async (e) => {
   const slot = e.target.closest('[data-tex]');

package/src/store.js

@@ -17,6 +17,7 @@
  * the previous file intact rather than a truncated one.
  */
 const { app } = require('electron');
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 
@@ -98,6 +99,7 @@ function load() {
     try {
       body = fs.readFileSync(path.join(DIR, file), 'utf8');
     } catch (_) { /* unreadable file: show it empty rather than vanish */ }
+    seen.set(file, digest(body));
     return {
       ...DEFAULTS,
       ...saved,
@@ -154,7 +156,6 @@ function migrateLegacy() {
 /* ---------- writing ---------- */
 
 function writeFileAtomic(target, contents) {
-  justWrote.set(path.basename(target), Date.now());
   const tmp = `${target}.${process.pid}.tmp`;
   const fd = fs.openSync(tmp, 'w');
   try {
@@ -164,6 +165,7 @@ function writeFileAtomic(target, contents) {
     fs.closeSync(fd);
   }
   fs.renameSync(tmp, target);
+  seen.set(path.basename(target), digest(contents));
 }
 
 // A kill between the temp write and the rename strands a .tmp file.
@@ -204,6 +206,22 @@ function flushIndex() {
 function flush() {
   timer = null;
   for (const note of all()) {
+    // Only the notes that actually changed. Rewriting every note on every
+    // keystroke multiplied the mtimes, the events and the chances of
+    // misattributing one -- four notes turned one save into twenty events --
+    // and churned any sync engine watching the folder.
+    if (!isDirty(note)) continue;
+
+    // Never write over a file that moved underneath us. The watcher usually
+    // gets there first, but a save already pending can land in between --
+    // and overwriting then is silent loss, with no event left to notice it.
+    // Skipping leaves the file alone; the watcher reports the conflict, and
+    // if it somehow missed the event, the next save checks again.
+    try {
+      const onDisk = fs.readFileSync(path.join(DIR, note.file), 'utf8');
+      if (digest(onDisk) !== seen.get(note.file)) continue;
+    } catch (_) { /* not there yet: writing it is exactly right */ }
+
     try {
       writeFileAtomic(path.join(DIR, note.file), note.body || '');
     } catch (err) {
@@ -213,6 +231,11 @@ function flush() {
   flushIndex();
 }
 
+/** Has this note been edited since it was last written to disk? */
+function isDirty(note) {
+  return digest(note.body || '') !== seen.get(note.file);
+}
+
 // Writes are frequent (every keystroke, every window drag), so coalesce them.
 function save() {
   if (timer) return;
@@ -235,6 +258,11 @@ function upsert(note) {
   const i = list.findIndex((n) => n.id === note.id);
 
   if (i === -1) {
+    // A patch for an id nobody has, carrying no text, is not a new note: it is
+    // a stray message about one that has gone -- a window closing after its
+    // note was deleted, or bounds arriving as it goes. Creating a note from it
+    // resurrects what the user just deleted, empty.
+    if (note.body === undefined) return;
     const taken = new Set(list.map((n) => n.file));
     list.push({ ...DEFAULTS, ...note, file: note.file || slugFor(note.body, taken) });
     save();
@@ -254,11 +282,8 @@ function upsert(note) {
     const next = slugFor(list[i].body, taken, path.extname(before.file) || '.md');
     try {
       const from = path.join(DIR, before.file);
-      // Both names count as our own writing, or the rename looks like an
-      // outside edit and the watcher reloads over the top of it.
-      justWrote.set(before.file, Date.now());
-      justWrote.set(next, Date.now());
       if (fs.existsSync(from)) fs.renameSync(from, path.join(DIR, next));
+      seen.delete(before.file);
       list[i].file = next;
       // Write this note's body now too. The rename is immediate but the body
       // is on the 400ms timer, so a reload in between would read the new file
@@ -284,6 +309,11 @@ function remove(id) {
     try {
       fs.unlinkSync(path.join(DIR, note.file));
     } catch (_) { /* already gone */ }
+    // Forget what that filename held. Otherwise a later note that takes the
+    // same name -- "note.md" is handed out again the moment an untitled note
+    // is deleted -- is compared against the dead file's content, matches, and
+    // is judged already saved. It then never reaches disk.
+    seen.delete(note.file);
   }
   notes = all().filter((n) => n.id !== id);
   save();
@@ -296,34 +326,106 @@ function saveNow() {
 
 /* ---------- watching the folder ---------- */
 
-/** Files we wrote ourselves, so our own saves do not look like outside edits. */
-const justWrote = new Map();
-const SETTLE_MS = 1200;
+/**
+ * The content we last wrote or read, per file, as a hash.
+ *
+ * This is how an event is attributed. A file whose bytes hash to what we last
+ * put there is our own save coming back, whenever it arrives; anything else is
+ * somebody else's edit. What it replaces was a 1200ms window after each write,
+ * which is not what mature editors do and was wrong in both directions: a save
+ * echoed back late -- measured at 2.5s when the main process stalls -- looked
+ * like an outside edit and reverted the note being typed in.
+ *
+ * VS Code uses mtime+size for the same job and has an open issue about content
+ * changing without the length changing; notes are small enough to just hash.
+ */
+const seen = new Map();
+const digest = (text) => crypto.createHash('sha256').update(text || '').digest('hex');
 
 /**
  * Calls back when a note file changes underneath us.
  *
  * This is the point of keeping notes as files: edit one in Vim, or let Dropbox
  * bring down a change from another machine, and the open note follows along.
- * Our own writes are filtered out, or every keystroke would echo back.
+ *
+ * Two rules, both taken from how VS Code and Zed handle this:
+ *
+ *   - Only the file the event names is touched. Fanning one event out into a
+ *     reload of every note is what let a change to one note revert the text
+ *     being typed into another.
+ *   - A note with unsaved edits is never overwritten. It is reported as a
+ *     conflict instead, for the window to offer as a choice. "Do not resolve a
+ *     model that is dirty" is the invariant every editor of this kind keeps.
  */
 function watch(onChanged) {
-  let timer = null;
+  const timers = new Map();
   let watcher = null;
+
+  const handle = (filename) => {
+    timers.delete(filename);
+    const full = path.join(DIR, filename);
+
+    let body;
+    try {
+      body = fs.readFileSync(full, 'utf8');
+    } catch (_) {
+      // Deleted or moved away. The window keeps what it has: a file vanishing
+      // underneath an open note is not a reason to blank it.
+      seen.delete(filename);
+      return;
+    }
+
+    const before = seen.get(filename);
+    const now = digest(body);
+
+    // Set LATEX_STICKIES_DEBUG_WATCH=1 to see why an event was attributed the
+    // way it was. Guessing at this from the outside cost a day: the question
+    // is always whether the bytes on disk are the bytes we last wrote.
+    if (process.env.LATEX_STICKIES_DEBUG_WATCH) {
+      const held = all().find((n) => n.file === filename);
+      console.log(
+        `WATCH ${filename} disk=${now.slice(0, 8)} lastWrote=${String(before).slice(0, 8)}`
+        + ` memory=${digest(held ? held.body : '').slice(0, 8)}`
+        + ` ours=${now === before} diskLen=${body.length}`
+        + ` memLen=${held ? (held.body || '').length : -1}`
+      );
+    }
+
+    if (now === before) return; // our own save, however late it arrives
+
+    const note = all().find((n) => n.file === filename);
+    if (!note) {
+      // A file that appeared from outside. Added on its own rather than by
+      // reloading the folder: a reload drops every note's unsaved edits on the
+      // floor, so one new file would cost the words being typed in another.
+      const meta = readIndex()[filename] || {};
+      const added = {
+        ...DEFAULTS, ...meta, id: meta.id || filename, file: filename, body,
+      };
+      all().push(added);
+      seen.set(filename, now);
+      onChanged([{ note: added, body, conflict: false }]);
+      return;
+    }
+
+    // Whether the note was edited since we last wrote it has to be judged
+    // against the hash from before this event, which is what our copy came
+    // from -- not against the disk we have just read.
+    const dirty = digest(note.body || '') !== before;
+    seen.set(filename, now); // seen it now, so a repeat event says nothing new
+
+    if (!dirty) note.body = body;
+    onChanged([{ note, body, conflict: dirty }]);
+  };
+
   try {
     watcher = fs.watch(DIR, (_event, filename) => {
       if (!filename || filename.startsWith('.') || filename.endsWith('.tmp')) return;
-      const wrote = justWrote.get(filename);
-      if (wrote && Date.now() - wrote < SETTLE_MS) return;
-
-      // Editors save in bursts; wait for the dust to settle.
-      clearTimeout(timer);
-      timer = setTimeout(() => {
-        const before = new Map(all().map((n) => [n.file, n.body]));
-        const after = reload();
-        const changed = after.filter((n) => before.get(n.file) !== n.body);
-        if (changed.length) onChanged(changed);
-      }, 150);
+      if (!/\.(md|tex|txt)$/i.test(filename)) return;
+
+      // Editors save in bursts; wait for the dust to settle, per file.
+      clearTimeout(timers.get(filename));
+      timers.set(filename, setTimeout(() => handle(filename), 150));
     });
   } catch (err) {
     console.error('could not watch the notes folder', err);
@@ -333,8 +435,8 @@ function watch(onChanged) {
   // watcher left open is enough to stop the process exiting after its last
   // window closes -- which on Windows leaves the app running invisibly.
   return () => {
-    clearTimeout(timer);
-    timer = null;
+    for (const timer of timers.values()) clearTimeout(timer);
+    timers.clear();
     if (watcher) watcher.close();
     watcher = null;
   };
@@ -371,5 +473,6 @@ function saveSettings(patch) {
 }
 
 module.exports = {
-  all, get, upsert, remove, saveNow, reload, watch, settings, saveSettings, DIR,
+  all, get, upsert, remove, saveNow, reload, watch, isDirty,
+  settings, saveSettings, DIR,
 };