fcr-ui-scene 3.6.0 → 3.6.2

package/dist/electron/ipc/ipc.js

@@ -0,0 +1,141 @@
+"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.IPCClient = void 0;
+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.slice.js");
+require("core-js/modules/es.date.to-json.js");
+require("core-js/modules/es.date.to-string.js");
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/esnext.async-iterator.for-each.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/esnext.json.parse.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+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 _net = require("net");
+var _events = _interopRequireDefault(require("events"));
+var _logger = require("../logger");
+var IPCClient = exports.IPCClient = /*#__PURE__*/function () {
+  function IPCClient(_ref) {
+    var _this = this;
+    var port = _ref.port;
+    (0, _classCallCheck2["default"])(this, IPCClient);
+    (0, _defineProperty2["default"])(this, "_logger", (0, _logger.getLogger)());
+    (0, _defineProperty2["default"])(this, "_observable", new _events["default"]());
+    (0, _defineProperty2["default"])(this, "_buffer", Buffer.alloc(0));
+    (0, _defineProperty2["default"])(this, "_handleMessage", function (message) {
+      _this._logger.log('Received message:', message);
+      try {
+        var parsedMessage = JSON.parse(message);
+        _this._observable.emit('onMessageReceived', parsedMessage);
+      } catch (error) {
+        _this._logger.error('Error parsing message:', error);
+      }
+    });
+    (0, _defineProperty2["default"])(this, "_handleError", function (error) {
+      _this._logger.error('Error:', error);
+      _this._observable.emit('onError', error);
+    });
+    this._logger.info('initialize tcp connection');
+    this._socket = (0, _net.createConnection)({
+      port: port,
+      timeout: 5000
+    }, function () {
+      _this._logger.info('connected to server!');
+    });
+    this._socket.on('end', function () {
+      _this._logger.info('disconnected from server');
+    });
+    this._socket.on('close', function () {
+      _this._logger.info('disconnected from server');
+      _this._observable.emit('onDisconnected');
+    });
+    this._socket.on('data', function (data) {
+      // 将新数据追加到现有缓冲区
+      _this._buffer = Buffer.concat([_this._buffer, data]);
+      // 处理可能的多条消息
+      _this._processBuffer();
+    });
+    this._socket.on('error', function (error) {
+      _this._logger.error('Socket error:', error);
+      _this._handleError(error);
+    });
+  }
+  return (0, _createClass2["default"])(IPCClient, [{
+    key: "_processBuffer",
+    value: function _processBuffer() {
+      // 循环处理缓冲区中的所有完整消息
+      while (this._buffer.length >= 4) {
+        // 读取消息长度
+        var messageLength = this._buffer.readUInt32BE(0);
+
+        // 检查是否有完整的消息
+        if (this._buffer.length >= messageLength + 4) {
+          // 提取消息内容（跳过4字节长度前缀）
+          var messageContent = this._buffer.slice(4, messageLength + 4);
+          // 更新缓冲区，移除已处理的消息
+          this._buffer = this._buffer.slice(messageLength + 4);
+
+          // 处理消息
+          var message = messageContent.toString();
+          this._handleMessage(message);
+        } else {
+          // 消息不完整，等待更多数据
+          break;
+        }
+      }
+    }
+  }, {
+    key: "sendMessage",
+    value: function sendMessage(message) {
+      var _this2 = this;
+      var messageString = JSON.stringify(message);
+      // 1. 创建包含消息长度的buffer(4字节)
+      var lengthBuffer = Buffer.alloc(4);
+      // 2. 以大端序(网络字节序)写入消息长度
+      var messageBuffer = Buffer.from(messageString);
+      lengthBuffer.writeUInt32BE(messageBuffer.length, 0);
+      // 3. 先发送长度，再发送消息内容
+
+      this._socket.write(Buffer.concat([lengthBuffer, Buffer.from(messageString)]), function (error) {
+        if (error) {
+          _this2._logger.error('Error sending message:', error);
+        } else {
+          _this2._logger.log('Message sent:', messageString);
+        }
+      });
+    }
+  }, {
+    key: "addObserver",
+    value: function addObserver(observer) {
+      var _this3 = this;
+      Object.keys(observer).forEach(function (eventKey) {
+        if (typeof observer[eventKey] === 'function') {
+          _this3._observable.on(eventKey, observer[eventKey]);
+        }
+      });
+    }
+  }, {
+    key: "removeObserver",
+    value: function removeObserver(observer) {
+      var _this4 = this;
+      Object.keys(observer).forEach(function (eventKey) {
+        if (typeof observer[eventKey] === 'function') {
+          _this4._observable.off(eventKey, observer[eventKey]);
+        }
+      });
+    }
+  }]);
+}();

