@adecore/editor-react 0.22.1 → 0.23.1

package/dist/workspace-edit.js

@@ -1,185 +1,324 @@
-import { applyTextEdits, fileUriToPath } from '@adecore/lsp';
+import { fileUriToPath, planWorkspaceOperations } from '@adecore/lsp';
 import { messageOf } from './error-message.js';
 function refused(failureReason) {
     return { applied: false, failureReason };
 }
-/* The steps of an edit; null when it deletes a file, which an edit is not applied with. */
-function stepsOf(edit) {
-    const steps = [];
-    for (const change of edit.documentChanges ?? []) {
-        if ('textDocument' in change) {
-            steps.push({ kind: 'edits', uri: change.textDocument.uri, edits: change.edits });
-        }
-        else if (change.kind === 'create') {
-            steps.push({ kind: 'create', file: change });
-        }
-        else if (change.kind === 'rename') {
-            steps.push({ kind: 'rename', oldUri: change.oldUri, newUri: change.newUri });
-        }
-        else {
-            return null;
-        }
-    }
+/* The text edits of an edit per document, as the entries a document has in it, whatever else the edit does. */
+export function textEntriesOf(edit) {
+    const entries = new Map();
+    const add = (uri, edits) => {
+        entries.set(uri, [...(entries.get(uri) ?? []), edits]);
+    };
     if (edit.documentChanges === undefined) {
         for (const [uri, edits] of Object.entries(edit.changes ?? {})) {
-            steps.push({ kind: 'edits', uri, edits });
+            add(uri, edits);
         }
+        return entries;
     }
-    return steps;
-}
-/* The text edits of an edit per document, as the entries a document has in it; null when it deletes a file. */
-export function entriesOf(edit) {
-    const steps = stepsOf(edit);
-    if (steps === null) {
-        return null;
-    }
-    const entries = new Map();
-    for (const step of steps) {
-        if (step.kind === 'edits') {
-            entries.set(step.uri, [...(entries.get(step.uri) ?? []), step.edits]);
+    for (const change of edit.documentChanges) {
+        if ('textDocument' in change) {
+            add(change.textDocument.uri, change.edits);
         }
     }
     return entries;
 }
+/* The text edits of an edit per document, as the entries a document has in it; null when it deletes a file. */
+export function entriesOf(edit) {
+    return (edit.documentChanges ?? []).some((change) => 'kind' in change && change.kind === 'delete') ? null : textEntriesOf(edit);
+}
 /* The files an edit moves, which a preview of lines cannot show. */
 export function renamesOf(edit) {
     return (edit.documentChanges ?? []).filter((change) => 'kind' in change && change.kind === 'rename');
 }
+/* Every file an edit makes, moves or deletes, in the order it says. */
+export function resourceOperationsOf(edit) {
+    const operations = [];
+    for (const change of edit.documentChanges ?? []) {
+        if ('textDocument' in change) {
+            continue;
+        }
+        operations.push(change.kind === 'rename' ? { kind: 'rename', uri: change.oldUri, newUri: change.newUri } : { kind: change.kind, uri: change.uri });
+    }
+    return operations;
+}
 function contentChangeOf(edit) {
     return { range: edit.range, text: edit.newText };
 }
-/*
- * Applies an LSP workspace edit step by step, after checking it against every text so one that does not fit
- * changes nothing. A file an editor holds takes its edits as one undo step; any other file gets an unsaved
- * draft, since nothing is written to disk on a server's word alone, unless the edit also moves a file: then it
- * is one change, saved and moved through the machine. A file the edit creates is made through the machine.
- */
-export async function applyWorkspaceEdit(edit, host) {
-    const steps = stepsOf(edit);
-    if (steps === null) {
-        return refused('Deleting files is not supported yet');
-    }
-    const planned = await plan(steps, host);
-    if (typeof planned === 'string') {
-        return refused(planned);
-    }
-    const moving = planned.some((item) => item.kind === 'rename');
-    const staged = [];
-    for (const item of planned) {
-        if (item.kind === 'rename' || item.kind === 'create') {
-            const reason = item.kind === 'rename' ? await host.files.rename(item.oldPath, item.newPath) : await host.files.create(item.path, item.text);
-            if (reason !== null) {
-                return refused(reason);
+/* The resource operations a project has a way to carry out; pass it as the session's `resourceOperations` so servers only ask for what can be done. */
+export function supportedResourceOperations(files) {
+    const operations = [];
+    if (files?.create !== undefined) {
+        operations.push('create');
+    }
+    if (files?.rename !== undefined) {
+        operations.push('rename');
+    }
+    if (files?.delete !== undefined) {
+        operations.push('delete');
+    }
+    return operations;
+}
+function within(uri, folder) {
+    return uri.startsWith(`${folder}/`);
+}
+/* Where a deleted URI stood before the renames that ran ahead of it, and what was moved into it: the places unsaved work can be. */
+function placesOf(uri, renames) {
+    const found = new Set([uri]);
+    for (let i = renames.length - 1; i >= 0; i--) {
+        const { oldUri, newUri } = renames[i];
+        for (const place of [...found]) {
+            if (place === newUri || within(place, newUri)) {
+                found.add(oldUri + place.slice(newUri.length));
             }
-            continue;
-        }
-        if (item.after === item.before) {
-            continue;
-        }
-        const editor = host.editorOf(item.uri);
-        if (editor) {
-            // The edits stay apart, so the caret and what is drawn over the text stay where they were between them.
-            if (!editor.applyEdits(item.edits.map(contentChangeOf))) {
-                return refused(`${item.uri} is read only`);
+            else if (within(newUri, place)) {
+                found.add(oldUri);
             }
-            continue;
-        }
-        const path = fileUriToPath(item.uri);
-        if (path === null || item.disk === null) {
-            continue;
-        }
-        const file = { path, disk: item.disk, text: item.after };
-        if (!moving) {
-            staged.push(file);
-            continue;
-        }
-        const reason = await host.files.save([file]);
-        if (reason !== null) {
-            return refused(reason);
         }
     }
-    if (staged.length > 0) {
-        host.files?.stage(staged);
+    return [...found];
+}
+/* Whether deleting or replacing loses work nobody saved at any of the places. Without `isUnsaved` that is an editor on, or under, a place. A `recursive` one may be a folder. */
+function losesWork(recursive, places, host) {
+    const files = host.files;
+    if (files.isUnsaved !== undefined) {
+        return places.some((place) => {
+            const path = fileUriToPath(place);
+            return path !== null && files.isUnsaved(path);
+        });
     }
-    return { applied: true };
+    if (host.openUris === undefined && recursive) {
+        return true;
+    }
+    const open = host.openUris?.() ?? [];
+    return places.some((place) => host.editorOf(place) !== undefined || open.some((uri) => uri === place || within(uri, place)));
 }
-/* Reads every text the edit needs and works out what each step leaves, or says why it does not fit. */
-async function plan(steps, host) {
-    const texts = new Map();
-    // A file that has moved is read where it still stands: nothing moves until the plan is made.
-    const origins = new Map();
-    // A file that is made is written once, with what every step leaves in it.
-    const creates = new Map();
-    const planned = [];
+function readOnlyAt(host, uri, editor) {
+    return host.isReadOnly?.(uri) ?? editor?.isReadOnly?.() ?? false;
+}
+/* Why a create or move over a file that is there is refused; null when the host can replace it without losing work. */
+function overwriteProblem(step, target, places, host, reads) {
+    const path = fileUriToPath(target);
+    if (host.files?.supportsOverwrite !== true) {
+        return `${path} already exists`;
+    }
+    // A target no text was read from may be a folder, with unsaved work anywhere under it.
+    const isText = step.kind === 'create' || reads.open.has(target) || reads.disks.has(target);
+    if (losesWork(!isText, places, host)) {
+        return `${path} has changes that are not saved`;
+    }
+    const editor = host.editorOf(target);
+    return editor !== undefined && step.kind === 'create' && readOnlyAt(host, target, editor) ? `${path} is read only` : null;
+}
+/* Checks a plan against what only the host can see: paths, overwrites, unsaved work and the editors it touches. Null when it fits. */
+function problemWith(steps, host, reads) {
+    const renames = [];
     for (const step of steps) {
-        if (step.kind === 'create') {
-            const made = await planCreate(step.file, host, texts);
-            if (typeof made === 'string') {
-                return made;
-            }
-            if (made !== null) {
-                creates.set(step.file.uri, made);
-                planned.push(made);
+        if (step.kind === 'edits') {
+            if (step.open && readOnlyAt(host, step.readUri, host.editorOf(step.readUri))) {
+                return `${step.uri} is read only`;
             }
             continue;
         }
-        if (step.kind === 'rename') {
-            const oldPath = fileUriToPath(step.oldUri);
-            const newPath = fileUriToPath(step.newUri);
-            if (oldPath === null || newPath === null || host.files === null) {
-                return `${step.oldUri} cannot be moved from here`;
-            }
-            origins.set(step.newUri, origins.get(step.oldUri) ?? step.oldUri);
-            planned.push({ kind: 'rename', oldPath, newPath });
-            continue;
+        const uris = step.kind === 'rename' ? [step.oldUri, step.newUri] : [step.uri];
+        const paths = uris.map((uri) => fileUriToPath(uri));
+        if (paths.includes(null)) {
+            return `${uris[0]} cannot be changed from here`;
         }
-        const source = origins.get(step.uri) ?? step.uri;
-        const created = creates.get(source);
-        if (created !== undefined) {
-            try {
-                created.text = applyTextEdits(created.text, step.edits);
-            }
-            catch (error) {
-                return messageOf(error);
+        if ((step.kind === 'create' || step.kind === 'rename') && step.overwrite) {
+            const target = step.kind === 'create' ? step.uri : step.newUri;
+            const refusal = overwriteProblem(step, target, placesOf(target, renames), host, reads);
+            if (refusal !== null) {
+                return refusal;
             }
-            continue;
         }
-        if (!texts.has(source)) {
-            const editor = host.editorOf(source);
-            if (editor) {
-                texts.set(source, { text: editor.getText(), disk: null });
-            }
-            else {
-                const path = fileUriToPath(source);
-                const disk = path === null || host.files === null ? null : await host.files.read(path);
+        if (step.kind === 'rename') {
+            renames.push({ kind: 'rename', oldUri: step.oldUri, newUri: step.newUri });
+        }
+        if (step.kind === 'delete' && losesWork(step.recursive, placesOf(step.uri, renames), host)) {
+            return `${paths[0]} has changes that are not saved`;
+        }
+    }
+    for (const [uri, planned] of reads.open) {
+        const editor = host.editorOf(uri);
+        if (editor === undefined || editor.getText() !== planned.text) {
+            return `${uri} changed while the edit was being prepared`;
+        }
+        const version = host.versionOf?.(uri) ?? null;
+        if (planned.version !== null && version !== planned.version) {
+            return `${uri} changed while the edit was being prepared`;
+        }
+    }
+    for (const uri of reads.disks.keys()) {
+        if (host.editorOf(uri) !== undefined) {
+            return `${uri} was opened while the edit was being prepared`;
+        }
+    }
+    return null;
+}
+/*
+ * Applies an LSP workspace edit step by step, after planning it against every text (`planWorkspaceOperations`)
+ * so one that does not fit changes nothing. What the host supports follows `host.files`: moves need `rename`,
+ * makes need `create` and deletes need `delete`. Just before the first step runs, every open editor must still
+ * hold the text and version the plan was made from, and a delete must not lose unsaved work. Each text step
+ * and each delete checks that again right before it runs, since the steps before it are awaited.
+ *
+ * A file an editor holds takes its edits as one undo step per step of the edit; any other file gets an unsaved
+ * draft, since nothing is written to disk on a server's word alone, unless the edit also moves files: then it
+ * is one change, saved and moved through the machine. A create or a move over a file that is there is refused,
+ * unless it says `overwrite` and `files.supportsOverwrite` is set. Then it is refused only when the target, or
+ * anything under a folder target, has unsaved work, checked again right before the step runs. `overwrite` wins
+ * over `ignoreIfExists`, as the protocol says. A created file that an editor still holds shows its new text.
+ * The steps run in order and a step that no longer fits stops the edit there, with the steps before it applied
+ * and nothing rolled back. A folder that only exists because an earlier move in the same edit made it is
+ * looked for where it was and refused.
+ */
+export async function applyWorkspaceEdit(edit, host) {
+    const reads = { open: new Map(), disks: new Map() };
+    const files = host.files;
+    let steps;
+    try {
+        ({ steps } = await planWorkspaceOperations(edit, {
+            operations: supportedResourceOperations(files),
+            read: async (uri) => {
+                const editor = host.editorOf(uri);
+                if (editor !== undefined) {
+                    const text = editor.getText();
+                    const version = host.versionOf?.(uri) ?? null;
+                    reads.open.set(uri, { text, version });
+                    return { text, version, open: true };
+                }
+                const path = fileUriToPath(uri);
+                const disk = path === null || files === null ? null : await files.read(path);
                 if (disk === null) {
-                    return `${source} cannot be read as text`;
+                    return null;
                 }
-                texts.set(source, { text: disk.text, disk });
-            }
+                reads.disks.set(uri, disk);
+                return { text: disk.text, version: null, open: false };
+            },
+            ...(files?.exists === undefined
+                ? {}
+                : {
+                    exists: async (uri) => {
+                        const path = fileUriToPath(uri);
+                        return path !== null && (await files.exists(path));
+                    }
+                }),
+            ...(files?.isFolder === undefined
+                ? {}
+                : {
+                    isFolder: async (uri) => {
+                        const path = fileUriToPath(uri);
+                        return path === null || (await files.isFolder(path));
+                    }
+                })
+        }));
+    }
+    catch (error) {
+        return refused(messageOf(error));
+    }
+    const problem = problemWith(steps, host, reads);
+    if (problem !== null) {
+        return refused(problem);
+    }
+    const running = { ahead: [], reads, saving: steps.some((step) => step.kind === 'rename'), staged: [], touched: new Set() };
+    for (const [index, step] of steps.entries()) {
+        running.ahead = steps.slice(index + 1);
+        const reason = await run(step, host, running);
+        if (reason !== null) {
+            return refused(reason);
         }
-        const held = texts.get(source);
-        let after;
-        try {
-            after = applyTextEdits(held.text, step.edits);
+    }
+    if (running.staged.length > 0) {
+        files?.stage(running.staged);
+    }
+    return { applied: true };
+}
+/* Why a text step no longer fits its editor, now that the steps before it ran; null when it does. */
+function driftOf(step, host, uri, editor, touched) {
+    if (editor.getText() !== step.before) {
+        return `${step.uri} changed while the edit was being applied`;
+    }
+    const version = uri === step.readUri && !touched.has(editor) ? host.versionOf?.(uri) : undefined;
+    if (version !== undefined && step.version !== null && version !== step.version) {
+        return `${step.uri} changed while the edit was being applied`;
+    }
+    return readOnlyAt(host, uri, editor) ? `${step.uri} is read only` : null;
+}
+/* Does one step; the reason it could not, or null. */
+async function run(step, host, running) {
+    const files = host.files;
+    if (step.kind === 'create') {
+        return step.overwrite ? overwriteFile(step, host) : files.create(fileUriToPath(step.uri), step.text);
+    }
+    if (step.kind === 'rename') {
+        const [from, to] = [fileUriToPath(step.oldUri), fileUriToPath(step.newUri)];
+        if (!step.overwrite) {
+            return files.rename(from, to);
         }
-        catch (error) {
-            return messageOf(error);
+        // The steps before this one ran, so the unsaved work at the target is looked for once more.
+        return losesWork(!running.reads.disks.has(step.newUri) && !running.reads.open.has(step.newUri), [step.newUri], host)
+            ? `${to} has changes that are not saved`
+            : files.rename(from, to, { overwrite: true });
+    }
+    if (step.kind === 'delete') {
+        const path = fileUriToPath(step.uri);
+        if (losesWork(step.recursive, [step.uri], host)) {
+            return `${path} has changes that are not saved`;
         }
-        planned.push({ kind: 'edits', uri: step.uri, edits: step.edits, before: held.text, after, disk: held.disk });
-        texts.set(source, { text: after, disk: held.disk });
+        return files.delete(path, { recursive: step.recursive });
     }
-    return planned;
+    if (step.after === step.before) {
+        return null;
+    }
+    if (step.open) {
+        const uri = host.editorOf(step.uri) === undefined ? step.readUri : step.uri;
+        return editOpen(step, host, running, uri, host.editorOf(uri));
+    }
+    return runDraft(step, host, running);
+}
+/* Empties a file that is there and gives it its text; the editor that still holds it is set to the same text. */
+async function overwriteFile(step, host) {
+    const path = fileUriToPath(step.uri);
+    if (losesWork(false, [step.uri], host)) {
+        return `${path} has changes that are not saved`;
+    }
+    const reason = await host.files.create(path, step.text, { overwrite: true });
+    if (reason === null) {
+        host.editorOf(step.uri)?.setText(step.text);
+    }
+    return reason;
+}
+function editOpen(step, host, running, uri, editor) {
+    if (editor === undefined) {
+        return `${step.uri} is not open any more`;
+    }
+    const drift = driftOf(step, host, uri, editor, running.touched);
+    if (drift !== null) {
+        return drift;
+    }
+    running.touched.add(editor);
+    // The edits stay apart, so the caret and what is drawn over the text stay where they were between them.
+    return editor.applyEdits(step.edits.map(contentChangeOf)) ? null : `${step.uri} is read only`;
+}
+/* Whether a later step deletes the file or a folder around it, so a draft or a save of it would only bring it back. */
+function deletedAhead(uri, ahead) {
+    return ahead.some((step) => step.kind === 'delete' && (step.uri === uri || within(uri, step.uri.replace(/\/$/, ''))));
 }
-/* A file that is not there yet, or null when it is and the create says to leave it. Making one over a file that is there is not supported. */
-async function planCreate(file, host, texts) {
-    const path = fileUriToPath(file.uri);
-    if (path === null || host.files?.create === undefined) {
-        return `Creating ${file.uri} is not supported here`;
+async function runDraft(step, host, running) {
+    const { reads, saving, staged, ahead } = running;
+    const uri = [step.uri, step.readUri].find((candidate) => host.editorOf(candidate) !== undefined);
+    if (uri !== undefined) {
+        return editOpen(step, host, running, uri, host.editorOf(uri));
     }
-    const there = texts.has(file.uri) || host.editorOf(file.uri) !== undefined || (await host.files.read(path)) !== null;
-    if (!there) {
-        return { kind: 'create', path, text: '' };
+    const path = fileUriToPath(step.uri);
+    const disk = reads.disks.get(step.readUri);
+    if (path === null || disk === undefined || deletedAhead(step.uri, ahead)) {
+        return null;
+    }
+    const file = { path, disk, text: step.after };
+    if (!saving) {
+        staged.push(file);
+        return null;
     }
-    return file.options?.ignoreIfExists === true && file.options.overwrite !== true ? null : `${path} already exists`;
+    return host.files.save([file]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/editor-react",
-  "version": "0.22.1",
+  "version": "0.23.1",
   "type": "module",
   "description": "Language-enabled editors, feature coordination and React popups over injected language services.",
   "license": "FSL-1.1-MIT",
@@ -49,6 +49,11 @@
     "./locales/*.json": {
       "source": "./src/locales/*.json",
       "default": "./dist/locales/*.json"
+    },
+    "./snippet-transform-worker": {
+      "source": "./src/snippet-transform-worker.ts",
+      "types": "./dist/snippet-transform-worker.d.ts",
+      "default": "./dist/snippet-transform-worker.js"
     }
   },
   "scripts": {
@@ -57,9 +62,9 @@
     "test": "bun test --conditions=source"
   },
   "dependencies": {
-    "@adecore/editor": "0.22.1",
-    "@adecore/lsp": "0.22.1",
-    "@adecore/merge": "0.22.1",
+    "@adecore/editor": "0.23.1",
+    "@adecore/lsp": "0.23.1",
+    "@adecore/merge": "0.23.1",
     "lucide-react": "^1.47.0",
     "react-markdown": "^10.1.0",
     "remark-breaks": "^4.0.0",
@@ -67,7 +72,7 @@
     "zustand": "^5.0.15"
   },
   "peerDependencies": {
-    "@adecore/ui": "^0.22.1",
+    "@adecore/ui": "^0.23.1",
     "i18next": "^26.4.2",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",