sourcemonkey 0.0.0-stage → 0.5.0

package/dist/extension/delete-dialog.js

@@ -0,0 +1,432 @@
+// The "delete local script file" confirmation, opened from the trash
+// can on a script whose file lives in the Downloads copies directory.
+//
+// It owns the whole action the way the copy dialog owns Copy: what will
+// be deleted, the confirmation, the deletion itself, and any failure in
+// its own error slot. The caller hears only about files that went.
+//
+// See docs/local-delete.md.
+import { effectiveDisplayName } from './collection-display.js';
+import { downloadsCopiesDir, readDownloadsCopiesSetting } from './local-copy.js';
+import { copyDeletePlan, deletableCopyPath, deleteCopyFiles, noDownloadRecord, SCRIPT_FILE, trackedFiles, } from './local-delete.js';
+import { describeError, getCollectionWithScriptMeta, } from './script-store.js';
+import { dlog } from '../debug-log.js';
+import { makeCopyButton } from './copy-button.js';
+import { missingFiles } from './file-changes.js';
+import { isFileSchemeAccessAllowed } from './file-access.js';
+let elements = null;
+// One at a time, claimed synchronously — the same guard the other
+// dialogs use: a second `showModal` throws and would leave the first
+// caller's promise unsettled.
+let dialogInFlight = false;
+function el(tag, className, text) {
+    const node = document.createElement(tag);
+    if (className)
+        node.className = className;
+    if (text !== undefined)
+        node.textContent = text;
+    return node;
+}
+function buildDialog() {
+    const dialog = el('dialog', 'sm-dialog delete-dialog');
+    dialog.appendChild(el('h2', 'dlg-title', 'Delete local script file'));
+    const body = el('div', 'dlg-body');
+    // Label and control carry the same tooltip, as in the copy dialog:
+    // either one is what a reader points at to ask "what is this?".
+    const row = (label, control, tooltip) => {
+        const cell = el('span', 'dlg-label', label);
+        cell.title = tooltip;
+        control.title = tooltip;
+        body.appendChild(cell);
+        body.appendChild(control);
+        return cell;
+    };
+    const collection = el('span', 'dlg-static');
+    collection.id = 'delete-collection';
+    row('Collection', collection, 'The collection this copy belongs to, and its directory');
+    const fileWrap = el('div', 'dlg-static');
+    const file = el('div', 'dlg-target-name');
+    file.id = 'delete-file';
+    const filePath = el('span', 'dlg-hint');
+    filePath.id = 'delete-file-path';
+    // Beside the full path, the same copy button the viewer's Location
+    // row has: the message below can tell the user to delete the file by
+    // hand, and a path they can paste is what that takes.
+    const pathRow = el('div', 'dlg-path-row');
+    pathRow.append(filePath, makeCopyButton({
+        label: 'Copy path to clipboard',
+        text: () => filePath.textContent || undefined,
+    }));
+    fileWrap.append(file, pathRow);
+    row('Script file', fileWrap, 'The file that will be deleted from disk');
+    // No choice to make here: what happens to each dependency file
+    // follows from facts the dialog can state — whether another script
+    // loads it, whether Chrome can still be asked to delete it, and
+    // whether it is still there. So the row is headed lists rather than
+    // a checkbox.
+    const depsWrap = el('div', 'dlg-deps');
+    const groups = DEP_GROUPS.map(() => {
+        const wrap = el('div', 'dlg-dep-group');
+        const heading = el('div', 'dlg-hint');
+        const list = el('ul', 'dlg-deps-list');
+        wrap.append(heading, list);
+        depsWrap.appendChild(wrap);
+        return { wrap, heading, list };
+    });
+    const depsRow = row('Dependencies', depsWrap, 'Local @require and @resource files this script loads from the collection’s directory.');
+    dialog.appendChild(body);
+    const errorRow = el('div', 'dlg-error-row');
+    const error = el('p', 'dlg-error');
+    error.setAttribute('role', 'alert');
+    errorRow.appendChild(error);
+    dialog.appendChild(errorRow);
+    const actions = el('div', 'dlg-actions');
+    const cancel = el('button', undefined, 'Cancel');
+    cancel.type = 'button';
+    const ok = el('button', 'primary danger', 'Delete');
+    ok.type = 'button';
+    ok.id = 'delete-confirm-btn';
+    actions.append(cancel, ok);
+    dialog.appendChild(actions);
+    document.body.appendChild(dialog);
+    return { dialog, collection, file, filePath, depsRow, depsWrap, groups, error, cancel, ok };
+}
+// Open the dialog and resolve with what was deleted, or null when it
+// was dismissed or nothing was deleted.
+export function openDeleteDialog(request) {
+    if (!elements)
+        elements = buildDialog();
+    const ui = elements;
+    if (dialogInFlight)
+        return Promise.resolve(null);
+    dialogInFlight = true;
+    return new Promise((resolve) => {
+        try {
+            runDialog(ui, request, (result) => {
+                dialogInFlight = false;
+                resolve(result);
+            });
+        }
+        catch (err) {
+            dialogInFlight = false;
+            resolve(null);
+            dlog(`[SourceMonkey] delete dialog failed to open: ${describeError(err)}`);
+        }
+    });
+}
+function runDialog(ui, request, resolve) {
+    const { script } = request;
+    let settled = false;
+    // A deletion is in flight. Esc is refused for its duration: closing
+    // would resolve the caller `null` while files are still going, so the
+    // step that removes the script's record would never run.
+    let submitting = false;
+    // The plan, what Chrome can still be asked to delete, and what is
+    // still on disk, once the open-time reads land. Until then there is nothing to confirm, so
+    // the Delete button stays off.
+    let plan = null;
+    let report = null;
+    // The watch for files going away while the dialog is up (`watchDisk`).
+    let watch = null;
+    let probing = false;
+    const finish = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        stopWatching();
+        if (ui.dialog.open)
+            ui.dialog.close();
+        resolve(result);
+    };
+    // The dialog can be telling the user to delete files by hand — the
+    // script file when its record is gone, dependencies under the third
+    // heading — and it has copy buttons for exactly that. So it watches
+    // for them doing it: a file that goes drops out of the lists, and a
+    // script file that goes turns the blocking message into the offer
+    // to remove the entry, without closing and reopening the dialog.
+    //
+    // Every file in the plan is probed each tick (one directory listing
+    // per folder, `missingFiles`), for the whole time the dialog is up. Not
+    // just the ones the user was told to delete: a file with a record
+    // can be deleted by hand too, and Chrome's `exists` flag is only as
+    // fresh as its last check — attempting it would fail after the
+    // fact, where moving it to the last list is right. And not just the
+    // ones still there: a file put back (an undo in the file manager)
+    // moves out of that list again.
+    //
+    // The user most likely deletes in another window and comes back, so
+    // the window regaining focus probes at once rather than making them
+    // wait out the tick. `focus` on `window` fires when the page's
+    // window is switched back to, and `visibilitychange` when its tab
+    // is; either counts.
+    const probe = () => {
+        if (settled || submitting || !plan || probing)
+            return;
+        const current = plan;
+        probing = true;
+        void goneFiles(planPaths(current), current.fileAccess).then((gone) => {
+            probing = false;
+            if (settled || plan !== current || sameSet(gone, current.gone))
+                return;
+            plan = { ...current, gone };
+            // A failed attempt's report described the files as they were;
+            // the line goes back to saying what Delete would do now.
+            report = null;
+            paintDependencies(ui, plan);
+            sync();
+        });
+    };
+    const onReturn = () => {
+        if (document.visibilityState === 'visible')
+            probe();
+    };
+    const stopWatching = () => {
+        if (watch !== null)
+            clearInterval(watch);
+        watch = null;
+        window.removeEventListener('focus', onReturn);
+        document.removeEventListener('visibilitychange', onReturn);
+    };
+    const watchDisk = () => {
+        if (settled)
+            return;
+        watch = setInterval(probe, DISK_POLL_MS);
+        window.addEventListener('focus', onReturn);
+        document.addEventListener('visibilitychange', onReturn);
+    };
+    // ----- The state that is known before any read -----
+    ui.collection.textContent = '…';
+    ui.file.textContent = script.relativePath;
+    ui.filePath.textContent = '';
+    paintDependencies(ui, null);
+    const sync = () => {
+        // The script file's own record is the one thing that blocks: with
+        // no way to delete it there is nothing to confirm, and its message
+        // outranks the warning line. Unless the file has already gone —
+        // then Delete is what clears the entry, and the line says so.
+        const view = plan && planView(plan);
+        const blocked = view !== null && view.scriptFile === 'untracked';
+        ui.error.textContent = report
+            ?? (blocked
+                // Its dependencies were going with it, and are staying too.
+                ? noDownloadRecord(SCRIPT_FILE, view.deleting.length + view.untracked.length > 0, 
+                // The watch can only see the file go with file access on.
+                plan.fileAccess)
+                : deleteWarning(view));
+        ui.error.classList.toggle('warn', !report && !blocked);
+        ui.ok.disabled = plan === null || blocked || submitting;
+    };
+    // Replaced on every open, so stale closures can't fire.
+    ui.cancel.onclick = () => finish(null);
+    ui.dialog.onclose = () => finish(null);
+    ui.dialog.oncancel = (event) => {
+        if (submitting)
+            event.preventDefault();
+    };
+    ui.ok.onclick = () => void submit();
+    const submit = async () => {
+        if (!plan)
+            return;
+        const view = planView(plan);
+        submitting = true;
+        report = null;
+        sync();
+        ui.cancel.disabled = true;
+        const spinner = el('span', 'busy-spinner');
+        ui.ok.after(spinner);
+        try {
+            const result = await deleteCopyFiles({
+                script: view.scriptFile === 'gone'
+                    ? null
+                    : { path: plan.path, relativePath: plan.relativePath },
+                // Only the files that are this script's alone AND that Chrome
+                // can still be asked about. The rest are on screen under the
+                // heading that says why they are staying.
+                dependencies: view.deleting,
+            });
+            if (result.scriptError) {
+                report = result.scriptError;
+            }
+            else {
+                finish({
+                    scriptId: script.id,
+                    collectionId: script.collectionId,
+                    dependencyErrors: result.dependencyErrors,
+                });
+                return;
+            }
+        }
+        catch (err) {
+            report = describeError(err);
+        }
+        finally {
+            submitting = false;
+            spinner.remove();
+            ui.cancel.disabled = false;
+            sync();
+        }
+    };
+    sync();
+    ui.dialog.showModal();
+    ui.cancel.focus();
+    // ----- The open-time reads, after the dialog is on screen -----
+    void openPlan(script).then((opened) => {
+        if (settled)
+            return;
+        plan = opened.plan;
+        ui.collection.replaceChildren(el('span', 'dlg-target-name', opened.collectionName), el('span', 'dlg-hint', ` (${opened.copiesDir})`));
+        ui.file.textContent = opened.plan.relativePath;
+        ui.filePath.textContent = opened.plan.path;
+        paintDependencies(ui, plan);
+        sync();
+        watchDisk();
+    }, (err) => {
+        if (settled)
+            return;
+        report = describeError(err);
+        sync();
+    });
+}
+function planView(plan) {
+    const onDisk = (d) => !plan.gone.has(d.path);
+    const own = plan.own.filter(onDisk);
+    return {
+        scriptFile: plan.gone.has(plan.path)
+            ? 'gone'
+            : plan.tracked.has(plan.path) ? 'tracked' : 'untracked',
+        deleting: own.filter((d) => plan.tracked.has(d.path)),
+        untracked: own.filter((d) => !plan.tracked.has(d.path)),
+        shared: plan.shared.filter(onDisk),
+        gone: [...plan.own, ...plan.shared].filter((d) => !onDisk(d)),
+    };
+}
+// Every file the plan mentions — the script's, and each dependency
+// under any heading.
+function planPaths(plan) {
+    return [plan.path, ...plan.own.map((d) => d.path), ...plan.shared.map((d) => d.path)];
+}
+// Everything the dialog needs, read once the dialog is up.
+async function openPlan(script) {
+    const setting = await readDownloadsCopiesSetting();
+    if (!setting)
+        throw new Error(NOT_A_LOCAL_COPY);
+    const copiesDir = downloadsCopiesDir(setting.downloadsDir);
+    const prior = await getCollectionWithScriptMeta(script.collectionId);
+    // The STORED row, not the snapshot the button closed over: a button
+    // painted once outlives any number of refreshes, so its copy of the
+    // row can name `@require`s the script no longer has — and can still
+    // say `ok` for a file that has since gone.
+    const row = prior?.scripts.find((s) => s.id === script.id) ?? null;
+    // Re-checked here, not trusted from the button: the row could have
+    // moved or gone missing since it was painted, and everything below
+    // assumes the collection at the copies directory is the whole set of
+    // scripts that could be reading these files.
+    if (!prior || !row || !deletableCopyPath(row, prior.collection, setting)) {
+        throw new Error(NOT_A_LOCAL_COPY);
+    }
+    const plan = copyDeletePlan(row, prior.scripts, copiesDir);
+    // The shared files are deliberately NOT asked about: they are never
+    // deleted, so whether Chrome could remove them changes nothing, and
+    // a shared file that is also untracked belongs under the heading
+    // that says another script needs it — the reason it is staying.
+    const fileAccess = await isFileSchemeAccessAllowed();
+    const [tracked, gone] = await Promise.all([
+        trackedFiles([plan.path, ...plan.own.map((d) => d.path)]),
+        goneFiles(planPaths(plan), fileAccess),
+    ]);
+    return {
+        plan: { ...plan, tracked, gone, fileAccess },
+        copiesDir,
+        collectionName: effectiveDisplayName(prior.collection),
+    };
+}
+// Which of `paths` are no longer on disk. Probed rather than trusted
+// from the rows' status — a row says `ok` until the collection's next
+// refresh, and this dialog is opened before that happens, typically
+// right after the user deleted a file by hand because it said to. The
+// probe is one directory listing per folder involved, so polling is
+// cheap; it never reports a file gone unless its folder listed and
+// the name wasn't there (`missingFiles`).
+//
+// With file access off, nothing is ever reported gone (see
+// `DeletePlan.gone`). `missingFiles` already answers that way — the
+// listing fails — but the guard keeps the promise the dialog's
+// wording makes explicit rather than incidental.
+async function goneFiles(paths, fileAccess) {
+    if (!fileAccess)
+        return new Set();
+    return missingFiles(paths);
+}
+function sameSet(a, b) {
+    return a.size === b.size && [...a].every((x) => b.has(x));
+}
+// How often the dialog re-probes its files (`watchDisk` in `runDialog`).
+const DISK_POLL_MS = 1000;
+const NOT_A_LOCAL_COPY = 'This script is not in the Downloads copies directory, so SourceMonkey cannot delete its file';
+// The line in the error slot when nothing has gone wrong: what Delete
+// is about to do. It is a warning, not an error — the user asked for
+// it — but it is the last thing they read before the files go.
+function deleteWarning(plan) {
+    if (!plan)
+        return '';
+    if (plan.scriptFile === 'gone') {
+        // The file went by hand; the entry is what is left. Any dependency
+        // files still going are on disk and listed above, so they are
+        // said once more here — this is the last thing read before they go.
+        const deps = plan.deleting.length;
+        const alsoFiles = deps > 0
+            ? ` and ${deps} ${deps === 1 ? 'dependency file' : 'dependency files'} from disk`
+            : '';
+        return `Script file has already been deleted.\nDelete will remove this script from SourceMonkey${alsoFiles}.`;
+    }
+    const count = 1 + plan.deleting.length;
+    // Once the dialog is showing lists of files, the line says how many
+    // of them are going, even when the answer is just the script. "This
+    // file" beside a list of files it isn't taking would read as though
+    // it meant all of them.
+    const listing = plan.deleting.length + plan.shared.length + plan.untracked.length > 0;
+    const files = listing
+        ? `${count} ${count === 1 ? 'file' : 'files'}`
+        : 'this file';
+    return `Delete will remove ${files} from disk.\nThis cannot be undone.`;
+}
+// The lists under Dependencies, in the order the user reads them:
+// what is going, the two reasons a file is staying, then what has
+// already gone. Each heading states a fact about the files under it,
+// so there is nothing to decide — which is why this row has no
+// control.
+const DEP_GROUPS = [
+    'Files used by this script only',
+    'Not deleting files also used by other scripts',
+    'Not deleting files no longer in Chrome download history',
+    'Files already deleted',
+];
+// Paint the row from the plan, `null` while it is still being read —
+// the row says nothing rather than guessing.
+function paintDependencies(ui, plan) {
+    const view = plan && planView(plan);
+    const lists = [view?.deleting ?? [], view?.shared ?? [], view?.untracked ?? [], view?.gone ?? []];
+    // Hidden while the plan is being read, so the row appears once with
+    // its real contents rather than flicking through an empty state.
+    ui.depsRow.hidden = plan === null || lists.every((files) => files.length === 0);
+    ui.depsWrap.hidden = ui.depsRow.hidden;
+    ui.groups.forEach((group, i) => {
+        group.wrap.hidden = lists[i].length === 0;
+        group.heading.textContent = DEP_GROUPS[i];
+        group.list.replaceChildren(...lists[i].map((d) => depRow(d)));
+    });
+}
+// One file in any of the lists: its path relative to the copies
+// directory, with the URL it stands in for as the tooltip, and a copy
+// button for its full path — a file under "no longer in Chrome
+// download history" is one the user has to delete by hand.
+function depRow(dep) {
+    const name = el('span', undefined, dep.relativePath);
+    name.title = dep.url;
+    const li = el('li', 'dlg-path-row');
+    li.append(name, makeCopyButton({
+        label: 'Copy path to clipboard',
+        text: () => dep.path,
+    }));
+    return li;
+}