package/dist/electron/ipc/type.js

@@ -0,0 +1,19 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IPCMessageCMD = void 0;
+var IPCMessageCMD = exports.IPCMessageCMD = /*#__PURE__*/function (IPCMessageCMD) {
+  IPCMessageCMD["ElectronMainWindowLoaded"] = "electron-main-window-loaded";
+  IPCMessageCMD["InitCreator"] = "init-creator";
+  IPCMessageCMD["LaunchMeeting"] = "launch-meeting";
+  IPCMessageCMD["OpenSetting"] = "open-setting";
+  IPCMessageCMD["CloseSetting"] = "close-setting";
+  IPCMessageCMD["LaunchSuccess"] = "launch-meeting-success";
+  IPCMessageCMD["LaunchFailure"] = "launch-meeting-failure";
+  IPCMessageCMD["SetParameters"] = "set-parameters";
+  IPCMessageCMD["ExitedMeeting"] = "exited-meeting";
+  return IPCMessageCMD;
+}({});

package/dist/electron/logger.js

@@ -0,0 +1,65 @@
+"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.getLogger = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.push.js");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _electron = require("electron");
+var _winston = _interopRequireDefault(require("winston"));
+var _path = _interopRequireDefault(require("path"));
+var _winston$format = _winston["default"].format,
+  combine = _winston$format.combine,
+  timestamp = _winston$format.timestamp,
+  printf = _winston$format.printf;
+var LoggerManager = /*#__PURE__*/function () {
+  function LoggerManager() {
+    (0, _classCallCheck2["default"])(this, LoggerManager);
+    this.initialize({
+      logFilePath: _path["default"].resolve(_electron.app.getPath('logs'), 'logs', 'apaas-main.log'),
+      console: true
+    });
+  }
+  return (0, _createClass2["default"])(LoggerManager, [{
+    key: "initialize",
+    value: function initialize(options) {
+      var logFilePath = options.logFilePath,
+        enableConsole = options.console;
+      var transports = [];
+      if (logFilePath) {
+        transports.push(new _winston["default"].transports.File({
+          filename: logFilePath,
+          maxFiles: 5,
+          maxsize: 1048576 //1MB
+        }));
+      }
+      if (enableConsole) {
+        transports.push(new _winston["default"].transports.Console());
+      }
+      this._logger = _winston["default"].createLogger({
+        level: 'info',
+        format: combine(timestamp(), printf(function (_ref) {
+          var level = _ref.level,
+            message = _ref.message,
+            timestamp = _ref.timestamp;
+          return "".concat(timestamp, " [").concat(level, "]: ").concat(message);
+        })),
+        transports: transports
+      });
+    }
+  }, {
+    key: "getLogger",
+    value: function getLogger() {
+      return this._logger;
+    }
+  }]);
+}();
+var loggerManager = new LoggerManager();
+var getLogger = exports.getLogger = function getLogger() {
+  return loggerManager.getLogger();
+};

package/dist/electron/main.js

