fcr-ui-scene 3.6.1 → 3.6.3

package/lib/electron/window.js

@@ -48,6 +48,7 @@ var baseUrl = env.devPageUrl;
 var logger = (0, _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 {
@@ -67,9 +68,6 @@ var open = exports.open = function open(entryPath, dialogId) {
       delete windows[key];
       delete windowKeyById[windowId];
     });
-    browserWindow.webContents.addListener('render-process-gone', function (event, arg) {
-      logger.info("BrowserWindow [".concat(entryPath, "] render-process-gone: ").concat(arg));
-    });
     loadFragment(browserWindow, entryPath);
     windows[key] = browserWindow;
     windowKeyById[windowId] = entryPath;
@@ -100,15 +98,15 @@ var closeAllWindows = exports.closeAllWindows = function closeAllWindows() {
   windowKeyById = {};
 };
 var putRendererWindow = exports.putRendererWindow = function putRendererWindow(entryPath, browserWindow) {
-  logger.info('[RendererWindow] putRendererWindow', entryPath);
+  logger.info("[RendererWindow] putRendererWindow', ".concat(entryPath, ", '<-test'"));
   rendererWindows[entryPath] = browserWindow;
 };
 var deleteRendererWindow = exports.deleteRendererWindow = function deleteRendererWindow(entryPath) {
-  logger.info('[RendererWindow] deleteRendererWindow', entryPath);
+  logger.info("[RendererWindow] deleteRendererWindow', ".concat(entryPath));
   delete rendererWindows[entryPath];
 };
 var getRendererWindow = exports.getRendererWindow = function getRendererWindow(entryPath) {
-  logger.info('[RendererWindow] getRendererWindow', entryPath, Object.keys(rendererWindows));
+  logger.info("[RendererWindow] getRendererWindow',\n    ".concat(entryPath, ",\n    ").concat(String(Object.keys(rendererWindows)), ",\n    ").concat(String(rendererWindows[entryPath])));
   return rendererWindows[entryPath];
 };
 var clearAllRendererWindows = exports.clearAllRendererWindows = function clearAllRendererWindows() {

package/lib/fragments/annotation/index.d.ts

@@ -0,0 +1,11 @@
+import { BaseFragment } from '../base';
+export declare class Annotation extends BaseFragment {
+    private _store;
+    get name(): string;
+    get component(): import("react/jsx-runtime").JSX.Element;
+    constructor(runtime: Runtime);
+    protected onEvent(event: RendererCustomEvent): void;
+}
+export declare const windowOptions: Electron.BrowserWindowConstructorOptions;
+export declare const title = "Annotation";
+export declare const webPreferences: Electron.WebPreferences;

package/lib/fragments/annotation/index.js

@@ -0,0 +1,121 @@
+"use strict";
+
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.object.define-property.js");
+require("core-js/modules/es.object.get-own-property-descriptor.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.reflect.construct.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.weak-map.js");
+require("core-js/modules/esnext.weak-map.delete-all.js");
+require("core-js/modules/esnext.weak-map.emplace.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.windowOptions = exports.webPreferences = exports.title = exports.Annotation = void 0;
+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 _react = _interopRequireDefault(require("react"));
+var _reactDom = _interopRequireDefault(require("react-dom"));
+var _base = require("../base");
+var _store = _interopRequireWildcard(require("./store"));
+var _constant = require("../../utilities/constant");
+var _view = _interopRequireDefault(require("./view"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+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 Annotation = exports.Annotation = /*#__PURE__*/function (_BaseFragment) {
+  function Annotation(runtime) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, Annotation);
+    _this = _callSuper(this, Annotation, [runtime]);
+    _this._store = new _store["default"]();
+    window.addEventListener('keydown', function (event) {
+      if ((event.ctrlKey || event.metaKey) && event.key === 'w') {
+        event.preventDefault();
+      }
+    });
+    return _this;
+  }
+  (0, _inherits2["default"])(Annotation, _BaseFragment);
+  return (0, _createClass2["default"])(Annotation, [{
+    key: "name",
+    get: function get() {
+      return 'annotation';
+    }
+  }, {
+    key: "component",
+    get: function get() {
+      return /*#__PURE__*/(0, _jsxRuntime.jsx)(_store.AnnotationStoreContext.Provider, {
+        value: this._store,
+        children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_view["default"], {})
+      });
+    }
+  }, {
+    key: "onEvent",
+    value: function onEvent(event) {
+      switch (event.action) {
+        case _constant.FcrUIRendererEventAction.SET_ANNOTATION_TO_SHOW:
+          if (event.payload) {
+            console.log('show annotation');
+            this._store.open();
+          } else {
+            console.log('hide annotation');
+            this._store.close();
+          }
+          break;
+        case _constant.FcrUIRendererEventAction.SET_CURRENT_SHARE_SCREEN_BOUNDS:
+          console.log('[annotation][onEvent]: set current share screen bounds', event);
+          this._store.setBounds(event.payload);
+          break;
+        case _constant.FcrUIRendererEventAction.SET_ANNOTATION_IGNORE:
+          this._store.setIgnore(event.payload);
+          break;
+        default:
+          this._store.toolChanged(event);
+          break;
+      }
+    }
+  }]);
+}(_base.BaseFragment);
+var windowOptions = exports.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
+};
+var title = exports.title = 'Annotation';
+var webPreferences = exports.webPreferences = {
+  nodeIntegration: true
+};
+var $$fragment = new Annotation(window.runtime);
+var App = function App() {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_react["default"].Fragment, {
+    children: $$fragment.component
+  });
+};
+_reactDom["default"].render(/*#__PURE__*/(0, _jsxRuntime.jsx)(App, {}), document.getElementById('root'));

