fcr-ui-scene 3.8.2 → 3.9.0-alpha

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

@@ -0,0 +1,335 @@
+"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.BrowserWindowProxyImpl = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+require("core-js/modules/es.error.cause.js");
+require("core-js/modules/es.error.to-string.js");
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.from.js");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.map.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.set.js");
+require("core-js/modules/es.string.iterator.js");
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/esnext.map.delete-all.js");
+require("core-js/modules/esnext.map.emplace.js");
+require("core-js/modules/esnext.map.every.js");
+require("core-js/modules/esnext.map.filter.js");
+require("core-js/modules/esnext.map.find.js");
+require("core-js/modules/esnext.map.find-key.js");
+require("core-js/modules/esnext.map.includes.js");
+require("core-js/modules/esnext.map.key-of.js");
+require("core-js/modules/esnext.map.map-keys.js");
+require("core-js/modules/esnext.map.map-values.js");
+require("core-js/modules/esnext.map.merge.js");
+require("core-js/modules/esnext.map.reduce.js");
+require("core-js/modules/esnext.map.some.js");
+require("core-js/modules/esnext.map.update.js");
+require("core-js/modules/esnext.set.add-all.js");
+require("core-js/modules/esnext.set.delete-all.js");
+require("core-js/modules/esnext.set.difference.v2.js");
+require("core-js/modules/esnext.set.difference.js");
+require("core-js/modules/esnext.set.every.js");
+require("core-js/modules/esnext.set.filter.js");
+require("core-js/modules/esnext.set.find.js");
+require("core-js/modules/esnext.set.intersection.v2.js");
+require("core-js/modules/esnext.set.intersection.js");
+require("core-js/modules/esnext.set.is-disjoint-from.v2.js");
+require("core-js/modules/esnext.set.is-disjoint-from.js");
+require("core-js/modules/esnext.set.is-subset-of.v2.js");
+require("core-js/modules/esnext.set.is-subset-of.js");
+require("core-js/modules/esnext.set.is-superset-of.v2.js");
+require("core-js/modules/esnext.set.is-superset-of.js");
+require("core-js/modules/esnext.set.join.js");
+require("core-js/modules/esnext.set.map.js");
+require("core-js/modules/esnext.set.reduce.js");
+require("core-js/modules/esnext.set.some.js");
+require("core-js/modules/esnext.set.symmetric-difference.v2.js");
+require("core-js/modules/esnext.set.symmetric-difference.js");
+require("core-js/modules/esnext.set.union.v2.js");
+require("core-js/modules/esnext.set.union.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _electron = require("electron");
+var _ipcProtocol = require("../../ipc-protocol");
+var _crypto = require("crypto");
+/**
+ * BrowserWindow 代理类
+ * 通过 IPC 通信与主进程中的 BrowserWindow 进行交互
+ */
+var BrowserWindowProxyImpl = exports.BrowserWindowProxyImpl = /*#__PURE__*/function () {
+  function BrowserWindowProxyImpl(windowId) {
+    (0, _classCallCheck2["default"])(this, BrowserWindowProxyImpl);
+    (0, _defineProperty2["default"])(this, "_eventListeners", new Map());
+    (0, _defineProperty2["default"])(this, "_isDestroyed", false);
+    (0, _defineProperty2["default"])(this, "_runtimeEventListener", null);
+    (0, _defineProperty2["default"])(this, "_addBrowserWindowEventListener", function (listener) {
+      _electron.ipcRenderer.addListener('browser-window-event', listener);
+    });
+    (0, _defineProperty2["default"])(this, "_removeBrowserWindowEventListener", function (listener) {
+      _electron.ipcRenderer.removeListener('browser-window-event', listener);
+    });
+    // 如果没有提供 windowId，尝试从 window 对象获取
+    this._windowId = windowId;
+    this._proxyId = (0, _crypto.randomUUID)().replace(/-/g, '').slice(0, 5);
+    this._setupEventListener();
+    console.log("BrowserWindowProxy created for windowId: ".concat(this._windowId, ", proxyId: ").concat(this._proxyId));
+  }
+  return (0, _createClass2["default"])(BrowserWindowProxyImpl, [{
+    key: "windowId",
+    get: function get() {
+      return this._windowId;
+    }
+  }, {
+    key: "proxyId",
+    get: function get() {
+      return this._proxyId;
+    }
+
+    /**
+     * 检查窗口是否已销毁
+     */
+  }, {
+    key: "isDestroyed",
+    value: function isDestroyed() {
+      return this._isDestroyed;
+    }
+  }, {
+    key: "setPreventClose",
+    value: function () {
+      var _setPreventClose = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(prevent) {
+        var params;
+        return _regenerator["default"].wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              params = {
+                prevent: prevent
+              };
+              _context.next = 1;
+              return this._sendIpcRequest(_ipcProtocol.BrowserWindowIPCAction.SET_PREVENT_CLOSE, params);
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function setPreventClose(_x) {
+        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 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(action, payload) {
+        var request, result, _t;
+        return _regenerator["default"].wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!this._isDestroyed) {
+                _context2.next = 1;
+                break;
+              }
+              throw new Error('BrowserWindow proxy has been destroyed');
+            case 1:
+              request = {
+                windowId: this._windowId,
+                proxyId: this._proxyId,
+                action: action,
+                payload: payload
+              };
+              _context2.prev = 2;
+              _context2.next = 3;
+              return _electron.ipcRenderer.invoke('browser-window-request', request);
+            case 3:
+              result = _context2.sent;
+              return _context2.abrupt("return", {
+                success: true,
+                data: result
+              });
+            case 4:
+              _context2.prev = 4;
+              _t = _context2["catch"](2);
+              throw new Error(_t instanceof Error ? _t.message : 'Unknown error');
+            case 5:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[2, 4]]);
+      }));
+      function _sendIpcRequest(_x2, _x3) {
+        return _sendIpcRequest2.apply(this, arguments);
+      }
+      return _sendIpcRequest;
+    }())
+  }, {
+    key: "_registerEventListener",
+    value: function () {
+      var _registerEventListener2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(events) {
+        var params;
+        return _regenerator["default"].wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              params = {
+                events: events
+              };
+              _context3.next = 1;
+              return this._sendIpcRequest(_ipcProtocol.BrowserWindowIPCAction.REGISTER_EVENT_LISTENER, params);
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function _registerEventListener(_x4) {
+        return _registerEventListener2.apply(this, arguments);
+      }
+      return _registerEventListener;
+    }()
+  }, {
+    key: "_unregisterEventListener",
+    value: function () {
+      var _unregisterEventListener2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4(events) {
+        var params;
+        return _regenerator["default"].wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              params = {
+                events: events
+              };
+              _context4.next = 1;
+              return this._sendIpcRequest(_ipcProtocol.BrowserWindowIPCAction.UNREGISTER_EVENT_LISTENER, params);
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function _unregisterEventListener(_x5) {
+        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;
+      }
+      if (notification.proxyId && notification.proxyId !== this._proxyId) {
+        // console.log(
+        //   `Proxy ID mismatch, ignoring event with proxyId: ${notification.proxyId}, current proxyId: ${this._proxyId}, event: ${notification.event}`,
+        // );
+        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 === _ipcProtocol.BrowserWindowIPCAction.EVENT_CLOSED) {
+        this._isDestroyed = true;
+      }
+    }
+  }, {
+    key: "_mapEventActionToName",
+    value: function _mapEventActionToName(action) {
+      var eventMap = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _ipcProtocol.BrowserWindowIPCAction.EVENT_SHOW, 'show'), _ipcProtocol.BrowserWindowIPCAction.EVENT_HIDE, 'hide'), _ipcProtocol.BrowserWindowIPCAction.EVENT_RESIZED, 'resized'), _ipcProtocol.BrowserWindowIPCAction.EVENT_MOVED, 'moved'), _ipcProtocol.BrowserWindowIPCAction.EVENT_CLOSE, 'close'), _ipcProtocol.BrowserWindowIPCAction.EVENT_CLOSED, 'closed'), _ipcProtocol.BrowserWindowIPCAction.EVENT_FOCUS, 'focus'), _ipcProtocol.BrowserWindowIPCAction.EVENT_BLUR, 'blur');
+      return eventMap[action] || action;
+    }
+  }]);
+}();