@@ -0,0 +1,94 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hookWindow = void 0;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.string.starts-with.js");
+require("core-js/modules/web.timers.js");
+var _window = require("./window");
+var _screenshot = require("./plugins/screenshot");
+var _logger = require("./logger");
+var _meetingState = require("./plugins/meeting-state");
+var logger = (0, _logger.getLogger)();
+var hookWindow = exports.hookWindow = function hookWindow(mainWindow) {
+  mainWindow.webContents.addListener('did-create-window', function (window, details) {
+    logger.info("browser window is opened, frameName: ".concat(details.frameName));
+    var builtinFrameNames = ['device-settings', 'chat', 'live-streaming', 'participant', 'share-screen-selection', 'invite', 'video-window', 'confirm', 'connection-gateway', 'whiteboard', 'progress-dialog', 'operation-waiting-room', 'operation-waiting-room', 'interpreter-setting', 'waiting-room-single-remove', 'waiting-room-all-remove', 'waiting-room-all-admit', 'control-bar', 'show-toast', 'system-preference', 'rename', 'annotation-tool', 'leave-meeting'];
+    if (!builtinFrameNames.includes(details.frameName) && !details.frameName.startsWith('widget')) {
+      logger.info("frameName [".concat(details.frameName, "] is not in builtinFrameNames, ignore it"));
+      return;
+    }
+    (0, _window.putRendererWindow)(details.frameName, window);
+    window.webContents.addListener('destroyed', function () {
+      logger.info("browser window is destroyed, frameName: ".concat(details.frameName));
+      (0, _window.deleteRendererWindow)(details.frameName);
+    });
+
+    // prevent the close event to keep the window alive and renderer process will take charge of when to close the window
+    // renderer process will receive the will-close event, do some clean up and then call window.close() to close the window
+    window.addListener('close', function (event) {
+      event.preventDefault();
+      logger.info("Window [".concat(window.title, ":").concat(window.id, "] is closed by shortcut CMD + W, send 'will-close' event to that window"));
+      window.emit('will-close');
+    });
+    window.addListener('will-resize', function (event, newBounds, details) {
+      logger.info("Window [".concat(window.title, ":").concat(window.id, "] is resized, send 'custom-resize' event to that window"));
+      window.emit('custom-resize', event, newBounds, details);
+    });
+    window.addListener('move', function () {
+      logger.info("Window [".concat(window.title, ":").concat(window.id, "] is move, send 'custom-move' event to that window"));
+      window.emit('custom-move');
+    });
+
+    // screen?.addListener('display-metrics-changed', (event, display, changedMetrics) => {
+    //   logger.info(
+    //     `Screen metrics [${window.title}:${window.id}] is changed, send 'display-metrics-changed' event to that window`,
+    //   );
+    //   window.emit('display-metrics-changed', event, display, changedMetrics);
+    // });
+
+    attachEventOnMethod(window, 'hide', 'CALL_HIDE');
+    attachEventOnMethod(window, 'show', 'CALL_SHOW');
+  });
+  mainWindow.webContents.addListener('render-process-gone', function (event, details) {
+    logger.info("main window render-process-gone, details: ".concat(details));
+    (0, _window.closeAllWindows)();
+    (0, _window.clearAllRendererWindows)();
+    setTimeout(function () {
+      logger.info('start reloading main window...');
+      mainWindow.reload();
+    }, 1000);
+  });
+  mainWindow.on('enter-full-screen', function () {
+    mainWindow.webContents.send('custom-event', {
+      action: 'ENTER_FULL_SCREEN'
+    });
+  });
+  mainWindow.on('leave-full-screen', function () {
+    mainWindow.webContents.send('custom-event', {
+      action: 'LEAVE_FULL_SCREEN'
+    });
+  });
+  (0, _screenshot.listenScreenshot)(mainWindow);
+  (0, _meetingState.listenMeetingState)(mainWindow);
+};
+var attachEventOnMethod = function attachEventOnMethod(browserWindow, method, action) {
+  var func = browserWindow[method];
+  if (typeof func === 'function') {
+    // @ts-ignore
+    browserWindow[method] = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      // @ts-ignore
+      func.apply(this, args);
+      this.webContents.send('custom-event', {
+        action: action
+      });
+    };
+  }
+};

