fcr-ui-scene 1.0.40 → 3.1.0-1

package/lib/modules/dialog/components/whiteboard/index.js

@@ -0,0 +1,74 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WhiteboardElectronDialog = void 0;
+var _mobxReact = require("mobx-react");
+var _react = require("react");
+var _dialogs = require("../../dialogs");
+var _constant = require("../../../../utilities/constant");
+var _context = require("../../context");
+var _reactDom = require("react-dom");
+var WhiteboardElectronDialog = exports.WhiteboardElectronDialog = (0, _mobxReact.observer)(function (_ref) {
+  var module = _ref.module;
+  var store = (0, _react.useContext)(_context.StoreContext);
+  (0, _react.useEffect)(function () {
+    var node;
+    window.runtime.openRendererWindow('whiteboard', function (dom, browserWindow) {
+      node = dom;
+      if (browserWindow) {
+        browserWindow.focus();
+        console.log('browserWindow', browserWindow);
+        // if (newWindow) {
+        //   const proxyHandler = {
+        //     get(target: Window, prop: any) {
+        //       console.log({ target, prop });
+        //       if (prop === 'addEventListener') {
+        //         return function (
+        //           type: string,
+        //           listener: () => void,
+        //           options: boolean | AddEventListenerOptions,
+        //         ) {
+        //           // console.log({ type, listener, options });
+        //           target?.addEventListener(type, listener, options);
+        //         };
+        //       }
+        //       return target[prop];
+        //     },
+        //   };
+        //   const proxy = new Proxy(window, proxyHandler);
+        //   newWindow.addEventListener = proxy.addEventListener.bind(proxy);
+        //   // window.addEventListener('resize', () => {
+        //   //   console.log(111111);
+        //   // });
+        //   // window.addEventListener('mousedown', () => {
+        //   //   console.log('yes');
+        //   // });
+        // }
+
+        _dialogs.dialogWindows.set(_constant.DialogKey.WHITEBOARD, browserWindow);
+      }
+      module.getComponent(dom);
+      // render(<div className="fcr-whiteboard-wrapper">{children}</div>, dom);
+    }, {
+      frame: true,
+      fullscreen: false,
+      maximizable: false,
+      // titleBarStyle: 'hidden',
+      width: 1920 / 1.5,
+      height: 1080 / 1.5,
+      minWidth: 530,
+      minHeight: 500,
+      maxWidth: 1920,
+      maxHeight: 1080
+    });
+    return function () {
+      _dialogs.dialogWindows["delete"](_constant.DialogKey.WHITEBOARD);
+      node && (0, _reactDom.unmountComponentAtNode)(node);
+      window.runtime.closeRendererWindow('whiteboard');
+    };
+  }, []);
+  return null;
+});

package/lib/modules/dialog/context.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import DialogStore from './store';
+export declare const StoreContext: import("react").Context<DialogStore>;

package/lib/modules/dialog/context.js

@@ -0,0 +1,9 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StoreContext = void 0;
+var _react = require("react");
+var StoreContext = exports.StoreContext = /*#__PURE__*/(0, _react.createContext)(null);

package/lib/modules/dialog/dialogs.d.ts

@@ -0,0 +1,11 @@
+import { FC, PropsWithChildren } from 'react';
+import { DialogKey } from '../../utilities/constant';
+export declare let dialogWindows: Map<DialogKey, Electron.BrowserWindow>;
+export declare const DeviceSettingDialog: ({ children }: PropsWithChildren<{}>) => import("react/jsx-runtime").JSX.Element;
+export declare const setDialogBounds: (browserWindow: Electron.BrowserWindow, currentDialogBounds: Partial<Electron.Rectangle>) => void;
+export declare const LiveStreamingDialog: FC<PropsWithChildren<{
+    title: string;
+}>>;
+export declare const InviteDialog: FC<PropsWithChildren<{}>>;
+export declare const VideoWindowDialog: ({ children }: PropsWithChildren<{}>) => import("react/jsx-runtime").JSX.Element | null;
+export default DeviceSettingDialog;

package/lib/modules/dialog/dialogs.js

