@wscsports/blaze-rtn-sdk/lib/module/classes/entry-point-delegate.js

WSC Sports Blaze SDK component for React Native

import { RegisterGlobalEvents } from './RegisterGlobalEvents';
import { CommonParser } from './common-parser';
export class BlazeEntryPointDelegateHelper {
  static registerEntryPointDelegate(entryPointDelegate) {
    BlazeEntryPointDelegateHelper.onDataLoadStarted(entryPointDelegate?.onDataLoadStarted);
    BlazeEntryPointDelegateHelper.onDataLoadComplete(entryPointDelegate?.onDataLoadComplete);
    BlazeEntryPointDelegateHelper.onPlayerDidAppear(entryPointDelegate?.onPlayerDidAppear);
    BlazeEntryPointDelegateHelper.onPlayerDidDismiss(entryPointDelegate?.onPlayerDidDismiss);
    BlazeEntryPointDelegateHelper.onTriggerCTA(entryPointDelegate?.onTriggerCTA);
    BlazeEntryPointDelegateHelper.onTriggerPlayerBodyTextLink(entryPointDelegate?.onTriggerPlayerBodyTextLink);
    BlazeEntryPointDelegateHelper.onPlayerEventTriggered(entryPointDelegate?.onPlayerEventTriggered);
  }
  static onDataLoadStarted(callback) {
    const eventName = 'Blaze.onDataLoadStarted';
    if (callback) {
      RegisterGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const playerType = BlazeEntryPointDelegateHelper.extractPlayerType(data);
          const sourceId = data['sourceId'];
          callback({
            playerType,
            sourceId
          });
        } catch (e) {
          console.error('onDataLoadStarted', e);
        }
      });
    } else {
      RegisterGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static onDataLoadComplete(callback) {
    const eventName = 'Blaze.onDataLoadComplete';
    if (callback) {
      RegisterGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const playerType = BlazeEntryPointDelegateHelper.extractPlayerType(data);
          const sourceId = data['sourceId'];
          const itemsCount = data['itemsCount'];
          const error = data['error'];
          callback({
            playerType,
            sourceId,
            itemsCount,
            error
          });
        } catch (e) {
          console.error('onDataLoadComplete', e);
        }
      });
    } else {
      RegisterGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static onPlayerDidAppear(callback) {
    const eventName = 'Blaze.onPlayerDidAppear';
    if (callback) {
      RegisterGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const playerType = BlazeEntryPointDelegateHelper.extractPlayerType(data);
          const sourceId = data['sourceId'];
          callback({
            playerType,
            sourceId
          });
        } catch (e) {
          console.error('onPlayerDidAppear', e);
        }
      });
    } else {
      RegisterGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static onPlayerDidDismiss(callback) {
    const eventName = 'Blaze.onPlayerDidDismiss';
    if (callback) {
      RegisterGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const playerType = BlazeEntryPointDelegateHelper.extractPlayerType(data);
          const sourceId = data['sourceId'];
          callback({
            playerType,
            sourceId
          });
        } catch (e) {
          console.error('onPlayerDidDismiss', e);
        }
      });
    } else {
      RegisterGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static onTriggerCTA(callback) {
    const eventName = 'Blaze.onTriggerCTA';
    if (callback) {
      RegisterGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const playerType = BlazeEntryPointDelegateHelper.extractPlayerType(data);
          const sourceId = data['sourceId'];
          const actionType = BlazeEntryPointDelegateHelper.extractCTAActionType(data);
          const actionParam = data['actionParam'];
          callback({
            playerType,
            sourceId,
            actionType,
            actionParam
          });
        } catch (e) {
          console.error('onTriggerCTA', e);
        }
      });
    } else {
      RegisterGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static onTriggerPlayerBodyTextLink(callback) {
    const eventName = 'Blaze.onTriggerPlayerBodyTextLink';
    if (callback) {
      RegisterGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const playerType = BlazeEntryPointDelegateHelper.extractPlayerType(data);
          const sourceId = data['sourceId'];
          const actionParam = data['actionParam'];
          callback({
            playerType,
            sourceId,
            actionParam
          });
        } catch (e) {
          console.error('onTriggerPlayerBodyTextLink', e);
        }
      });
    } else {
      RegisterGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static onPlayerEventTriggered(callback) {
    const eventName = 'Blaze.onPlayerEventTriggered';
    if (callback) {
      RegisterGlobalEvents.createEventSubscription(eventName, data => {
        try {
          const playerType = BlazeEntryPointDelegateHelper.extractPlayerType(data);
          const sourceId = data['sourceId'];
          const playerEventType = data['playerEventType'];
          const playerEventParams = data['playerEventParams'];
          const result = CommonParser.extractPlayerEvent(playerEventType, playerEventParams);
          if (result != null) {
            callback({
              playerType: playerType,
              sourceId: sourceId,
              event: result
            });
          }
        } catch (e) {
          console.error('onPlayerEventTriggered', e);
        }
      });
    } else {
      RegisterGlobalEvents.cancelEventSubscription(eventName);
    }
  }
  static extractPlayerType(data) {
    return data['playerType'];
  }
  static extractCTAActionType(data) {
    return data['actionType'];
  }
}
//# sourceMappingURL=entry-point-delegate.js.map