BlazeSDK class

document.addEventListener("onBlazeSDKConnect", onBlazeSDKConnect);

if (!BlazeSDK.isInitialized()) {
    BlazeSDK.Initialize('<API-KEY>',{
     geoLocation: 'IL', // Country code by two letters
     externalUserId: 'user-123',
     doNotTrack: false,
     runInShadowDom: true, // default value is true
     shouldModifyUrlWithContentId: true, // default value is true
     playerStyleCustomization: { // only for Stories, not supported to Moments
       iconsPosition: 'VERTICAL'
     },
     prefetchingPolicy: 'default',
     shouldAllowHorizontalStories: false, // by default false
     layoutDirection: "LTR", // by default LTR
     followedEntities: ['player-123', 'team-123', 'property-123'],
		 disableAnalytics: false,
		 disableUserActivity: false
   })
}

const myTheme: IWidgetTheme = BlazeSDK.Theme('row-rectangle');

const myDataSource = BlazeSDK.DataSourceBuilder().labels({
   labels: 'live-stories',
   orderType: 'RecentlyUpdatedFirst',
   maxItems: 10,
	 advancedOrdering: 'LiveFirst',

})

const options: IWidgetViewOptions = {
   dataSource: myDataSource, // Use a data source instead of labels
   maxDisplayItemsCount: 1, // Display only 1 item
   theme: myTheme // Set the theme of the widget,
   shouldOrderWidgetByReadStatus: true // the default value is true   
   perItemStyleOverrides: {
        "playerId": [
            {
                name: "35450",
                theme: rowCircleThemePlayer
            },
            {
                name: "28237",
                theme: rowCircleThemePlayer
            },
            {
                name: "46046",
                theme: rowCircleThemePlayer
            }
        ],
        "teamId": [
            {
                name: "real-madrid",
                theme: rowCircleThemeRealMadrid
            }
        ]
    },
    actionHandlers: [
        {
          actionId: 'addCustomActionButton',
          options: {
            buttonName: 'go-to-fans-page',
            onClick: (e, entities) => {
              console.log(entities?.gameId, entities?.playerId, entities?.teamId);
            },
          },
        },
        {
          actionId: 'addCustomActionButton',
          options: {
            buttonName: 'go-to-social-page',
            onClick: (e, entities) => {
              console.log(entities?.gameId, entities?.playerId, entities?.teamId);
            },
          },
        },
	{
          actionId: 'addFollowButton',
          options: {
            onClick: (e, data) => {
              console.log(data.sourceId,
                          data.sourceContentType,
                          data.newFollowingState,
                          data.followEntity.entityType,
 			  data.followEntity.entityId);
            },
          },
        },
     ],
};

const widgetView: IWidgetView = BlazeSDK.WidgetRowView('<DOM-CONTAINER-ID>', options);

//widgetView has an interface, which allows you to interact with the widget in the DOM 
//widgetView.reload()

const theme = BlazeSDK.Theme('row-rectangle','story');

const theme: IWidgetTheme = BlazeSDK.Theme('row-rectangle');

BlazeSDK.setDoNotTrack(true);

BlazeSDK.setDisableAnalytics(true);

BlazeSDK.setDisableUserActivity(true);

BlazeSDK.clearLocalUserActivity();

BlazeSDK.setExternalUserId('1234');

BlazeSDK.setGeoLocation('IL')

BlazeSDK.setGeoLocation('IL')

BlazeSDK.setOnItemClick((context) => {
  console.log('Clicked:', context.item.title, context.contentThumbnailUrl);
  return { shouldPreventOpen: false };
});

// Remove the callback
BlazeSDK.setOnItemClick(undefined);

const dataSource = BlazeSDK.DataSourceBuilder().labels({
  labels: BlazeSDK.LabelBuilder().atLeastOneOf('top-stories', 'live-stories'),
  maxItems: 4,
})
const playerStyle = BlazeSDK.Theme('default').playerStyle;
theme.playerStyle.iconsButton.filter(icon => icon.value === 'CUSTOM_ACTION_BUTTON_ONE')[0].isVisible = true;
theme.playerStyle.iconsButton.filter(icon => icon.value === 'CUSTOM_ACTION_BUTTON_TWO')[0].isVisible = true;

actionHandlers: [
        {
          actionId: 'addCustomActionButton',
          options: {
            buttonName: 'go-to-fans-page',
            onClick: (e, entities) => {
              console.log(entities?.gameId, entities?.playerId, entities?.teamId);
            },
          },
        },
        {
          actionId: 'addCustomActionButton',
          options: {
            buttonName: 'go-to-social-page',
            onClick: (e, entities) => {
              console.log(entities?.gameId, entities?.playerId, entities?.teamId);
            },
          },
        },
      ],

BlazeSDK.playContent('story',{
  dataSource,
  style: playerStyle,
  actionHandlers,
  shouldOrderContentByReadStatus: true
});

