_handleDeckGLEvent()

in modules/main/src/lib/nebula.ts [158:262]
85 lines of code
35 McCabe index (conditional complexity)

  _handleDeckGLEvent(event: Record<string, any>) {
    const {
      deckgl,
      props: { onMapMouseEvent, selectionType, eventFilter },
    } = this;
    let sendMapEvent = true;
    let cursor = 'auto';

    if (event && deckgl && selectionType) {
      if (!this._deckDrawer) this._deckDrawer = new DeckDrawer(this);

      const lngLat = this.getMouseGroundPosition(event);
      if (eventFilter && !eventFilter(lngLat, event)) return;
      const drawerResult = this._deckDrawer.handleEvent(event, lngLat, selectionType);
      if (drawerResult.redraw) this.forceUpdate();
      return;
    }

    if (event && deckgl && (!event.buttons || event.type !== 'mousemove')) {
      // TODO: sort by mouse priority
      const layerIds = deckgl.props.layers
        .filter(
          (l: any) => l && l.props && l.props.nebulaLayer && l.props.nebulaLayer.enablePicking
        )
        .map((l: any) => l.id);

      const pickingInfo = deckgl.pickObject({
        x: event.offsetX,
        y: event.offsetY,
        radius: 5,
        layerIds,
      });
      this.queryObjectEvents.emit('pick', { event, pickingInfo });
      if (pickingInfo) {
        sendMapEvent = false;

        const { index, lngLat } = pickingInfo;
        if (eventFilter && !eventFilter(lngLat, event)) return;

        const { layer: deckLayer, object } = pickingInfo;

        if (
          deckLayer &&
          deckLayer.props &&
          deckLayer.props.nebulaLayer &&
          deckLayer.props.nebulaLayer.eventHandler
        ) {
          deckLayer.props.nebulaLayer.eventHandler(event, pickingInfo);
        }

        const original =
          object.original ||
          (deckLayer.props.nebulaLayer &&
            deckLayer.props.nebulaLayer.deckCache &&
            deckLayer.props.nebulaLayer.deckCache.originals[index]);

        if (original) {
          this.deckglMouseOverInfo = { originalLayer: deckLayer.props.nebulaLayer, index };
          // @ts-expect-error narrow event type
          const nebulaMouseEvent = new LayerMouseEvent(event, {
            data: original,
            metadata: object.metadata,
            groundPoint: lngLat,
            nebula: this,
          });
          deckLayer.props.nebulaLayer.emit(event.type, nebulaMouseEvent);
          this.forceUpdate();
        }

        cursor = 'pointer';
      }
    }

    if (document.documentElement) {
      document.documentElement.style.cursor = cursor;
    }

    if (sendMapEvent) {
      this.deckglMouseOverInfo = null;

      const lngLat = this.getMouseGroundPosition(event);
      if (eventFilter && !eventFilter(lngLat, event)) return;

      // send to layers first
      // @ts-expect-error narrow event type
      const nebulaMouseEvent = new LayerMouseEvent(event, {
        groundPoint: lngLat,
        nebula: this,
      });
      this.getAllLayers()
        .filter((layer) => layer && layer.usesMapEvents)
        .forEach((layer) => layer.emit('mapMouseEvent', nebulaMouseEvent));

      this.getAllLayers()
        .filter(
          (layer) =>
            layer && layer.props && layer.props.nebulaLayer && layer.props.nebulaLayer.mapMouseEvent
        )
        .forEach((layer) => layer.props.nebulaLayer.mapMouseEvent(nebulaMouseEvent, layer));

      if (onMapMouseEvent) {
        onMapMouseEvent(event, lngLat);
      }
    }
  }