@@ -0,0 +1,376 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setDialogBounds = exports.dialogWindows = exports["default"] = exports.VideoWindowDialog = exports.LiveStreamingDialog = exports.InviteDialog = exports.DeviceSettingDialog = void 0;
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _windowHeader = require("agora-ui-foundation/lib/components/window-header");
+var _react = require("react");
+var _context = require("./context");
+var _reactRnd = require("react-rnd");
+var _mobxReact = require("mobx-react");
+var _env = require("agora-foundation/lib/utilities/env");
+var _draggableDialog = require("agora-ui-foundation/lib/components/dialog/draggable-dialog");
+var _reactDom = require("react-dom");
+var _debounce = _interopRequireDefault(require("lodash/debounce"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _constant = require("../../utilities/constant");
+var _i18n = require("agora-ui-foundation/lib/i18n");
+var _renderer = require("../../utilities/renderer");
+var _videoTrackRenderContext = require("../../utilities/video-track-render-context");
+var _type = require("./../video-window/type");
+var _jsxRuntime = require("react/jsx-runtime");
+var dialogWindows = exports.dialogWindows = new Map();
+var DeviceSettingDialog = exports.DeviceSettingDialog = (0, _mobxReact.observer)(function (_ref) {
+  var children = _ref.children;
+  if ((0, _env.isElectron)()) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(DeviceSettingElectronDialog, {
+      children: children
+    });
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+    children: children
+  });
+});
+var setDialogBounds = exports.setDialogBounds = function setDialogBounds(browserWindow, currentDialogBounds) {
+  browserWindow.setBounds(currentDialogBounds, true);
+  browserWindow.center();
+  browserWindow.setVisibleOnAllWorkspaces(false, {
+    visibleOnFullScreen: true,
+    skipTransformProcessType: true
+  });
+  browserWindow.setSkipTaskbar(false);
+};
+var DeviceSettingElectronDialog = (0, _mobxReact.observer)(function (_ref2) {
+  var children = _ref2.children;
+  var store = (0, _react.useContext)(_context.StoreContext);
+  var t = (0, _i18n.useI18n)();
+  (0, _react.useEffect)(function () {
+    var node;
+    window.runtime.openRendererWindow('device-setting', function (dom, browserWindow) {
+      dialogWindows.set(_constant.DialogKey.DEVICE_SETTINGS, browserWindow);
+      node = dom;
+      if (store.currentDialogBounds.height) {
+        setDialogBounds(browserWindow, {
+          y: store.currentDialogBounds.y
+        });
+      }
+      (0, _renderer.handleWillClose)(browserWindow, function () {
+        (0, _reactDom.unmountComponentAtNode)(node);
+        dialogWindows["delete"](_constant.DialogKey.DEVICE_SETTINGS);
+        store.closeDeviceSettingFromDialog();
+      });
+      var handleCloseClick = function handleCloseClick() {
+        store.closeDeviceSettingFromDialog();
+      };
+      (0, _reactDom.render)( /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+        className: "fcr-device-setting-dialog-wrapper",
+        children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_windowHeader.FcrWindowHeader, {
+          showClose: true,
+          title: t('fmt_modules_labels_devicesettings'),
+          onClose: handleCloseClick,
+          type: _windowHeader.WindowType.WINDOW,
+          withWindowPopUpButton: false
+        }), children]
+      }), dom);
+    }, {
+      frame: false,
+      fullscreen: false,
+      maximizable: false,
+      // titleBarStyle: 'hidden',
+      trafficLightPosition: {
+        x: 10,
+        y: 60
+      },
+      width: 580,
+      height: 600,
+      minWidth: 580,
+      minHeight: 600,
+      maxWidth: 670,
+      maxHeight: 800
+    });
+    return function () {
+      node && (0, _reactDom.unmountComponentAtNode)(node);
+      window.runtime.closeRendererWindow('device-setting');
+    };
+  }, []);
+  return null;
+});
+var LiveStreamingDialogContent = (0, _mobxReact.observer)(function (_ref3) {
+  var children = _ref3.children,
+    title = _ref3.title;
+  var _useContext = (0, _react.useContext)(_context.StoreContext),
+    closeLiveStreamingDialog = _useContext.closeLiveStreamingDialog;
+  return /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+    className: "fcr-livestreaming-dialog-wrapper",
+    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_windowHeader.FcrWindowHeader, {
+      showClose: true,
+      title: title,
+      type: _windowHeader.WindowType.WINDOW,
+      onClose: closeLiveStreamingDialog,
+      withWindowPopUpButton: false
+    }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+      className: "fcr-livestreaming-dialog-content",
+      children: children
+    })]
+  });
+});
+var LiveStreamingDialog = exports.LiveStreamingDialog = function LiveStreamingDialog(_ref4) {
+  var children = _ref4.children,
+    title = _ref4.title;
+  var defaultSize = {
+    x: (document.body.clientWidth - 440) / 2,
+    y: (document.body.clientHeight - 434) / 2,
+    width: 440,
+    height: 434
+  };
+  if ((0, _env.isElectron)()) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(LiveStreamingElectronDialog, {
+      title: title,
+      children: children
+    });
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_reactRnd.Rnd, {
+    "default": defaultSize,
+    maxHeight: 700,
+    maxWidth: 620,
+    minWidth: 440,
+    minHeight: 434,
+    bounds: '.fcr-layout-content',
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(LiveStreamingDialogContent, {
+      title: title,
+      children: children
+    })
+  });
+};
+var LiveStreamingElectronDialog = (0, _mobxReact.observer)(function (_ref5) {
+  var children = _ref5.children,
+    title = _ref5.title;
+  var store = (0, _react.useContext)(_context.StoreContext);
+  (0, _react.useEffect)(function () {
+    var node;
+    window.runtime.openRendererWindow('live-streaming', function (dom, browserWindow) {
+      node = dom;
+      dialogWindows.set(_constant.DialogKey.LIVE_STREAMING, browserWindow);
+      if (store.currentDialogBounds.height) {
+        setDialogBounds(browserWindow, {
+          y: store.currentDialogBounds.y
+        });
+      }
+      (0, _renderer.handleWillClose)(browserWindow, function () {
+        (0, _reactDom.unmountComponentAtNode)(dom);
+        dialogWindows["delete"](_constant.DialogKey.LIVE_STREAMING);
+        store.closeLiveStreamingDialog();
+      });
+      (0, _reactDom.render)( /*#__PURE__*/(0, _jsxRuntime.jsx)(_context.StoreContext.Provider, {
+        value: store,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(LiveStreamingDialogContent, {
+          title: title,
+          children: children
+        })
+      }), dom);
+    }, {
+      frame: false,
+      fullscreen: false,
+      maximizable: false,
+      width: 440,
+      height: 434,
+      y: store.currentDialogBounds.y
+    });
+    return function () {
+      node && (0, _reactDom.unmountComponentAtNode)(node);
+      window.runtime.closeRendererWindow('live-streaming');
+    };
+  }, []);
+  return null;
+});
+var InviteDialog = exports.InviteDialog = function InviteDialog(_ref6) {
+  var children = _ref6.children;
+  var _useContext2 = (0, _react.useContext)(_context.StoreContext),
+    closeInviteDialog = _useContext2.closeInviteDialog;
+  if ((0, _env.isElectron)()) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(InviteElectronDialog, {
+      children: children
+    });
+  }
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_draggableDialog.FcrDraggableModal, {
+    title: '',
+    onClose: closeInviteDialog,
+    width: 400,
+    height: 350,
+    rootClassName: "invite-dialog",
+    children: children
+  });
+};
+var InviteElectronDialog = function InviteElectronDialog(_ref7) {
+  var children = _ref7.children;
+  var _useContext3 = (0, _react.useContext)(_context.StoreContext),
+    closeInviteDialog = _useContext3.closeInviteDialog;
+  (0, _react.useEffect)(function () {
+    var node;
+    window.runtime.openRendererWindow('invite', function (dom, browserWindow) {
+      node = dom;
+      dialogWindows.set(_constant.DialogKey.INVITE, browserWindow);
+      (0, _renderer.handleWillClose)(browserWindow, function () {
+        (0, _reactDom.unmountComponentAtNode)(dom);
+        dialogWindows["delete"](_constant.DialogKey.INVITE);
+        closeInviteDialog();
+      });
+      (0, _reactDom.render)( /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+        className: (0, _classnames["default"])('invite-dialog'),
+        children: [(0, _env.getPlatform)() === _env.FcrApplicationPlatform.WINDOWS && /*#__PURE__*/(0, _jsxRuntime.jsx)(_windowHeader.FcrWindowHeader, {
+          type: _windowHeader.WindowType.WINDOW,
+          enableMaximize: false,
+          enableMinimize: false,
+          withWindowPopUpButton: false,
+          onClose: closeInviteDialog
+        }), children]
+      }), dom);
+    }, {
+      titleBarStyle: 'hidden',
+      trafficLightPosition: {
+        x: 10,
+        y: 40
+      },
+      maximizable: false,
+      minimizable: false,
+      fullscreenable: false,
+      // resizable: false,
+      width: 420,
+      height: 420
+      // maxHeight: 420,
+      // maxWidth: 420,
+    });
+    return function () {
+      node && (0, _reactDom.unmountComponentAtNode)(node);
+      window.runtime.closeRendererWindow('invite');
+    };
+  }, []);
+  return null;
+};
+var VideoWindowElectronDialog = (0, _mobxReact.observer)(function (_ref8) {
+  var children = _ref8.children;
+  var store = (0, _react.useContext)(_context.StoreContext);
+  var _store$videoWindowBou = store.videoWindowBounds,
+    videoWindowHeight = _store$videoWindowBou.videoWindowHeight,
+    videoWindowPreviewType = _store$videoWindowBou.videoWindowPreviewType,
+    workareaX = _store$videoWindowBou.workareaX,
+    workareaY = _store$videoWindowBou.workareaY,
+    workareaWidth = _store$videoWindowBou.workareaWidth,
+    workareaHeight = _store$videoWindowBou.workareaHeight;
+  var videoWindowRef = (0, _react.useRef)();
+  var handleBounds = function handleBounds(newBounds) {
+    var height = newBounds.height;
+    var width = newBounds.width;
+    store.resizeVideoWindow(width < _type.DefaultVideoWindowWidth || !width ? _type.DefaultVideoWindowWidth : width, height < _type.DefaultVideoWindowSmallTypeHeight || !height ? _type.DefaultVideoWindowSmallTypeHeight : height);
+  };
+  (0, _react.useEffect)(function () {
+    var node;
+    window.runtime.openRendererWindow('video-window', function (dom, browserWindow) {
+      node = dom;
+      videoWindowRef.current = browserWindow;
+      browserWindow.setTitle('Video Window');
+      browserWindow.setBackgroundColor('#00000000');
+      browserWindow.setVisibleOnAllWorkspaces(true, {
+        visibleOnFullScreen: true
+      });
+      browserWindow.setAlwaysOnTop(true, 'screen-saver');
+      dialogWindows.set(_constant.DialogKey.VIDEO_WINDOW, browserWindow);
+      (0, _renderer.handleWillClose)(browserWindow, function () {
+        (0, _reactDom.unmountComponentAtNode)(node);
+        dialogWindows["delete"](_constant.DialogKey.VIDEO_WINDOW);
+        browserWindow.removeAllListeners('will-resize');
+        browserWindow.setResizable(false);
+        browserWindow.setAspectRatio(0);
+        browserWindow.setMinimumSize(0, 0);
+        browserWindow.setMaximumSize(0, 0);
+        browserWindow.setBounds({
+          x: workareaX + workareaWidth - _type.DefaultVideoWindowWidth - 168,
+          y: workareaY + 80,
+          width: _type.DefaultVideoWindowWidth,
+          height: _type.DefaultVideoWindowHeight
+        });
+      });
+      if (browserWindow) {
+        browserWindow.addListener('will-resize', (0, _debounce["default"])(function (event, newBounds) {
+          handleBounds(newBounds);
+        }, 100));
+      }
+      (0, _reactDom.render)( /*#__PURE__*/(0, _jsxRuntime.jsx)(_videoTrackRenderContext.FcrVideoTrackRenderContext.Provider, {
+        value: {
+          deviceStore: store.deviceStore,
+          streamControl: store.streamControl
+        },
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_context.StoreContext.Provider, {
+          value: store,
+          children: children
+        })
+      }), dom);
+    }, {
+      frame: false,
+      fullscreen: false,
+      maximizable: false,
+      x: workareaX + workareaWidth - _type.DefaultVideoWindowWidth - 168,
+      y: workareaY + 80,
+      width: _type.DefaultVideoWindowWidth,
+      height: _type.DefaultVideoWindowHeight,
+      minWidth: _type.DefaultVideoWindowWidth,
+      transparent: true,
+      alwaysOnTop: true,
+      hasShadow: false,
+      resizable: false
+    });
+    return function () {
+      node && (0, _reactDom.unmountComponentAtNode)(node);
+      window.runtime.closeRendererWindow('video-window');
+    };
+  }, []);
+  (0, _react.useEffect)(function () {
+    if (!videoWindowRef.current) return;
+    videoWindowRef.current.setBounds({
+      x: workareaX + workareaWidth - _type.DefaultVideoWindowWidth - 168,
+      y: workareaY + 80
+    });
+  }, [workareaX, workareaY]);
+  (0, _react.useEffect)(function () {
+    if (!videoWindowRef.current) return;
+    if (videoWindowPreviewType === 'small') {
+      videoWindowRef.current.setResizable(true);
+      videoWindowRef.current.setAspectRatio(_type.VideoWindowRadio);
+      videoWindowRef.current.setMinimumSize(_type.DefaultVideoWindowWidth, _type.DefaultVideoWindowSmallTypeHeight);
+      videoWindowRef.current.setMaximumSize(_type.VideoWindowZoomMaxWidth, _type.VideoWindowZoomMaxHeight);
+    } else if (videoWindowPreviewType === 'mix') {
+      videoWindowRef.current.setResizable(false);
+      videoWindowRef.current.setAspectRatio(0);
+      videoWindowRef.current.setMinimumSize(0, 0);
+      videoWindowRef.current.setMaximumSize(0, 0);
+    } else {
+      videoWindowRef.current.setResizable(false);
+      videoWindowRef.current.setAspectRatio(0);
+      videoWindowRef.current.setMinimumSize(0, 0);
+      videoWindowRef.current.setMaximumSize(0, 0);
+    }
+    videoWindowRef.current.setBounds({
+      width: _type.DefaultVideoWindowWidth,
+      height: videoWindowHeight
+    });
+  }, [videoWindowHeight, videoWindowPreviewType]);
+  return null;
+});
+var VideoWindowDialog = exports.VideoWindowDialog = (0, _mobxReact.observer)(function (_ref9) {
+  var children = _ref9.children;
+  if ((0, _env.isElectron)()) {
+    return /*#__PURE__*/(0, _jsxRuntime.jsx)(VideoWindowElectronDialog, {
+      children: children
+    });
+  }
+  return null;
+});
+var _default = exports["default"] = DeviceSettingDialog;