package/lib/fragments/annotation/libs.d.ts

@@ -0,0 +1,55 @@
+import { WhiteboardToolType } from '@netless/forge-whiteboard';
+import { FcrBoardToolType } from 'fcr-core/lib/room-control/whiteboard-control/enums';
+export declare function convertTool(type: FcrBoardToolType): WhiteboardToolType;
+export declare const engineRestConfig: {
+    dualCameraVideoStreamConfig: {
+        highVideoEncoderConfig: {
+            dimensions: {
+                width: number;
+                height: number;
+            };
+            frameRate: number;
+            bitrate: number;
+            orientationMode: undefined;
+            degradationPreference: undefined;
+            isMirror: undefined;
+        };
+        lowVideoEncoderConfig: {
+            dimensions: {
+                width: number;
+                height: number;
+            };
+            frameRate: number;
+            bitrate: number;
+            orientationMode: undefined;
+            degradationPreference: undefined;
+            isMirror: undefined;
+        };
+        enableDualStreamMode: boolean;
+    };
+    dualScreenVideoStreamConfig: {
+        highVideoEncoderConfig: {
+            dimensions: {
+                width: number;
+                height: number;
+            };
+            frameRate: number;
+            bitrate: number;
+            orientationMode: undefined;
+            degradationPreference: undefined;
+            isMirror: undefined;
+        };
+        lowVideoEncoderConfig: {
+            dimensions: {
+                width: number;
+                height: number;
+            };
+            frameRate: number;
+            bitrate: number;
+            orientationMode: undefined;
+            degradationPreference: undefined;
+            isMirror: undefined;
+        };
+        enableDualStreamMode: boolean;
+    };
+};

package/lib/fragments/annotation/libs.js

@@ -0,0 +1,93 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertTool = convertTool;
+exports.engineRestConfig = void 0;
+var _enums = require("fcr-core/lib/room-control/whiteboard-control/enums");
+function convertTool(type) {
+  switch (type) {
+    case _enums.FcrBoardToolType.ARROW:
+      return 'arrow';
+    case _enums.FcrBoardToolType.CURVE:
+      return 'curve';
+    case _enums.FcrBoardToolType.ELLIPSE:
+      return 'ellipse';
+    case _enums.FcrBoardToolType.ERASER:
+      return 'eraser';
+    case _enums.FcrBoardToolType.LASER_POINTER:
+      return 'laser';
+    case _enums.FcrBoardToolType.TEXT:
+      return 'text';
+    case _enums.FcrBoardToolType.RECTANGLE:
+      return 'rectangle';
+    case _enums.FcrBoardToolType.TRIANGLE:
+      return 'triangle';
+    case _enums.FcrBoardToolType.SELECTOR:
+      return 'selector';
+    case _enums.FcrBoardToolType.STRAIGHT:
+      return 'line';
+    // case FcrBoardToolType.PENTAGRAM:
+    //   return 'pentagram';
+    // case FcrBoardToolType.RHOMBUS:
+    //   return 'rhombus';
+    case _enums.FcrBoardToolType.HAND:
+      return 'grab';
+    default:
+      return 'curve';
+  }
+}
+var engineRestConfig = exports.engineRestConfig = {
+  dualCameraVideoStreamConfig: {
+    highVideoEncoderConfig: {
+      dimensions: {
+        width: 0,
+        height: 0
+      },
+      frameRate: 0,
+      bitrate: 0,
+      orientationMode: undefined,
+      degradationPreference: undefined,
+      isMirror: undefined
+    },
+    lowVideoEncoderConfig: {
+      dimensions: {
+        width: 0,
+        height: 0
+      },
+      frameRate: 0,
+      bitrate: 0,
+      orientationMode: undefined,
+      degradationPreference: undefined,
+      isMirror: undefined
+    },
+    enableDualStreamMode: false
+  },
+  dualScreenVideoStreamConfig: {
+    highVideoEncoderConfig: {
+      dimensions: {
+        width: 0,
+        height: 0
+      },
+      frameRate: 0,
+      bitrate: 0,
+      orientationMode: undefined,
+      degradationPreference: undefined,
+      isMirror: undefined
+    },
+    lowVideoEncoderConfig: {
+      dimensions: {
+        width: 0,
+        height: 0
+      },
+      frameRate: 0,
+      bitrate: 0,
+      orientationMode: undefined,
+      degradationPreference: undefined,
+      isMirror: undefined
+    },
+    enableDualStreamMode: false
+  }
+};

package/lib/fragments/annotation/store.d.ts

@@ -0,0 +1,30 @@
+declare class AnnotationStore {
+    protected logger: import("agora-foundation/lib/logger").Logger;
+    private _engine;
+    private _FORGE_WHITEBOARD_APP_ID;
+    private _boardInstance;
+    private _boardRoom;
+    private _boardView;
+    private _boardDom?;
+    private _config;
+    accessor joined: boolean;
+    accessor bounds: Electron.Rectangle;
+    accessor currentTool: string;
+    private timer;
+    constructor();
+    open(): Promise<void>;
+    handleBoardDomLoad(dom: HTMLDivElement): void;
+    close(): Promise<void>;
+    setBounds(bounds: Electron.Rectangle): void;
+    setIgnore(ignore: boolean): void;
+    toolChanged(event: RendererCustomEvent): void;
+    private _initBoardStyle;
+    private _handleSetTool;
+    private _init;
+    private _initBoardRoom;
+    private _initEngine;
+    private _launchHandler;
+    private _terminalHandler;
+}
+export default AnnotationStore;
+export declare const AnnotationStoreContext: import("react").Context<AnnotationStore>;