export function fromMultipleMove()

in packages/ketcher-core/src/application/editor/actions/fragment.ts [42:151]
89 lines of code
20 McCabe index (conditional complexity)

export function fromMultipleMove(
  restruct,
  lists,
  d: Vec2,
  shouldPerform = true,
) {
  d = new Vec2(d);

  const action = new Action();
  const struct = restruct.molecule;
  const loops = new Pile();
  const atomsToInvalidate = new Pile();

  if (lists.atoms) {
    const atomSet = new Pile(lists.atoms);
    const bondlist: Array<number> = [];

    restruct.bonds.forEach((bond, bid) => {
      if (atomSet.has(bond.b.begin) && atomSet.has(bond.b.end)) {
        bondlist.push(bid);
        // add all adjacent loops
        // those that are not completely inside the structure will get redrawn anyway
        ['hb1', 'hb2'].forEach((hb) => {
          const loop = struct.halfBonds.get(bond.b[hb]).loop;
          if (loop >= 0) loops.add(loop);
        });
        return;
      }

      if (atomSet.has(bond.b.begin)) {
        atomsToInvalidate.add(bond.b.begin);
        return;
      }

      if (atomSet.has(bond.b.end)) atomsToInvalidate.add(bond.b.end);
    });

    bondlist.forEach((bond) => {
      action.addOp(new BondMove(bond, d));
    });

    loops.forEach((loopId) => {
      if (restruct.reloops.get(loopId) && restruct.reloops.get(loopId).visel) {
        // hack
        action.addOp(new LoopMove(loopId, d));
      }
    });

    lists.atoms.forEach((aid) => {
      action.addOp(new AtomMove(aid, d, !atomsToInvalidate.has(aid)));
    });

    if (lists.sgroupData && lists.sgroupData.length === 0) {
      const sgroups = getRelSGroupsBySelection(struct, lists.atoms);
      sgroups.forEach((sg) => {
        action.addOp(new SGroupDataMove(sg.id, d));
      });
    }
  }

  if (lists.rxnArrows) {
    lists.rxnArrows.forEach((rxnArrow) => {
      action.addOp(new RxnArrowMove(rxnArrow, d, true));
    });
  }

  if (lists.rxnPluses) {
    lists.rxnPluses.forEach((rxnPulse) => {
      action.addOp(new RxnPlusMove(rxnPulse, d, true));
    });
  }

  if (lists.simpleObjects) {
    lists.simpleObjects.forEach((simpleObject) => {
      action.addOp(new SimpleObjectMove(simpleObject, d, true));
    });
  }

  if (lists.sgroupData) {
    lists.sgroupData.forEach((sgData) => {
      action.addOp(new SGroupDataMove(sgData, d));
    });
  }

  if (lists.enhancedFlags) {
    lists.enhancedFlags.forEach((fid) => {
      action.addOp(new EnhancedFlagMove(fid, d));
    });
  }

  if (lists.texts) {
    lists.texts.forEach((text) => {
      action.addOp(new TextMove(text, d, true));
    });
  }

  if (lists[IMAGE_KEY]) {
    lists[IMAGE_KEY].forEach((image) => {
      action.addOp(new ImageMove(image, d));
    });
  }

  if (lists[MULTITAIL_ARROW_KEY]) {
    lists[MULTITAIL_ARROW_KEY].forEach((multitailArrow) => {
      action.addOp(new MultitailArrowMove(multitailArrow, d));
    });
  }

  return shouldPerform ? action.perform(restruct) : action;
}