get keyboardEventHandlers()

in packages/ketcher-core/src/application/editor/modes/SequenceMode.ts [745:927]
167 lines of code
19 McCabe index (conditional complexity)

  get keyboardEventHandlers() {
    const deleteNode = (direction: Direction) => {
      const editor = CoreEditor.provideEditorInstance();
      const nodeToDelete =
        direction === Direction.Left
          ? SequenceRenderer.previousNode
          : SequenceRenderer.getNodeByPointer(SequenceRenderer.caretPosition);
      const caretPosition =
        direction === Direction.Left
          ? (SequenceRenderer.previousCaretPosition as number)
          : SequenceRenderer.caretPosition;
      const selections = SequenceRenderer.selections;
      const modelChanges = new Command();
      let nodesToDelete: NodesSelection;

      if (selections.length) {
        modelChanges.merge(this.deleteSelectedDrawingEntities());
        nodesToDelete = selections;
      } else if (nodeToDelete) {
        nodeToDelete.monomers.forEach((monomer) => {
          modelChanges.merge(
            editor.drawingEntitiesManager.deleteMonomer(monomer),
          );
        });
        nodesToDelete = [
          [
            {
              node: nodeToDelete,
              nodeIndexOverall: caretPosition,
            },
          ],
        ];
      } else {
        return;
      }

      modelChanges.merge(this.handleNodesDeletion(nodesToDelete));

      this.finishNodesDeletion(
        modelChanges,
        nodesToDelete[0][0].nodeIndexOverall,
        nodesToDelete[0][0].nodeIndexOverall,
      );

      if (
        SequenceRenderer.caretPosition === 0 &&
        SequenceRenderer.chainsCollection.chains.length === 0
      ) {
        this.startNewSequence();
      }
    };

    return {
      delete: {
        shortcut: ['Delete'],
        handler: () => deleteNode(Direction.Right),
      },
      backspace: {
        shortcut: ['Backspace'],
        handler: () => deleteNode(Direction.Left),
      },
      'turn-off-edit-mode': {
        shortcut: ['Escape'],
        handler: () => {
          this.turnOffEditMode();
        },
      },
      'start-new-sequence': {
        shortcut: ['Enter'],
        handler: () => {
          this.unselectAllEntities();
          this.startNewSequence();
        },
      },
      'move-caret-up': {
        shortcut: ['ArrowUp'],
        handler: () => {
          SequenceRenderer.moveCaretUp();
          this.unselectAllEntities();
        },
      },
      'move-caret-down': {
        shortcut: ['ArrowDown'],
        handler: () => {
          SequenceRenderer.moveCaretDown();
          this.unselectAllEntities();
        },
      },
      'move-caret-forward': {
        shortcut: ['ArrowRight'],
        handler: () => {
          if (!this.isEditMode) {
            return;
          }

          SequenceRenderer.moveCaretForward();
          SequenceRenderer.resetLastUserDefinedCaretPosition();
          this.unselectAllEntities();
        },
      },
      'move-caret-back': {
        shortcut: ['ArrowLeft'],
        handler: () => {
          if (!this.isEditMode) {
            return;
          }

          SequenceRenderer.moveCaretBack();
          SequenceRenderer.resetLastUserDefinedCaretPosition();

          this.unselectAllEntities();
        },
      },
      'add-sequence-item': {
        shortcut: [
          ...naturalAnalogues,
          ...naturalAnalogues.map((naturalAnalogue) =>
            naturalAnalogue.toLowerCase(),
          ),
        ],
        handler: (event) => {
          if (SequenceRenderer.isEmptyCanvas() && !this.isEditMode) {
            this.turnOnEditMode();
            SequenceRenderer.setCaretPosition(0);
          }

          if (!this.isEditMode) {
            return;
          }

          if (!this.deleteSelection()) {
            return;
          }

          const enteredSymbol = event.code.replace('Key', '');
          const editor = CoreEditor.provideEditorInstance();
          const history = new EditorHistory(editor);
          const modelChanges = this.insertNewSequenceItem(
            editor,
            enteredSymbol,
          );

          // Case when user type symbol that does not exist in current sequence type mode
          if (!modelChanges) {
            return;
          }

          modelChanges.addOperation(new ReinitializeModeOperation());
          editor.renderersContainer.update(modelChanges);
          modelChanges.addOperation(SequenceRenderer.moveCaretForward());
          history.update(modelChanges);
        },
      },
      'sequence-edit-select': {
        shortcut: [
          'Shift+ArrowLeft',
          'Shift+ArrowRight',
          'Shift+ArrowUp',
          'Shift+ArrowDown',
        ],
        handler: (event) => {
          const arrowKey = event.key;

          if (
            SequenceRenderer.caretPosition === 0 &&
            arrowKey === 'ArrowLeft'
          ) {
            return;
          }

          this.selectionStartCaretPosition =
            this.selectionStartCaretPosition !== -1
              ? this.selectionStartCaretPosition
              : SequenceRenderer.caretPosition;
          SequenceRenderer.shiftArrowSelectionInEditMode(event);

          if (arrowKey === 'ArrowLeft' || arrowKey === 'ArrowRight') {
            SequenceRenderer.resetLastUserDefinedCaretPosition();
          }
        },
      },
    };
  }