package/dist/electron/plugins/devtool-shortcut.js

@@ -0,0 +1,33 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listenDevToolShortcut = void 0;
+var _electron = require("electron");
+var _logger = require("../logger");
+var logger = (0, _logger.getLogger)();
+var listenDevToolShortcut = exports.listenDevToolShortcut = function listenDevToolShortcut(window) {
+  _electron.globalShortcut.register('CommandOrControl+Shift+X', function () {
+    if (window.isFocused()) {
+      logger.info('CommandOrControl+Shift+X is pressed');
+      window.webContents.openDevTools({
+        mode: 'detach'
+      });
+    }
+  });
+  _electron.globalShortcut.register('CommandOrControl+Shift+R', function () {
+    if (window.isFocused()) {
+      logger.info('CommandOrControl+Shift+R is pressed');
+      window.webContents.reloadIgnoringCache();
+    }
+  });
+  logger.info("CommandOrControl+Shift+X is ".concat(_electron.globalShortcut.isRegistered('CommandOrControl+Shift+X') ? 'registered' : 'not registered', " "));
+  logger.info("CommandOrControl+Shift+R is ".concat(_electron.globalShortcut.isRegistered('CommandOrControl+Shift+R') ? 'registered' : 'not registered', " "));
+  var unregister = function unregister() {
+    _electron.globalShortcut.unregister('CommandOrControl+Shift+X');
+    _electron.globalShortcut.unregister('CommandOrControl+Shift+R');
+  };
+  window.addListener('closed', unregister);
+};

package/dist/electron/plugins/meeting-state.js

