dblclick()

in packages/ketcher-react/src/script/editor/tool/select/select.ts [421:545]

• 119 lines of code
• 32 McCabe index (conditional complexity)

  dblclick(event) {
    const editor = this.editor;
    const struct = editor.render.ctab;
    const { molecule, sgroups } = struct;
    const functionalGroups = molecule.functionalGroups;
    const ci = editor.findItem(
      event,
      ['atoms', 'bonds', 'sgroups', 'functionalGroups', 'sgroupData', 'texts'],
      null,
    );

    const atomResult: any[] = [];
    const bondResult: any[] = [];
    const result: any[] = [];
    if (ci && functionalGroups && ci.map === 'atoms') {
      const atomId = FunctionalGroup.atomsInFunctionalGroup(
        functionalGroups,
        ci.id,
      );
      const atomFromStruct = atomId !== null && struct.atoms.get(atomId)?.a;
      if (
        atomFromStruct &&
        !FunctionalGroup.isAtomInContractedFunctionalGroup(
          // TODO: examine if this code is really needed, seems like its a hack
          atomFromStruct,
          sgroups,
          functionalGroups,
          true,
        )
      )
        atomResult.push(atomId);
    }
    if (ci && functionalGroups && ci.map === 'bonds') {
      const bondId = FunctionalGroup.bondsInFunctionalGroup(
        molecule,
        functionalGroups,
        ci.id,
      );
      const bondFromStruct = bondId !== null && struct.bonds.get(bondId)?.b;
      if (
        bondFromStruct &&
        !FunctionalGroup.isBondInContractedFunctionalGroup(
          // TODO: examine if this code is really needed, seems like its a hack
          bondFromStruct,
          sgroups,
          functionalGroups,
        )
      )
        bondResult.push(bondId);
    }
    if (atomResult.length > 0) {
      for (const id of atomResult) {
        const fgId = FunctionalGroup.findFunctionalGroupByAtom(
          functionalGroups,
          id,
        );
        if (fgId !== null && !result.includes(fgId)) {
          result.push(fgId);
        }
      }
      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) return;

    const selection = this.editor.selection();

    if (ci.map === 'atoms') {
      const atoms = getSelectedAtoms(selection, molecule);
      const changeAtomPromise = editor.event.elementEdit.dispatch(atoms);
      updateSelectedAtoms({
        atoms: selection?.atoms || [],
        editor,
        changeAtomPromise,
      });
    } else if (ci.map === 'bonds') {
      const bonds = getSelectedBonds(selection, molecule);
      const changeBondPromise = editor.event.bondEdit.dispatch(bonds);
      updateSelectedBonds({
        bonds: selection?.bonds || [],
        changeBondPromise,
        editor,
      });
    } else if (
      (ci.map === 'sgroups' &&
        !FunctionalGroup.isFunctionalGroup(molecule.sgroups.get(ci.id))) ||
      ci.map === 'sgroupData'
    ) {
      editor.selection(closestToSel(ci));
      SGroupTool.sgroupDialog(editor, ci.id);
    } else if (ci.map === 'texts') {
      editor.selection(closestToSel(ci));
      const text = molecule.texts.get(ci.id);
      const dialog = editor.event.elementEdit.dispatch({
        ...text,
        type: 'text',
      });

      dialog
        .then(({ content }) => {
          if (!content) {
            editor.update(fromTextDeletion(struct, ci.id));
          } else if (content !== text?.content) {
            editor.update(fromTextUpdating(struct, ci.id, content));
          }
        })
        .catch((e) => {
          KetcherLogger.error('select.ts::SelectTool::dblclick', e);
        });
    }
    return true;
  }