mousedown()

in packages/ketcher-react/src/script/editor/tool/sgroup.ts [169:268]
88 lines of code
29 McCabe index (conditional complexity)

  mousedown(event) {
    const ci = this.editor.findItem(event, searchMaps);
    const struct = this.editor.render.ctab;
    const sgroups = struct.sgroups;
    const molecule = struct.molecule;
    const functionalGroups = molecule.functionalGroups;
    const atomResult: Array<number> = [];
    const bondResult: Array<number> = [];
    const result: Array<number> = [];

    if (ci && functionalGroups.size && ci.map === 'atoms') {
      const atomId = FunctionalGroup.atomsInFunctionalGroup(
        functionalGroups,
        ci.id,
      );
      const atomFromStruct = atomId !== null && struct.atoms.get(atomId)?.a;

      if (
        atomFromStruct &&
        !(
          FunctionalGroup.isAtomInContractedFunctionalGroup(
            atomFromStruct,
            sgroups,
            functionalGroups,
            true,
          ) || SGroup.isAtomInContractedSGroup(atomFromStruct, sgroups)
        )
      ) {
        atomResult.push(atomId);
      }
    }

    if (ci && functionalGroups.size && ci.map === 'bonds') {
      const bondId = FunctionalGroup.bondsInFunctionalGroup(
        molecule,
        functionalGroups,
        ci.id,
      );
      const bondFromStruct = bondId !== null && struct.bonds.get(bondId)?.b;

      if (
        bondFromStruct &&
        !(
          FunctionalGroup.isBondInContractedFunctionalGroup(
            bondFromStruct,
            sgroups,
            functionalGroups,
          ) || SGroup.isBondInContractedSGroup(bondFromStruct, sgroups)
        )
      ) {
        bondResult.push(bondId);
      }
    }

    if (ci && functionalGroups.size && ci.map === 'functionalGroups') {
      const sgroup = sgroups.get(ci.id);

      if (FunctionalGroup.isFunctionalGroup(sgroup?.item)) {
        this.editor.event.removeFG.dispatch({ fgIds: [ci.id] });
        return;
      }
    }

    if (atomResult.length > 0) {
      for (const id of atomResult) {
        const fgId = FunctionalGroup.findFunctionalGroupByAtom(
          functionalGroups,
          id,
        );

        if (fgId !== null && !result.includes(fgId)) {
          result.push(fgId);
        }
      }
      if (result.length > 0) {
        this.editor.event.removeFG.dispatch({ fgIds: result });
        return;
      }
    } else if (bondResult.length > 0) {
      for (const id of bondResult) {
        const fgId = FunctionalGroup.findFunctionalGroupByBond(
          molecule,
          functionalGroups,
          id,
        );

        if (fgId !== null && !result.includes(fgId)) {
          result.push(fgId);
        }
      }

      this.editor.event.removeFG.dispatch({ fgIds: result });
      return;
    }

    if (!ci) {
      //  ci.type == 'Canvas'
      this.lassoHelper.begin(event);
    }
  }