package/lib/modules/dialog/index.css

@@ -0,0 +1,55 @@
+.dialog-container {
+  background: var(--fcr_mobile_ui_scene_color_popup_fill2);
+  border-radius: var(--fcr_cornerradius_m);
+}
+/* .react-draggable {
+  transition: all 0.3s;
+} */
+.fcr-chat-dialog-wrapper,
+.fcr-participant-dialog-wrapper,
+.fcr-livestreaming-dialog-wrapper {
+  background: var(--fcr_mobile_ui_scene_color_popup_fill2);
+  border-radius: var(--fcr_cornerradius_m);
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  box-shadow: var(--fcr_web_light_dropup);
+}
+.fcr-livestreaming-dialog-content {
+  flex: 1;
+  overflow: hidden;
+  padding: 0 20px;
+}
+.frc-common-dialog {
+  background: var(--fcr_mobile_ui_scene_color_popup_fill2);
+  border-radius: var(--fcr_cornerradius_m);
+  box-shadow: 0 0 15px 0 var(--fcr_web_light_dropup);
+  border: 1px solid var(--fcr_ui_scene_line1);
+  padding: 16px 20px;
+}
+
+.frc-window-header {
+  cursor: pointer;
+}
+
+.invite-dialog {
+  padding: 10px;
+  padding-bottom: 0px;
+}
+
+.fcr-confirm-dialog-wrapper {
+  background: #fff;
+}
+.fcr-confirm-dialog-wrapper_web {
+  background: var(--fcr_mobile_ui_scene_color_popup_fill2);
+  border-radius: var(--fcr_cornerradius_xl);
+  box-shadow: var(--fcr_web_light_dropup);
+  border: 1px solid var(--fcr_ui_scene_line1);
+}
+
+.fcr-device-setting-dialog-wrapper {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+}