package/dist/extension/delete-icon.js

@@ -0,0 +1,40 @@
+// The two trash cans.
+//
+// SourceMonkey has two removal actions that look alike and aren't:
+//
+// - `record` — drop SourceMonkey's row for a script. The bytes it came
+//   from are untouched (they may not even be reachable any more).
+// - `file`   — delete the script FILE from disk, which only a local
+//   copy in the copies directory qualifies for. This is the one
+//   action that destroys something SourceMonkey didn't create.
+//
+// Both used to render the same trash-can emoji and differ only in
+// `title`, so the difference was invisible until you hovered. They now
+// share a trash-can silhouette — same family, same action shape — and the
+// file variant carries a small disk badge in its lower-right corner
+// plus a red resting colour, so the destructive one is marked twice:
+// by shape and by colour, since colour alone isn't a cue everyone gets.
+//
+// The glyphs live as `<symbol>`s in the shared sprite
+// (src/glyph-sprite.svg, inlined into each page by the build) rather
+// than being written out per button, so a hundred rows share one copy
+// of the path data. Every call site goes through `setDeleteIcon` so
+// the pair can't drift apart again.
+import { renderGlyph } from './glyph.js';
+const SYMBOL_ID = {
+    record: '#sm-trash',
+    file: '#sm-trash-file',
+};
+// Replace the button's contents with the glyph for `kind`, and mark
+// the file-deleting variant with `.deletes-file` so the stylesheet can
+// give it its own resting colour. Callers keep owning `title` /
+// `aria-label`: the icon narrows what the tooltip has to explain, it
+// doesn't replace it.
+export function setDeleteIcon(btn, kind) {
+    btn.textContent = '';
+    btn.classList.add('icon-btn');
+    // Its own glyph class so the cans can be found and styled as a pair,
+    // but the same `.icon-btn` box as every other glyph button.
+    btn.appendChild(renderGlyph(btn.ownerDocument, SYMBOL_ID[kind], 'delete-icon'));
+    btn.classList.toggle('deletes-file', kind === 'file');
+}

