@raydiant/playlist-window-manager 0.22.0-rc-electron-upgrade-26-03 → 0.22.0

package/build/BrowserWindowRenderer.js

@@ -76,10 +76,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var path = __importStar(require("path"));
 var electron_1 = require("electron");
 var WindowUnresponsiveError_1 = __importDefault(require("./WindowUnresponsiveError"));
-var globalWebPreferences = {
-    nodeIntegration: true,
-    contextIsolation: false,
-};
 var BrowserWindowRenderer = /** @class */ (function () {
     function BrowserWindowRenderer(opts) {
         this.opts = opts;
@@ -92,7 +88,9 @@ var BrowserWindowRenderer = /** @class */ (function () {
             show: false,
             frame: this.opts.frame,
             hasShadow: this.opts.hasShadow,
-            webPreferences: __assign({ preload: path.join(__dirname, 'preload.js') }, globalWebPreferences),
+            webPreferences: {
+                preload: path.join(__dirname, 'preload.js'),
+            },
         });
         this.proxySettings = null;
         this.offscreenWindow.setBounds(opts.bounds);
@@ -118,7 +116,9 @@ var BrowserWindowRenderer = /** @class */ (function () {
                             // render all child windows as browser views.
                             view: parentWindowId && this.opts.renderChildWindowsAsBrowserViews
                                 ? this.createOrGetPooledBrowserView(windowId, {
-                                    webPreferences: __assign({ preload: path.join(__dirname, 'preload.js') }, globalWebPreferences),
+                                    webPreferences: {
+                                        preload: path.join(__dirname, 'preload.js'),
+                                    },
                                 })
                                 : this.createOrGetPooledBrowserWindow(windowId, {
                                     show: false,
@@ -130,7 +130,9 @@ var BrowserWindowRenderer = /** @class */ (function () {
                                         : undefined,
                                     transparent: backgroundColor === 'transparent',
                                     hasShadow: this.opts.hasShadow,
-                                    webPreferences: __assign({ preload: path.join(__dirname, 'preload.js') }, globalWebPreferences),
+                                    webPreferences: {
+                                        preload: path.join(__dirname, 'preload.js'),
+                                    },
                                 }),
                             // 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
@@ -157,10 +159,7 @@ var BrowserWindowRenderer = /** @class */ (function () {
                             },
                         };
                         // Attached crash handlers to skip presentation on error.
-                        window.view.webContents.on(
-                        // FIXME
-                        // @ts-ignore
-                        'render-process-gone', window.renderProcessGoneCallback);
+                        window.view.webContents.on('render-process-gone', window.renderProcessGoneCallback);
                         window.view.webContents.on('unresponsive', window.unresponsiveCallback);
                         if (window.view instanceof electron_1.BrowserView) {
                             this.moveWindowOffscreen(window);
@@ -266,10 +265,7 @@ var BrowserWindowRenderer = /** @class */ (function () {
                             throw new Error("Failed to remove window, missing window id '".concat(windowId, "'"));
                         }
                         // Remove crash handlers
-                        window.view.webContents.removeListener(
-                        // FIXME
-                        // @ts-ignore
-                        'render-process-gone', window.renderProcessGoneCallback);
+                        window.view.webContents.removeListener('render-process-gone', window.renderProcessGoneCallback);
                         window.view.webContents.removeListener('unresponsive', window.unresponsiveCallback);
                         // Remove message handler
                         electron_1.ipcMain.removeListener(windowId, window.receiveMessageCallback);

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;
@@ -640,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) {
@@ -682,7 +718,8 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
             ruleEngineState: this.ruleEngine.state,
             globalRule: this.ruleEngine.globalRule,
             isPreview: isPreview,
-            workerState: this.workerState
+            workerState: this.workerState,
+            getTerminal: this.options.getTerminal,
         });
     };
     PlaylistWindowManager.prototype.loadCurrentWindow = function () {
@@ -702,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();
@@ -906,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();
@@ -997,12 +1036,12 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
     };
     PlaylistWindowManager.prototype.emitCurrentWindowErrorEvent = function (event, error) {
         return this.emitCurrentWindowEvent(event, {
-            errorMessage: this.getErrorMessage(error)
+            errorMessage: this.getErrorMessage(error),
         });
     };
     PlaylistWindowManager.prototype.emitNextWindowErrorEvent = function (event, error) {
         return this.emitNextWindowEvent(event, {
-            errorMessage: this.getErrorMessage(error)
+            errorMessage: this.getErrorMessage(error),
         });
     };
     PlaylistWindowManager.prototype.getErrorMessage = function (error) {

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;

package/build/PresentationWindow.js

@@ -81,7 +81,7 @@ var PlaylistWindowManager_1 = __importDefault(require("./PlaylistWindowManager")
 var WindowTimeoutError_1 = __importDefault(require("./WindowTimeoutError"));
 var WindowLoadError_1 = __importDefault(require("./WindowLoadError"));
 // TODO: Automatically inject latest version when building in CI.
-var defaultAppRendererUrl = 'https://apps.raydiant.com/3.0.0/index.html';
+var defaultAppRendererUrl = 'https://apps.raydiant.com/3.0.4/index.html';
 var isValidNumber = function (value) {
     return typeof value === 'number' && !isNaN(value);
 };
@@ -94,6 +94,18 @@ var isValidAnalyticsEvent = function (value) {
             value.productCategory === undefined ||
             value.productCategory === null);
 };
+var isValidChargeRequest = function (value) {
+    return value &&
+        typeof value === 'object' &&
+        typeof value.requestId === 'string' &&
+        typeof value.amount === 'number' &&
+        (value.tags === undefined ||
+            value.tags === null ||
+            typeof value.tags === 'object') &&
+        (value.idempotencyId === undefined ||
+            value.idempotencyId === null ||
+            typeof value.idempotencyId === 'string');
+};
 var PresentationWindow = /** @class */ (function () {
     function PresentationWindow(options) {
         var _this = this;
@@ -114,6 +126,7 @@ var PresentationWindow = /** @class */ (function () {
         this.enableInterruptLockCallback = null;
         this.disableInterruptLockCallback = null;
         this.analyticsEventCallback = null;
+        this.chargeRequestCallback = null;
         this.forceMute = false;
         this.error = null;
         this.workerState = {};
@@ -121,6 +134,7 @@ var PresentationWindow = /** @class */ (function () {
         this.runtimeSubscriptions = new Set();
         this.previewSubscriptions = new Set();
         this.previewState = { inputs: {} };
+        this.paymentSubscriptions = new Set();
         this.createObjectURLResolvers = {};
         this.createObjectURLTimeouts = {};
         this.handleEmbeddedMessage = function (type, payload) { return __awaiter(_this, void 0, void 0, function () {
@@ -200,8 +214,13 @@ var PresentationWindow = /** @class */ (function () {
                         break;
                     }
                     case 'analytics-event': {
-                        if (this.analyticsEventCallback && isValidAnalyticsEvent(payload)) {
-                            this.analyticsEventCallback(payload);
+                        if (isValidAnalyticsEvent(payload)) {
+                            if (this.analyticsEventCallback) {
+                                this.analyticsEventCallback(payload);
+                            }
+                        }
+                        else {
+                            this.logWarning("Invalid payload for analytics-event message: ".concat(payload));
                         }
                         break;
                     }
@@ -245,6 +264,44 @@ var PresentationWindow = /** @class */ (function () {
                         }
                         break;
                     }
+                    case 'payments-charge-request': {
+                        if (isValidChargeRequest(payload)) {
+                            if (this.chargeRequestCallback) {
+                                this.chargeRequestCallback(payload);
+                            }
+                        }
+                        else {
+                            this.logWarning("Invalid payload for payments-charge-request message: ".concat(payload));
+                        }
+                        break;
+                    }
+                    case 'payments-subscribe': {
+                        if (typeof payload === 'string') {
+                            this.logInfo("Received 'worker-subscribe' from window '".concat(windowId, "'"));
+                            // The payload is the payment subscription type (ex. 'charge', 'terminal')
+                            this.paymentSubscriptions.add(payload);
+                            // Immediately send terminal when subscribing.
+                            if (payload === 'terminal' && this.options.getTerminal) {
+                                this.sendMessageObject('payments-terminal-event', {
+                                    terminal: this.options.getTerminal(),
+                                });
+                            }
+                        }
+                        else {
+                            this.logWarning("Invalid payload for payments-subscribe message: ".concat(payload));
+                        }
+                        break;
+                    }
+                    case 'payments-unsubscribe': {
+                        if (typeof payload === 'string') {
+                            this.logInfo("Received 'payments-unsubscribe' from window '".concat(windowId, "'"));
+                            this.paymentSubscriptions.delete(payload);
+                        }
+                        else {
+                            this.logWarning("Invalid payload for payments-unsubscribe message: ".concat(payload));
+                        }
+                        break;
+                    }
                     default: {
                         this.logWarning("Received unknown embedded message type: ".concat(type));
                     }
@@ -480,6 +537,9 @@ var PresentationWindow = /** @class */ (function () {
     PresentationWindow.prototype.onAnalyticsEvent = function (callback) {
         this.analyticsEventCallback = callback;
     };
+    PresentationWindow.prototype.onChargeRequest = function (callback) {
+        this.chargeRequestCallback = 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
@@ -571,6 +631,39 @@ var PresentationWindow = /** @class */ (function () {
             });
         });
     };
+    PresentationWindow.prototype.sendChargeResponse = function (response) {
+        // TODO: Instead of sending the charge to all windows, we should only send it to the app
+        // that requested the charge. We probably don't want to use the windowId to avoid missing
+        // the events in case the window was closed/restarted. Since we are only sending the charge
+        // id and status this seems ok for now but need to be mindful of sending any sensitive data.
+        this.sendMessageObject('payments-charge-response', {
+            requestId: response.requestId,
+            charge: response.charge,
+            error: response.error,
+        });
+        // Forward the event to the child window managers.
+        Object.values(this.windowManagers).forEach(function (wm) {
+            return wm.sendChargeResponse(response);
+        });
+    };
+    PresentationWindow.prototype.sendCharge = function (charge) {
+        // TODO: Instead of sending the charge to all windows, we should only send it to the app
+        // that requested the charge.
+        if (this.paymentSubscriptions.has('charge')) {
+            this.sendMessageObject('payments-charge-event', { charge: charge });
+        }
+        // Forward the event to the child window managers.
+        Object.values(this.windowManagers).forEach(function (wm) { return wm.sendCharge(charge); });
+    };
+    PresentationWindow.prototype.sendTerminal = function (terminal) {
+        if (this.paymentSubscriptions.has('terminal')) {
+            this.sendMessageObject('payments-terminal-event', { terminal: terminal });
+        }
+        // Forward the event to the child window managers.
+        Object.values(this.windowManagers).forEach(function (wm) {
+            return wm.sendTerminal(terminal);
+        });
+    };
     PresentationWindow.prototype.isEmbeddedApp = function () {
         var _a = this.options, applicationVersion = _a.applicationVersion, isPreview = _a.isPreview;
         // If the application has a source url, always use it for rendering the preview.
@@ -859,6 +952,7 @@ var PresentationWindow = /** @class */ (function () {
                             isPreview: isPreview,
                             onEnableInterruptLock: function () { return _this.enableInteruptLock(windowName); },
                             onDisableInterruptLock: function () { return _this.disableInteruptLock(windowName); },
+                            getTerminal: this.options.getTerminal,
                         });
                         // Hook up child window manager events to bubble up to the parent.
                         if (parentWindowManager) {
@@ -877,6 +971,9 @@ var PresentationWindow = /** @class */ (function () {
                             windowManager.on('window_analytics_event', function (metadata) {
                                 parentWindowManager.emit('window_analytics_event', metadata);
                             });
+                            windowManager.on('window_charge_request', function (metadata) {
+                                parentWindowManager.emit('window_charge_request', metadata);
+                            });
                         }
                         this.windowManagers[windowName] = windowManager;
                         windowManager.setRenderer(renderer);

package/build/PresentationWindow.test.js

@@ -238,4 +238,103 @@ describe('embedded apps', function () {
         });
     }); });
 });
+describe('payments', function () {
+    test('charge request', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window, callback;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-charge-request',
+                        presentation: (0, testUtils_1.createPresentation)(),
+                        applicationVersion: (0, testUtils_1.createApplicationVersion)({
+                            embeddedUrlFormat: 'http://test.local/:input',
+                        }),
+                        renderer: testRenderer,
+                    });
+                    callback = jest.fn();
+                    window.onChargeRequest(callback);
+                    return [4 /*yield*/, window.load()];
+                case 1:
+                    _a.sent();
+                    testRenderer.runReceiveMessageCallback('payments-charge-request', {
+                        requestId: 'test',
+                        amount: 100,
+                    });
+                    expect(callback).toHaveBeenCalledWith({
+                        requestId: 'test',
+                        amount: 100,
+                    });
+                    // Send charge response.
+                    window.sendChargeResponse({
+                        requestId: 'test',
+                        charge: { id: '1', status: 'pending' },
+                    });
+                    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith('test-charge-request', 'payments-charge-response', { requestId: 'test', charge: { id: '1', status: 'pending' } });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('subscribe to charge', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-payments-subscribe-charge',
+                        presentation: (0, testUtils_1.createPresentation)(),
+                        applicationVersion: (0, testUtils_1.createApplicationVersion)({
+                            embeddedUrlFormat: 'http://test.local/:input',
+                        }),
+                        renderer: testRenderer,
+                    });
+                    return [4 /*yield*/, window.load()];
+                case 1:
+                    _a.sent();
+                    testRenderer.runReceiveMessageCallback('payments-subscribe', 'charge');
+                    window.sendCharge({ id: 'test', status: 'success' });
+                    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith('test-payments-subscribe-charge', 'payments-charge-event', { charge: { id: 'test', status: 'success' } });
+                    // Unsubscribe should not send a message.
+                    testRenderer.runReceiveMessageCallback('payments-unsubscribe', 'charge');
+                    window.sendCharge({ id: 'test2', status: 'success' });
+                    expect(testRenderer.sendMessageObject).toHaveBeenCalledTimes(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    test('subscribe to terminal', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var testRenderer, window;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    testRenderer = (0, testUtils_1.createRenderer)();
+                    window = (0, testUtils_1.createPresentationWindow)({
+                        windowId: 'test-payments-subscribe-terminal',
+                        presentation: (0, testUtils_1.createPresentation)(),
+                        applicationVersion: (0, testUtils_1.createApplicationVersion)({
+                            embeddedUrlFormat: 'http://test.local/:input',
+                        }),
+                        renderer: testRenderer,
+                        getTerminal: function () { return null; },
+                    });
+                    return [4 /*yield*/, window.load()];
+                case 1:
+                    _a.sent();
+                    testRenderer.runReceiveMessageCallback('payments-subscribe', 'terminal');
+                    // Terminal subscriptions should receive the current terminal immediately after subscribing.
+                    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith('test-payments-subscribe-terminal', 'payments-terminal-event', { terminal: null });
+                    // Send terminal update event.
+                    window.sendTerminal({ status: 'open' });
+                    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith('test-payments-subscribe-terminal', 'payments-terminal-event', { terminal: { status: 'open' } });
+                    // Unsubscribe should not send a message.
+                    testRenderer.runReceiveMessageCallback('payments-unsubscribe', 'terminal');
+                    window.sendTerminal({ status: 'closed' });
+                    expect(testRenderer.sendMessageObject).toHaveBeenCalledTimes(2);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
 // TODO: Backfill tests for all legacy and embedded apps.

package/build/testUtils.js

@@ -98,6 +98,7 @@ function createPresentationWindow(overrides) {
             muteWindow: function () { },
             unMuteWindow: function () { },
         },
+        getTerminal: overrides.getTerminal,
     });
 }
 exports.createPresentationWindow = createPresentationWindow;

package/build/types.d.ts

@@ -140,3 +140,23 @@ export interface AnalyticsEvent {
     source: string;
     productCategory?: string | null;
 }
+export interface ChargeRequest {
+    requestId: string;
+    amount: number;
+    tags?: Record<string, undefined | null | boolean | number | string>;
+    idempotencyId?: string;
+}
+export interface Charge {
+    id: string;
+    status: string;
+}
+export interface ChargeResponse {
+    requestId: string;
+    charge?: Charge;
+    error?: {
+        message: string;
+    };
+}
+export interface Terminal {
+    status: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raydiant/playlist-window-manager",
-  "version": "0.22.0-rc-electron-upgrade-26-03",
+  "version": "0.22.0",
   "description": "Window manager for playlist playback.",
   "main": "build/index.js",
   "scripts": {
@@ -22,7 +22,7 @@
     "@types/jschannel": "^1.0.1",
     "@types/jest": "^24.0.15",
     "@types/uuid": "8.3.0",
-    "electron": "26.2.0",
+    "electron": "10.1.5",
     "jest": "^24.8.0",
     "ts-jest": "^24.0.2",
     "typescript": "^4.1.2"

package/src/BrowserWindowRenderer.ts

@@ -46,11 +46,6 @@ interface BrowserWindowRendererOptions {
   windowCrashHandler?: () => void;
 }
 
-const globalWebPreferences = {
-  // nodeIntegration: true,
-  contextIsolation: false,
-};
-
 export default class BrowserWindowRenderer
   implements PresentationWindowRenderer
 {
@@ -69,7 +64,6 @@ export default class BrowserWindowRenderer
     hasShadow: this.opts.hasShadow,
     webPreferences: {
       preload: path.join(__dirname, 'preload.js'),
-      ...globalWebPreferences,
     },
   });
 
@@ -107,7 +101,6 @@ export default class BrowserWindowRenderer
           ? this.createOrGetPooledBrowserView(windowId, {
               webPreferences: {
                 preload: path.join(__dirname, 'preload.js'),
-                ...globalWebPreferences,
               },
             })
           : this.createOrGetPooledBrowserWindow(windowId, {
@@ -122,7 +115,6 @@ export default class BrowserWindowRenderer
               hasShadow: this.opts.hasShadow,
               webPreferences: {
                 preload: path.join(__dirname, 'preload.js'),
-                ...globalWebPreferences,
               },
             }),
       // If we are creating a child window and renderChildWindowsAsBrowserViews is false that means
@@ -177,12 +169,12 @@ export default class BrowserWindowRenderer
 
     // Attached crash handlers to skip presentation on error.
     window.view.webContents.on(
-      // FIXME
-      // @ts-ignore
       'render-process-gone',
       window.renderProcessGoneCallback
     );
+
     window.view.webContents.on('unresponsive', window.unresponsiveCallback);
+
     if (window.view instanceof BrowserView) {
       this.moveWindowOffscreen(window);
     }
@@ -190,6 +182,7 @@ export default class BrowserWindowRenderer
     this.windows[windowId] = window;
     // Listen for messages from window.
     ipcMain.on(windowId, window.receiveMessageCallback);
+
     if (backgroundColor) {
       // To make a transparent window you need to set it's value to #00000000
       // Electron issue: https://github.com/electron/electron/issues/20357
@@ -286,8 +279,6 @@ export default class BrowserWindowRenderer
 
     // Remove crash handlers
     window.view.webContents.removeListener(
-      // FIXME
-      // @ts-ignore
       'render-process-gone',
       window.renderProcessGoneCallback
     );

package/src/PlaylistWindowManager.ts

@@ -8,7 +8,11 @@ import {
   Theme,
   Logger,
   WorkerState,
-  AnalyticsEvent
+  AnalyticsEvent,
+  Charge,
+  ChargeRequest,
+  ChargeResponse,
+  Terminal,
 } from './types';
 import PresentationWindow from './PresentationWindow';
 import PlaylistWindowManagerState from './PlaylistWindowManagerState';
@@ -67,6 +71,9 @@ export interface PlaylistWindowManagerOptions {
 
   // Called when the current window wants to disable the interrupt lock
   onDisableInterruptLock?: () => void;
+
+  // Called when a window needs the current terminal object.
+  getTerminal?: () => Terminal | null;
 }
 
 // Wait at least 3 seconds before restarting or moving onto the next window
@@ -440,6 +447,43 @@ export default class PlaylistWindowManager extends EventEmitter {
     }
   }
 
+  public sendChargeResponse(response: ChargeResponse) {
+    // 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);
+    }
+  }
+
+  public sendCharge(charge: 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);
+    }
+  }
+
+  public sendTerminal(terminal: Terminal | null) {
+    // 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);
+    }
+  }
+
   private createWindow(pr: RE.NextPresentationID): PresentationWindow {
     const {
       readyTimeoutDurationSeconds,
@@ -449,7 +493,7 @@ export default class PlaylistWindowManager extends EventEmitter {
       logger,
       windowName,
       parentWindowId,
-      isPreview
+      isPreview,
     } = this.options;
 
     if (!this.ruleEngine) {
@@ -503,7 +547,8 @@ export default class PlaylistWindowManager extends EventEmitter {
       ruleEngineState: this.ruleEngine.state,
       globalRule: this.ruleEngine.globalRule,
       isPreview,
-      workerState: this.workerState
+      workerState: this.workerState,
+      getTerminal: this.options.getTerminal,
     });
   }
 
@@ -523,6 +568,7 @@ export default class PlaylistWindowManager extends EventEmitter {
     this.currentWindow.onEnableInterruptLock(this.handleEnableInterruptLock);
     this.currentWindow.onDisableInterruptLock(this.handleDisableInterruptLock);
     this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+    this.currentWindow.onChargeRequest(this.handleChargeRequest);
 
     await this.currentWindow.load();
   }
@@ -695,6 +741,7 @@ export default class PlaylistWindowManager extends EventEmitter {
         this.handleDisableInterruptLock
       );
       this.currentWindow.onAnalyticsEvent(this.handleAnalyticsEvent);
+      this.currentWindow.onChargeRequest(this.handleChargeRequest);
     }
 
     // Play new current window.
@@ -764,6 +811,12 @@ export default class PlaylistWindowManager extends EventEmitter {
     this.emitCurrentWindowEvent('window_analytics_event', event);
   };
 
+  private handleChargeRequest = (request: ChargeRequest) => {
+    // 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);
+  };
+
   private handleCurrentPresentationComplete = async () => {
     const { logger } = this.options;
 
@@ -1005,7 +1058,7 @@ export default class PlaylistWindowManager extends EventEmitter {
     if (window) {
       this.emit(event, {
         ...window.metadata(),
-        data
+        data,
       });
     } else {
       logger.warn(`Attempted to emit ${label} window event but window not set`);
@@ -1022,13 +1075,13 @@ export default class PlaylistWindowManager extends EventEmitter {
 
   private emitCurrentWindowErrorEvent(event: string, error: any) {
     return this.emitCurrentWindowEvent(event, {
-      errorMessage: this.getErrorMessage(error)
+      errorMessage: this.getErrorMessage(error),
     });
   }
 
   private emitNextWindowErrorEvent(event: string, error: any) {
     return this.emitNextWindowEvent(event, {
-      errorMessage: this.getErrorMessage(error)
+      errorMessage: this.getErrorMessage(error),
     });
   }
 

package/src/PresentationWindow.test.ts

@@ -218,4 +218,116 @@ describe('embedded apps', () => {
   });
 });
 
+describe('payments', () => {
+  test('charge request', async () => {
+    const testRenderer = createRenderer();
+
+    const window = createPresentationWindow({
+      windowId: 'test-charge-request',
+      presentation: createPresentation(),
+      applicationVersion: createApplicationVersion({
+        embeddedUrlFormat: 'http://test.local/:input',
+      }),
+      renderer: testRenderer,
+    });
+
+    const callback = jest.fn();
+    window.onChargeRequest(callback);
+
+    await window.load();
+
+    testRenderer.runReceiveMessageCallback('payments-charge-request', {
+      requestId: 'test',
+      amount: 100,
+    });
+
+    expect(callback).toHaveBeenCalledWith({
+      requestId: 'test',
+      amount: 100,
+    });
+
+    // Send charge response.
+
+    window.sendChargeResponse({
+      requestId: 'test',
+      charge: { id: '1', status: 'pending' },
+    });
+
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith(
+      'test-charge-request',
+      'payments-charge-response',
+      { requestId: 'test', charge: { id: '1', status: 'pending' } }
+    );
+  });
+
+  test('subscribe to charge', async () => {
+    const testRenderer = createRenderer();
+
+    const window = createPresentationWindow({
+      windowId: 'test-payments-subscribe-charge',
+      presentation: createPresentation(),
+      applicationVersion: createApplicationVersion({
+        embeddedUrlFormat: 'http://test.local/:input',
+      }),
+      renderer: testRenderer,
+    });
+
+    await window.load();
+
+    testRenderer.runReceiveMessageCallback('payments-subscribe', 'charge');
+
+    window.sendCharge({ id: 'test', status: 'success' });
+
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith(
+      'test-payments-subscribe-charge',
+      'payments-charge-event',
+      { charge: { id: 'test', status: 'success' } }
+    );
+
+    // Unsubscribe should not send a message.
+    testRenderer.runReceiveMessageCallback('payments-unsubscribe', 'charge');
+    window.sendCharge({ id: 'test2', status: 'success' });
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledTimes(1);
+  });
+
+  test('subscribe to terminal', async () => {
+    const testRenderer = createRenderer();
+
+    const window = createPresentationWindow({
+      windowId: 'test-payments-subscribe-terminal',
+      presentation: createPresentation(),
+      applicationVersion: createApplicationVersion({
+        embeddedUrlFormat: 'http://test.local/:input',
+      }),
+      renderer: testRenderer,
+      getTerminal: () => null,
+    });
+
+    await window.load();
+
+    testRenderer.runReceiveMessageCallback('payments-subscribe', 'terminal');
+
+    // Terminal subscriptions should receive the current terminal immediately after subscribing.
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith(
+      'test-payments-subscribe-terminal',
+      'payments-terminal-event',
+      { terminal: null }
+    );
+
+    // Send terminal update event.
+    window.sendTerminal({ status: 'open' });
+
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledWith(
+      'test-payments-subscribe-terminal',
+      'payments-terminal-event',
+      { terminal: { status: 'open' } }
+    );
+
+    // Unsubscribe should not send a message.
+    testRenderer.runReceiveMessageCallback('payments-unsubscribe', 'terminal');
+    window.sendTerminal({ status: 'closed' });
+    expect(testRenderer.sendMessageObject).toHaveBeenCalledTimes(2);
+  });
+});
+
 // TODO: Backfill tests for all legacy and embedded apps.

package/src/PresentationWindow.ts

@@ -20,6 +20,10 @@ import {
   EmbeddedAppMetadata,
   AnalyticsEvent,
   PreviewState,
+  Charge,
+  ChargeRequest,
+  ChargeResponse,
+  Terminal,
 } from './types';
 
 export interface PresentationWindowOptions {
@@ -52,10 +56,11 @@ export interface PresentationWindowOptions {
     properties: any[],
     string: { [key: string]: string }
   ) => void;
+  getTerminal?: () => Terminal | null;
 }
 
 // TODO: Automatically inject latest version when building in CI.
-const defaultAppRendererUrl = 'https://apps.raydiant.com/3.0.0/index.html';
+const defaultAppRendererUrl = 'https://apps.raydiant.com/3.0.4/index.html';
 
 const isValidNumber = (value: any) =>
   typeof value === 'number' && !isNaN(value);
@@ -69,6 +74,18 @@ const isValidAnalyticsEvent = (value: any): value is AnalyticsEvent =>
     value.productCategory === undefined ||
     value.productCategory === null);
 
+const isValidChargeRequest = (value: any): value is ChargeRequest =>
+  value &&
+  typeof value === 'object' &&
+  typeof value.requestId === 'string' &&
+  typeof value.amount === 'number' &&
+  (value.tags === undefined ||
+    value.tags === null ||
+    typeof value.tags === 'object') &&
+  (value.idempotencyId === undefined ||
+    value.idempotencyId === null ||
+    typeof value.idempotencyId === 'string');
+
 export default class PresentationWindow {
   private didReceiveReady: boolean = false;
   private readyCallback: (() => void) | null = null;
@@ -88,6 +105,8 @@ export default class PresentationWindow {
   private disableInterruptLockCallback: (() => void) | null = null;
   private analyticsEventCallback: ((event: AnalyticsEvent) => void) | null =
     null;
+  private chargeRequestCallback: ((request: ChargeRequest) => void) | null =
+    null;
 
   private builderState: BuilderState | undefined;
   private presentation: Presentation;
@@ -102,6 +121,7 @@ export default class PresentationWindow {
   private runtimeSubscriptions = new Set<string>();
   private previewSubscriptions = new Set<string>();
   private previewState: PreviewState = { inputs: {} };
+  private paymentSubscriptions = new Set<string>();
 
   private createObjectURLResolvers: Record<string, (url: string) => void> = {};
   private createObjectURLTimeouts: Record<
@@ -288,6 +308,10 @@ export default class PresentationWindow {
     this.analyticsEventCallback = callback;
   }
 
+  public onChargeRequest(callback: ((request: ChargeRequest) => void) | null) {
+    this.chargeRequestCallback = 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
@@ -394,6 +418,42 @@ export default class PresentationWindow {
     return URL.createObjectURL(blob);
   }
 
+  public sendChargeResponse(response: ChargeResponse) {
+    // TODO: Instead of sending the charge to all windows, we should only send it to the app
+    // that requested the charge. We probably don't want to use the windowId to avoid missing
+    // the events in case the window was closed/restarted. Since we are only sending the charge
+    // id and status this seems ok for now but need to be mindful of sending any sensitive data.
+    this.sendMessageObject('payments-charge-response', {
+      requestId: response.requestId,
+      charge: response.charge,
+      error: response.error,
+    });
+    // Forward the event to the child window managers.
+    Object.values(this.windowManagers).forEach((wm) =>
+      wm.sendChargeResponse(response)
+    );
+  }
+
+  public sendCharge(charge: Charge) {
+    // TODO: Instead of sending the charge to all windows, we should only send it to the app
+    // that requested the charge.
+    if (this.paymentSubscriptions.has('charge')) {
+      this.sendMessageObject('payments-charge-event', { charge });
+    }
+    // Forward the event to the child window managers.
+    Object.values(this.windowManagers).forEach((wm) => wm.sendCharge(charge));
+  }
+
+  public sendTerminal(terminal: Terminal | null) {
+    if (this.paymentSubscriptions.has('terminal')) {
+      this.sendMessageObject('payments-terminal-event', { terminal });
+    }
+    // Forward the event to the child window managers.
+    Object.values(this.windowManagers).forEach((wm) =>
+      wm.sendTerminal(terminal)
+    );
+  }
+
   private isEmbeddedApp() {
     const { applicationVersion, isPreview } = this.options;
 
@@ -714,6 +774,7 @@ export default class PresentationWindow {
         isPreview,
         onEnableInterruptLock: () => this.enableInteruptLock(windowName),
         onDisableInterruptLock: () => this.disableInteruptLock(windowName),
+        getTerminal: this.options.getTerminal,
       });
 
       // Hook up child window manager events to bubble up to the parent.
@@ -733,6 +794,9 @@ export default class PresentationWindow {
         windowManager.on('window_analytics_event', (metadata) => {
           parentWindowManager.emit('window_analytics_event', metadata);
         });
+        windowManager.on('window_charge_request', (metadata) => {
+          parentWindowManager.emit('window_charge_request', metadata);
+        });
       }
 
       this.windowManagers[windowName] = windowManager;
@@ -917,8 +981,14 @@ export default class PresentationWindow {
       }
 
       case 'analytics-event': {
-        if (this.analyticsEventCallback && isValidAnalyticsEvent(payload)) {
-          this.analyticsEventCallback(payload);
+        if (isValidAnalyticsEvent(payload)) {
+          if (this.analyticsEventCallback) {
+            this.analyticsEventCallback(payload);
+          }
+        } else {
+          this.logWarning(
+            `Invalid payload for analytics-event message: ${payload}`
+          );
         }
         break;
       }
@@ -973,6 +1043,53 @@ export default class PresentationWindow {
         break;
       }
 
+      case 'payments-charge-request': {
+        if (isValidChargeRequest(payload)) {
+          if (this.chargeRequestCallback) {
+            this.chargeRequestCallback(payload);
+          }
+        } else {
+          this.logWarning(
+            `Invalid payload for payments-charge-request message: ${payload}`
+          );
+        }
+        break;
+      }
+
+      case 'payments-subscribe': {
+        if (typeof payload === 'string') {
+          this.logInfo(`Received 'worker-subscribe' from window '${windowId}'`);
+          // The payload is the payment subscription type (ex. 'charge', 'terminal')
+          this.paymentSubscriptions.add(payload);
+
+          // Immediately send terminal when subscribing.
+          if (payload === 'terminal' && this.options.getTerminal) {
+            this.sendMessageObject('payments-terminal-event', {
+              terminal: this.options.getTerminal(),
+            });
+          }
+        } else {
+          this.logWarning(
+            `Invalid payload for payments-subscribe message: ${payload}`
+          );
+        }
+        break;
+      }
+
+      case 'payments-unsubscribe': {
+        if (typeof payload === 'string') {
+          this.logInfo(
+            `Received 'payments-unsubscribe' from window '${windowId}'`
+          );
+          this.paymentSubscriptions.delete(payload);
+        } else {
+          this.logWarning(
+            `Invalid payload for payments-unsubscribe message: ${payload}`
+          );
+        }
+        break;
+      }
+
       default: {
         this.logWarning(`Received unknown embedded message type: ${type}`);
       }

package/src/testUtils.ts

@@ -38,6 +38,7 @@ export function createPresentationWindow(
       muteWindow() {},
       unMuteWindow() {},
     },
+    getTerminal: overrides.getTerminal,
   });
 }
 

package/src/types.ts

@@ -173,3 +173,27 @@ export interface AnalyticsEvent {
   source: string;
   productCategory?: string | null;
 }
+
+export interface ChargeRequest {
+  requestId: string;
+  amount: number;
+  tags?: Record<string, undefined | null | boolean | number | string>;
+  idempotencyId?: string;
+}
+
+export interface Charge {
+  id: string;
+  status: string;
+}
+
+export interface ChargeResponse {
+  requestId: string;
+  charge?: Charge;
+  error?: {
+    message: string;
+  };
+}
+
+export interface Terminal {
+  status: string;
+}