@raydiant/playlist-window-manager 0.0.0-test-27 → 0.0.0-test-29

package/build/BrowserViewRenderer.d.ts

@@ -5,7 +5,7 @@ export default class BrowserViewRenderer implements PresentationWindowRenderer {
     private offscreenWindow;
     private windows;
     constructor(mainWindow: BrowserWindow, offscreenWindow: BrowserWindow);
-    createWindow({ windowId, parentWindowId, bounds, logger, backgroundColor, receiveMessageCallback, }: CreateWindowOptions): Promise<void>;
+    createWindow({ windowId, parentWindowId, bounds, backgroundColor, receiveMessageCallback, }: CreateWindowOptions): Promise<void>;
     loadWindow(windowId: string, url: string): Promise<void>;
     updateWindowBounds(windowId: string, bounds: WindowBounds): void;
     showWindow(windowId: string, isFocused: boolean): void;

package/build/BrowserViewRenderer.js

@@ -79,11 +79,10 @@ var BrowserViewRenderer = /** @class */ (function () {
         this.windows = {};
     }
     BrowserViewRenderer.prototype.createWindow = function (_a) {
-        var windowId = _a.windowId, parentWindowId = _a.parentWindowId, bounds = _a.bounds, logger = _a.logger, backgroundColor = _a.backgroundColor, receiveMessageCallback = _a.receiveMessageCallback;
+        var windowId = _a.windowId, parentWindowId = _a.parentWindowId, bounds = _a.bounds, backgroundColor = _a.backgroundColor, receiveMessageCallback = _a.receiveMessageCallback;
         return __awaiter(this, void 0, void 0, function () {
             var window;
             return __generator(this, function (_b) {
-                logger.info("playlist-window-manager/src/BrowserViewRenderer.ts createWindow1 ".concat(JSON.stringify(bounds || __assign(__assign({}, this.mainWindow.getBounds()), { x: 0, y: 0 }))));
                 window = {
                     view: new electron_1.BrowserView({
                         webPreferences: {
@@ -100,9 +99,7 @@ var BrowserViewRenderer = /** @class */ (function () {
                 this.windows[windowId] = window;
                 electron_1.ipcMain.on(windowId, window.receiveMessageCallback);
                 this.offscreenWindow.addBrowserView(window.view);
-                logger.info("playlist-window-manager/src/BrowserViewRenderer.ts createWindow2 ".concat(JSON.stringify(window.bounds)));
                 window.view.setBounds(window.bounds);
-                logger.info("playlist-window-manager/src/BrowserViewRenderer.ts createWindow3 ".concat(JSON.stringify(window.view.getBounds())));
                 if (backgroundColor) {
                     window.view.setBackgroundColor(backgroundColor);
                 }
@@ -141,7 +138,6 @@ var BrowserViewRenderer = /** @class */ (function () {
         if (!window) {
             throw new Error("Failed to update window bounds, missing window id '".concat(windowId, "'"));
         }
-        // TODO log bounds
         window.bounds = bounds;
         window.view.setBounds(window.bounds);
     };

package/build/BrowserWindowRenderer.d.ts

@@ -16,7 +16,6 @@ interface BrowserWindowRendererOptions {
 export default class BrowserWindowRenderer implements PresentationWindowRenderer {
     private opts;
     private windows;
-    private windowsBounds;
     private windowCrashHandler;
     private browserWindowPool;
     private browserViewPool;
@@ -34,15 +33,7 @@ export default class BrowserWindowRenderer implements PresentationWindowRenderer
     sendMessageObject(windowId: string, type: string, payload?: any): void;
     muteWindow(windowId: string): void;
     unMuteWindow(windowId: string): void;
-    /**
-     * This function is designed to solve missing 1px issue.
-     * If we set 1920x1080 bounds on 1920x1080 display
-     * then the actual BrowserWindow resolution would be
-     * 1919x1079.
-     */
-    private setWindowOrViewBounds;
     private getWindow;
-    private getWindowBounds;
     private moveWindowOffscreen;
     private addWindowToParent;
     private removeWindowFromParent;

package/build/BrowserWindowRenderer.js

@@ -75,34 +75,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var path = __importStar(require("path"));
 var electron_1 = require("electron");
-var lodash_1 = __importDefault(require("lodash"));
 var WindowUnresponsiveError_1 = __importDefault(require("./WindowUnresponsiveError"));
-var boundUtils_1 = require("./boundUtils");
 var BrowserWindowRenderer = /** @class */ (function () {
     function BrowserWindowRenderer(opts) {
         this.opts = opts;
         this.windows = {};
-        this.windowsBounds = {};
         this.windowCrashHandler = function (_) { };
         this.browserWindowPool = new WindowPool();
         this.browserViewPool = new WindowPool();
         // Create a hidden window to preload BrowserViews.
-        this.offscreenWindow = new electron_1.BrowserWindow(__assign(__assign({}, this.opts.bounds), { show: false, frame: this.opts.frame, hasShadow: this.opts.hasShadow, useContentSize: true, fullscreen: (0, boundUtils_1.isFullscreen)(this.opts.bounds), webPreferences: {
+        this.offscreenWindow = new electron_1.BrowserWindow({
+            show: false,
+            frame: this.opts.frame,
+            hasShadow: this.opts.hasShadow,
+            webPreferences: {
                 preload: path.join(__dirname, 'preload.js'),
-            } }));
+                contextIsolation: false,
+            },
+        });
         this.proxySettings = null;
-        this.logger = opts.logger;
-        opts.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts constructor1 ".concat(JSON.stringify(opts.bounds)));
-        this.setWindowOrViewBounds(this.offscreenWindow, opts.bounds);
-        opts.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts constructor2 ".concat(JSON.stringify({
-            fullscreen: this.offscreenWindow.isFullScreen(),
-            bounds: this.offscreenWindow.getBounds(),
-            normalBounds: this.offscreenWindow.getNormalBounds(),
-            contentBounds: this.offscreenWindow.getContentBounds(),
-        })));
+        this.offscreenWindow.setBounds(opts.bounds);
         if (opts.proxySettings) {
             this.proxySettings = opts.proxySettings;
         }
+        this.logger = opts.logger;
         if (opts.windowCrashHandler) {
             this.windowCrashHandler = opts.windowCrashHandler;
         }
@@ -110,14 +106,11 @@ var BrowserWindowRenderer = /** @class */ (function () {
     BrowserWindowRenderer.prototype.createWindow = function (_a) {
         var windowId = _a.windowId, parentWindowId = _a.parentWindowId, _b = _a.bounds, bounds = _b === void 0 ? this.opts.bounds : _b, backgroundColor = _a.backgroundColor, receiveMessageCallback = _a.receiveMessageCallback, errorCallback = _a.errorCallback;
         return __awaiter(this, void 0, void 0, function () {
-            var windowBounds, window;
+            var window;
             var _this = this;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        windowBounds = parentWindowId && !this.opts.renderChildWindowsAsBrowserViews
-                            ? __assign(__assign({}, bounds), { x: bounds.x + this.opts.bounds.x, y: bounds.y + this.opts.bounds.y }) : bounds;
-                        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts createWindow1: ".concat(JSON.stringify(windowBounds)));
                         window = {
                             parentWindowId: parentWindowId,
                             // If we are creating a child window and renderChildWindowsAsBrowserViews is true,
@@ -131,7 +124,6 @@ var BrowserWindowRenderer = /** @class */ (function () {
                                 : this.createOrGetPooledBrowserWindow(windowId, {
                                     show: false,
                                     frame: this.opts.frame,
-                                    fullscreen: (0, boundUtils_1.isFullscreen)(this.opts.bounds),
                                     // NOTE: useWindowPool: true does not work with renderChildWindowsAsBrowserViews: false
                                     // because the parent can't be changed after creating the BrowserWindow.
                                     parent: parentWindowId
@@ -141,13 +133,15 @@ var BrowserWindowRenderer = /** @class */ (function () {
                                     hasShadow: this.opts.hasShadow,
                                     webPreferences: {
                                         preload: path.join(__dirname, 'preload.js'),
+                                        contextIsolation: false,
                                     },
                                 }),
                             // If we are creating a child window and renderChildWindowsAsBrowserViews is false that means
                             // we are rendering child windows with BrowserWindow. BrowserWindows are positioned absolutely so
                             // to place them in the correct spot relative to their parent we need to add the main window's x / y.
                             // BrowserViews are relatively positioned so we don't need to do that.
-                            bounds: windowBounds,
+                            bounds: parentWindowId && !this.opts.renderChildWindowsAsBrowserViews
+                                ? __assign(__assign({}, bounds), { x: bounds.x + this.opts.bounds.x, y: bounds.y + this.opts.bounds.y }) : bounds,
                             receiveMessageCallback: function (_, type, payload) {
                                 if (receiveMessageCallback) {
                                     receiveMessageCallback(type, payload);
@@ -171,15 +165,8 @@ var BrowserWindowRenderer = /** @class */ (function () {
                         window.view.webContents.on('unresponsive', window.unresponsiveCallback);
                         if (window.view instanceof electron_1.BrowserView) {
                             this.moveWindowOffscreen(window);
-                            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts createWindow2: ".concat(JSON.stringify({
-                                fullscreen: this.offscreenWindow.isFullScreen(),
-                                bounds: this.offscreenWindow.getBounds(),
-                                normalBounds: this.offscreenWindow.getNormalBounds(),
-                                contentBounds: this.offscreenWindow.getContentBounds(),
-                            })));
                         }
                         this.windows[windowId] = window;
-                        this.windowsBounds[windowId] = lodash_1.default.cloneDeep(windowBounds);
                         // Listen for messages from window.
                         electron_1.ipcMain.on(windowId, window.receiveMessageCallback);
                         if (backgroundColor) {
@@ -187,35 +174,7 @@ var BrowserWindowRenderer = /** @class */ (function () {
                             // Electron issue: https://github.com/electron/electron/issues/20357
                             window.view.setBackgroundColor(backgroundColor === 'transparent' ? '#00000000' : backgroundColor);
                         }
-                        if (window.view instanceof electron_1.BrowserWindow) {
-                            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts createWindow4: ".concat(JSON.stringify({
-                                newBounds: window.bounds,
-                                fullscreen: window.view.isFullScreen(),
-                                bounds: window.view.getBounds(),
-                                contentBounds: window.view.getContentBounds(),
-                                normalBounds: window.view.getNormalBounds(),
-                            })));
-                        }
-                        else {
-                            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts createWindow5: ".concat(JSON.stringify({
-                                newBounds: window.bounds,
-                                bounds: window.view.getBounds(),
-                            })));
-                        }
-                        this.setWindowOrViewBounds(window.view, window.bounds);
-                        if (window.view instanceof electron_1.BrowserWindow) {
-                            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts createWindow7: ".concat(JSON.stringify({
-                                fullscreen: window.view.isFullScreen(),
-                                bounds: window.view.getBounds(),
-                                contentBounds: window.view.getContentBounds(),
-                                normalBounds: window.view.getNormalBounds(),
-                            })));
-                        }
-                        else {
-                            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts createWindow8: ".concat(JSON.stringify({
-                                bounds: window.view.getBounds(),
-                            })));
-                        }
+                        window.view.setBounds(window.bounds);
                         if (!this.proxySettings) return [3 /*break*/, 2];
                         return [4 /*yield*/, window.view.webContents.session.setProxy(this.proxySettings)];
                     case 1:
@@ -253,54 +212,22 @@ var BrowserWindowRenderer = /** @class */ (function () {
         if (!window) {
             throw new Error("Failed to update window bounds, missing window id '".concat(windowId, "'"));
         }
-        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds1: ".concat(JSON.stringify(bounds)));
         window.bounds = bounds;
         if (window.view instanceof electron_1.BrowserWindow && window.parentWindowId) {
             // Child BrowserWindows are absolutely positioned so we need to add the main windows
             // x/y to when updating the child window's bounds.
-            var newBounds = __assign(__assign({}, window.bounds), { x: window.bounds.x + this.opts.bounds.x, y: window.bounds.y + this.opts.bounds.y });
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds2: ".concat(JSON.stringify(newBounds)));
-            this.setWindowOrViewBounds(window.view, newBounds);
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds3: ".concat(JSON.stringify({
-                fullscreen: window.view.isFullScreen(),
-                bounds: window.view.getBounds(),
-                normalBounds: window.view.getNormalBounds(),
-                contentBounds: window.view.getContentBounds(),
-            })));
+            window.view.setBounds(__assign(__assign({}, window.bounds), { x: window.bounds.x + this.opts.bounds.x, y: window.bounds.y + this.opts.bounds.y }));
         }
         else {
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds4: ".concat(JSON.stringify(window.bounds)));
-            this.setWindowOrViewBounds(window.view, window.bounds);
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts updateWindowBounds5: ".concat(JSON.stringify(window.view.getBounds())));
+            window.view.setBounds(window.bounds);
         }
     };
     BrowserWindowRenderer.prototype.showWindow = function (windowId, isFocused) {
-        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts showWindow1: ".concat(windowId));
         var window = this.getWindow(windowId);
-        var windowBounds = this.getWindowBounds(windowId);
-        if (!window || !windowBounds) {
+        if (!window) {
             throw new Error("Failed to show window, missing window id '".concat(windowId, "'"));
         }
         if (window.view instanceof electron_1.BrowserWindow) {
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts showWindow2: ".concat(JSON.stringify({
-                fullscreen: window.view.isFullScreen(),
-                isMaximized: window.view.isMaximized(),
-                bounds: window.view.getBounds(),
-                windowBounds: windowBounds,
-                normalBounds: window.view.getNormalBounds(),
-                contentBounds: window.view.getContentBounds(),
-            })));
-            if (!(0, boundUtils_1.areBoundsEqual)(window.view.getBounds(), windowBounds)) {
-                this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts showWindow3: setWindowOrViewBounds");
-                this.setWindowOrViewBounds(window.view, windowBounds);
-            }
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts showWindow4: ".concat(JSON.stringify({
-                fullscreen: window.view.isFullScreen(),
-                isMaximized: window.view.isMaximized(),
-                bounds: window.view.getBounds(),
-                normalBounds: window.view.getNormalBounds(),
-                contentBounds: window.view.getContentBounds(),
-            })));
             if (isFocused) {
                 window.view.show();
             }
@@ -360,7 +287,6 @@ var BrowserWindowRenderer = /** @class */ (function () {
                         _a.label = 4;
                     case 4:
                         delete this.windows[windowId];
-                        delete this.windowsBounds[windowId];
                         if (this.opts.useWindowPool) {
                             this.logPoolStats();
                         }
@@ -397,81 +323,9 @@ var BrowserWindowRenderer = /** @class */ (function () {
         }
         window.view.webContents.setAudioMuted(false);
     };
-    /**
-     * This function is designed to solve missing 1px issue.
-     * If we set 1920x1080 bounds on 1920x1080 display
-     * then the actual BrowserWindow resolution would be
-     * 1919x1079.
-     */
-    BrowserWindowRenderer.prototype.setWindowOrViewBounds = function (window, bounds) {
-        if (window instanceof electron_1.BrowserView) {
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds1: ".concat(JSON.stringify({
-                windowBounds: window.getBounds(),
-                bounds: bounds,
-            })));
-            window.setBounds(bounds);
-            return;
-        }
-        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds2: ".concat(JSON.stringify({
-            newBounds: bounds,
-            fullscreen: window.isFullScreen(),
-            isMaximized: window.isMaximized(),
-            bounds: window.getBounds(),
-            contentBounds: window.getContentBounds(),
-            normalBounds: window.getNormalBounds(),
-        })));
-        // calling setBounds or setFullscreen may introduce -1px resolution error
-        // so we try to avoid unnecessary calls
-        if ((0, boundUtils_1.areBoundsEqual)(window.getBounds(), bounds)) {
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds3: bounds are equal");
-            return;
-        }
-        if ((0, boundUtils_1.isFullscreen)(bounds) !== window.isFullScreen()) {
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds4: setFullScreen");
-            window.setFullScreen((0, boundUtils_1.isFullscreen)(bounds));
-        }
-        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds5: ".concat(JSON.stringify({
-            fullscreen: window.isFullScreen(),
-            isMaximized: window.isMaximized(),
-            bounds: window.getBounds(),
-            contentBounds: window.getContentBounds(),
-            normalBounds: window.getNormalBounds(),
-        })));
-        if (!(0, boundUtils_1.areBoundsEqual)(window.getBounds(), bounds)) {
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds6: setBounds");
-            window.setBounds(bounds);
-        }
-        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds7: ".concat(JSON.stringify({
-            fullscreen: window.isFullScreen(),
-            isMaximized: window.isMaximized(),
-            bounds: window.getBounds(),
-            contentBounds: window.getContentBounds(),
-            normalBounds: window.getNormalBounds(),
-        })));
-        if (window.isFullScreen() && !(0, boundUtils_1.isFullscreen)(window.getBounds())) {
-            this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds8: maximize: ".concat(JSON.stringify({
-                fullscreen: window.isFullScreen(),
-                isMaximized: window.isMaximized(),
-                bounds: window.getBounds(),
-                contentBounds: window.getContentBounds(),
-                normalBounds: window.getNormalBounds(),
-            })));
-            window.maximize();
-        }
-        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts setWindowOrViewBounds9: ".concat(JSON.stringify({
-            fullscreen: window.isFullScreen(),
-            isMaximized: window.isMaximized(),
-            bounds: window.getBounds(),
-            contentBounds: window.getContentBounds(),
-            normalBounds: window.getNormalBounds(),
-        })));
-    };
     BrowserWindowRenderer.prototype.getWindow = function (windowId) {
         return this.windows[windowId];
     };
