Method run

src/actions/CopyLines.ts:67–125

([targets]: [TypedSelection[]])

  }

  async run([targets]: [TypedSelection[]]): Promise<ActionReturnValue> {
    const results = flatten(
      await runOnTargetsForEachEditor(targets, async (editor, targets) => {
        const ranges = this.getRanges(editor, targets);
        const editWrappers = this.getEdits(editor, ranges);
        const rangeSelections = ranges.map(
          ({ range }) => new Selection(range.start, range.end)
        );

        const [editorSelections, copySelections] =
          await performEditsAndUpdateSelections(
            this.graph.rangeUpdater,
            editor,
            editWrappers.map((wrapper) => wrapper.edit),
            [editor.selections, rangeSelections]
          );

        editor.selections = editorSelections;
        editor.revealRange(copySelections[0]);

        let sourceSelections;
        if (this.isUp) {
          sourceSelections = editWrappers.map((wrapper) => {
            const startIndex =
              editor.document.offsetAt(wrapper.edit.range.start) +
              wrapper.offset;
            const endIndex = startIndex + wrapper.length;
            return new Selection(
              editor.document.positionAt(startIndex),
              editor.document.positionAt(endIndex)
            );
          });
        } else {
          sourceSelections = rangeSelections;
        }

        return {
          sourceMark: sourceSelections.map((selection) => ({
            editor,
            selection,
          })),
          thatMark: copySelections.map((selection) => ({
            editor,
            selection,
          })),
        };
      })
    );

    await displayPendingEditDecorationsForSelection(
      results.flatMap((result) => result.thatMark),
      this.graph.editStyles.justAdded.token
    );

    const sourceMark = results.flatMap((result) => result.sourceMark);
    const thatMark = results.flatMap((result) => result.thatMark);

    return { sourceMark, thatMark };