package/lib/modules/dialog/index.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { UIModule } from '../../base';
+import { FcrUIEventStore } from '../../common/event-store';
+import { FcrSecurityStore } from '../../common/security-store';
+import { FcrUserInfo } from 'agora-edu-core/lib/type';
+import { FcrStreamControl, FcrUserControl } from 'agora-edu-core';
+import { FcrChatRoomControl } from 'agora-edu-core/lib/room-control/chatroom-control';
+import { ConfirmContentProps } from 'agora-ui-foundation/lib/components/confirm-content';
+import { FcrDeviceStore } from '../../common/device-store';
+export declare class DialogUIModule extends UIModule {
+    private _dialogs;
+    private _store;
+    constructor(args: {
+        uiEventStore: FcrUIEventStore;
+        userInfo: FcrUserInfo;
+        securityStore: FcrSecurityStore;
+        userControl: FcrUserControl;
+        chatRoomControl: FcrChatRoomControl;
+        deviceStore: FcrDeviceStore;
+        streamControl: FcrStreamControl;
+    });
+    protected onUnload(): void;
+    getComponent(): import("react/jsx-runtime").JSX.Element;
+    addDialogs(dialogs: {
+        key: string;
+        component: (params?: ConfirmContentProps) => React.JSX.Element;
+    }[]): void;
+    protected onProcessEvent(event: RendererCustomEvent): void;
+}

