fcr-ui-scene 3.8.1 → 3.8.2

package/lib-es/electron/window-proxy/browser-window-proxy.js

@@ -0,0 +1,720 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.set.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.map.delete-all.js";
+import "core-js/modules/esnext.map.emplace.js";
+import "core-js/modules/esnext.map.every.js";
+import "core-js/modules/esnext.map.filter.js";
+import "core-js/modules/esnext.map.find.js";
+import "core-js/modules/esnext.map.find-key.js";
+import "core-js/modules/esnext.map.includes.js";
+import "core-js/modules/esnext.map.key-of.js";
+import "core-js/modules/esnext.map.map-keys.js";
+import "core-js/modules/esnext.map.map-values.js";
+import "core-js/modules/esnext.map.merge.js";
+import "core-js/modules/esnext.map.reduce.js";
+import "core-js/modules/esnext.map.some.js";
+import "core-js/modules/esnext.map.update.js";
+import "core-js/modules/esnext.set.add-all.js";
+import "core-js/modules/esnext.set.delete-all.js";
+import "core-js/modules/esnext.set.difference.v2.js";
+import "core-js/modules/esnext.set.difference.js";
+import "core-js/modules/esnext.set.every.js";
+import "core-js/modules/esnext.set.filter.js";
+import "core-js/modules/esnext.set.find.js";
+import "core-js/modules/esnext.set.intersection.v2.js";
+import "core-js/modules/esnext.set.intersection.js";
+import "core-js/modules/esnext.set.is-disjoint-from.v2.js";
+import "core-js/modules/esnext.set.is-disjoint-from.js";
+import "core-js/modules/esnext.set.is-subset-of.v2.js";
+import "core-js/modules/esnext.set.is-subset-of.js";
+import "core-js/modules/esnext.set.is-superset-of.v2.js";
+import "core-js/modules/esnext.set.is-superset-of.js";
+import "core-js/modules/esnext.set.join.js";
+import "core-js/modules/esnext.set.map.js";
+import "core-js/modules/esnext.set.reduce.js";
+import "core-js/modules/esnext.set.some.js";
+import "core-js/modules/esnext.set.symmetric-difference.v2.js";
+import "core-js/modules/esnext.set.symmetric-difference.js";
+import "core-js/modules/esnext.set.union.v2.js";
+import "core-js/modules/esnext.set.union.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { ipcRenderer } from 'electron';
+import { BrowserWindowIPCAction } from '../ipc-protocol';
+/**
+ * BrowserWindow 代理类
+ * 通过 IPC 通信与主进程中的 BrowserWindow 进行交互
+ */
+export var BrowserWindowProxyImpl = /*#__PURE__*/function () {
+  function BrowserWindowProxyImpl(windowId) {
+    _classCallCheck(this, BrowserWindowProxyImpl);
+    _defineProperty(this, "_eventListeners", new Map());
+    _defineProperty(this, "_isDestroyed", false);
+    _defineProperty(this, "_runtimeEventListener", null);
+    _defineProperty(this, "_addBrowserWindowEventListener", function (listener) {
+      ipcRenderer.addListener('browser-window-event', listener);
+    });
+    _defineProperty(this, "_removeBrowserWindowEventListener", function (listener) {
+      ipcRenderer.removeListener('browser-window-event', listener);
+    });
+    // 如果没有提供 windowId，尝试从 window 对象获取
+    this._windowId = windowId;
+    this._setupEventListener();
+    console.log("BrowserWindowProxy created for windowId: ".concat(this._windowId));
+  }
+  return _createClass(BrowserWindowProxyImpl, [{
+    key: "windowId",
+    get: function get() {
+      return this._windowId;
+    }
+
+    /**
+     * 检查窗口是否已销毁
+     */
+  }, {
+    key: "isDestroyed",
+    value: function isDestroyed() {
+      return this._isDestroyed;
+    }
+  }, {
+    key: "moveTop",
+    value: function () {
+      var _moveTop = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.MOVE_TOP);
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function moveTop() {
+        return _moveTop.apply(this, arguments);
+      }
+      return moveTop;
+    }()
+  }, {
+    key: "setPosition",
+    value: function () {
+      var _setPosition = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(x, y) {
+        var params;
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              params = {
+                x: x,
+                y: y
+              };
+              _context2.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.SET_POSITION, params);
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function setPosition(_x, _x2) {
+        return _setPosition.apply(this, arguments);
+      }
+      return setPosition;
+    }()
+  }, {
+    key: "getPosition",
+    value: function () {
+      var _getPosition = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var response;
+        return _regeneratorRuntime.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.GET_POSITION);
+            case 1:
+              response = _context3.sent;
+              return _context3.abrupt("return", response.data);
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function getPosition() {
+        return _getPosition.apply(this, arguments);
+      }
+      return getPosition;
+    }()
+  }, {
+    key: "close",
+    value: function () {
+      var _close = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        return _regeneratorRuntime.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.CLOSE);
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function close() {
+        return _close.apply(this, arguments);
+      }
+      return close;
+    }()
+  }, {
+    key: "show",
+    value: function () {
+      var _show = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+        return _regeneratorRuntime.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.SHOW);
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function show() {
+        return _show.apply(this, arguments);
+      }
+      return show;
+    }()
+  }, {
+    key: "hide",
+    value: function () {
+      var _hide = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+        return _regeneratorRuntime.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.HIDE);
+            case 1:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function hide() {
+        return _hide.apply(this, arguments);
+      }
+      return hide;
+    }()
+  }, {
+    key: "focus",
+    value: function () {
+      var _focus = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+        return _regeneratorRuntime.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.FOCUS);
+            case 1:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function focus() {
+        return _focus.apply(this, arguments);
+      }
+      return focus;
+    }()
+  }, {
+    key: "maximize",
+    value: function () {
+      var _maximize = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+        return _regeneratorRuntime.wrap(function (_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.MAXIMIZE);
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function maximize() {
+        return _maximize.apply(this, arguments);
+      }
+      return maximize;
+    }()
+  }, {
+    key: "unmaximize",
+    value: function () {
+      var _unmaximize = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+        return _regeneratorRuntime.wrap(function (_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              _context9.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.UNMAXIMIZE);
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function unmaximize() {
+        return _unmaximize.apply(this, arguments);
+      }
+      return unmaximize;
+    }()
+  }, {
+    key: "isVisible",
+    value: function () {
+      var _isVisible = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
+        var response;
+        return _regeneratorRuntime.wrap(function (_context0) {
+          while (1) switch (_context0.prev = _context0.next) {
+            case 0:
+              _context0.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.IS_VISIBLE);
+            case 1:
+              response = _context0.sent;
+              return _context0.abrupt("return", response.data);
+            case 2:
+            case "end":
+              return _context0.stop();
+          }
+        }, _callee0, this);
+      }));
+      function isVisible() {
+        return _isVisible.apply(this, arguments);
+      }
+      return isVisible;
+    }()
+  }, {
+    key: "isMaximized",
+    value: function () {
+      var _isMaximized = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee1() {
+        var response;
+        return _regeneratorRuntime.wrap(function (_context1) {
+          while (1) switch (_context1.prev = _context1.next) {
+            case 0:
+              _context1.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.IS_MAXIMIZED);
+            case 1:
+              response = _context1.sent;
+              return _context1.abrupt("return", response.data);
+            case 2:
+            case "end":
+              return _context1.stop();
+          }
+        }, _callee1, this);
+      }));
+      function isMaximized() {
+        return _isMaximized.apply(this, arguments);
+      }
+      return isMaximized;
+    }()
+  }, {
+    key: "isFullScreen",
+    value: function () {
+      var _isFullScreen = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+        var response;
+        return _regeneratorRuntime.wrap(function (_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              _context10.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.IS_FULLSCREEN);
+            case 1:
+              response = _context10.sent;
+              return _context10.abrupt("return", response.data);
+            case 2:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function isFullScreen() {
+        return _isFullScreen.apply(this, arguments);
+      }
+      return isFullScreen;
+    }()
+  }, {
+    key: "getTitle",
+    value: function () {
+      var _getTitle = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+        var response;
+        return _regeneratorRuntime.wrap(function (_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              _context11.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.GET_TITLE);
+            case 1:
+              response = _context11.sent;
+              return _context11.abrupt("return", response.data);
+            case 2:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, this);
+      }));
+      function getTitle() {
+        return _getTitle.apply(this, arguments);
+      }
+      return getTitle;
+    }()
+  }, {
+    key: "getBounds",
+    value: function () {
+      var _getBounds = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+        var response;
+        return _regeneratorRuntime.wrap(function (_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              _context12.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.GET_BOUNDS);
+            case 1:
+              response = _context12.sent;
+              return _context12.abrupt("return", response.data);
+            case 2:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this);
+      }));
+      function getBounds() {
+        return _getBounds.apply(this, arguments);
+      }
+      return getBounds;
+    }()
+    /**
+     * 窗口设置方法
+     */
+  }, {
+    key: "setBounds",
+    value: (function () {
+      var _setBounds = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee13(bounds) {
+        var params;
+        return _regeneratorRuntime.wrap(function (_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              params = {
+                bounds: bounds
+              };
+              _context13.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.SET_BOUNDS, params);
+            case 1:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function setBounds(_x3) {
+        return _setBounds.apply(this, arguments);
+      }
+      return setBounds;
+    }())
+  }, {
+    key: "setFullScreen",
+    value: function () {
+      var _setFullScreen = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee14(fullscreen) {
+        var params;
+        return _regeneratorRuntime.wrap(function (_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              params = {
+                fullscreen: fullscreen
+              };
+              _context14.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.SET_FULLSCREEN, params);
+            case 1:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function setFullScreen(_x4) {
+        return _setFullScreen.apply(this, arguments);
+      }
+      return setFullScreen;
+    }()
+  }, {
+    key: "setIgnoreMouseEvents",
+    value: function () {
+      var _setIgnoreMouseEvents = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee15(ignore, options) {
+        var params;
+        return _regeneratorRuntime.wrap(function (_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              params = {
+                ignore: ignore,
+                options: options
+              };
+              _context15.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.SET_IGNORE_MOUSE_EVENTS, params);
+            case 1:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this);
+      }));
+      function setIgnoreMouseEvents(_x5, _x6) {
+        return _setIgnoreMouseEvents.apply(this, arguments);
+      }
+      return setIgnoreMouseEvents;
+    }()
+  }, {
+    key: "setAlwaysOnTop",
+    value: function () {
+      var _setAlwaysOnTop = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee16(flag, level, relativeLevel) {
+        var params;
+        return _regeneratorRuntime.wrap(function (_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              params = {
+                flag: flag,
+                level: level,
+                relativeLevel: relativeLevel
+              };
+              _context16.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.SET_ALWAYS_ON_TOP, params);
+            case 1:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function setAlwaysOnTop(_x7, _x8, _x9) {
+        return _setAlwaysOnTop.apply(this, arguments);
+      }
+      return setAlwaysOnTop;
+    }()
+  }, {
+    key: "setPreventClose",
+    value: function () {
+      var _setPreventClose = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee17(prevent) {
+        var params;
+        return _regeneratorRuntime.wrap(function (_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              params = {
+                prevent: prevent
+              };
+              _context17.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.SET_PREVENT_CLOSE, params);
+            case 1:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this);
+      }));
+      function setPreventClose(_x0) {
+        return _setPreventClose.apply(this, arguments);
+      }
+      return setPreventClose;
+    }()
+    /**
+     * 事件监听方法
+     */
+  }, {
+    key: "addListener",
+    value: function addListener(event, listener) {
+      if (!this._eventListeners.has(event)) {
+        this._eventListeners.set(event, new Set());
+        // 向主进程注册事件监听
+        this._registerEventListener([event]);
+      }
+      this._eventListeners.get(event).add(listener);
+    }
+  }, {
+    key: "removeListener",
+    value: function removeListener(event, listener) {
+      var listeners = this._eventListeners.get(event);
+      if (listeners) {
+        listeners["delete"](listener);
+        if (listeners.size === 0) {
+          this._eventListeners["delete"](event);
+          // 向主进程取消事件监听
+          this._unregisterEventListener([event]);
+        }
+      }
+    }
+  }, {
+    key: "removeAllListeners",
+    value: function removeAllListeners(event) {
+      if (event) {
+        this._eventListeners["delete"](event);
+        this._unregisterEventListener([event]);
+      } else {
+        var events = Array.from(this._eventListeners.keys());
+        this._eventListeners.clear();
+        this._unregisterEventListener(events);
+      }
+    }
+
+    /**
+     * 销毁代理对象
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.removeAllListeners();
+      this._removeEventListener();
+      this._isDestroyed = true;
+    }
+
+    /**
+     * 私有方法
+     */
+  }, {
+    key: "_sendIpcRequest",
+    value: (function () {
+      var _sendIpcRequest2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee18(action, payload) {
+        var request, result, _t;
+        return _regeneratorRuntime.wrap(function (_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              if (!this._isDestroyed) {
+                _context18.next = 1;
+                break;
+              }
+              throw new Error('BrowserWindow proxy has been destroyed');
+            case 1:
+              request = {
+                windowId: this._windowId,
+                action: action,
+                payload: payload
+              };
+              _context18.prev = 2;
+              _context18.next = 3;
+              return ipcRenderer.invoke('browser-window-request', request);
+            case 3:
+              result = _context18.sent;
+              return _context18.abrupt("return", {
+                success: true,
+                data: result
+              });
+            case 4:
+              _context18.prev = 4;
+              _t = _context18["catch"](2);
+              throw new Error(_t instanceof Error ? _t.message : 'Unknown error');
+            case 5:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this, [[2, 4]]);
+      }));
+      function _sendIpcRequest(_x1, _x10) {
+        return _sendIpcRequest2.apply(this, arguments);
+      }
+      return _sendIpcRequest;
+    }())
+  }, {
+    key: "_registerEventListener",
+    value: function () {
+      var _registerEventListener2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee19(events) {
+        var params;
+        return _regeneratorRuntime.wrap(function (_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              params = {
+                events: events
+              };
+              _context19.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.REGISTER_EVENT_LISTENER, params);
+            case 1:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this);
+      }));
+      function _registerEventListener(_x11) {
+        return _registerEventListener2.apply(this, arguments);
+      }
+      return _registerEventListener;
+    }()
+  }, {
+    key: "_unregisterEventListener",
+    value: function () {
+      var _unregisterEventListener2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee20(events) {
+        var params;
+        return _regeneratorRuntime.wrap(function (_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
+            case 0:
+              params = {
+                events: events
+              };
+              _context20.next = 1;
+              return this._sendIpcRequest(BrowserWindowIPCAction.UNREGISTER_EVENT_LISTENER, params);
+            case 1:
+            case "end":
+              return _context20.stop();
+          }
+        }, _callee20, this);
+      }));
+      function _unregisterEventListener(_x12) {
+        return _unregisterEventListener2.apply(this, arguments);
+      }
+      return _unregisterEventListener;
+    }()
+  }, {
+    key: "_setupEventListener",
+    value: function _setupEventListener() {
+      var _this = this;
+      // 使用 renderer 封装的 browser-window-event 监听方法
+      this._runtimeEventListener = function (_event, notification) {
+        _this._handleWindowEvent(_event, notification);
+      };
+      this._addBrowserWindowEventListener(this._runtimeEventListener);
+    }
+  }, {
+    key: "_removeEventListener",
+    value: function _removeEventListener() {
+      if (this._runtimeEventListener) {
+        this._removeBrowserWindowEventListener(this._runtimeEventListener);
+        this._runtimeEventListener = null;
+      }
+    }
+  }, {
+    key: "_handleWindowEvent",
+    value: function _handleWindowEvent(_event, notification) {
+      if (notification.windowId !== this._windowId) {
+        return;
+      }
+      var eventName = this._mapEventActionToName(notification.event);
+      var listeners = this._eventListeners.get(eventName);
+      if (listeners) {
+        listeners.forEach(function (listener) {
+          try {
+            listener(notification.data);
+          } catch (error) {
+            console.error("Error in event listener for ".concat(eventName, ":"), error);
+          }
+        });
+      }
+
+      // 处理特殊事件
+      if (notification.event === BrowserWindowIPCAction.EVENT_CLOSED) {
+        this._isDestroyed = true;
+      }
+    }
+  }, {
+    key: "_mapEventActionToName",
+    value: function _mapEventActionToName(action) {
+      var eventMap = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, BrowserWindowIPCAction.EVENT_SHOW, 'show'), BrowserWindowIPCAction.EVENT_HIDE, 'hide'), BrowserWindowIPCAction.EVENT_RESIZED, 'resized'), BrowserWindowIPCAction.EVENT_MOVED, 'moved'), BrowserWindowIPCAction.EVENT_CLOSE, 'close'), BrowserWindowIPCAction.EVENT_CLOSED, 'closed'), BrowserWindowIPCAction.EVENT_FOCUS, 'focus'), BrowserWindowIPCAction.EVENT_BLUR, 'blur');
+      return eventMap[action] || action;
+    }
+  }]);
+}();