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

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

@@ -904,7 +904,8 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
     };
     PlaylistWindowManager.prototype.swapWindows = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var nextPreviewPresentationId, preview, result, nextPresentation, shouldPreload;
+            var nextPreviewPresentationId, preview, result, nextPresentation, shouldPreload, closeWindowPromise;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -940,13 +941,42 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                         if (this.nextWindow) {
                             this.nextWindow.show(this.isFocused);
                         }
-                        if (!this.currentWindow) return [3 /*break*/, 2];
+                        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) {
+                            // Capture the current window reference to close because this.currentWindow will be
+                            // set to the next window before the timeout fires.
+                            var windowToClose = _this.currentWindow;
+                            setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            if (!windowToClose) return [3 /*break*/, 2];
+                                            // We can't use this.removeCurrentWindow because the currentWindow reference has already
+                                            // changed by the time the timeout fires.
+                                            return [4 /*yield*/, windowToClose.remove()];
+                                        case 1:
+                                            // We can't use this.removeCurrentWindow because the currentWindow reference has already
+                                            // changed by the time the timeout fires.
+                                            _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) {
@@ -974,7 +1004,12 @@ var PlaylistWindowManager = /** @class */ (function (_super) {
                             this.nextWindow = null;
                             this.nextPresentation = null;
                         }
-                        return [2 /*return*/];
+                        if (!closeWindowPromise) return [3 /*break*/, 5];
+                        return [4 /*yield*/, closeWindowPromise];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/];
                 }
             });
         });

package/build/preload.js

@@ -89,3 +89,12 @@ Object.defineProperty(window, 'removeEventListener', {
         }
     },
 });
+// Hide the Cast button on video elements to prevent casting from the device.
+// After trying many different approaches including flags, chrome policies and
+// blocking ports, the only reliable way to hide the Cast button is via CSS without
+// updating every video element with disableRemotePlayback.
+window.addEventListener('DOMContentLoaded', function () {
+    var style = document.createElement('style');
+    style.textContent = "\n    video::-internal-media-controls-overlay-cast-button {\n      display: none !important;\n    }\n  ";
+    document.head.append(style);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raydiant/playlist-window-manager",
-  "version": "0.28.2",
+  "version": "0.29.1-rc1",
   "description": "Window manager for playlist playback.",
   "main": "build/index.js",
   "scripts": {
@@ -11,18 +11,18 @@
     "deploy": "sh tasks/npm-publish.sh"
   },
   "dependencies": {
-    "@raydiant/playlist-rule-engine": "3.3.0",
-    "eventemitter3": "^4.0.7",
     "fast-deep-equal": "^3.1.3",
+    "@raydiant/playlist-rule-engine": "3.3.0",
     "raydiant-kit": "4.7.3",
-    "uuid": "^8.3.0"
+    "uuid": "^8.3.0",
+    "eventemitter3": "^4.0.7"
   },
   "devDependencies": {
     "@babel/core": "^7.5.5",
-    "@types/jest": "^24.0.15",
     "@types/jschannel": "^1.0.1",
+    "@types/jest": "^24.0.15",
     "@types/uuid": "8.3.0",
-    "electron": "28.1.2",
+    "electron": "38.0.0",
     "jest": "^24.8.0",
     "ts-jest": "^24.0.2",
     "typescript": "^4.1.2"

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;
 
@@ -749,9 +751,28 @@ 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.
+    let closeWindowPromise;
     if (this.currentWindow) {
-      this.currentWindow.hide();
-      await this.removeCurrentWindow();
+      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 = new Promise((resolve) => {
+          // Capture the current window reference to close because this.currentWindow will be
+          // set to the next window before the timeout fires.
+          const windowToClose = this.currentWindow;
+          setTimeout(async () => {
+            if (windowToClose) {
+              // We can't use this.removeCurrentWindow because the currentWindow reference has already
+              // changed by the time the timeout fires.
+              await windowToClose.remove();
+            }
+            resolve(undefined);
+          }, this.options.closeWindowDelayMs);
+        });
+      } else {
+        this.currentWindow.hide();
+        await this.removeCurrentWindow();
+      }
     }
 
     // Swap windows.
@@ -784,6 +805,10 @@ export default class PlaylistWindowManager extends EventEmitter {
       this.nextWindow = null;
       this.nextPresentation = null;
     }
+
+    if (closeWindowPromise) {
+      await closeWindowPromise;
+    }
   }
 
   private evalRuleEngine(warnIfPreloadMismatch = true): EvalRuleEngineResult {

package/src/preload.ts

@@ -106,3 +106,18 @@ Object.defineProperty(window, 'removeEventListener', {
     }
   },
 });
+
+// Hide the Cast button on video elements to prevent casting from the device.
+// After trying many different approaches including flags, chrome policies and
+// blocking ports, the only reliable way to hide the Cast button is via CSS without
+// updating every video element with disableRemotePlayback.
+window.addEventListener('DOMContentLoaded', () => {
+  const style = document.createElement('style');
+  style.textContent = `
+    video::-internal-media-controls-overlay-cast-button {
+      display: none !important;
+    }
+  `;
+
+  document.head.append(style);
+});

package/tasks/npm-publish.sh

@@ -10,4 +10,4 @@ mkdir build
 yarn build
 
 # Publish
-yarn publish --access public
+yarn publish --non-interactive --access public