Use built in action for copy and paste

src/CommandAction.ts

@@ -12,12 +12,19 @@ import { runOnTargetsForEachEditor } from "./targetUtils";
 import { focusEditor } from "./setSelectionsAndFocusEditor";
 import { flatten } from "lodash";
 import { callFunctionAndUpdateSelections } from "./updateSelections";
+import { ensureSingleEditor } from "./targetUtils";
 
 export default class CommandAction implements Action {
   targetPreferences: ActionPreferences[] = [{ insideOutsideType: "inside" }];
+  private ensureSingleEditor: boolean;
 
-  constructor(private graph: Graph, private command: string) {
+  constructor(
+    private graph: Graph,
+    private command: string,
+    { ensureSingleEditor = false } = {}
+  ) {
     this.run = this.run.bind(this);
+    this.ensureSingleEditor = ensureSingleEditor;
   }
 
   private async runCommandAndUpdateSelections(targets: TypedSelection[]) {
@@ -57,14 +64,20 @@ export default class CommandAction implements Action {
     );
   }
 
-  async run([targets]: [
-    TypedSelection[],
-    TypedSelection[]
-  ]): Promise<ActionReturnValue> {
-    await displayPendingEditDecorations(
-      targets,
-      this.graph.editStyles.referenced
-    );
+  async run(
+    [targets]: [TypedSelection[]],
+    { showDecorations = true } = {}
+  ): Promise<ActionReturnValue> {
+    if (showDecorations) {
+      await displayPendingEditDecorations(
+        targets,
+        this.graph.editStyles.referenced
+      );
+    }
+
+    if (this.ensureSingleEditor) {
+      ensureSingleEditor(targets);
+    }
 
     const originalEditor = window.activeTextEditor;
 

src/actions/CutCopyPaste.ts

@@ -0,0 +1,70 @@
+import {
+  Action,
+  ActionPreferences,
+  ActionReturnValue,
+  Graph,
+  TypedSelection,
+} from "../Types";
+import { performInsideOutsideAdjustment } from "../performInsideOutsideAdjustment";
+import CommandAction from "../CommandAction";
+import displayPendingEditDecorations from "../editDisplayUtils";
+import { getOutsideOverflow } from "../targetUtils";
+import { zip } from "lodash";
+
+export class Cut implements Action {
+  targetPreferences: ActionPreferences[] = [{ insideOutsideType: null }];
+
+  constructor(private graph: Graph) {
+    this.run = this.run.bind(this);
+  }
+
+  async run([targets]: [TypedSelection[]]): Promise<ActionReturnValue> {
+    const insideTargets = targets.map((target) =>
+      performInsideOutsideAdjustment(target, "inside")
+    );
+    const outsideTargets = targets.map((target) =>
+      performInsideOutsideAdjustment(target, "outside")
+    );
+    const outsideTargetDecorations = zip(insideTargets, outsideTargets).flatMap(
+      ([inside, outside]) => getOutsideOverflow(inside!, outside!)
+    );
+    const options = { showDecorations: false };
+
+    await Promise.all([
+      displayPendingEditDecorations(
+        insideTargets,
+        this.graph.editStyles.referenced
+      ),
+      displayPendingEditDecorations(
+        outsideTargetDecorations,
+        this.graph.editStyles.pendingDelete
+      ),
+    ]);
+
+    await this.graph.actions.copy.run([insideTargets], options);
+
+    const { thatMark } = await this.graph.actions.delete.run(
+      [outsideTargets],
+      options
+    );
+
+    return {
+      returnValue: null,
+      thatMark,
+    };
+  }
+}
+
+const OPTIONS = { ensureSingleEditor: true };
+
+export class Copy extends CommandAction {
+  constructor(graph: Graph) {
+    super(graph, "editor.action.clipboardCopyAction", OPTIONS);
+  }
+}
+
+export class Paste extends CommandAction {
+  constructor(graph: Graph) {
+    super(graph, "editor.action.clipboardPasteAction", OPTIONS);
+  }
+}

src/actions/delete.ts

@@ -17,11 +17,16 @@ export default class Delete implements Action {
     this.run = this.run.bind(this);
   }
 
-  async run([targets]: [TypedSelection[]]): Promise<ActionReturnValue> {
-    await displayPendingEditDecorations(
-      targets,
-      this.graph.editStyles.pendingDelete,
-    );
+  async run(
+    [targets]: [TypedSelection[]],
+    { showDecorations = true } = {}
+  ): Promise<ActionReturnValue> {
+    if (showDecorations) {
+      await displayPendingEditDecorations(
+        targets,
+        this.graph.editStyles.pendingDelete
+      );
+    }
 
     const thatMark = flatten(
       await runOnTargetsForEachEditor(targets, async (editor, targets) => {

src/actions/index.ts

@@ -1,7 +1,6 @@
 import { ActionRecord, Graph } from "../Types";
 import Clear from "./clear";
-import Copy from "./copy";
-import Cut from "./cut";
+import { Cut, Copy, Paste } from "./CutCopyPaste";
 import Delete from "./delete";
 import ExtractVariable from "./extractVariable";
 import { Fold, Unfold } from "./fold";
@@ -15,7 +14,6 @@ import Wrap from "./wrap";
 import { ScrollToTop, ScrollToCenter, ScrollToBottom } from "./Scroll";
 import { IndentLines, OutdentLines } from "./Indent";
 import { CommentLines } from "./Comment";
-import Paste from "./Paste";
 import { Bring, Move, Swap } from "./BringMoveSwap";
 import {
   InsertEmptyLineAbove,

src/targetUtils.ts

@@ -1,6 +1,7 @@
-import { TextEditor } from "vscode";
+import { TextEditor, Selection, Position } from "vscode";
 import { groupBy } from "./itertools";
 import { TypedSelection } from "./Types";
+import update from "immutability-helper";
 
 export function ensureSingleEditor(targets: TypedSelection[]) {
   if (targets.length === 0) {
@@ -42,3 +43,47 @@ export async function runOnTargetsForEachEditor<T>(
 ): Promise<T[]> {
   return runForEachEditor(targets, (target) => target.selection.editor, func);
 }
+
+/** Get the possible leading and trailing overflow ranges of the outside target compared to the inside target */
+export function getOutsideOverflow(
+  insideTarget: TypedSelection,
+  outsideTarget: TypedSelection
+): TypedSelection[] {
+  const { start: insideStart, end: insideEnd } =
+    insideTarget.selection.selection;
+  const { start: outsideStart, end: outsideEnd } =
+    outsideTarget.selection.selection;
+  const result = [];
+  if (outsideStart.isBefore(insideStart)) {
+    result.push(
+      createTypeSelection(
+        insideTarget.selection.editor,
+        outsideStart,
+        insideStart
+      )
+    );
+  }
+  if (outsideEnd.isAfter(insideEnd)) {
+    result.push(
+      createTypeSelection(insideTarget.selection.editor, insideEnd, outsideEnd)
+    );
+  }
+  return result;
+}
+
+function createTypeSelection(
+  editor: TextEditor,
+  start: Position,
+  end: Position
+): TypedSelection {
+  return {
+    selection: {
+      editor,
+      selection: new Selection(start, end),
+    },
+    selectionType: "token",
+    selectionContext: {},
+    insideOutsideType: "inside",
+    position: "contents",
+  };
+}