-    BrowserWindowRenderer.prototype.getWindowBounds = function (windowId) {
-        return this.windowsBounds[windowId];
-    };
     BrowserWindowRenderer.prototype.moveWindowOffscreen = function (window) {
         if (!(window.view instanceof electron_1.BrowserView)) {
             throw new Error("Failed move window offscreen, window is not a BrowserView");
@@ -545,13 +399,6 @@ var BrowserWindowRenderer = /** @class */ (function () {
                 this.browserWindowPool.add(browserWindow);
             }
         }
-        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts createOrGetPooledBrowserWindow1: ".concat(JSON.stringify({
-            screen: electron_1.screen.getPrimaryDisplay().bounds,
-            fullscreen: browserWindow.isFullScreen(),
-            bounds: browserWindow.getBounds(),
-            contentBounds: browserWindow.getContentBounds(),
-            normalBounds: browserWindow.getNormalBounds(),
-        })));
         return browserWindow;
     };
     BrowserWindowRenderer.prototype.destroyOrUnloadPooledBrowserWindow = function (windowId, browserWindow) {
@@ -559,9 +406,6 @@ var BrowserWindowRenderer = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        this.logger.info("playlist-window-manager/src/BrowserWindowRenderer.ts destroyOrUnloadPooledBrowserWindow1: ".concat(JSON.stringify({
-                            windowId: windowId,
-                        })));
                         if (!this.opts.useWindowPool) return [3 /*break*/, 2];
                         this.hideWindow(windowId);
                         return [4 /*yield*/, browserWindow.webContents.loadURL('about:blank')];

package/build/PlaylistWindowManager.d.ts

@@ -1,6 +1,6 @@
 import * as RE from '@raydiant/playlist-rule-engine';
 import EventEmitter from 'eventemitter3';
-import { PresentationWindowRenderer, Device, WindowBounds, Theme, Logger, WorkerState } from './types';
+import { PresentationWindowRenderer, Device, WindowBounds, Theme, Logger, WorkerState, Charge, ChargeResponse, Terminal } from './types';
 import PlaylistWindowManagerState from './PlaylistWindowManagerState';
 export interface PlaylistWindowManagerOptions {
     ruleEngine: RE.RuleEngine;
@@ -18,6 +18,7 @@ export interface PlaylistWindowManagerOptions {
     isPreview?: boolean;
     onEnableInterruptLock?: () => void;
     onDisableInterruptLock?: () => void;
+    getTerminal?: () => Terminal | null;
 }
 export default class PlaylistWindowManager extends EventEmitter {
     private options;
@@ -75,6 +76,9 @@ export default class PlaylistWindowManager extends EventEmitter {
     isReady(): boolean;
     isLocked(): boolean;
     runWorkerSubscriptions(state: WorkerState): void;
+    sendChargeResponse(response: ChargeResponse): void;
+    sendCharge(charge: Charge): void;
+    sendTerminal(terminal: Terminal | null): void;
     private createWindow;
     private loadCurrentWindow;
     private shouldPreload;
@@ -90,6 +94,7 @@ export default class PlaylistWindowManager extends EventEmitter {
     private handleEnableInterruptLock;
     private handleDisableInterruptLock;
     private handleAnalyticsEvent;
+    private handleChargeRequest;
     private handleCurrentPresentationComplete;
     private handleCurrentPresentationError;
     private handleNextPresentationError;

package/build/PlaylistWindowManager.js

@@ -117,6 +117,11 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
             // send analytics events since the next window is not visible.
             _this.emitCurrentWindowEvent('window_analytics_event', event);
         };
+        _this.handleChargeRequest = function (request) {
+            // Emit the event on the current window. Only the current window should
+            // send charge requests since the next window is not visible.
+            _this.emitCurrentWindowEvent('window_charge_request', request);
+        };
         _this.handleCurrentPresentationComplete = function () { return __awaiter(_this, void 0, void 0, function () {
             var logger, isThrottled, now, timeSinceLastComplete, delay, _a, next, preview, nextPreviewPresentationId;
             var _this = this;
@@ -547,7 +552,6 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
         });
     };
     PlaylistWindowManager.prototype.updateBounds = function (bounds) {
-        // TODO log bounds
         this.bounds = bounds;
         if (this.currentWindow) {
             this.currentWindow.updateBounds(this.bounds);
@@ -641,6 +645,37 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
             this.nextWindow.runWorkerSubscriptions(state);
         }
     };
+    PlaylistWindowManager.prototype.sendChargeResponse = function (response) {
+        // Send charge response to the current window. The window will check if
+        // has a matching request id and if so, send the response to the app.
+        if (this.currentWindow) {
+            this.currentWindow.sendChargeResponse(response);
+        }
+        // Send charge response to the next window.
+        if (this.nextWindow) {
+            this.nextWindow.sendChargeResponse(response);
+        }
+    };
+    PlaylistWindowManager.prototype.sendCharge = function (charge) {
+        // Send charge to the current window.
+        if (this.currentWindow) {
+            this.currentWindow.sendCharge(charge);
+        }
+        // Send charge to the next window.
+        if (this.nextWindow) {
+            this.nextWindow.sendCharge(charge);
+        }
+    };
+    PlaylistWindowManager.prototype.sendTerminal = function (terminal) {
+        // Send terminal to the current window.
+        if (this.currentWindow) {
+            this.currentWindow.sendTerminal(terminal);
+        }
+        // Send terminal to the next window.
+        if (this.nextWindow) {
+            this.nextWindow.sendTerminal(terminal);
+        }
+    };
     PlaylistWindowManager.prototype.createWindow = function (pr) {
         var _a = this.options, readyTimeoutDurationSeconds = _a.readyTimeoutDurationSeconds, appRendererUrl = _a.appRendererUrl, backgroundColor = _a.backgroundColor, device = _a.device, logger = _a.logger, windowName = _a.windowName, parentWindowId = _a.parentWindowId, isPreview = _a.isPreview;
         if (!this.ruleEngine) {
@@ -659,7 +694,6 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
         var presentation = this.state.getPresentation(presentationId);
         var applicationVersion = this.state.getApplicationVersion(presentation.applicationDeploymentId);
         var windowId = (0, uuid_1.v4)();
-        logger.info("playlist-window-manager/src/PlaylistWindowManager.ts createWindow1 ".concat(JSON.stringify(this.bounds)));
         return new PresentationWindow_1.default({
             windowManager: this,
             renderer: this.renderer,
@@ -685,6 +719,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
             globalRule: this.ruleEngine.globalRule,
             isPreview: isPreview,
             workerState: this.workerState,
+            getTerminal: this.options.getTerminal,
         });
     };
     PlaylistWindowManager.prototype.loadCurrentWindow = function () {
@@ -704,6 +739,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
                         this.currentWindow.onDisableInterruptLock(this.handleDisableInterruptLock);
                         this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+                        this.currentWindow.onChargeRequest(this.handleChargeRequest);
                         return [4 /*yield*/, this.currentWindow.load()];
                     case 1:
                         _a.sent();
@@ -908,6 +944,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                             this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
                             this.currentWindow.onDisableInterruptLock(this.handleDisableInterruptLock);
                             this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+                            this.currentWindow.onChargeRequest(this.handleChargeRequest);
                         }
                         // 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, AnalyticsEvent } from './types';
+import { Presentation, ApplicationVersion, Theme, Device, PresentationWindowRenderer, WindowBounds, Logger, BuilderState, WorkerState, AnalyticsEvent, Charge, ChargeRequest, ChargeResponse, Terminal } from './types';
 export interface PresentationWindowOptions {
     windowManager?: PlaylistWindowManager;
     windowId: string;
@@ -31,6 +31,7 @@ export interface PresentationWindowOptions {
     onPresentationProperties?: (properties: any[], string: {
         [key: string]: string;
     }) => void;
+    getTerminal?: () => Terminal | null;
 }
 export default class PresentationWindow {
     private options;
@@ -50,6 +51,7 @@ export default class PresentationWindow {
     private enableInterruptLockCallback;
     private disableInterruptLockCallback;
     private analyticsEventCallback;
+    private chargeRequestCallback;
     private builderState;
     private presentation;
     private playlistWindowManagerState;
@@ -62,6 +64,7 @@ export default class PresentationWindow {
     private runtimeSubscriptions;
     private previewSubscriptions;
     private previewState;
+    private paymentSubscriptions;
     private createObjectURLResolvers;
     private createObjectURLTimeouts;
     constructor(options: PresentationWindowOptions);
@@ -79,6 +82,7 @@ export default class PresentationWindow {
     onEnableInterruptLock(callback: (() => void) | null): void;
     onDisableInterruptLock(callback: (() => void) | null): void;
     onAnalyticsEvent(callback: ((event: AnalyticsEvent) => void) | null): void;
+    onChargeRequest(callback: ((request: ChargeRequest) => void) | null): void;
     isReady(): boolean;
     isComplete(): boolean;
     isPlaying(): boolean;
@@ -92,6 +96,9 @@ export default class PresentationWindow {
     reload(): Promise<void>;
     runGetProperties(builderState?: BuilderState): void;
     createObjectURL(blob: Blob): Promise<string>;
+    sendChargeResponse(response: ChargeResponse): void;
+    sendCharge(charge: Charge): void;
+    sendTerminal(terminal: Terminal | null): void;
     private isEmbeddedApp;
     private allChildWindowManagersReady;
     private checkIsReadyCallback;