package/dist/extension/details-tooltips.js

@@ -0,0 +1,66 @@
+// Tooltip text for the details panel's row labels.
+//
+// Why the rows carry tooltips at all: the panel is a curated set, not a
+// dump of the metadata block, so several rows report something the
+// label alone can't convey — what we checked but deliberately didn't
+// act on (`Version at update URL`), what a value is NOT (`Homepage` is
+// an unverified claim), or where a name shows up outside this page
+// (`Log ID`). The tooltip's job is to correct the likely misreading,
+// not to restate the label.
+//
+// Wording rules, matching the rest of the UI:
+//   - Capitalized, and no trailing period on a ONE-sentence tooltip.
+//   - A two-sentence tooltip ends BOTH sentences with a period and puts
+//     a newline between them, so the second reads as a separate remark
+//     rather than a run-on. `title` renders `\n` as a line break.
+//
+// Kept in one table rather than beside each `appendRow` call so the
+// whole set can be read — and copy-edited — as a unit.
+// Row labels whose text is fixed. `Version` is absent on purpose: it
+// depends on which mode is rendering (see `rowTooltip`), because a
+// preview has nothing installed to describe.
+const FIXED = {
+    Name: "The script's @name",
+    Description: "The script's @description",
+    'Version at update URL': "The version published at the script's @updateURL",
+    'Version at download URL': "The version published at the script's @downloadURL",
+    Collection: 'The collection this script was added from.\n'
+        + 'Click through to manage it on the Collections page.',
+    Location: 'Where this script file lives, and where a refresh re-reads it from',
+    Homepage: "The script's @homepage",
+    'Log ID': 'How SourceMonkey labels this script in the Chrome console and in stack traces.\n'
+        + 'The #E number distinguishes it from other scripts with the same filename.',
+    Match: "Pages the script runs on, from its @match rules",
+    Include: "Pages the script runs on, from its @include rules",
+    Exclude: "Pages the script is blocked from, from its @exclude rules",
+    // Spell out the "as you" part: the grant is closer to "may act as
+    // you there" than to "may fetch a URL".
+    'Network access': 'Other sites the script may contact.\n'
+        + 'Warning: The requests carry your cookies, so the script can act as you on these sites.',
+    'Local overrides': '@require / @resource files being read from your disk '
+        + 'instead of the URL the script declares',
+    Size: 'Size of the script, plus any libraries or resources it loads',
+    Status: 'Status from loading and executing this script.\n'
+        + 'Click to open the Log.',
+};
+// The `Version` row describes different things in the two modes: an
+// installed script has a copy that is actually running, a preview is
+// just a file making a claim. One string for both would have to be
+// vague enough to be true of a file on disk, which throws away the more
+// useful reading on the page people spend their time on.
+const VERSION_INSTALLED = 'The @version of the script that is installed and running';
+const VERSION_PREVIEW = "The script's @version";
+// The hosting-site row's label is the site's own name — `Greasy Fork
+// page`, `OpenUserJS page`, `GitHub Gist page` — so it can't be a key.
+// Matched on the shape those labels share; `Homepage` is a separate
+// entry above and doesn't end in ` page`.
+const SITE_PAGE_SUFFIX = ' page';
+const SITE_PAGE_TOOLTIP = "The hosting site's page where this script is published";
+export function rowTooltip(label, mode) {
+    if (label === 'Version') {
+        return mode === 'preview' ? VERSION_PREVIEW : VERSION_INSTALLED;
+    }
+    if (label.endsWith(SITE_PAGE_SUFFIX))
+        return SITE_PAGE_TOOLTIP;
+    return FIXED[label];
+}