@@ -0,0 +1,39 @@
+"use strict";
+
+require("core-js/modules/es.object.define-property.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listenMeetingState = exports.isInMeeting = void 0;
+require("core-js/modules/es.array.concat.js");
+var _electron = require("electron");
+var _logger = require("../logger");
+var logger = (0, _logger.getLogger)();
+var isInMeeting = exports.isInMeeting = 0;
+var listenMeetingState = exports.listenMeetingState = function listenMeetingState(window) {
+  var saveBlockerId = 0;
+  _electron.ipcMain.addListener('set-in-meeting-state', function (_, state) {
+    exports.isInMeeting = isInMeeting = state;
+    logger.info('in-meeting state changed', state);
+    if (state === 1) {
+      if (!_electron.powerSaveBlocker.isStarted(saveBlockerId)) {
+        saveBlockerId = _electron.powerSaveBlocker.start('prevent-display-sleep');
+        logger.info("power save blocker is started, blocker id: ".concat(saveBlockerId));
+      }
+    } else {
+      if (_electron.powerSaveBlocker.isStarted(saveBlockerId)) {
+        var isStopped = _electron.powerSaveBlocker.stop(saveBlockerId);
+        logger.info("power save blocker is stopped, blocker id: ".concat(saveBlockerId, ", isStopped: ").concat(isStopped));
+      }
+    }
+  });
+  window.addListener('close', function (event) {
+    if (isInMeeting === 1) {
+      event.preventDefault();
+      window.webContents.send('custom-event', {
+        action: 'CALL_CLOSE_MAIN_WINDOW',
+        payload: window.id
+      });
+    }
+  });
+};

package/dist/electron/plugins/screenshot.js

@@ -0,0 +1,54 @@
+"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.listenScreenshot = void 0;
+require("core-js/modules/web.timers.js");
+var _electron = require("electron");
+var _electronScreenshots = _interopRequireDefault(require("electron-screenshots"));
+var listenScreenshot = exports.listenScreenshot = function listenScreenshot(window) {
+  var shortcutCapture = new _electronScreenshots["default"]();
+  var isCapturing = false,
+    module = '',
+    alwaysHide = false;
+  var timer = null;
+  var stopScreen = function stopScreen() {
+    !alwaysHide && window.setOpacity(1);
+    isCapturing = false;
+    timer && clearTimeout(timer);
+  };
+  shortcutCapture.on('ok', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('finish', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('cancel', function () {
+    stopScreen();
+  });
+  shortcutCapture.on('save', function () {
+    stopScreen();
+  });
+  var showScreenShot = function showScreenShot() {
+    if (shortcutCapture) {
+      shortcutCapture.startCapture();
+    }
+  };
+  _electron.ipcMain.addListener('short-cut-capture', function (_, event, payload) {
+    if (!isCapturing) {
+      isCapturing = true;
+      var hideWindow = false;
+      hideWindow = payload.hideWindow;
+      module = payload.module;
+      alwaysHide = !!(payload !== null && payload !== void 0 && payload.alwaysHide);
+      hideWindow && window.setOpacity(0);
+      if (!shortcutCapture) {
+        shortcutCapture = new _electronScreenshots["default"]();
+      }
+      timer = setTimeout(showScreenShot, 500);
+    }
+  });
+};

package/dist/electron/preload.js

@@ -0,0 +1,108 @@
+"use strict";
+
+require("core-js/modules/es.object.keys.js");
+require("core-js/modules/esnext.json.parse.js");
+var _renderer = require("electron/renderer");
+var _injections = require("./injections");
+var _type = require("./ipc/type");
+window.runtime = {
+  open: _injections.open,
+  close: _injections.close,
+  openRendererWindow: _injections.openRendererWindow,
+  closeRendererWindow: _injections.closeRendererWindow,
+  sendEvent: _injections.sendEvent,
+  addEventListener: _injections.addEventListener,
+  removeEventListener: _injections.removeEventListener,
+  getBrowserWindowById: _injections.getBrowserWindowById,
+  captureScreen: _injections.captureScreen,
+  browserWindow: _injections.browserWindow,
+  setFragmentOptions: _injections.setFragmentOptions,
+  openLinkInDefaultBrowser: _injections.openLinkInDefaultBrowser,
+  openDirectory: _injections.openDirectory,
+  showItemInFolder: _injections.showItemInFolder,
+  screen: _injections.screen,
+  launch: _injections.launch,
+  quitApp: _injections.quitApp,
+  getLaunchOptions: _injections.getLaunchOptions,
+  getSystemMemorySize: _injections.getSystemMemorySize,
+  getSystemCpuInfo: _injections.getSystemCpuInfo,
+  getNetworkType: _injections.getNetworkType,
+  setFragmentBaseUrl: _injections.setFragmentBaseUrl,
+  getResourceByFileType: _injections.getResourceByFileType,
+  fileToBlob: _injections.fileToBlob,
+  registerListenerReady: _injections.registerListenerReady,
+  releaseSubAllWindowRefs: _injections.releaseSubAllWindowRefs,
+  getMediaSourceIdList: _injections.getMediaSourceIdList,
+  setInMeetingState: _injections.setInMeetingState,
+  restartApp: _injections.restartApp,
+  getBundleType: _injections.getBundleType,
+  checkMediaPermission: _injections.checkMediaPermission,
+  openSystemPreferences: _injections.openSystemPreferences,
+  getUserSettingData: _injections.getUserSettingData,
+  setUserSettingData: _injections.setUserSettingData,
+  getActiveWindow: _injections.getActiveWindow,
+  getWindows: _injections.getWindows,
+  initSDK: _injections.initSDK,
+  getIsSDKReady: _injections.getIsSDKReady,
+  openSetting: _injections.openSetting,
+  loadBuiltinResources: _injections.loadBuiltinResources,
+  launchSuccess: _injections.launchSuccess,
+  launchFailure: _injections.launchFailure,
+  setParameters: _injections.setParameters,
+  exitedMeeting: _injections.exitedMeeting,
+  getIsMeetingLaunched: _injections.getIsMeetingLaunched
+};
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.InitCreator, function (_event, value) {
+  if (window.runtime.onCreatorInit) {
+    var data = value;
+    try {
+      if (typeof value == 'string') {
+        data = JSON.parse(value);
+      }
+    } catch (e) {
+      console.error('Failed to parse init options:', e);
+    }
+    window.runtime.onCreatorInit(data);
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.OpenSetting, function (_event, value) {
+  if (window.runtime.onSettingOpen) {
+    window.runtime.onSettingOpen();
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.CloseSetting, function (_event, value) {
+  if (window.runtime.onSettingClose) {
+    window.runtime.onSettingClose();
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.SetParameters, function (_event, value) {
+  if (window.runtime.onSetParameters) {
+    window.runtime.onSetParameters(value);
+  }
+});
+_renderer.ipcRenderer.on(_type.IPCMessageCMD.LaunchMeeting, function (_event, value) {
+  if (window.runtime.onLaunchMeeting) {
+    var data = value;
+    try {
+      data = JSON.parse(value);
+    } catch (e) {
+      console.error('Failed to parse launch options:', e);
+    }
+    window.runtime.onLaunchMeeting(data);
+  }
+});
+_renderer.ipcRenderer.on('sdk-ready', function () {
+  if (window.runtime.onSDKReady) {
+    window.runtime.onSDKReady();
+  }
+});
+_renderer.ipcRenderer.on('close-window-before-launch-success', function () {
+  if (window.runtime.onCloseWindowBeforeLaunchSuccess) {
+    window.runtime.onCloseWindowBeforeLaunchSuccess();
+  }
+});
+_renderer.ipcRenderer.on('exited-meeting', function (_event, roomId, reason) {
+  if (window.runtime.exitedMeeting) {
+    window.runtime.exitedMeeting(roomId, reason);
+  }
+});

package/dist/electron/tools.js

@@ -0,0 +1,66 @@
+"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.getCpuUsage = getCpuUsage;
+exports.getProcessIds = getProcessIds;
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.filter.js");
+require("core-js/modules/es.array.for-each.js");
+require("core-js/modules/es.array.includes.js");
+require("core-js/modules/es.array.map.js");
+require("core-js/modules/es.array.reduce.js");
+require("core-js/modules/es.function.name.js");
+require("core-js/modules/es.number.to-fixed.js");
+require("core-js/modules/es.object.to-string.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.string.includes.js");
+require("core-js/modules/esnext.async-iterator.filter.js");
+require("core-js/modules/esnext.async-iterator.for-each.js");
+require("core-js/modules/esnext.async-iterator.map.js");
+require("core-js/modules/esnext.async-iterator.reduce.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/esnext.iterator.for-each.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.iterator.reduce.js");
+require("core-js/modules/web.dom-collections.for-each.js");
+var _systeminformation = _interopRequireDefault(require("systeminformation"));
+function getProcessIds(processName) {
+  return new Promise(function (resolve, reject) {
+    _systeminformation["default"].processes().then(function (processes) {
+      var appProcess = processes.list.filter(function (process) {
+        return process.name.includes(processName);
+      });
+      var processIds = appProcess.map(function (item) {
+        return String(item.pid);
+      });
+      console.log("Process IDs for ".concat(processName, ":"), processIds);
+      resolve(processIds);
+    })["catch"](function (err) {
+      return reject(err);
+    });
+  });
+}
+function getCpuUsage() {
+  return new Promise(function (resolve, reject) {
+    _systeminformation["default"].currentLoad().then(function (data) {
+      var total = data.cpus.reduce(function (prev, curr) {
+        return prev + curr.load;
+      }, 0);
+      console.log("Total CPU Usage: ".concat(data.currentLoad.toFixed(2), "%, total: ").concat(total, ", average: ").concat(total / data.cpus.length));
+      data.cpus.forEach(function (cpu, index) {
+        console.log("Core ".concat(index, " - CPU Usage: ").concat(cpu.load.toFixed(2), "%"));
+      });
+      resolve({
+        coreCount: data.cpus.length,
+        totalUsage: total
+      });
+    })["catch"](function (err) {
+      return reject(err);
+    });
+  });
+}