projview 0.5.2 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projview",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Ephemeral local previewer for markdown + mermaid files in any directory",
   "type": "module",
   "bin": {

package/src/search.js

@@ -53,10 +53,15 @@ export async function buildIndex(root, store) {
   return { store, total: entries.length, reindexed, warm: !!cached };
 }
 
+// Re-read one file into the in-memory index; return its store entry (or null).
 export async function updateFile(rel) {
-  if (!theRoot) return;
-  try { addToIndex(rel, await fsp.readFile(path.join(theRoot, rel), 'utf8')); }
-  catch { /* gone between event and read - ignore */ }
+  if (!theRoot) return null;
+  const abs = path.join(theRoot, rel);
+  try {
+    const [content, stat] = await Promise.all([fsp.readFile(abs, 'utf8'), fsp.stat(abs)]);
+    addToIndex(rel, content);
+    return { path: rel, name: rel.split('/').pop(), ext: path.extname(rel).toLowerCase(), mtime: stat.mtimeMs, content };
+  } catch { return null; }
 }
 
 export function removeFile(rel) { index.delete(rel); }

package/src/server.js

@@ -113,24 +113,33 @@ export async function startServer(root, { port = 4321, host = '127.0.0.1', store
   });
 
   // --- file watcher -> live reload ---
+  const store = createStore(storeConfig, root);
+  const indexInfo = await buildIndex(root, store);   // load-or-build the search index
+
+  // file watcher -> keep the in-memory index, the persisted store, AND the
+  // browser in sync as files change during a session
   const watcher = chokidar.watch(root, {
     ignoreInitial: true,
     ignored: (p) => p.split(path.sep).some(isIgnoredDir)
   });
   const rel = (p) => path.relative(root, p).split(path.sep).join('/');
+  const touch = async (p, event) => {
+    if (!isPreviewable(p)) return;
+    const entry = await updateFile(rel(p));   // refresh in-memory index, get the entry
+    if (entry) await store.update(entry);     // mirror the change into the store
+    broadcast(event, { path: rel(p) });
+  };
   watcher
-    .on('change', (p) => {
+    .on('change', (p) => touch(p, 'change'))
+    .on('add', (p) => touch(p, 'tree'))
+    .on('unlink', async (p) => {
       if (!isPreviewable(p)) return;
-      updateFile(rel(p));
-      broadcast('change', { path: rel(p) });
+      removeFile(rel(p));
+      await store.remove(rel(p));
+      broadcast('tree');
     })
-    .on('add', (p) => { if (isPreviewable(p)) { updateFile(rel(p)); broadcast('tree'); } })
-    .on('unlink', (p) => { if (isPreviewable(p)) { removeFile(rel(p)); broadcast('tree'); } })
     .on('addDir', () => broadcast('tree'))
     .on('unlinkDir', () => broadcast('tree'));
-
-  const store = createStore(storeConfig, root);
-  const indexInfo = await buildIndex(root, store);   // load-or-build the search index
   const listenPort = await listenWithRetry(server, port, host);
 
   const close = () => new Promise((resolve) => {

package/src/store.js

@@ -78,6 +78,8 @@ function memoryStore() {
     kind: 'memory',
     async load() { return null; },
     async save() {},
+    async update() {},
+    async remove() {},
     async close() {},
     describe() { return 'in-memory (ephemeral - nothing persisted)'; }
   };
@@ -85,15 +87,29 @@ function memoryStore() {
 
 function superliteStore(root, persist) {
   const file = fileFor(root, persist, 'json');
+  let map = null;   // path -> entry, lazily loaded
+  const ensure = async () => {
+    if (map) return map;
+    try {
+      const d = JSON.parse(await fsp.readFile(file, 'utf8'));
+      map = new Map((d.entries || []).map((e) => [e.path, e]));
+    } catch { map = new Map(); }
+    return map;
+  };
+  const flush = () => fsp.writeFile(file, JSON.stringify({ builtAt: Date.now(), entries: [...map.values()] }));
   return {
     kind: 'superlite',
     file,
     async load() {
-      try { return JSON.parse(await fsp.readFile(file, 'utf8')); } catch { return null; }
+      const m = await ensure();
+      return m.size ? { entries: [...m.values()] } : null;
     },
     async save(entries) {
-      await fsp.writeFile(file, JSON.stringify({ builtAt: Date.now(), entries }));
+      map = new Map(entries.map((e) => [e.path, e]));
+      await flush();
     },
+    async update(entry) { (await ensure()).set(entry.path, entry); await flush(); },
+    async remove(p) { (await ensure()).delete(p); await flush(); },
     async close({ keep } = {}) {
       if (!persist && !keep) { try { await fsp.unlink(file); } catch { /* gone */ } }
     },
@@ -127,6 +143,15 @@ function sqliteAt(file, { cleanup }) {
       for (const e of entries) ins.run(e.path, e.name, e.ext, e.mtime, e.content);
       d.exec('COMMIT');
     },
+    async update(entry) {
+      const d = await open();
+      d.prepare('INSERT OR REPLACE INTO files (path, name, ext, mtime, content) VALUES (?, ?, ?, ?, ?)')
+        .run(entry.path, entry.name, entry.ext, entry.mtime, entry.content);
+    },
+    async remove(p) {
+      const d = await open();
+      d.prepare('DELETE FROM files WHERE path = ?').run(p);
+    },
     async close({ keep } = {}) {
       if (db) { db.close(); db = null; }
       if (cleanup && !keep) { try { await fsp.unlink(file); } catch { /* gone */ } }
@@ -183,6 +208,18 @@ function postgresStore(url) {
       }
       await c.query('COMMIT');
     },
+    async update(entry) {
+      const c = await open();
+      await c.query(
+        'INSERT INTO projview_files (path, name, ext, mtime, content) VALUES ($1, $2, $3, $4, $5)' +
+          ' ON CONFLICT (path) DO UPDATE SET name = $2, ext = $3, mtime = $4, content = $5',
+        [entry.path, entry.name, entry.ext, entry.mtime, entry.content]
+      );
+    },
+    async remove(p) {
+      const c = await open();
+      await c.query('DELETE FROM projview_files WHERE path = $1', [p]);
+    },
     async close() { if (client) { await client.end(); client = null; } },   // never drop the user's table
     describe() { return `custom/postgres ${redact(url)}`; }
   };