@statiolake/coc-explorer 0.1.0 → 0.2.0

package/README.md

@@ -9,6 +9,6 @@ single click; right click opens the item's context action menu through
 files intentionally have no type-specific icons.
 
 View actions define both the right-click context menu and NvimTree-style local
-keys: `o`, `<C-x>`, `<C-v>`, `<C-t>`, `a`, `d`, `r`, `R`, `gy`, `.`, `s`, `-`,
-`+`, `<BS>`, and `P`. Coc's native `<CR>`, `<Tab>`, `f`, `t`, and `M` TreeView
-bindings remain available.
+keys: `o`, `<C-x>`, `<C-v>`, `<C-t>`, `a`, `x` (cut), `y` (copy), `p` (paste),
+`d` (delete), `r`, `R`, `gy`, `.`, `s`, `-`, `+`, `<BS>`, and `P`. Coc's native
+`<CR>`, `<Tab>`, `f`, `t`, and `M` TreeView bindings remain available.

package/lib/index.js

@@ -212,6 +212,18 @@ var Explorer = class {
         "coc-explorer.delete",
         (node) => this.delete(node)
       ),
+      import_coc.commands.registerCommand(
+        "coc-explorer.cut",
+        (node) => this.stage(node, "cut")
+      ),
+      import_coc.commands.registerCommand(
+        "coc-explorer.copy",
+        (node) => this.stage(node, "copy")
+      ),
+      import_coc.commands.registerCommand(
+        "coc-explorer.paste",
+        (node) => this.paste(node)
+      ),
       import_coc.commands.registerCommand(
         "coc-explorer.copyPath",
         (node) => this.copyPath(node)
@@ -222,6 +234,7 @@ var Explorer = class {
   }
   provider = new ExplorerProvider();
   tree;
+  clipboard;
   refreshTimer;
   async show() {
     await this.ui.showContainer("explorer");
@@ -314,6 +327,7 @@ var Explorer = class {
     const target = import_node_path.default.isAbsolute(name) ? name : import_node_path.default.join(import_node_path.default.dirname(node.path), name);
     if (target === node.path) return;
     await import_node_fs.promises.rename(node.path, target);
+    this.clearClipboardWithin(node.path);
     this.provider.refresh(node.parent);
   }
   async delete(node) {
@@ -324,8 +338,71 @@ var Explorer = class {
     );
     if (answer !== "Delete") return;
     await import_node_fs.promises.rm(node.path, { recursive: node.directory });
+    this.clearClipboardWithin(node.path);
     this.provider.refresh(node.parent);
   }
+  stage(node, operation) {
+    if (!node) return;
+    this.clipboard = {
+      operation,
+      source: node.path,
+      directory: node.directory
+    };
+    import_coc.window.showInformationMessage(
+      `${operation === "copy" ? "Copied" : "Cut"} ${node.path}`
+    );
+  }
+  async paste(node) {
+    if (!node) return;
+    const entry = this.clipboard;
+    if (!entry) {
+      import_coc.window.showWarningMessage("Explorer clipboard is empty");
+      return;
+    }
+    const destination = node.directory ? node.path : import_node_path.default.dirname(node.path);
+    const target = import_node_path.default.join(destination, import_node_path.default.basename(entry.source));
+    if (target === entry.source) {
+      import_coc.window.showWarningMessage("Source and destination are the same");
+      return;
+    }
+    if (entry.directory && isWithin(target, entry.source)) {
+      import_coc.window.showWarningMessage("Cannot paste a directory inside itself");
+      return;
+    }
+    try {
+      await import_node_fs.promises.lstat(entry.source);
+    } catch {
+      this.clipboard = void 0;
+      import_coc.window.showWarningMessage(`Source no longer exists: ${entry.source}`);
+      return;
+    }
+    const replace = await pathExists(target);
+    if (replace) {
+      const answer = await import_coc.window.showWarningMessage(
+        `Replace ${target}?`,
+        "Replace"
+      );
+      if (answer !== "Replace") return;
+    }
+    await writeReplacing(target, replace, async () => {
+      if (entry.operation === "copy") {
+        await import_node_fs.promises.cp(entry.source, target, {
+          recursive: entry.directory,
+          errorOnExist: true,
+          force: false
+        });
+      } else {
+        await move(entry.source, target, entry.directory);
+      }
+    });
+    if (entry.operation === "cut") this.clipboard = void 0;
+    this.provider.refresh();
+  }
+  clearClipboardWithin(parent) {
+    if (this.clipboard && isWithin(this.clipboard.source, parent)) {
+      this.clipboard = void 0;
+    }
+  }
   async copyPath(node) {
     if (!node) return;
     await import_coc.workspace.nvim.call("setreg", ["+", node.path]);
@@ -423,6 +500,24 @@ var Explorer = class {
         keys: ["r"],
         handler: (node) => this.rename(node)
       },
+      {
+        id: "coc-explorer.cut",
+        title: "Cut",
+        keys: ["x"],
+        handler: (node) => this.stage(node, "cut")
+      },
+      {
+        id: "coc-explorer.copy",
+        title: "Copy",
+        keys: ["y"],
+        handler: (node) => this.stage(node, "copy")
+      },
+      {
+        id: "coc-explorer.paste",
+        title: "Paste",
+        keys: ["p"],
+        handler: (node) => this.paste(node)
+      },
       {
         id: "coc-explorer.delete",
         title: "Delete",
@@ -466,6 +561,50 @@ var Explorer = class {
 function fnameescape(filename) {
   return filename.replace(/([\\\s|"'])/g, "\\$1");
 }
+function isWithin(filename, parent) {
+  const relative = import_node_path.default.relative(parent, filename);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${import_node_path.default.sep}`) && !import_node_path.default.isAbsolute(relative);
+}
+async function pathExists(filename) {
+  try {
+    await import_node_fs.promises.lstat(filename);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeReplacing(target, replace, write) {
+  if (!replace) {
+    await write();
+    return;
+  }
+  const backup = import_node_path.default.join(
+    import_node_path.default.dirname(target),
+    `.coc-explorer-${import_node_path.default.basename(target)}-${process.pid}-${Date.now()}`
+  );
+  await import_node_fs.promises.rename(target, backup);
+  try {
+    await write();
+  } catch (error) {
+    await import_node_fs.promises.rm(target, { recursive: true, force: true });
+    await import_node_fs.promises.rename(backup, target);
+    throw error;
+  }
+  await import_node_fs.promises.rm(backup, { recursive: true, force: true });
+}
+async function move(source, target, directory) {
+  try {
+    await import_node_fs.promises.rename(source, target);
+  } catch (error) {
+    if (error.code !== "EXDEV") throw error;
+    await import_node_fs.promises.cp(source, target, {
+      recursive: directory,
+      errorOnExist: true,
+      force: false
+    });
+    await import_node_fs.promises.rm(source, { recursive: directory });
+  }
+}
 async function activate(context) {
   const extension = import_coc.extensions.getExtensionById("@statiolake/coc-ui");
   if (!extension?.exports) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statiolake/coc-explorer",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A lean filesystem explorer for coc.nvim view containers",
   "author": "statiolake",
   "license": "MIT",
@@ -85,6 +85,18 @@
         "command": "coc-explorer.delete",
         "title": "Delete Explorer Item"
       },
+      {
+        "command": "coc-explorer.cut",
+        "title": "Cut Explorer Item"
+      },
+      {
+        "command": "coc-explorer.copy",
+        "title": "Copy Explorer Item"
+      },
+      {
+        "command": "coc-explorer.paste",
+        "title": "Paste Explorer Item"
+      },
       {
         "command": "coc-explorer.copyPath",
         "title": "Copy Explorer Item Path"