fcr-ui-scene 3.8.1 → 3.9.0-alpha

package/lib-es/modules/secondary-window/index.js

@@ -0,0 +1,173 @@
+import "core-js/modules/es.reflect.construct.js";
+import _get from "@babel/runtime/helpers/get";
+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 _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+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";
+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 { UIModule } from '../../base';
+import { SecondaryWindowStore, SecondaryWindowStoreContext } from './store';
+import { SubWindowView } from './view';
+import { AgoraObservable } from 'fcr-core/lib/imports';
+import { LeaveMeetingStoreContext } from '../components/leave-meeting/store.base';
+import LeaveMeetingStoreMain from '../components/leave-meeting/main-scene/store';
+import { isElectron } from 'agora-foundation/lib/utilities/env';
+import { FcrUIGlobalNodeEventType } from '../../type';
+import { createLogger, generateLogObserver } from '../../utilities/logger';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var FcrUISecondaryWindowModule = /*#__PURE__*/function (_UIModule) {
+  function FcrUISecondaryWindowModule() {
+    var _this;
+    _classCallCheck(this, FcrUISecondaryWindowModule);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, FcrUISecondaryWindowModule, [].concat(args));
+    _defineProperty(_this, "_store", null);
+    _defineProperty(_this, "_leaveMeetingStore", null);
+    return _this;
+  }
+  _inherits(FcrUISecondaryWindowModule, _UIModule);
+  return _createClass(FcrUISecondaryWindowModule, [{
+    key: "store",
+    get: function get() {
+      if (!this._store) {
+        throw new Error('SecondaryWindowStore is not initialized');
+      }
+      return this._store;
+    }
+  }, {
+    key: "leaveMeetingStore",
+    get: function get() {
+      if (!this._leaveMeetingStore) {
+        throw new Error('LeaveMeetingStore is not initialized');
+      }
+      return this._leaveMeetingStore;
+    }
+  }, {
+    key: "onNodeWillActive",
+    value: function onNodeWillActive() {
+      if (!isElectron()) return;
+      var args = {
+        objectManager: this.objectManager
+      };
+      this._store = new SecondaryWindowStore(args);
+      this._leaveMeetingStore = new LeaveMeetingStoreMain(args);
+    }
+  }, {
+    key: "onNodeWillInactive",
+    value: function onNodeWillInactive() {
+      if (!isElectron()) return;
+      this.store.release();
+      this.leaveMeetingStore.release();
+    }
+  }, {
+    key: "onNodeReceivedEvent",
+    value: function onNodeReceivedEvent(event) {
+      if (!isElectron()) return;
+      if (event.type === FcrUIGlobalNodeEventType.SCENE_MOUNTED) {
+        this.store.handleSceneMounted();
+      }
+    }
+  }, {
+    key: "component",
+    value: function component(shareScreenModule) {
+      return /*#__PURE__*/_jsx(SecondaryWindowStoreContext.Provider, {
+        value: this.store,
+        children: /*#__PURE__*/_jsx(LeaveMeetingStoreContext.Provider, {
+          value: this.leaveMeetingStore,
+          children: /*#__PURE__*/_jsx(SubWindowView, {
+            renderScreenShareControl: function renderScreenShareControl(secondaryWindowProprs) {
+              return shareScreenModule.getControlComponent(secondaryWindowProprs);
+            }
+          })
+        })
+      });
+    }
+  }]);
+}(UIModule);
+export var FcrUIMainWindowRendererImpl = /*#__PURE__*/function (_ref) {
+  function FcrUIMainWindowRendererImpl() {
+    var _this2;
+    _classCallCheck(this, FcrUIMainWindowRendererImpl);
+    _this2 = _callSuper(this, FcrUIMainWindowRendererImpl);
+    _defineProperty(_this2, "logger", createLogger({
+      prefix: 'FcrUIMainWindowRendererImpl'
+    }));
+    _defineProperty(_this2, "_backgroundColor", '#ffffff');
+    _defineProperty(_this2, "_hasWriteBoardPermission", false);
+    _this2.addObserver(generateLogObserver(_this2.logger, ['onConnectionStateUpdated', 'onViewportSizeUpdated', 'onBackgroundColorUpdated', 'onDraftSaved', 'onPermissionUpdated', 'onRedoStateUpdated', 'onUndoStateUpdated', 'onWhiteboardStrokeColorChanged', 'onWhiteboardStrokeWidthChanged', 'onWhiteboardToolSelected']));
+    return _this2;
+  }
+  _inherits(FcrUIMainWindowRendererImpl, _ref);
+  return _createClass(FcrUIMainWindowRendererImpl, [{
+    key: "ownerUser",
+    get: function get() {
+      return this._ownerUser;
+    }
+  }, {
+    key: "backgroundColor",
+    get: function get() {
+      return this._backgroundColor;
+    }
+  }, {
+    key: "hasWriteBoardPermission",
+    get: function get() {
+      return this._hasWriteBoardPermission;
+    }
+  }, {
+    key: "toolPayload",
+    get: function get() {
+      return this._toolPayload;
+    }
+  }, {
+    key: "strokeColor",
+    get: function get() {
+      return this._strokeColor;
+    }
+  }, {
+    key: "strokeWidth",
+    get: function get() {
+      return this._strokeWidth;
+    }
+  }, {
+    key: "notifyObservers",
+    value: function notifyObservers(event) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+      switch (event) {
+        case 'onBackgroundColorUpdated':
+          this._backgroundColor = args[0];
+          break;
+        case 'onPermissionUpdated':
+          this._hasWriteBoardPermission = args[0];
+          break;
+        case 'onWhiteboardToolSelected':
+          this._toolPayload = args[0];
+          break;
+        case 'onWhiteboardStrokeColorChanged':
+          this._strokeColor = args[0];
+          break;
+        case 'onWhiteboardStrokeWidthChanged':
+          this._strokeWidth = args[0];
+          break;
+      }
+
+      // @ts-expect-error
+      _superPropGet(FcrUIMainWindowRendererImpl, "notifyObservers", this, 3)([event].concat(args));
+    }
+  }, {
+    key: "release",
+    value: function release() {
+      this.removeAllObservers();
+    }
+  }]);
+}(AgoraObservable);