fcr-ui-scene 3.8.1 → 3.8.2

package/lib-es/electron/window-proxy/main-process-handler.js

@@ -0,0 +1,441 @@
+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.concat.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.date.to-json.js";
+import "core-js/modules/es.function.bind.js";
+import "core-js/modules/es.json.stringify.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 { ipcMain } from 'electron';
+import { BrowserWindowIPCAction } from '../ipc-protocol';
+import { getLogger } from '../logger';
+
+/**
+ * 主进程中的 BrowserWindow IPC 处理器
+ */
+export var BrowserWindowIPCHandler = /*#__PURE__*/function () {
+  function BrowserWindowIPCHandler() {
+    _classCallCheck(this, BrowserWindowIPCHandler);
+    _defineProperty(this, "logger", getLogger());
+    _defineProperty(this, "_windows", new Map());
+    _defineProperty(this, "_frameNameToId", new Map());
+    _defineProperty(this, "_preventCloseWindows", new Set());
+    _defineProperty(this, "_windowEventListeners", new Map());
+    _defineProperty(this, "_mainWindow", null);
+    this._setupIpcHandlers();
+  }
+
+  /**
+   * 设置主窗口，所有事件通知都通过主窗口发送
+   */
+  return _createClass(BrowserWindowIPCHandler, [{
+    key: "setMainWindow",
+    value: function setMainWindow(mainWindow) {
+      this.logger.info('Set main window for event broadcasting');
+      this._mainWindow = mainWindow;
+    }
+
+    /**
+     * 注册窗口
+     */
+  }, {
+    key: "registerWindow",
+    value: function registerWindow(windowId, window, frameName) {
+      var _this = this;
+      this.logger.info("Register window: ".concat(windowId, ", frameName: ").concat(frameName, ", remaining windows: ").concat(this._windows.size));
+      this._windows.set(windowId, window);
+      this._frameNameToId.set(frameName, windowId);
+      this._windowEventListeners.set(windowId, new Map());
+      var closeListener = function closeListener(e) {
+        var isMainWindow = frameName === 'main';
+        var shouldPreventClose = _this._preventCloseWindows.has(windowId);
+        if (isMainWindow) {
+          _this._handleMainWindowClose(e, windowId, shouldPreventClose);
+        } else {
+          _this._handleSubWindowClose(e, window, windowId, shouldPreventClose);
+        }
+      };
+      window.on('close', closeListener);
+      var _closedListener = function closedListener() {
+        _this.logger.info("Unregister window: ".concat(windowId, ", due to closed event, frameName: ").concat(frameName, ", remaining windows: ").concat(_this._windows.size));
+        window.off('close', closeListener);
+        window.off('closed', _closedListener);
+        _this._unregisterWindow(windowId);
+      };
+
+      // 监听窗口销毁事件
+      window.on('closed', _closedListener);
+    }
+  }, {
+    key: "clearAllWindows",
+    value: function clearAllWindows() {
+      var _this2 = this;
+      this.logger.info('Clear all registered windows');
+      this._windows.forEach(function (window, windowId) {
+        if (window === _this2._mainWindow) return;
+
+        // this._unregisterWindow(windowId);
+
+        if (!window.isDestroyed()) {
+          window.destroy();
+        }
+      });
+    }
+
+    /**
+     * 注销窗口
+     */
+    // unregisterWindow(windowId: string): void {
+    //   this.logger.info(`Unregister window: ${windowId}`);
+    //   this._unregisterWindow(windowId);
+    // }
+
+    /**
+     * 获取窗口
+     */
+  }, {
+    key: "getWindow",
+    value: function getWindow(frameName) {
+      var windowId = this._frameNameToId.get(frameName);
+      if (windowId) {
+        return this._windows.get(windowId);
+      }
+      this.logger.warn("cannot find window for frameName: ".concat(frameName));
+      return undefined;
+    }
+  }, {
+    key: "_unregisterWindow",
+    value: function _unregisterWindow(windowId) {
+      var _this3 = this;
+      var window = this._windows.get(windowId);
+      if (window) {
+        // 移除所有事件监听器
+        var listeners = this._windowEventListeners.get(windowId);
+        if (listeners) {
+          listeners.forEach(function (listener, event) {
+            window.removeListener(event, listener);
+          });
+        }
+        this._windows["delete"](windowId);
+        this._frameNameToId.forEach(function (id, name) {
+          if (id === windowId) {
+            _this3._frameNameToId["delete"](name);
+          }
+        });
+        this._preventCloseWindows["delete"](windowId);
+        this._windowEventListeners["delete"](windowId);
+      }
+    }
+  }, {
+    key: "_setupIpcHandlers",
+    value: function _setupIpcHandlers() {
+      ipcMain.handle('browser-window-request', this._handleWindowRequest.bind(this));
+    }
+  }, {
+    key: "_handleWindowRequest",
+    value: function () {
+      var _handleWindowRequest2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_event, data) {
+        var windowId, action, payload, windowIdStr, window;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              this.logger.info("Received window request: ".concat(JSON.stringify(data)));
+              windowId = data.windowId, action = data.action, payload = data.payload;
+              windowIdStr = "".concat(windowId);
+              window = this._windows.get(windowIdStr);
+              if (!(!window || window.isDestroyed())) {
+                _context.next = 1;
+                break;
+              }
+              throw new Error("Window ".concat(windowId, " not found or destroyed"));
+            case 1:
+              _context.next = 2;
+              return this._executeWindowAction(window, windowIdStr, action, payload);
+            case 2:
+              return _context.abrupt("return", _context.sent);
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function _handleWindowRequest(_x, _x2) {
+        return _handleWindowRequest2.apply(this, arguments);
+      }
+      return _handleWindowRequest;
+    }()
+  }, {
+    key: "_executeWindowAction",
+    value: function () {
+      var _executeWindowAction2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(window, windowId, action, payload) {
+        var posParams, bounds, preventCloseParams, registerParams, unregisterParams, _t;
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              this.logger.info("Execute window action: ".concat(action, ", windowId: ").concat(windowId));
+              _t = action;
+              _context2.next = _t === BrowserWindowIPCAction.MOVE_TOP ? 1 : _t === BrowserWindowIPCAction.SET_POSITION ? 2 : _t === BrowserWindowIPCAction.GET_POSITION ? 3 : _t === BrowserWindowIPCAction.CLOSE ? 4 : _t === BrowserWindowIPCAction.SHOW ? 5 : _t === BrowserWindowIPCAction.HIDE ? 6 : _t === BrowserWindowIPCAction.FOCUS ? 7 : _t === BrowserWindowIPCAction.MAXIMIZE ? 8 : _t === BrowserWindowIPCAction.UNMAXIMIZE ? 9 : _t === BrowserWindowIPCAction.IS_VISIBLE ? 10 : _t === BrowserWindowIPCAction.IS_MAXIMIZED ? 11 : _t === BrowserWindowIPCAction.IS_FULLSCREEN ? 12 : _t === BrowserWindowIPCAction.GET_TITLE ? 13 : _t === BrowserWindowIPCAction.GET_BOUNDS ? 14 : _t === BrowserWindowIPCAction.SET_PREVENT_CLOSE ? 15 : _t === BrowserWindowIPCAction.REGISTER_EVENT_LISTENER ? 16 : _t === BrowserWindowIPCAction.UNREGISTER_EVENT_LISTENER ? 17 : 18;
+              break;
+            case 1:
+              window.moveTop();
+              return _context2.abrupt("continue", 19);
+            case 2:
+              posParams = payload;
+              window.setPosition(posParams.x, posParams.y);
+              return _context2.abrupt("continue", 19);
+            case 3:
+              return _context2.abrupt("return", window.getPosition());
+            case 4:
+              window.close();
+              return _context2.abrupt("continue", 19);
+            case 5:
+              window.show();
+              return _context2.abrupt("continue", 19);
+            case 6:
+              window.hide();
+              return _context2.abrupt("continue", 19);
+            case 7:
+              window.focus();
+              return _context2.abrupt("continue", 19);
+            case 8:
+              window.maximize();
+              return _context2.abrupt("continue", 19);
+            case 9:
+              window.unmaximize();
+              return _context2.abrupt("continue", 19);
+            case 10:
+              return _context2.abrupt("return", window.isVisible());
+            case 11:
+              return _context2.abrupt("return", window.isMaximized());
+            case 12:
+              return _context2.abrupt("return", window.isFullScreen());
+            case 13:
+              return _context2.abrupt("return", window.getTitle());
+            case 14:
+              bounds = window.getBounds();
+              return _context2.abrupt("return", {
+                x: bounds.x,
+                y: bounds.y,
+                width: bounds.width,
+                height: bounds.height
+              });
+            case 15:
+              preventCloseParams = payload;
+              if (preventCloseParams.prevent) {
+                this.logger.info("Set prevent close for window: ".concat(windowId));
+                this._preventCloseWindows.add(windowId);
+              } else {
+                this.logger.info("Unset prevent close for window: ".concat(windowId));
+                this._preventCloseWindows["delete"](windowId);
+              }
+              return _context2.abrupt("continue", 19);
+            case 16:
+              registerParams = payload;
+              this._registerWindowEventListeners(window, windowId, registerParams.events);
+              return _context2.abrupt("continue", 19);
+            case 17:
+              unregisterParams = payload;
+              this._unregisterWindowEventListeners(window, windowId, unregisterParams.events);
+              return _context2.abrupt("continue", 19);
+            case 18:
+              throw new Error("Unknown action: ".concat(action));
+            case 19:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function _executeWindowAction(_x3, _x4, _x5, _x6) {
+        return _executeWindowAction2.apply(this, arguments);
+      }
+      return _executeWindowAction;
+    }()
+  }, {
+    key: "_registerWindowEventListeners",
+    value: function _registerWindowEventListeners(window, windowId, events) {
+      var _this4 = this;
+      this.logger.info("Register event listeners for window ".concat(windowId, ": ").concat(events));
+      var windowListeners = this._windowEventListeners.get(windowId);
+      if (!windowListeners) return;
+      events.forEach(function (eventName) {
+        if (windowListeners.has(eventName)) {
+          return; // 已经注册过了
+        }
+        var listener = function listener() {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          _this4._notifyWindowEvent(window, windowId, eventName, args);
+        };
+        windowListeners.set(eventName, listener);
+        _this4.logger.info("Add listener for event ".concat(eventName, " on window ").concat(windowId));
+        window.on(eventName, listener);
+      });
+    }
+  }, {
+    key: "_unregisterWindowEventListeners",
+    value: function _unregisterWindowEventListeners(window, windowId, events) {
+      this.logger.info("Unregister event listeners for window ".concat(windowId, ": ").concat(events));
+      var windowListeners = this._windowEventListeners.get(windowId);
+      if (!windowListeners) return;
+      events.forEach(function (eventName) {
+        var listener = windowListeners.get(eventName);
+        if (listener) {
+          window.removeListener(eventName, listener);
+          windowListeners["delete"](eventName);
+        }
+      });
+    }
+  }, {
+    key: "_notifyWindowEvent",
+    value: function _notifyWindowEvent(window, windowId, eventName, args) {
+      // isDestroyed is true when 'closed' event is emitted
+      if (eventName !== 'closed' && window.isDestroyed()) {
+        this.logger.info("window is destroyed, skip notify event: ".concat(eventName, ", windowId: ").concat(windowId));
+        return;
+      }
+      var actionMap = {
+        show: BrowserWindowIPCAction.EVENT_SHOW,
+        hide: BrowserWindowIPCAction.EVENT_HIDE,
+        resized: BrowserWindowIPCAction.EVENT_RESIZED,
+        moved: BrowserWindowIPCAction.EVENT_MOVED,
+        close: BrowserWindowIPCAction.EVENT_CLOSE,
+        closed: BrowserWindowIPCAction.EVENT_CLOSED,
+        focus: BrowserWindowIPCAction.EVENT_FOCUS,
+        blur: BrowserWindowIPCAction.EVENT_BLUR
+      };
+      var action = actionMap[eventName];
+      if (!action) return;
+
+      // 根据事件类型转换数据，确保可序列化
+      var eventData = null;
+      switch (eventName) {
+        case 'resized':
+        case 'moved':
+          // 对于 resized 和 moved 事件，传递窗口的 bounds 信息
+          var bounds = window.getBounds();
+          eventData = {
+            x: bounds.x,
+            y: bounds.y,
+            width: bounds.width,
+            height: bounds.height
+          };
+          break;
+        case 'show':
+        case 'hide':
+        case 'focus':
+        case 'blur':
+        case 'close':
+        case 'closed':
+          // 这些事件不需要额外数据
+          eventData = null;
+          break;
+        default:
+          // 对于其他事件，尝试序列化 args，如果失败则设为 null
+          try {
+            eventData = args.length === 1 ? args[0] : args;
+            JSON.stringify(eventData); // 测试是否可序列化
+          } catch (_unused) {
+            eventData = null;
+          }
+      }
+      var notification = {
+        windowId: windowId,
+        event: action,
+        data: eventData
+      };
+      try {
+        this.logger.info("notify window event: ".concat(JSON.stringify(notification)));
+
+        // 通过主窗口发送事件，因为所有监听器都在主窗口的 preload 中
+        if (this._mainWindow && !this._mainWindow.isDestroyed()) {
+          this._mainWindow.webContents.send('browser-window-event', notification);
+        } else {
+          this.logger.warn('main window not available for event broadcasting');
+        }
+      } catch (error) {
+        this.logger.error("failed to send window event notification: ".concat(error));
+      }
+    }
+
+    /**
+     * 处理主窗口关闭事件
+     */
+  }, {
+    key: "_handleMainWindowClose",
+    value: function _handleMainWindowClose(event, windowId, shouldPreventClose) {
+      if (shouldPreventClose) {
+        this.logger.info("Prevent close main window: ".concat(windowId));
+        event.preventDefault();
+      }
+    }
+
+    /**
+     * 处理子窗口关闭事件
+     */
+  }, {
+    key: "_handleSubWindowClose",
+    value: function _handleSubWindowClose(event, window, windowId, shouldPreventClose) {
+      event.preventDefault();
+      if (shouldPreventClose) {
+        this.logger.info("Prevent close sub window: ".concat(windowId));
+      } else {
+        this.logger.info("Hide sub window instead of closing it: ".concat(windowId));
+        this._notifyWindowEvent(window, windowId, 'closed', []);
+      }
+    }
+  }]);
+}();
+
+// 全局单例
+export var browserWindowIPCHandler = new BrowserWindowIPCHandler();

package/lib-es/electron/window.js

@@ -0,0 +1,91 @@
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.object.define-properties.js";
+import "core-js/modules/es.object.define-property.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import "core-js/modules/es.array.concat.js";
+import { BrowserWindow } from 'electron';
+import { defaultWebPreferences, defaultWindowOptions } from './default-options';
+import * as env from './env';
+import { getLogger } from './logger';
+export var windowOptionsMap = {};
+export var webPreferencesMap = {};
+
+// fragments
+var windows = {};
+var windowKeyById = {};
+var isDev = env.isDev;
+var baseUrl = env.devPageUrl;
+var logger = getLogger();
+var loadFragment = function loadFragment(browserWindow, path) {
+  var url = isDev ? "".concat(baseUrl, "/").concat(path, ".html") : "dist/".concat(path, ".html");
+  logger.info("[loadFragment] url: ".concat(url, ", baseUrl: ").concat(baseUrl, ", path: ").concat(path));
+  if (isDev) {
+    return browserWindow.loadURL(url);
+  } else {
+    return browserWindow.loadFile(url);
+  }
+};
+export var open = function open(entryPath, dialogId) {
+  var _windowOptionsMap$ent;
+  var key = entryPath + (dialogId ? dialogId : '');
+  var browserWindow = windows[key];
+  if (!browserWindow) {
+    browserWindow = new BrowserWindow(_objectSpread(_objectSpread(_objectSpread({}, defaultWindowOptions), windowOptionsMap[entryPath]), {}, {
+      webPreferences: _objectSpread(_objectSpread({}, defaultWebPreferences), webPreferencesMap[entryPath])
+    }));
+    var windowId = browserWindow.id;
+    browserWindow.addListener('closed', function () {
+      delete windows[key];
+      delete windowKeyById[windowId];
+    });
+    loadFragment(browserWindow, entryPath);
+    windows[key] = browserWindow;
+    windowKeyById[windowId] = entryPath;
+  }
+  if ((_windowOptionsMap$ent = windowOptionsMap[entryPath].show) !== null && _windowOptionsMap$ent !== void 0 ? _windowOptionsMap$ent : true) {
+    browserWindow.show();
+  }
+};
+export var close = function close(entryPath, dialogId) {
+  logger.info("close window, entryPath: ".concat(entryPath, ", dialogId: ").concat(dialogId));
+  var key = entryPath + (dialogId ? dialogId : '');
+  if (key in windows) {
+    var browserWindow = windows[key];
+    if (browserWindow) {
+      browserWindow.close();
+      delete windows[key];
+      delete windowKeyById[browserWindow.id];
+    }
+  }
+};
+export var getWindowKeyById = function getWindowKeyById(windowId) {
+  return windowKeyById[windowId];
+};
+export var closeAllWindows = function closeAllWindows() {
+  logger.info('close all windows');
+  for (var key in windows) {
+    var window = windows[key];
+    if (!window.isDestroyed()) {
+      window.close();
+    }
+  }
+  windows = {};
+  windowKeyById = {};
+};
+export var setFragmentBaseUrl = function setFragmentBaseUrl(_isDev, _baseUrl) {
+  isDev = _isDev;
+  baseUrl = _baseUrl;
+};

package/lib-es/fragments/annotation/index.js

@@ -0,0 +1,130 @@
+import "core-js/modules/es.reflect.construct.js";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { FcrUIRendererEventAction } from '../../utilities/constant';
+import { BaseFragment } from '../base';
+import { FragmentAnnotationStoreContext, FragmentAnnotationStore } from './store';
+import View from './view';
+import { createFragmentLogger } from '../../utilities/logger';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var AnnotationFragment = /*#__PURE__*/function (_BaseFragment) {
+  function AnnotationFragment(runtime) {
+    var _this;
+    _classCallCheck(this, AnnotationFragment);
+    _this = _callSuper(this, AnnotationFragment, [runtime]);
+    _defineProperty(_this, "logger", createFragmentLogger({
+      prefix: 'AnnotationFragment'
+    }));
+    _defineProperty(_this, "_fragmentStore", new FragmentAnnotationStore());
+    window.addEventListener('keydown', function (event) {
+      if ((event.ctrlKey || event.metaKey) && event.key === 'w') {
+        event.preventDefault();
+      }
+    });
+    return _this;
+  }
+  _inherits(AnnotationFragment, _BaseFragment);
+  return _createClass(AnnotationFragment, [{
+    key: "name",
+    get: function get() {
+      return 'annotation';
+    }
+  }, {
+    key: "component",
+    get: function get() {
+      return /*#__PURE__*/_jsx(FragmentAnnotationStoreContext.Provider, {
+        value: this._fragmentStore,
+        children: /*#__PURE__*/_jsx(View, {})
+      });
+    }
+  }, {
+    key: "onEvent",
+    value: function onEvent(event) {
+      switch (event.action) {
+        case FcrUIRendererEventAction.SET_ANNOTATION_TO_OPEN:
+          if (event.payload) {
+            this.logger.info('onEvent open annotation');
+            this._fragmentStore.open();
+          } else {
+            this.logger.info('onEvent close annotation');
+            this._fragmentStore.close();
+          }
+          break;
+        case FcrUIRendererEventAction.SET_ANNOTATION_TO_SHOW:
+          if (event.payload) {
+            this.logger.info('show annotation');
+            this._fragmentStore.show();
+          } else {
+            this.logger.info('hide annotation');
+            this._fragmentStore.hide();
+          }
+          break;
+        case FcrUIRendererEventAction.SET_ANNOTATION_TO_FOCUS:
+          this.logger.info('focus annotation');
+          this._fragmentStore.focus();
+          break;
+        case FcrUIRendererEventAction.SET_CURRENT_SHARE_SCREEN_BOUNDS:
+          this.logger.info('[annotation][onEvent]: set current share screen bounds', event);
+          this._fragmentStore.setBounds(event.payload);
+          break;
+        case FcrUIRendererEventAction.SET_ANNOTATION_IGNORE:
+          this._fragmentStore.setIgnore(event.payload);
+          break;
+        case FcrUIRendererEventAction.UPDATE_ANNOTATION_WINDOW_SIZE:
+          var size = event.payload;
+          if (size) {
+            this._fragmentStore.updateWindowSize(size.width, size.height);
+          }
+          break;
+        default:
+          this._fragmentStore.toolChanged(event);
+          break;
+      }
+    }
+  }]);
+}(BaseFragment);
+export var windowOptions = {
+  width: 800,
+  height: 600,
+  minHeight: 100,
+  minWidth: 100,
+  webPreferences: {
+    nodeIntegration: true
+  },
+  show: false,
+  frame: false,
+  alwaysOnTop: true,
+  transparent: true,
+  backgroundColor: 'rgba(0, 0, 0, 0)',
+  resizable: false,
+  enableLargerThanScreen: true,
+  hasShadow: false,
+  x: 0,
+  y: 0,
+  hiddenInMissionControl: true,
+  type: 'panel',
+  skipTaskbar: true,
+  minimizable: false,
+  maximizable: false
+};
+export var title = 'Annotation';
+export var webPreferences = {
+  nodeIntegration: true
+};
+var $$fragment = new AnnotationFragment(
+// @ts-ignore
+window.runtime);
+var App = function App() {
+  return /*#__PURE__*/_jsx(React.Fragment, {
+    children: $$fragment.component
+  });
+};
+ReactDOM.render(/*#__PURE__*/_jsx(App, {}), document.getElementById('root'));