@aller/blink/src/senderMiddleware.ts

A library for tracking user behaviour.

import prepareAdEvent, {
  getAllAdEventsPrepared,
} from './events/prepare-ad-event';
import prepareActiveTimeEvent, {
  getAllActiveTimeEventsPrepared,
} from './events/prepare-active-time-event';
import preparePageloadEvent from './events/prepare-pageload-event';
import prepareClickEvent from './events/prepare-click-event';
import prepareCustomEvent from './events/prepare-custom-event';
import prepareBoxEvent from './events/prepare-box-event';
import prepareImpressionEvent from './events/prepare-impression-event';
import prepareConsentEvent from './events/prepare-consent-event';

import {
  AD_SCREEN_EXIT,
  AD_SCREEN_EXIT_0,
  ARTICLE_ACTIVITY_STOP,
  ARTICLE_PREVIEW_SCREEN_ENTER,
  BOX_SCREEN_ENTER,
  CLICK,
  CONSENT_V2,
  CUSTOM,
  DFP_IMPRESSION_VIEWABLE,
  DFP_SLOT_ON_LOAD,
  DFP_SLOT_RENDER_ENDED,
  PAGE_INIT,
  PAGE_LOAD,
  PERFORMANCE,
  PLAYER_HIDDEN,
  SEND_ALL_EVENTS,
  VIDEO_AD,
  VIDEO_LOAD,
  VIDEO_PLAY,
  VIDEO_STOP,
  WEB_VITALS,
} from './actions';

import { BlinkEvent } from './types';
import prepareVideoLoadForSending from './events/prepare-video-load-event';
import prepareVideoWatchForSending, {
  getAllVideoWatchEventsPrepared,
} from './events/prepare-video-watch-event';
import prepareVideoAdForSending from './events/prepare-video-ad-event';
import preparePerformanceEvent from './events/prepare-performance-event';
import prepareCwvEvent from './events/prepare-cwv-event';
import getPageState from './selectors/get-page-state';
import { getUniqueVideoIdsForPlayer } from './utils/player';
import prepareVideoPlayForSending from './events/prepare-video-play-event';

export default function senderMiddleware(
  send: (events: BlinkEvent[]) => any,
  sendDirect: (events: BlinkEvent[]) => any,
) {
  return ({ getState }: { getState: any }) =>
    (next: any) =>
    (action: any) => {
      // Send all events if we get a pageInit event
      // Make sure we do it before the PAGE_INIT flushes the state
      if (action.type === PAGE_INIT) {
        const { payload } = action;
        const beforePage = getPageState(getState(), payload.pageId).state;
        const eventsToSend = [
          ...getAllAdEventsPrepared(beforePage, payload.time),
          ...getAllActiveTimeEventsPrepared(beforePage, payload.time),
        ];
        if (eventsToSend.length > 0) {
          send(eventsToSend);
        }
      }

      // Execute the action, which might mutate the state
      const returnValue = next(action);
      const state: any = getState();
      const page = getPageState(state, action.payload.pageId);
      switch (action.type) {
        case DFP_IMPRESSION_VIEWABLE:
        case DFP_SLOT_RENDER_ENDED:
        case DFP_SLOT_ON_LOAD:
          send([
            prepareAdEvent({
              page,
              id: action.payload.id,
            }),
          ]);
          break;
        case CLICK:
          sendDirect([
            prepareClickEvent({
              page,
              url: action.payload.url,
              abId: action.payload.abId,
              clickId: action.payload.clickId,
              externalId: action.payload.id,
              context: action.payload.context,
            }),
          ]);
          break;
        case VIDEO_PLAY:
          send([
            prepareVideoPlayForSending({
              page,
              ...action.payload,
            }),
          ]);
          break;
        case VIDEO_LOAD:
          send([
            prepareVideoLoadForSending({
              page,
              ...action.payload,
            }),
          ]);
          break;
        case VIDEO_STOP:
          let _send = send;
          if (action && action.payload && action.payload.beforeunload) {
            _send = sendDirect;
          }

          _send(
            prepareVideoWatchForSending({
              page,
              ...action.payload,
            }),
          );
          break;
        case PLAYER_HIDDEN:
          const videoIds = getUniqueVideoIdsForPlayer(
            page.state.video.events,
            action.payload.playerId,
          );
          // "Brodcast" player hidden event to all videos with the playerId
          videoIds.forEach(videoId => {
            send(
              prepareVideoWatchForSending({
                page: page,
                videoId,
                ...action.payload,
              }),
            );
          });
          break;
        case VIDEO_AD:
          send([
            prepareVideoAdForSending({
              page,
              ...action.payload,
            }),
          ]);
          break;
        case CUSTOM:
          send([
            prepareCustomEvent({
              page,
              customDomain: action.payload.customDomain,
              customType: action.payload.customType,
              customContent: action.payload.customContent,
              customValue: action.payload.customValue,
              time: action.payload.time,
            }),
          ]);
          break;
        case PAGE_LOAD:
          send([
            preparePageloadEvent({
              page,
              url: action.payload.url,
            }),
          ]);
          break;
        case PERFORMANCE:
          send([
            preparePerformanceEvent({
              page,
              performanceTimings: action.payload.performanceTimings,
            }),
          ]);
          break;
        case WEB_VITALS:
          send([
            prepareCwvEvent({
              page,
              webVitals: action.payload.webVitals,
            }),
          ]);
          break;
        case ARTICLE_PREVIEW_SCREEN_ENTER:
          send([
            prepareImpressionEvent({
              page,
              id: action.payload.id,
              abId: action.payload.abId,
              context: action.payload.context,
              url: action.payload.url,
              title: action.payload.title,
              personalizationSystemUsed:
                action.payload.personalizationSystemUsed,
              personalizationParametersRequested:
                action.payload.personalizationParametersRequested,
              height: action.payload.height,
              width: action.payload.width,
            }),
          ]);
          break;
        case BOX_SCREEN_ENTER:
          send([
            prepareBoxEvent({
              page,
              id: action.payload.id,
              title: action.payload.title,
              height: action.payload.height,
              width: action.payload.width,
            }),
          ]);
          break;
        case AD_SCREEN_EXIT:
        case AD_SCREEN_EXIT_0:
          send([
            prepareAdEvent({
              page,
              id: action.payload.id,
            }),
          ]);
          break;
        case ARTICLE_ACTIVITY_STOP:
          send([
            prepareActiveTimeEvent({
              page,
              id: action.payload.id,
            }),
          ]);
          break;
        case SEND_ALL_EVENTS:
          {
            const { payload } = action;
            const eventsToSend = [
              ...getAllAdEventsPrepared(page, payload.time),
              ...getAllActiveTimeEventsPrepared(page, payload.time),
              ...getAllVideoWatchEventsPrepared(page, payload.time),
            ];
            if (eventsToSend.length > 0) {
              sendDirect(eventsToSend);
            }
          }
          break;
        case CONSENT_V2:
          send([
            prepareConsentEvent({
              page,
              uuid: action.payload.uuid,
              tcfV2: action.payload.tcfV2,
              kind: action.payload.kind,
              consentGranted: action.payload.consentGranted,
              consentedToAll: action.payload.consentedToAll,
              applies: action.payload.applies,
            }),
          ]);
          break;
        default:
          break;
      }
      return returnValue;
    };
}