@raydiant/playlist-window-manager 0.28.2-rc3 → 0.28.2-rc4

package/build/PlaylistWindowManager.js

@@ -74,7 +74,6 @@ 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) {
@@ -124,7 +123,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_1, _a, next, preview, nextPreviewPresentationId;
+            var logger, isThrottled, now, timeSinceLastComplete, delay, _a, next, preview, nextPreviewPresentationId;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -138,12 +137,12 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                                 isThrottled = true;
                                 // Throttle presentation complete handler if we have not throttled already.
                                 if (this.currentPresentationCompleteTimeout === null) {
-                                    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"));
+                                    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"));
                                     this.currentPresentationCompleteTimeout = setTimeout(function () {
                                         _this.currentPresentationCompleteTimeout = null;
                                         _this.handleCurrentPresentationComplete();
-                                    }, delay_1);
+                                    }, delay);
                                 }
                                 else {
                                     logger.warn("Skipping presentation complete because it is currently throttled");
@@ -906,6 +905,7 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
     PlaylistWindowManager.prototype.swapWindows = function () {
         return __awaiter(this, void 0, void 0, function () {
             var nextPreviewPresentationId, preview, result, nextPresentation, shouldPreload, closeWindowPromise;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -941,22 +941,36 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         if (this.nextWindow) {
                             this.nextWindow.show(this.isFocused);
                         }
-                        if (!this.currentWindow) return [3 /*break*/, 2];
-                        // TODO: Kind of a hack, could use win.on('show') event to trigger hide?
-                        // Would only work in electron environment so need to do in BrowserWindowRenderer.
-                        // Should show be async then?
-                        // Or try paintWhenInitiallyHidden: false?
-                        if (this.options.closeWindowDelayMs !== undefined) {
-                            // Don't await here because this will cause a slight delay when playing the next window.
-                            // Instead we want to wait for window close at the end of this method.
-                            closeWindowPromise = delay(this.options.closeWindowDelayMs);
-                        }
+                        if (!this.currentWindow) return [3 /*break*/, 3];
+                        if (!(this.options.closeWindowDelayMs !== undefined)) return [3 /*break*/, 1];
+                        // Don't await here because this will cause a slight delay when playing the next window.
+                        // Instead we want to wait for window close at the end of this method.
+                        closeWindowPromise = new Promise(function (resolve) {
+                            setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            if (!this.currentWindow) return [3 /*break*/, 2];
+                                            this.currentWindow.hide();
+                                            return [4 /*yield*/, this.removeCurrentWindow()];
+                                        case 1:
+                                            _a.sent();
+                                            _a.label = 2;
+                                        case 2:
+                                            resolve(undefined);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }, _this.options.closeWindowDelayMs);
+                        });
+                        return [3 /*break*/, 3];
+                    case 1:
                         this.currentWindow.hide();
                         return [4 /*yield*/, this.removeCurrentWindow()];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
                     case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
                         // Swap windows.
                         this.currentWindow = this.nextWindow;
                         if (this.currentWindow) {
@@ -984,12 +998,12 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                             this.nextWindow = null;
                             this.nextPresentation = null;
                         }
-                        if (!closeWindowPromise) return [3 /*break*/, 4];
+                        if (!closeWindowPromise) return [3 /*break*/, 5];
                         return [4 /*yield*/, closeWindowPromise];
-                    case 3:
+                    case 4:
                         _a.sent();
-                        _a.label = 4;
-                    case 4: return [2 /*return*/];
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
                 }
             });
         });

package/package.json

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

package/src/PlaylistWindowManager.ts

@@ -89,8 +89,6 @@ 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;
@@ -762,10 +760,19 @@ export default class PlaylistWindowManager extends EventEmitter {
       if (this.options.closeWindowDelayMs !== undefined) {
         // Don't await here because this will cause a slight delay when playing the next window.
         // Instead we want to wait for window close at the end of this method.
-        closeWindowPromise = delay(this.options.closeWindowDelayMs);
+        closeWindowPromise = new Promise((resolve) => {
+          setTimeout(async () => {
+            if (this.currentWindow) {
+              this.currentWindow.hide();
+              await this.removeCurrentWindow();
+            }
+            resolve(undefined);
+          }, this.options.closeWindowDelayMs);
+        });
+      } else {
+        this.currentWindow.hide();
+        await this.removeCurrentWindow();
       }
-      this.currentWindow.hide();
-      await this.removeCurrentWindow();
     }
 
     // Swap windows.