package/lib/modules/dialog/index.js

@@ -0,0 +1,80 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.reflect.construct.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DialogUIModule = void 0;
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _base = require("../../base");
+var _store = _interopRequireDefault(require("./store"));
+var _view = require("./view");
+var _context = require("./context");
+var _constant = require("../../utilities/constant");
+var _jsxRuntime = require("react/jsx-runtime");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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; })(); }
+var DialogUIModule = exports.DialogUIModule = /*#__PURE__*/function (_UIModule) {
+  function DialogUIModule(args) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, DialogUIModule);
+    _this = _callSuper(this, DialogUIModule);
+    (0, _defineProperty2["default"])(_this, "_dialogs", new Map());
+    _this._store = new _store["default"](args);
+    return _this;
+  }
+  (0, _inherits2["default"])(DialogUIModule, _UIModule);
+  return (0, _createClass2["default"])(DialogUIModule, [{
+    key: "onUnload",
+    value: function onUnload() {
+      this._store.release();
+    }
+  }, {
+    key: "getComponent",
+    value: function getComponent() {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_context.StoreContext.Provider, {
+        value: this._store,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_view.View, {
+          dialogs: this._dialogs
+        })
+      }, "dialog");
+    }
+  }, {
+    key: "addDialogs",
+    value: function addDialogs(dialogs) {
+      var _this2 = this;
+      dialogs.forEach(function (dialog) {
+        _this2._dialogs.set(dialog.key, dialog.component);
+      });
+    }
+  }, {
+    key: "onProcessEvent",
+    value: function onProcessEvent(event) {
+      var action = event.action,
+        payload = event.payload;
+      switch (action) {
+        case _constant.RendererEventAction.START_SHARE_SCREEN:
+          var _ref = payload,
+            id = _ref.id,
+            type = _ref.type;
+          this._store.setCurrentShareId(id, type);
+          break;
+      }
+    }
+  }]);
+}(_base.UIModule);