package/lib/electron/window-proxy/implementations/electron-event-broadcaster.d.ts

@@ -0,0 +1,9 @@
+import { BrowserWindow } from 'electron';
+import { IEventBroadcaster, ILogger } from '../interfaces';
+import { BrowserWindowEventNotification } from '../../ipc-protocol';
+export declare class ElectronEventBroadcaster implements IEventBroadcaster {
+    private logger;
+    private getMainWindow;
+    constructor(logger: ILogger, getMainWindow: () => BrowserWindow | null);
+    broadcast(channel: string, data: BrowserWindowEventNotification): void;
+}

package/lib/electron/window-proxy/implementations/electron-event-broadcaster.js

@@ -0,0 +1,32 @@
+"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.ElectronEventBroadcaster = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var ElectronEventBroadcaster = exports.ElectronEventBroadcaster = /*#__PURE__*/function () {
+  function ElectronEventBroadcaster(logger, getMainWindow) {
+    (0, _classCallCheck2["default"])(this, ElectronEventBroadcaster);
+    this.logger = logger;
+    this.getMainWindow = getMainWindow;
+  }
+  return (0, _createClass2["default"])(ElectronEventBroadcaster, [{
+    key: "broadcast",
+    value: function broadcast(channel, data) {
+      try {
+        var mainWindow = this.getMainWindow();
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.webContents.send(channel, data);
+        } else {
+          this.logger.warn('main window not available for event broadcasting');
+        }
+      } catch (error) {
+        this.logger.error("failed to send window event notification: ".concat(error));
+      }
+    }
+  }]);
+}();