const playerStyle = BlazeSDK.Theme('default').playerStyle;

BlazeSDK.playStory('66c0d0c6607d0c10cf3dd98d',playerStyle)

const dataSource = BlazeSDK.DataSourceBuilder().labels({
  labels: BlazeSDK.LabelBuilder().atLeastOneOf('top-stories', 'live-stories'),
  maxItems: 4,
})
const playerStyle = BlazeSDK.Theme('default').playerStyle;

BlazeSDK.playStories(dataSource, playerStyle)

function appendContentToPlayer(contentType: ContentType, dataSource: BlazeDataSourceType, options?: {
    shouldOrderContentByReadStatus?: boolean;
}): Promise<void>

BlazeSDK.appendContentToPlayer('moment', 
                                BlazeSDK.DataSourceBuilder().labels({ labels: "my-label" })
                              );
BlazeSDK.appendContentToPlayer('moment', 
                               BlazeSDK.DataSourceBuilder().ids({ ids: ["6706731d200c07e22d70a2ed","663a1c0a4e167da3d5a3ddf9"] }),
                               { shouldOrderContentByReadStatus: false } 
                              );

interface BeforeContentPlayContext {
  originalUrl: string;
}

interface BeforeContentPlayResult {
  resultUrl: string;
}

type BeforeContentPlayCallback = (
  context: BeforeContentPlayContext
) => Promise<BeforeContentPlayResult> | BeforeContentPlayResult;

// URL tokenization example for protected content
BlazeSDK.setBeforeContentPlayCallback(async (context) => {
  const { originalUrl } = context;

  const response = await fetch(`https://example-service.com/tokenGen?url=${originalUrl}`)
  const data = await response.json()

  return {
    resultUrl: data.data.url
  };
});

// Synchronous URL modification example
BlazeSDK.setBeforeContentPlayCallback((context) => {
  const { originalUrl } = context;
  
  const url = new URL(originalUrl);
  url.searchParams.set('token', getUserToken());
  url.searchParams.set('timestamp', Date.now().toString());
  
  return {
    resultUrl: url.toString()
  };
});

// Remove callback
BlazeSDK.setBeforeContentPlayCallback(undefined);

 BlazeSDK.pauseCurrentPlayer();

 BlazeSDK.resumeCurrentPlayer();

BlazeSDK.getAppContextManager().userName = "Lorem Ipsum"

type CustomNativeTargeting = Record<string, string | string[]>;
type CustomNativeArgs = {
  path: string;
};

interface CustomNativeAdHandler {
  provideAdExtraParams?: (args: CustomNativeArgs, contentExtraInfo?: ContentExtraInfo) => CustomNativeTargeting;
}

function provideAdExtraParams(args: { path: string }, contentExtraInfo?: ContentExtraInfo): CustomNativeTargeting;

// Usage example:
BlazeSDK.setGoogleCustomNativeAdsHandler({
  provideAdExtraParams: (args, contentExtraInfo) => {
    return {
    	"gdpr": "1",
    	"age": ["1", "2"],
    	"next": JSON.stringify(contentExtraInfo?.next),
    	"prev": JSON.stringify(contentExtraInfo?.previous)     
}
}});

type ImaExtraParams = Record<string, string>;

interface ImaAdHandler {  
  provideAdExtraParams?: (contentExtraInfo?: ContentExtraInfo) => ImaExtraParams;
}

function provideAdExtraParams(contentExtraInfo? : ContentExtraInfo): ImaExtraParams;

// Usage example:  
BlazeSDK.setImaHandler({  
  provideAdExtraParams: (contentExtraInfo) => {  
    return {
    	"cust_params": "gdpr=1"
    }  
}});

const filters = BlazeSDK.VideoFilterBuilder();

// Live games section
const liveGames = BlazeSDK.WidgetRowView('live-container', {
  dataSource: BlazeSDK.DataSourceBuilder().labels({
    labels: 'sports-games',
    advancedOrdering: 'LiveFirst',
    maxItems: 10
  }),
  contentType: 'video',
  videoFilters: filters.liveOnly()
});

// Upcoming schedule
const schedule = BlazeSDK.WidgetGridView('schedule-container', {
  dataSource: BlazeSDK.DataSourceBuilder().labels({
    labels: 'sports-games',
    orderType: 'OldestFirst',
    maxItems: 20
  }),
  contentType: 'video',
  videoFilters: filters.upcomingOnly()
});

// Replays library
const replays = BlazeSDK.WidgetRowView('replays-container', {
  dataSource: BlazeSDK.DataSourceBuilder().labels({
    labels: 'sports-games',
    orderType: 'RecentlyUpdatedFirst',
    maxItems: 20
  }),
  contentType: 'video',
  videoFilters: filters.endedOnly()
});