/**
|
* Shared helpers for the pending-manual-edits buffer on disk.
|
*
|
* Location: .impeccable/live/pending-manual-edits.json (project-local).
|
* Schema: { version: 1, entries: [{ id, pageUrl, element, ops, stagedAt }] }
|
*
|
* Each entry corresponds to one Save action from the browser. Ops merge by
|
* (pageUrl, ref): if the user re-edits the same element before committing, the
|
* existing entry's `newText` is replaced and `originalText` is kept (it holds
|
* the real source state).
|
*/
|
|
import fs from 'node:fs';
|
import path from 'node:path';
|
import { getLiveDir } from '../lib/impeccable-paths.mjs';
|
|
const BUFFER_VERSION = 1;
|
const BUFFER_FILENAME = 'pending-manual-edits.json';
|
|
export function getBufferPath(cwd = process.cwd()) {
|
return path.join(getLiveDir(cwd), BUFFER_FILENAME);
|
}
|
|
export function readBuffer(cwd = process.cwd()) {
|
return readBufferInternal(cwd, { strict: false });
|
}
|
|
export function readBufferStrict(cwd = process.cwd()) {
|
return readBufferInternal(cwd, { strict: true });
|
}
|
|
function readBufferInternal(cwd, { strict }) {
|
const filePath = getBufferPath(cwd);
|
try {
|
const raw = fs.readFileSync(filePath, 'utf-8');
|
const parsed = JSON.parse(raw);
|
if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.entries)) {
|
if (strict) throw new Error('manual_edit_buffer_invalid_schema');
|
return { version: BUFFER_VERSION, entries: [] };
|
}
|
return { version: BUFFER_VERSION, entries: parsed.entries };
|
} catch (err) {
|
if (strict && err?.code !== 'ENOENT') {
|
throw new Error('manual_edit_buffer_unreadable: ' + (err.message || String(err)));
|
}
|
return { version: BUFFER_VERSION, entries: [] };
|
}
|
}
|
|
export function writeBuffer(cwd, buffer) {
|
const filePath = getBufferPath(cwd);
|
fs.mkdirSync(path.dirname(filePath), { recursive: true });
|
fs.writeFileSync(filePath, JSON.stringify({ version: BUFFER_VERSION, entries: buffer.entries }, null, 2));
|
}
|
|
/**
|
* Merge a new entry into the buffer. For each op in the new entry, if there's
|
* already a buffered op for the same (pageUrl, ref), update that op's newText
|
* and keep its original originalText (the true source state). Otherwise add
|
* the op (creating an entry if needed).
|
*
|
* Multiple ops in one Save are allowed; each is keyed by (pageUrl, ref).
|
*/
|
export function stageEntry(cwd, newEntry) {
|
const buf = readBufferStrict(cwd);
|
const pageUrl = newEntry.pageUrl;
|
for (const newOp of newEntry.ops) {
|
let mergedIntoExisting = false;
|
for (const existing of buf.entries) {
|
if (existing.pageUrl !== pageUrl) continue;
|
const existingOpIdx = existing.ops.findIndex((op) => op.ref === newOp.ref);
|
if (existingOpIdx >= 0) {
|
// Keep the original source text but refresh the latest DOM/source evidence.
|
existing.ops[existingOpIdx] = {
|
...newOp,
|
originalText: existing.ops[existingOpIdx].originalText,
|
newText: newOp.newText,
|
deleted: newOp.deleted || false,
|
};
|
if (newEntry.element) existing.element = newEntry.element;
|
existing.stagedAt = new Date().toISOString();
|
mergedIntoExisting = true;
|
break;
|
}
|
}
|
if (mergedIntoExisting) continue;
|
// No existing op for this (pageUrl, ref). Find or create an entry to hold it.
|
let entry = buf.entries.find((e) => e.pageUrl === pageUrl && e.id === newEntry.id);
|
if (!entry) {
|
entry = {
|
id: newEntry.id,
|
pageUrl,
|
element: newEntry.element,
|
ops: [],
|
stagedAt: new Date().toISOString(),
|
};
|
buf.entries.push(entry);
|
}
|
entry.ops.push(newOp);
|
entry.stagedAt = new Date().toISOString();
|
}
|
writeBuffer(cwd, buf);
|
return buf;
|
}
|
|
/**
|
* Remove entries matching a predicate. Returns count of removed *ops* (not
|
* entries) so callers report a unit consistent with truncateBuffer and the
|
* pill's per-page op count. Empty entries (no ops left) are also pruned.
|
*/
|
export function removeEntries(cwd, predicate) {
|
const buf = readBuffer(cwd);
|
let removedOps = 0;
|
const kept = [];
|
for (const entry of buf.entries) {
|
if (predicate(entry)) {
|
removedOps += entry.ops?.length || 0;
|
} else if (entry.ops && entry.ops.length > 0) {
|
kept.push(entry);
|
}
|
}
|
buf.entries = kept;
|
writeBuffer(cwd, buf);
|
return removedOps;
|
}
|
|
/**
|
* Count by page for the counter UI. Returns { totalCount, perPage: {[pageUrl]: count} }.
|
*/
|
export function countByPage(cwd = process.cwd()) {
|
const buf = readBuffer(cwd);
|
const perPage = {};
|
let totalCount = 0;
|
for (const entry of buf.entries) {
|
const n = entry.ops.length;
|
perPage[entry.pageUrl] = (perPage[entry.pageUrl] || 0) + n;
|
totalCount += n;
|
}
|
return { totalCount, perPage };
|
}
|
|
/**
|
* Truncate the buffer to empty (used by discard-all). Returns the count of
|
* removed ops.
|
*/
|
export function truncateBuffer(cwd) {
|
const buf = readBuffer(cwd);
|
let removed = 0;
|
for (const entry of buf.entries) removed += entry.ops.length;
|
writeBuffer(cwd, { version: BUFFER_VERSION, entries: [] });
|
return removed;
|
}
|
