fcr-ui-scene 3.8.1-beta → 3.8.2

package/lib-es/electron/injections.js

@@ -0,0 +1,830 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.array.reduce.js";
+import "core-js/modules/es.date.now.js";
+import "core-js/modules/es.date.to-json.js";
+import "core-js/modules/es.json.stringify.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.object.entries.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.promise.all-settled.js";
+import "core-js/modules/es.promise.finally.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.string.starts-with.js";
+import "core-js/modules/es.string.trim.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.find.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/esnext.iterator.reduce.js";
+import "core-js/modules/esnext.json.parse.js";
+import "core-js/modules/esnext.map.delete-all.js";
+import "core-js/modules/esnext.map.emplace.js";
+import "core-js/modules/esnext.map.every.js";
+import "core-js/modules/esnext.map.filter.js";
+import "core-js/modules/esnext.map.find.js";
+import "core-js/modules/esnext.map.find-key.js";
+import "core-js/modules/esnext.map.includes.js";
+import "core-js/modules/esnext.map.key-of.js";
+import "core-js/modules/esnext.map.map-keys.js";
+import "core-js/modules/esnext.map.map-values.js";
+import "core-js/modules/esnext.map.merge.js";
+import "core-js/modules/esnext.map.reduce.js";
+import "core-js/modules/esnext.map.some.js";
+import "core-js/modules/esnext.map.update.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import { ipcRenderer } from 'electron';
+import { BrowserWindow, getCurrentWindow, shell, dialog, screen as _screen, app as _app, net as _net } from '@electron/remote';
+import os from 'os';
+import { exec } from 'child_process';
+import _path from 'path';
+import _fs from 'fs';
+import _fsp from 'fs/promises';
+import JSZip from 'jszip';
+import path from 'path';
+import { AppExitCode } from './exit-codes';
+import { BrowserWindowProxyImpl } from './window-proxy/browser-window-proxy';
+import { devPageUrl, isDev } from './env';
+import { md5 } from 'js-md5';
+var USER_SETTING_DATA_FILE_NAME = 'UserSettingData.json';
+var isDevMode = process.env.DEV === 'true';
+var appPath = _app.getAppPath();
+var appDataPath = _app.getPath('appData');
+var buildtinResourcesPath = isDevMode ? _path.resolve(_path.dirname(require.resolve('fcr-ui-scene/package.json')), 'public/assets/electron') : _path.resolve(appPath, '../assets');
+var userDataPath = _app.getPath('userData');
+var cachePath = _path.resolve(userDataPath, 'cache');
+var imageExtensions = ['.png', '.jpg'];
+var videoExtensions = ['.mp4'];
+var audioExtensions = ['.mp3', '.wav'];
+var zipExtensions = ['.zip'];
+var extensionMap = {
+  image: imageExtensions,
+  video: videoExtensions,
+  audio: audioExtensions
+};
+console.log("Preload script loaded, process id: ".concat(process.pid));
+console.log("Is dev mode: ".concat(isDevMode));
+console.log("App path: ".concat(appPath));
+console.log("App data path: ".concat(appDataPath));
+console.log("Builtin ui resource path: ".concat(buildtinResourcesPath));
+console.log("User data path: ".concat(userDataPath));
+console.log("Cache path: ".concat(cachePath));
+var rendererWindows = new Map();
+export var openDirectory = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _yield$dialog$showOpe, filePaths;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 1;
+          return dialog.showOpenDialog(getCurrentWindow(), {
+            properties: ['openDirectory']
+          });
+        case 1:
+          _yield$dialog$showOpe = _context.sent;
+          filePaths = _yield$dialog$showOpe.filePaths;
+          return _context.abrupt("return", filePaths[0]);
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function openDirectory() {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var showItemInFolder = function showItemInFolder(path) {
+  shell.showItemInFolder(path);
+};
+export var sendEvent = function sendEvent(event) {
+  BrowserWindow.getAllWindows().forEach(function (window) {
+    var currentWindow = getCurrentWindow();
+    if (window.id !== currentWindow.id) {
+      window.webContents.send('custom-event', event);
+    }
+  });
+};
+export var addEventListener = function addEventListener(listener) {
+  ipcRenderer.addListener('custom-event', listener);
+};
+export var removeEventListener = function removeEventListener(listener) {
+  ipcRenderer.removeListener('custom-event', listener);
+};
+export var createBrowserWindowProxy = function createBrowserWindowProxy(windowId) {
+  var windowProxy = new BrowserWindowProxyImpl(windowId);
+
+  //
+  // windowProxy.addListener('closed', () => {
+  //   rendererWindows.forEach(({ windowId, disposer }, frameName) => {
+  //     if (windowId === windowProxy.windowId) {
+  //       disposer();
+
+  //       console.log(`delete from rendererWindows by window id: ${windowId}`);
+
+  //       rendererWindows.delete(frameName);
+  //     }
+  //   });
+  // });
+
+  return windowProxy;
+};
+export var setFragmentOptions = function setFragmentOptions(entryPath, windowOptions, webPreferences) {
+  ipcRenderer.send('setFragmentOptions', entryPath, windowOptions, webPreferences);
+};
+export var openLinkInDefaultBrowser = function openLinkInDefaultBrowser(url) {
+  shell.openExternal(url);
+};
+export var screen = _screen;
+export var open = function open(entryPath, dialogId) {
+  ipcRenderer.send('open', entryPath, dialogId);
+};
+export var close = function close(entryPath, dialogId) {
+  ipcRenderer.send('close', entryPath, dialogId);
+};
+export var setFragmentBaseUrl = function setFragmentBaseUrl(isDev, baseUrl) {
+  ipcRenderer.send('setFragmentBaseUrl', isDev, baseUrl);
+};
+export var captureScreen = function captureScreen(options) {
+  ipcRenderer.send('short-cut-capture', "short-cut-capture-reply-".concat(Date.now()), options);
+};
+
+// export const getActiveWindow = () => {
+//   return wm.getActiveWindow();
+// };
+
+// export const getWindowInfoList = () => {
+//   return wm.getWindows();
+// };
+
+export var getBaseUrl = function getBaseUrl() {
+  return isDev ? devPageUrl : '.';
+};
+export var openRendererWindow = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(frameName, callback, windowOptions) {
+    var isAlreadyOpened, windowConstructorOptionsString, newRendererWindow, windowId, windowIdStr, htmlTemplate, renderDom, parentWindow, parentHead, parentStyles, parentStyleLinks, stylesLoadedPromises, presetWindoStyle, observer, parentRoot, parentRootStyles, _renderDom;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          isAlreadyOpened = rendererWindows.has(frameName);
+          windowConstructorOptionsString = Object.entries(windowOptions).reduce(function (acc, _ref3) {
+            var _ref4 = _slicedToArray(_ref3, 2),
+              key = _ref4[0],
+              value = _ref4[1];
+            if (typeof value === 'string') {
+              return "".concat(acc, ",").concat(key, "=").concat(value);
+            }
+            return "".concat(acc, ",").concat(key, "=").concat(JSON.stringify(value));
+          }, 'show=false');
+          newRendererWindow = window.open('', frameName, windowConstructorOptionsString);
+          _context2.next = 1;
+          return ipcRenderer.invoke('getBrowserWindowId', frameName);
+        case 1:
+          windowId = _context2.sent;
+          if (windowId) {
+            _context2.next = 2;
+            break;
+          }
+          throw new Error("cannot open renderer window, windowId not found after open window, frameName: ".concat(frameName));
+        case 2:
+          windowIdStr = "".concat(windowId);
+          if (newRendererWindow) {
+            _context2.next = 3;
+            break;
+          }
+          throw new Error('cannot open renderer window, window.open returned null');
+        case 3:
+          if (isAlreadyOpened) {
+            _context2.next = 5;
+            break;
+          }
+          htmlTemplate = '<div id="root"></div>';
+          newRendererWindow.document.writeln(htmlTemplate);
+          console.log('render window opened:', frameName, windowIdStr);
+          renderDom = newRendererWindow.document.getElementById('root');
+          if (renderDom) {
+            _context2.next = 4;
+            break;
+          }
+          throw new Error("cannot find #root dom in new renderer window: ".concat(frameName));
+        case 4:
+          // copy styles from parent window
+          parentWindow = window;
+          parentHead = parentWindow.document.head;
+          parentStyles = parentHead.querySelectorAll('style');
+          parentStyleLinks = parentHead.querySelectorAll('link[rel="stylesheet"]');
+          stylesLoadedPromises = [];
+          parentStyles.forEach(function (style) {
+            newRendererWindow.document.head.appendChild(style.cloneNode(true));
+          });
+          parentStyleLinks.forEach(function (style) {
+            var linkNode = style.cloneNode(true);
+            newRendererWindow.document.head.appendChild(linkNode);
+            stylesLoadedPromises.push(new Promise(function (resolve, reject) {
+              linkNode.addEventListener('load', function () {
+                return resolve();
+              });
+              linkNode.addEventListener('error', function () {
+                return reject("failed to load style: ".concat(linkNode.href));
+              });
+            }));
+          });
+
+          // inject preset style to set background transparent
+          presetWindoStyle = document.createElement('style'); // 1. set background transparent
+          // 2. prevent flickering scrollbar
+          presetWindoStyle.innerHTML = "\n      html, body {\n        background: transparent;\n        overflow: hidden;\n    }";
+          newRendererWindow.document.head.appendChild(presetWindoStyle);
+          observer = new MutationObserver(function (mutations) {
+            mutations.forEach(function (mutation) {
+              if (mutation.type === 'childList') {
+                mutation.addedNodes.forEach(function (node) {
+                  if (node.nodeType === Node.ELEMENT_NODE && node.tagName === 'STYLE') {
+                    newRendererWindow.document.head.appendChild(node.cloneNode(true));
+                  }
+                });
+              }
+            });
+          });
+          observer.observe(document.head, {
+            childList: true
+          });
+
+          // copy css variables from parent window
+          parentRoot = parentWindow.document.documentElement;
+          parentRootStyles = parentRoot.style.cssText;
+          newRendererWindow.document.documentElement.style.cssText = parentRootStyles;
+          Promise.allSettled(stylesLoadedPromises)["finally"](function () {
+            callback(renderDom, windowIdStr, newRendererWindow);
+          });
+          rendererWindows.set(frameName, {
+            windowId: windowIdStr,
+            disposer: function disposer() {
+              observer.disconnect();
+            }
+          });
+          _context2.next = 7;
+          break;
+        case 5:
+          _renderDom = newRendererWindow.document.getElementById('root');
+          if (_renderDom) {
+            _context2.next = 6;
+            break;
+          }
+          throw new Error("cannot find #root dom in new renderer window: ".concat(frameName));
+        case 6:
+          callback(_renderDom, windowIdStr, newRendererWindow);
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function openRendererWindow(_x, _x2, _x3) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+export var checkMediaPermission = /*#__PURE__*/function () {
+  var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(mediaType) {
+    var res;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 1;
+          return ipcRenderer.invoke('checkMediaPermission', mediaType);
+        case 1:
+          res = _context3.sent;
+          return _context3.abrupt("return", res);
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return function checkMediaPermission(_x4) {
+    return _ref5.apply(this, arguments);
+  };
+}();
+export var openSystemPreferences = function openSystemPreferences(mediaType) {
+  ipcRenderer.send('openSystemPreferences', mediaType);
+};
+export var quitApp = function quitApp() {
+  _app.exit(AppExitCode.NORMAL_EXIT);
+};
+export var getSystemMemorySize = function getSystemMemorySize() {
+  return os.totalmem();
+};
+export var getSystemCpuInfo = function getSystemCpuInfo() {
+  return os.cpus();
+};
+export var getNetworkType = function getNetworkType() {
+  var resolve = function resolve(res) {};
+  var p = new Promise(function (_resolve) {
+    resolve = _resolve;
+  });
+  var platform = os.platform();
+  if (platform === 'darwin') {
+    // macos
+    exec('networksetup -getairportnetwork en0', function (error, stdout, stderr) {
+      if (error || stderr) {
+        resolve({
+          isWifiConnected: false,
+          connection: ''
+        });
+        return;
+      }
+      if (stdout.includes('Wi-Fi power is currently off')) {
+        resolve({
+          isWifiConnected: false,
+          connection: ''
+        });
+      } else {
+        var _stdout$split$;
+        var network = (_stdout$split$ = stdout.split(': ')[1]) === null || _stdout$split$ === void 0 ? void 0 : _stdout$split$.trim();
+        resolve({
+          isWifiConnected: true,
+          connection: network || ''
+        });
+      }
+    });
+  } else if (platform === 'win32') {
+    // windows
+    exec('chcp 65001 && netsh wlan show interfaces', function (error, stdout, stderr) {
+      if (error || stderr) {
+        resolve({
+          isWifiConnected: false,
+          connection: ''
+        });
+        return;
+      }
+      var lines = stdout.split('\n');
+      lines.forEach(function (line) {
+        if (line.includes('State') && line.includes('connected')) {
+          resolve({
+            isWifiConnected: true,
+            connection: ''
+          });
+        }
+      });
+      resolve({
+        isWifiConnected: false,
+        connection: ''
+      });
+    });
+  } else if (platform === 'linux') {
+    // linux
+    exec('nmcli -t -f TYPE,STATE,CONNECTION device status', function (error, stdout, stderr) {
+      if (error || stderr) {
+        resolve({
+          isWifiConnected: false,
+          connection: ''
+        });
+        return;
+      }
+      var devices = stdout.split('\n');
+      devices.forEach(function (device) {
+        var _device$split = device.split(':'),
+          _device$split2 = _slicedToArray(_device$split, 3),
+          type = _device$split2[0],
+          state = _device$split2[1],
+          connection = _device$split2[2];
+        if (type === 'wifi' && state === 'connected') {
+          resolve({
+            isWifiConnected: true,
+            connection: connection
+          });
+        }
+      });
+      resolve({
+        isWifiConnected: false,
+        connection: ''
+      });
+    });
+  } else {
+    resolve({
+      isWifiConnected: false,
+      connection: ''
+    });
+  }
+  return p;
+};
+var getZipCachePath = function getZipCachePath(type) {
+  var resourcePath = type === 'audio' ? 'sound_effect_' : 'virtual_bg_';
+  return _path.resolve(cachePath, "fcr_scene/".concat(resourcePath).concat(type, "s"));
+};
+var getResourcePath = function getResourcePath(type, path) {
+  var resourcePath = type === 'audio' ? 'sound_effect_' : 'virtual_bg_';
+  return _path.resolve(userDataPath, "fcr_scene/".concat(resourcePath).concat(type, "s/").concat(path));
+};
+
+// 解压 zip 文件并保存
+var unZipAndSaveFile = /*#__PURE__*/function () {
+  var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(zipFile, outputPath, type) {
+    var zipBuffer, zip, fileNames;
+    return _regeneratorRuntime.wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          zipBuffer = _fs.readFileSync(zipFile);
+          _context5.next = 1;
+          return JSZip.loadAsync(zipBuffer);
+        case 1:
+          zip = _context5.sent;
+          fileNames = [];
+          _context5.next = 2;
+          return Promise.all(Object.keys(zip.files).filter(function (filename) {
+            // 忽略目录、扩展文件或不需要的文件
+            var isDirectory = zip.files[filename].dir;
+            var isExtensionFile = filename.includes('__MACOSX') || filename.includes('.DS_Store') || filename.startsWith('.') ||
+            // 忽略以.开头的文件（隐藏文件）
+            filename.includes('Thumbs.db'); // 忽略 Windows 的缩略图数据库文件
+
+            var isUserDataFile = type === 'image' ? imageExtensions.includes(_path.extname(filename)) : type === 'video' ? videoExtensions.includes(_path.extname(filename)) : audioExtensions.includes(_path.extname(filename));
+            return !isDirectory && !isExtensionFile && isUserDataFile;
+          }).map(/*#__PURE__*/function () {
+            var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(filenameTmp) {
+              var fileData, realFileName, outputFile;
+              return _regeneratorRuntime.wrap(function (_context4) {
+                while (1) switch (_context4.prev = _context4.next) {
+                  case 0:
+                    _context4.next = 1;
+                    return zip.files[filenameTmp].async('nodebuffer');
+                  case 1:
+                    fileData = _context4.sent;
+                    realFileName = _path.basename(filenameTmp);
+                    outputFile = _path.resolve(outputPath, realFileName);
+                    _fs.mkdirSync(_path.dirname(outputFile), {
+                      recursive: true
+                    });
+                    _fs.writeFileSync(outputFile, fileData);
+                    fileNames.push(outputFile);
+                  case 2:
+                  case "end":
+                    return _context4.stop();
+                }
+              }, _callee4);
+            }));
+            return function (_x8) {
+              return _ref7.apply(this, arguments);
+            };
+          }()));
+        case 2:
+          // 删除 zip 文件
+          _fs.unlinkSync(zipFile);
+          return _context5.abrupt("return", fileNames);
+        case 3:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return function unZipAndSaveFile(_x5, _x6, _x7) {
+    return _ref6.apply(this, arguments);
+  };
+}();
+
+// 检查指定路径下是否有指定的文件
+function getSpecificFiles(directory, extensions, fileName) {
+  // 检查目录是否存在
+  if (!_fs.existsSync(directory)) {
+    // 如果目录不存在，则创建目录
+    _fs.mkdirSync(directory, {
+      recursive: true
+    });
+    return [];
+  }
+  try {
+    var files = _fs.readdirSync(directory);
+
+    // 筛选出符合扩展名的文件
+    var filteredFiles = files.filter(function (file) {
+      var ext = _path.extname(file).toLowerCase();
+      return extensions.includes(ext);
+    });
+
+    // 如果传入了文件名，则只返回符合条件的文件
+    if (fileName) {
+      filteredFiles = filteredFiles.filter(function (file) {
+        return file === fileName;
+      });
+    }
+
+    // 符合条件的文件
+    return filteredFiles.length > 0 ? filteredFiles.map(function (file) {
+      return _path.resolve(directory, file);
+    }) : [];
+  } catch (err) {
+    console.error("Error reading directory: ".concat(err === null || err === void 0 ? void 0 : err.message));
+    return [];
+  }
+}
+function downloadFile(_x9, _x0) {
+  return _downloadFile.apply(this, arguments);
+} // 获取资源
+function _downloadFile() {
+  _downloadFile = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0(url, destination) {
+    return _regeneratorRuntime.wrap(function (_context0) {
+      while (1) switch (_context0.prev = _context0.next) {
+        case 0:
+          return _context0.abrupt("return", new Promise(function (resolve, reject) {
+            var request = _net.request(url);
+            request.on('response', function (response) {
+              var fileStream = _fs.createWriteStream(destination);
+              fileStream.on('finish', function () {
+                resolve();
+              });
+              response.on('end', function () {
+                fileStream.end();
+              });
+              response.on('data', function (chunk) {
+                fileStream.write(chunk);
+              });
+              response.on('error', function (err) {
+                reject(new Error("Download failed: ".concat(err.message, ", url: ").concat(url, ", file path: ").concat(destination)));
+              });
+            });
+            request.on('error', function (err) {
+              reject(new Error("Request failed: ".concat(err.message, ", url: ").concat(url, ", file path: ").concat(destination)));
+            });
+            request.end();
+          }));
+        case 1:
+        case "end":
+          return _context0.stop();
+      }
+    }, _callee0);
+  }));
+  return _downloadFile.apply(this, arguments);
+}
+export var downloadAndExtractResourceFileFromZip = /*#__PURE__*/function () {
+  var _ref8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6(zipUrl, type) {
+    var md5Str, resourcePath, extensions, cachedFiles, zipFileName, zipCacheDir, zipFiles, tempZipPath, zipPath, zipFilePath, filePathList;
+    return _regeneratorRuntime.wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          md5Str = md5(zipUrl);
+          resourcePath = getResourcePath(type, md5Str);
+          extensions = extensionMap[type]; // 已有缓存文件，直接使用
+          cachedFiles = getSpecificFiles(resourcePath, extensions);
+          if (!(cachedFiles.length > 0)) {
+            _context6.next = 1;
+            break;
+          }
+          console.log("Using cached files for ".concat(zipUrl, ": ").concat(JSON.stringify(cachedFiles)));
+          return _context6.abrupt("return", cachedFiles);
+        case 1:
+          // 已有 zip
+          zipFileName = "".concat(md5Str, ".zip");
+          zipCacheDir = getZipCachePath(type);
+          zipFiles = getSpecificFiles(zipCacheDir, zipExtensions, zipFileName); // 没有 zip，需要下载
+          if (!(zipFiles.length <= 0)) {
+            _context6.next = 3;
+            break;
+          }
+          tempZipPath = _path.resolve("".concat(zipCacheDir, "/").concat(md5Str, ".temp"));
+          zipPath = _path.resolve("".concat(zipCacheDir, "/").concat(zipFileName));
+          console.log("start downloading zip file from ".concat(zipUrl, " to ").concat(tempZipPath));
+          _context6.next = 2;
+          return downloadFile(zipUrl, tempZipPath);
+        case 2:
+          console.log("finished downloading zip file to ".concat(tempZipPath));
+
+          // temp 文件重命名为 zip
+          _fs.renameSync(tempZipPath, zipPath);
+          console.log("renamed temp file from ".concat(tempZipPath, " to ").concat(zipPath));
+          zipFiles = getSpecificFiles(zipCacheDir, zipExtensions, zipFileName);
+        case 3:
+          if (!(!zipFiles || zipFiles.length <= 0)) {
+            _context6.next = 4;
+            break;
+          }
+          console.warn("No zip files found for ".concat(zipUrl));
+          return _context6.abrupt("return", []);
+        case 4:
+          zipFilePath = zipFiles[0]; // 解压并返回背景文件
+          _context6.next = 5;
+          return unZipAndSaveFile(zipFilePath, resourcePath, type);
+        case 5:
+          filePathList = _context6.sent;
+          console.log("Unzipped files from ".concat(zipFilePath, ": ").concat(JSON.stringify(filePathList)));
+          return _context6.abrupt("return", filePathList);
+        case 6:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return function downloadAndExtractResourceFileFromZip(_x1, _x10) {
+    return _ref8.apply(this, arguments);
+  };
+}();
+export var downloadResourceFile = /*#__PURE__*/function () {
+  var _ref9 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(fileUrl, type) {
+    var md5Str, resourceDirPath, resourceFilePath, _t;
+    return _regeneratorRuntime.wrap(function (_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          _context7.prev = 0;
+          md5Str = md5(fileUrl);
+          resourceDirPath = getResourcePath(type, md5Str);
+          resourceFilePath = _path.resolve(resourceDirPath, 'sound.mp3');
+          if (!_fs.existsSync(resourceFilePath)) {
+            _context7.next = 1;
+            break;
+          }
+          console.log("Using cached file for ".concat(fileUrl, ": ").concat(resourceFilePath));
+          return _context7.abrupt("return", resourceFilePath);
+        case 1:
+          if (!_fs.existsSync(resourceDirPath)) {
+            _fs.mkdirSync(resourceDirPath, {
+              recursive: true
+            });
+          }
+          _context7.next = 2;
+          return downloadFile(fileUrl, resourceFilePath);
+        case 2:
+          return _context7.abrupt("return", resourceFilePath);
+        case 3:
+          _context7.prev = 3;
+          _t = _context7["catch"](0);
+          console.error('download error', _t);
+          throw _t;
+        case 4:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7, null, [[0, 3]]);
+  }));
+  return function downloadResourceFile(_x11, _x12) {
+    return _ref9.apply(this, arguments);
+  };
+}();
+
+// UI 层拿到 file path 需要转为 base64
+export var fileToBase64 = function fileToBase64(file, type) {
+  var data = _fs.readFileSync(file, {
+    encoding: 'base64'
+  });
+  if (type === 'video') {
+    return "data:video/mp4;base64,".concat(data);
+  } else if (type === 'audio') {
+    return "data:audio/mp3;base64,".concat(data);
+  } else {
+    return "data:image/jpeg;base64,".concat(data);
+  }
+};
+export var fileToBlob = function fileToBlob(file, type) {
+  var data = _fs.readFileSync(file, {
+    encoding: 'base64'
+  });
+  return new Blob([Buffer.from(data, 'base64')], {
+    type: type === 'video' ? 'video/mp4' : type === 'audio' ? 'audio/mp3' : 'image/jpeg'
+  });
+};
+export var loadBuiltinResources = /*#__PURE__*/function () {
+  var _ref0 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+    var builtinVirtualBackgroundImagePath, builtinVirtualBackgroundVideoPath, builtinSoundEffectsPath;
+    return _regeneratorRuntime.wrap(function (_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          builtinVirtualBackgroundImagePath = _path.join(buildtinResourcesPath, 'images');
+          builtinVirtualBackgroundVideoPath = _path.join(buildtinResourcesPath, 'videos');
+          builtinSoundEffectsPath = _path.join(buildtinResourcesPath, 'sound_effects');
+          return _context9.abrupt("return", new Promise(/*#__PURE__*/function () {
+            var _ref1 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8(resolve) {
+              var _yield$Promise$allSet, _yield$Promise$allSet2, images, videos, sounds, virtualBackgroundImages, virtualBackgroundVideos, soundEffectAudios;
+              return _regeneratorRuntime.wrap(function (_context8) {
+                while (1) switch (_context8.prev = _context8.next) {
+                  case 0:
+                    _context8.next = 1;
+                    return Promise.allSettled([_fsp.readdir(builtinVirtualBackgroundImagePath), _fsp.readdir(builtinVirtualBackgroundVideoPath), _fsp.readdir(builtinSoundEffectsPath)]);
+                  case 1:
+                    _yield$Promise$allSet = _context8.sent;
+                    _yield$Promise$allSet2 = _slicedToArray(_yield$Promise$allSet, 3);
+                    images = _yield$Promise$allSet2[0];
+                    videos = _yield$Promise$allSet2[1];
+                    sounds = _yield$Promise$allSet2[2];
+                    virtualBackgroundImages = [];
+                    if (images.status === 'fulfilled') {
+                      images.value.forEach(function (file) {
+                        var ext = _path.extname(file).toLowerCase();
+                        if (imageExtensions.includes(ext)) {
+                          virtualBackgroundImages.push(_path.join(builtinVirtualBackgroundImagePath, file));
+                        }
+                      });
+                    }
+                    virtualBackgroundVideos = [];
+                    if (videos.status === 'fulfilled') {
+                      videos.value.forEach(function (file) {
+                        var ext = _path.extname(file).toLowerCase();
+                        if (videoExtensions.includes(ext)) {
+                          virtualBackgroundVideos.push(_path.join(builtinVirtualBackgroundVideoPath, file));
+                        }
+                      });
+                    }
+                    soundEffectAudios = {};
+                    if (sounds.status === 'fulfilled') {
+                      sounds.value.forEach(function (file) {
+                        var ext = _path.extname(file).toLowerCase();
+                        var fileNameWithoutExt = _path.basename(file, ext);
+                        if (audioExtensions.includes(ext)) {
+                          soundEffectAudios[fileNameWithoutExt] = _path.join(builtinSoundEffectsPath, file);
+                        }
+                      });
+                    }
+                    resolve({
+                      virtualBackgroundImages: virtualBackgroundImages,
+                      virtualBackgroundVideos: virtualBackgroundVideos,
+                      soundEffectAudios: soundEffectAudios
+                    });
+                  case 2:
+                  case "end":
+                    return _context8.stop();
+                }
+              }, _callee8);
+            }));
+            return function (_x13) {
+              return _ref1.apply(this, arguments);
+            };
+          }()));
+        case 1:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  }));
+  return function loadBuiltinResources() {
+    return _ref0.apply(this, arguments);
+  };
+}();
+export var getMediaSourceIdList = function getMediaSourceIdList() {
+  return BrowserWindow.getAllWindows().map(function (window) {
+    return {
+      title: window.title,
+      mediaSourceId: window.getMediaSourceId()
+    };
+  });
+};
+export var restartApp = function restartApp() {
+  _app.relaunch();
+  _app.exit(AppExitCode.NORMAL_EXIT);
+};
+export var getUserSettingData = function getUserSettingData() {
+  try {
+    var userSettingDataStr = _fs.readFileSync(path.resolve(userDataPath, USER_SETTING_DATA_FILE_NAME), {
+      encoding: 'utf-8'
+    });
+    return JSON.parse(userSettingDataStr);
+  } catch (e) {
+    return {};
+  }
+};
+export var setUserSettingData = function setUserSettingData(data) {
+  _fs.writeFileSync(path.resolve(userDataPath, USER_SETTING_DATA_FILE_NAME), JSON.stringify(data));
+};
+export var initialize = function initialize() {
+  ipcRenderer.send('initialize');
+};
+export var getCursorScreenPoint = function getCursorScreenPoint() {
+  return screen.getCursorScreenPoint();
+};
+export var getDisplayMatching = function getDisplayMatching(bounds) {
+  return screen.getDisplayMatching(bounds);
+};
+export var getAllDisplays = function getAllDisplays() {
+  return screen.getAllDisplays();
+};
+export var getPrimaryDisplay = function getPrimaryDisplay() {
+  return screen.getPrimaryDisplay();
+};
+export var getDisplayNearestPoint = function getDisplayNearestPoint(point) {
+  return screen.getDisplayNearestPoint(point);
+};
+export var getCurrentBrowserWindow = function getCurrentBrowserWindow() {
+  return getCurrentWindow();
+};
+export var getBrowserWindowById = function getBrowserWindowById(windowId) {
+  var browserWindow = BrowserWindow.getAllWindows().find(function (win) {
+    return "".concat(win.id) === windowId;
+  });
+  return browserWindow !== null && browserWindow !== void 0 ? browserWindow : null;
+};
+window.addEventListener('DOMContentLoaded', function () {
+  initialize();
+});