@raydiant/playlist-window-manager 0.28.0 → 0.28.2-rc1

package/build/IFrameRenderer.d.ts

@@ -4,6 +4,7 @@ export default class IFrameRenderer implements PresentationWindowRenderer {
     private windows;
     constructor(container: HTMLElement);
     createWindow({ windowId, bounds, backgroundColor, receiveMessageCallback, }: CreateWindowOptions): Promise<void>;
+    private loadWindowResolvers;
     loadWindow(windowId: string, url: string): Promise<void>;
     updateWindowBounds(windowId: string, bounds: WindowBounds): void;
     showWindow(windowId: string, isFocused: boolean): void;

package/build/IFrameRenderer.js

@@ -42,6 +42,7 @@ var IFrameRenderer = /** @class */ (function () {
         var _this = this;
         this.container = container;
         this.windows = {};
+        this.loadWindowResolvers = [];
         this.globalMessageHandler = function (event) {
             // Ignore messages that don't start with the message prefix.
             if (typeof event.data === 'string' && event.data.startsWith(namespace)) {
@@ -106,18 +107,35 @@ var IFrameRenderer = /** @class */ (function () {
         });
     };
     IFrameRenderer.prototype.loadWindow = function (windowId, url) {
+        var _this = this;
         var window = this.getWindow(windowId);
         if (!window) {
             throw new Error("Failed to update window bounds, missing window id '".concat(windowId, "'"));
         }
         // Return a promise that resolves then the window has successfully loaded.
         return new Promise(function (resolve, reject) {
-            window.frame.onload = function () {
-                resolve();
-            };
-            window.frame.onerror = function () {
-                reject(new Error("Error loading window for '".concat(url, "'")));
-            };
+            _this.loadWindowResolvers.push([resolve, reject]);
+            // If we reassign onload, we may lost any pending promise called previously.
+            // Basically, if this function is called a first time, then it's called a
+            // second time without the first one completes load, the resolve callback
+            // will never be called, and the code that is awaiting for the promise will
+            // never be fulfilled.
+            if (!window.frame.onload) {
+                window.frame.onload = function () {
+                    while (_this.loadWindowResolvers.length) {
+                        var resolve_1 = (_this.loadWindowResolvers.shift() || [])[0];
+                        resolve_1 === null || resolve_1 === void 0 ? void 0 : resolve_1();
+                    }
+                };
+            }
+            if (!window.frame.onerror) {
+                window.frame.onerror = function () {
+                    while (_this.loadWindowResolvers.length) {
+                        var _a = _this.loadWindowResolvers.shift() || [], _ = _a[0], reject_1 = _a[1];
+                        reject_1 === null || reject_1 === void 0 ? void 0 : reject_1(new Error("Error loading window for '".concat(url, "'")));
+                    }
+                };
+            }
             window.frame.src = url;
         });
     };

package/build/PlaylistWindowManager.d.ts

@@ -17,6 +17,7 @@ export interface PlaylistWindowManagerOptions {
     parentWindowId?: string;
     windowName?: string;
     isPreview?: boolean;
+    closeWindowDelayMs?: number;
     onEnableInterruptLock?: () => void;
     onDisableInterruptLock?: () => void;
     getTerminal?: () => Terminal | null;

package/build/PlaylistWindowManager.js

@@ -74,6 +74,7 @@ var WindowLoadError_1 = __importDefault(require("./WindowLoadError"));
 // Wait at least 3 seconds before restarting or moving onto the next window
 // to prevent log spam causing devices to become unresponsive.
 var minTimeBetweenCompletes = 3000;
+var delay = function (ms) { return new Promise(function (res) { return setTimeout(res, ms); }); };
 var PlaylistWindowManager = /** @class */ (function (_super) {
     __extends(PlaylistWindowManager, _super);
     function PlaylistWindowManager(options) {
@@ -123,7 +124,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
             _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 logger, isThrottled, now, timeSinceLastComplete, delay_1, _a, next, preview, nextPreviewPresentationId;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -137,12 +138,12 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                                 isThrottled = true;
                                 // Throttle presentation complete handler if we have not throttled already.
                                 if (this.currentPresentationCompleteTimeout === null) {
-                                    delay = minTimeBetweenCompletes - timeSinceLastComplete + 1;
-                                    logger.warn("Throttling presentation complete handler for ".concat(delay, "ms because it was called again in less than ").concat(minTimeBetweenCompletes, "ms"));
+                                    delay_1 = minTimeBetweenCompletes - timeSinceLastComplete + 1;
+                                    logger.warn("Throttling presentation complete handler for ".concat(delay_1, "ms because it was called again in less than ").concat(minTimeBetweenCompletes, "ms"));
                                     this.currentPresentationCompleteTimeout = setTimeout(function () {
                                         _this.currentPresentationCompleteTimeout = null;
                                         _this.handleCurrentPresentationComplete();
-                                    }, delay);
+                                    }, delay_1);
                                 }
                                 else {
                                     logger.warn("Skipping presentation complete because it is currently throttled");
@@ -940,13 +941,19 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         if (this.nextWindow) {
                             this.nextWindow.show(this.isFocused);
                         }
-                        if (!this.currentWindow) return [3 /*break*/, 2];
-                        this.currentWindow.hide();
-                        return [4 /*yield*/, this.removeCurrentWindow()];
+                        if (!this.currentWindow) return [3 /*break*/, 4];
+                        if (!(this.options.closeWindowDelayMs !== undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, delay(this.options.closeWindowDelayMs)];
                     case 1:
                         _a.sent();
                         _a.label = 2;
                     case 2:
+                        this.currentWindow.hide();
+                        return [4 /*yield*/, this.removeCurrentWindow()];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
                         // Swap windows.
                         this.currentWindow = this.nextWindow;
                         if (this.currentWindow) {

package/package.json

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

package/src/IFrameRenderer.ts

@@ -69,6 +69,8 @@ export default class IFrameRenderer implements PresentationWindowRenderer {
     this.container.appendChild(frame);
   }
 
+  private loadWindowResolvers: Array<[() => void, (err: Error) => void]> = [];
+
   public loadWindow(windowId: string, url: string) {
     const window = this.getWindow(windowId);
     if (!window) {
@@ -79,13 +81,30 @@ export default class IFrameRenderer implements PresentationWindowRenderer {
 
     // Return a promise that resolves then the window has successfully loaded.
     return new Promise<void>((resolve, reject) => {
-      window.frame.onload = () => {
-        resolve();
-      };
+      this.loadWindowResolvers.push([resolve, reject]);
+
+      // If we reassign onload, we may lost any pending promise called previously.
+      // Basically, if this function is called a first time, then it's called a
+      // second time without the first one completes load, the resolve callback
+      // will never be called, and the code that is awaiting for the promise will
+      // never be fulfilled.
+      if (!window.frame.onload) {
+        window.frame.onload = () => {
+          while (this.loadWindowResolvers.length) {
+            const [resolve] = this.loadWindowResolvers.shift() || [];
+            resolve?.();
+          }
+        };
+      }
 
-      window.frame.onerror = () => {
-        reject(new Error(`Error loading window for '${url}'`));
-      };
+      if (!window.frame.onerror) {
+        window.frame.onerror = () => {
+          while (this.loadWindowResolvers.length) {
+            const [_, reject] = this.loadWindowResolvers.shift() || [];
+            reject?.(new Error(`Error loading window for '${url}'`));
+          }
+        };
+      }
 
       window.frame.src = url;
     });

package/src/PlaylistWindowManager.ts

@@ -70,6 +70,8 @@ export interface PlaylistWindowManagerOptions {
   // Set to true to render the presentation window as a preview.
   isPreview?: boolean;
 
+  closeWindowDelayMs?: number;
+
   // Called when the current window wants to enable the interrupt lock
   onEnableInterruptLock?: () => void;
 
@@ -87,6 +89,8 @@ export interface PlaylistWindowManagerOptions {
 // to prevent log spam causing devices to become unresponsive.
 const minTimeBetweenCompletes = 3000;
 
+const delay = (ms: number) => new Promise((res) => setTimeout(res, ms));
+
 interface EvalRuleEngineResult {
   next: RE.NextPresentationID;
   preview: RE.NextPresentationID;
@@ -750,6 +754,9 @@ export default class PlaylistWindowManager extends EventEmitter {
     // If current window isn't defined we don't need to hide it but we still
     // want to make the next window the new current window.
     if (this.currentWindow) {
+      if (this.options.closeWindowDelayMs !== undefined) {
+        await delay(this.options.closeWindowDelayMs);
+      }
       this.currentWindow.hide();
       await this.removeCurrentWindow();
     }