package/lib/electron/window-proxy/implementations/electron-ipc-handler.d.ts

@@ -0,0 +1,6 @@
+import { IpcMainInvokeEvent } from 'electron';
+import { IIPCHandler } from '../interfaces';
+export declare class ElectronIPCHandler implements IIPCHandler {
+    handle(channel: string, handler: (event: IpcMainInvokeEvent, ...args: any[]) => Promise<any> | any): void;
+    removeHandler(channel: string): void;
+}

package/lib/electron/window-proxy/implementations/electron-ipc-handler.js

@@ -0,0 +1,27 @@
+"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.ElectronIPCHandler = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _electron = require("electron");
+var ElectronIPCHandler = exports.ElectronIPCHandler = /*#__PURE__*/function () {
+  function ElectronIPCHandler() {
+    (0, _classCallCheck2["default"])(this, ElectronIPCHandler);
+  }
+  return (0, _createClass2["default"])(ElectronIPCHandler, [{
+    key: "handle",
+    value: function handle(channel, handler) {
+      _electron.ipcMain.handle(channel, handler);
+    }
+  }, {
+    key: "removeHandler",
+    value: function removeHandler(channel) {
+      _electron.ipcMain.removeHandler(channel);
+    }
+  }]);
+}();

package/lib/electron/window-proxy/implementations/electron-logger.d.ts

@@ -0,0 +1,7 @@
+import { ILogger } from '../interfaces';
+export declare class ElectronLogger implements ILogger {
+    private logger;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}

package/lib/electron/window-proxy/implementations/electron-logger.js

@@ -0,0 +1,34 @@
+"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.ElectronLogger = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _logger = require("../../logger");
+var ElectronLogger = exports.ElectronLogger = /*#__PURE__*/function () {
+  function ElectronLogger() {
+    (0, _classCallCheck2["default"])(this, ElectronLogger);
+    (0, _defineProperty2["default"])(this, "logger", (0, _logger.getLogger)());
+  }
+  return (0, _createClass2["default"])(ElectronLogger, [{
+    key: "info",
+    value: function info(message) {
+      this.logger.info(message);
+    }
+  }, {
+    key: "warn",
+    value: function warn(message) {
+      this.logger.warn(message);
+    }
+  }, {
+    key: "error",
+    value: function error(message) {
+      this.logger.error(message);
+    }
+  }]);
+}();

package/lib/electron/window-proxy/{main-process-handler.d.ts → implementations/main-process-handler.d.ts}

@@ -1,15 +1,24 @@
-import { BrowserWindow } from 'electron';
+import type { BrowserWindow } from 'electron';
+import { IIPCHandler, IEventBroadcaster, ILogger, IBrowserWindowIPCConfig, IWindowManager } from '../interfaces';
 /**
  * 主进程中的 BrowserWindow IPC 处理器
  */
-export declare class BrowserWindowIPCHandler {
-    protected logger: import("winston").Logger;
+export declare class BrowserWindowIPCHandler implements IWindowManager {
+    private ipcHandler;
+    private eventBroadcaster;
+    private logger;
+    private config;
     private _windows;
     private _frameNameToId;
+    private _windowProxyMap;
     private _preventCloseWindows;
     private _windowEventListeners;
     private _mainWindow;
-    constructor();
+    constructor(ipcHandler: IIPCHandler, eventBroadcaster: IEventBroadcaster, logger: ILogger, config?: IBrowserWindowIPCConfig);
+    /**
+     * 清理资源
+     */
+    destroy(): void;
     /**
      * 设置主窗口，所有事件通知都通过主窗口发送
      */
@@ -19,14 +28,11 @@ export declare class BrowserWindowIPCHandler {
      */
     registerWindow(windowId: string, window: BrowserWindow, frameName: string): void;
     clearAllWindows(): void;
-    /**
-     * 注销窗口
-     */
     /**
      * 获取窗口
      */
     getWindow(frameName: string): BrowserWindow | undefined;
-    private _unregisterWindow;
+    unregisterWindow(windowId: string): void;
     private _setupIpcHandlers;
     private _handleWindowRequest;
     private _executeWindowAction;
@@ -41,5 +47,6 @@ export declare class BrowserWindowIPCHandler {
      * 处理子窗口关闭事件
      */
     private _handleSubWindowClose;
+    private _bindProxyToWindow;
+    private _unbindProxyFromWindow;
 }
-export declare const browserWindowIPCHandler: BrowserWindowIPCHandler;