@raydiant/playlist-window-manager 0.19.0 → 0.20.0-rc.1

package/build/PlaylistWindowManager.d.ts

@@ -89,6 +89,7 @@ export default class PlaylistWindowManager extends EventEmitter {
     private evalRuleEngine;
     private handleEnableInterruptLock;
     private handleDisableInterruptLock;
+    private handleAnalyticsEvent;
     private handleCurrentPresentationComplete;
     private handleCurrentPresentationError;
     private handleNextPresentationError;

package/build/PlaylistWindowManager.js

@@ -109,6 +109,11 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                 _this.endCurrentPresentation();
             }
         };
+        _this.handleAnalyticsEvent = function (event) {
+            // Emit the event on the current window. Only the current window should
+            // send analytics events since the next window is not visible.
+            _this.emitCurrentWindowEvent('window_analytics_event', event);
+        };
         _this.handleCurrentPresentationComplete = function () { return __awaiter(_this, void 0, void 0, function () {
             var logger, isThrottled, now, timeSinceLastComplete, delay, _a, next, preview, nextPreviewPresentationId;
             var _this = this;
@@ -693,6 +698,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         this.currentWindow.onError(this.handleCurrentPresentationError);
                         this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
                         this.currentWindow.onDisableInterruptLock(this.handleDisableInterruptLock);
+                        this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
                         return [4 /*yield*/, this.currentWindow.load()];
                     case 1:
                         _a.sent();
@@ -896,6 +902,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                             this.currentWindow.onError(this.handleCurrentPresentationError);
                             this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
                             this.currentWindow.onDisableInterruptLock(this.handleDisableInterruptLock);
+                            this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
                         }
                         // Play new current window.
                         this.playCurrentWindow();

package/build/PresentationWindow.d.ts

@@ -1,7 +1,7 @@
 import * as RE from '@raydiant/playlist-rule-engine';
 import PlaylistWindowManagerState from './PlaylistWindowManagerState';
 import PlaylistWindowManager from './PlaylistWindowManager';
-import { Presentation, ApplicationVersion, Theme, Device, PresentationWindowRenderer, WindowBounds, Logger, BuilderState, WorkerState } from './types';
+import { Presentation, ApplicationVersion, Theme, Device, PresentationWindowRenderer, WindowBounds, Logger, BuilderState, WorkerState, AnalyticsEvent } from './types';
 export interface PresentationWindowOptions {
     windowManager?: PlaylistWindowManager;
     windowId: string;
@@ -49,6 +49,7 @@ export default class PresentationWindow {
     private isChildWindowLocked;
     private enableInterruptLockCallback;
     private disableInterruptLockCallback;
+    private analyticsEventCallback;
     private builderState;
     private presentation;
     private playlistWindowManagerState;
@@ -73,6 +74,7 @@ export default class PresentationWindow {
     onError(callback: ((err: Error) => void) | null): void;
     onEnableInterruptLock(callback: (() => void) | null): void;
     onDisableInterruptLock(callback: (() => void) | null): void;
+    onAnalyticsEvent(callback: ((event: AnalyticsEvent) => void) | null): void;
     isReady(): boolean;
     isComplete(): boolean;
     isPlaying(): boolean;

package/build/PresentationWindow.js

@@ -67,6 +67,15 @@ var defaultAppRendererUrl = 'https://apps.raydiant.com/3.0.0/index.html';
 var isValidNumber = function (value) {
     return typeof value === 'number' && !isNaN(value);
 };
+var isValidAnalyticsEvent = function (value) {
+    return value &&
+        typeof value === 'object' &&
+        typeof value.type === 'string' &&
+        typeof value.source === 'string' &&
+        (typeof value.productCategory === 'string' ||
+            value.productCategory === undefined ||
+            value.productCategory === null);
+};
 var PresentationWindow = /** @class */ (function () {
     function PresentationWindow(options) {
         var _this = this;
@@ -87,6 +96,7 @@ var PresentationWindow = /** @class */ (function () {
         this.isChildWindowLocked = {};
         this.enableInterruptLockCallback = null;
         this.disableInterruptLockCallback = null;
+        this.analyticsEventCallback = null;
         this.forceMute = false;
         this.error = null;
         this.workerState = {};
@@ -168,6 +178,12 @@ var PresentationWindow = /** @class */ (function () {
                         }
                         break;
                     }
+                    case 'analytics-event': {
+                        if (this.analyticsEventCallback && isValidAnalyticsEvent(payload)) {
+                            this.analyticsEventCallback(payload);
+                        }
+                        break;
+                    }
                     default: {
                         this.logWarning("Received unknown embedded message type: " + type);
                     }
@@ -400,6 +416,9 @@ var PresentationWindow = /** @class */ (function () {
     PresentationWindow.prototype.onDisableInterruptLock = function (callback) {
         this.disableInterruptLockCallback = callback;
     };
+    PresentationWindow.prototype.onAnalyticsEvent = function (callback) {
+        this.analyticsEventCallback = callback;
+    };
     PresentationWindow.prototype.isReady = function () {
         // TODO: To support the 'ready' event in embedded apps, they will need to tell the
         // runtime that it should wait for ready instead of DOMLoaded. This could be a "wait
@@ -523,7 +542,7 @@ var PresentationWindow = /** @class */ (function () {
                         }
                         url = this.getEmbeddedAppUrl();
                         this.logInfo("Create window '" + windowId + "' for embedded app url '" + url + "'");
-                        return [4 /*yield*/, this.createAndLoadWindow(this.appendWindowIdToHash(url, windowId), 
+                        return [4 /*yield*/, this.createAndLoadWindow(url, 
                             // Embedded apps should not have a backgroundColor because some sites expect
                             // the browser default of white will be applied.
                             '#ffffff', this.handleEmbeddedMessage)];
@@ -766,6 +785,9 @@ var PresentationWindow = /** @class */ (function () {
                             windowManager.on('window_end_error', function (metadata) {
                                 parentWindowManager.emit('window_end_error', metadata);
                             });
+                            windowManager.on('window_analytics_event', function (metadata) {
+                                parentWindowManager.emit('window_analytics_event', metadata);
+                            });
                         }
                         this.windowManagers[windowName] = windowManager;
                         windowManager.setRenderer(renderer);
@@ -832,10 +854,12 @@ var PresentationWindow = /** @class */ (function () {
         }
     };
     PresentationWindow.prototype.getEmbeddedAppUrl = function () {
+        var windowId = this.options.windowId;
         var metadata = {
             renderMode: this.options.isPreview ? 'preview' : 'live'
         };
-        return embeddedApps_1.default(this.presentation, this.options.applicationVersion, metadata);
+        var url = embeddedApps_1.default(this.presentation, this.options.applicationVersion, metadata);
+        return this.appendWindowIdToHash(url, windowId);
     };
     PresentationWindow.prototype.handleReady = function () {
         this.didReceiveReady = true;

package/build/types.d.ts

@@ -130,3 +130,8 @@ export interface InputState {
 export interface EmbeddedAppMetadata {
     renderMode: 'preview' | 'live';
 }
+export interface AnalyticsEvent {
+    type: string;
+    source: string;
+    productCategory?: string | null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raydiant/playlist-window-manager",
-  "version": "0.19.0",
+  "version": "0.20.0-rc.1",
   "description": "Window manager for playlist playback.",
   "main": "build/index.js",
   "scripts": {

package/src/PlaylistWindowManager.ts

@@ -7,7 +7,8 @@ import {
   WindowBounds,
   Theme,
   Logger,
-  WorkerState
+  WorkerState,
+  AnalyticsEvent
 } from './types';
 import PresentationWindow from './PresentationWindow';
 import PlaylistWindowManagerState from './PlaylistWindowManagerState';
@@ -521,6 +522,8 @@ export default class PlaylistWindowManager extends EventEmitter {
     this.currentWindow.onError(this.handleCurrentPresentationError);
     this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
     this.currentWindow.onDisableInterruptLock(this.handleDisableInterruptLock);
+    this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+
     await this.currentWindow.load();
   }
 
@@ -691,6 +694,7 @@ export default class PlaylistWindowManager extends EventEmitter {
       this.currentWindow.onDisableInterruptLock(
         this.handleDisableInterruptLock
       );
+      this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
     }
 
     // Play new current window.
@@ -754,6 +758,12 @@ export default class PlaylistWindowManager extends EventEmitter {
     }
   };
 
+  private handleAnalyticsEvent = (event: AnalyticsEvent) => {
+    // Emit the event on the current window. Only the current window should
+    // send analytics events since the next window is not visible.
+    this.emitCurrentWindowEvent('window_analytics_event', event);
+  };
+
   private handleCurrentPresentationComplete = async () => {
     const { logger } = this.options;
 

package/src/PresentationWindow.ts

@@ -16,7 +16,8 @@ import {
   OpenChildWindowOptions,
   BuilderState,
   WorkerState,
-  EmbeddedAppMetadata
+  EmbeddedAppMetadata,
+  AnalyticsEvent
 } from './types';
 
 export interface PresentationWindowOptions {
@@ -57,6 +58,15 @@ const defaultAppRendererUrl = 'https://apps.raydiant.com/3.0.0/index.html';
 const isValidNumber = (value: any) =>
   typeof value === 'number' && !isNaN(value);
 
+const isValidAnalyticsEvent = (value: any): value is AnalyticsEvent =>
+  value &&
+  typeof value === 'object' &&
+  typeof value.type === 'string' &&
+  typeof value.source === 'string' &&
+  (typeof value.productCategory === 'string' ||
+    value.productCategory === undefined ||
+    value.productCategory === null);
+
 export default class PresentationWindow {
   private didReceiveReady: boolean = false;
   private readyCallback: (() => void) | null = null;
@@ -76,6 +86,9 @@ export default class PresentationWindow {
   private isChildWindowLocked: { [windowId: string]: boolean } = {};
   private enableInterruptLockCallback: (() => void) | null = null;
   private disableInterruptLockCallback: (() => void) | null = null;
+  private analyticsEventCallback:
+    | ((event: AnalyticsEvent) => void)
+    | null = null;
 
   private builderState: BuilderState | undefined;
   private presentation: Presentation;
@@ -264,6 +277,10 @@ export default class PresentationWindow {
     this.disableInterruptLockCallback = callback;
   }
 
+  public onAnalyticsEvent(callback: ((event: AnalyticsEvent) => void) | null) {
+    this.analyticsEventCallback = callback;
+  }
+
   public isReady() {
     // TODO: To support the 'ready' event in embedded apps, they will need to tell the
     // runtime that it should wait for ready instead of DOMLoaded. This could be a "wait
@@ -408,7 +425,7 @@ export default class PresentationWindow {
     this.logInfo(`Create window '${windowId}' for embedded app url '${url}'`);
 
     await this.createAndLoadWindow(
-      this.appendWindowIdToHash(url, windowId),
+      url,
       // Embedded apps should not have a backgroundColor because some sites expect
       // the browser default of white will be applied.
       '#ffffff',
@@ -671,6 +688,9 @@ export default class PresentationWindow {
         windowManager.on('window_end_error', metadata => {
           parentWindowManager.emit('window_end_error', metadata);
         });
+        windowManager.on('window_analytics_event', metadata => {
+          parentWindowManager.emit('window_analytics_event', metadata);
+        });
       }
 
       this.windowManagers[windowName] = windowManager;
@@ -741,15 +761,19 @@ export default class PresentationWindow {
   }
 
   private getEmbeddedAppUrl() {
+    const { windowId } = this.options;
+
     const metadata: EmbeddedAppMetadata = {
       renderMode: this.options.isPreview ? 'preview' : 'live'
     };
 
-    return createEmbeddedApp(
+    const url = createEmbeddedApp(
       this.presentation,
       this.options.applicationVersion,
       metadata
     );
+
+    return this.appendWindowIdToHash(url, windowId);
   }
 
   private handleEmbeddedMessage = async (type: string, payload?: any) => {
@@ -850,6 +874,13 @@ export default class PresentationWindow {
         break;
       }
 
+      case 'analytics-event': {
+        if (this.analyticsEventCallback && isValidAnalyticsEvent(payload)) {
+          this.analyticsEventCallback(payload);
+        }
+        break;
+      }
+
       default: {
         this.logWarning(`Received unknown embedded message type: ${type}`);
       }

package/src/types.ts

@@ -156,3 +156,9 @@ export interface InputState {
 export interface EmbeddedAppMetadata {
   renderMode: 'preview' | 'live';
 }
+
+export interface AnalyticsEvent {
+  type: string;
+  source: string;
+  productCategory?: string | null;
+}