Home Reference Source

cables_dev/cables_electron/src_client/cables_electron.js

  1. import { Logger } from "cables-shared-client";
  2. import ElectronEditor from "./electron_editor.js";
  3. import electronCommands from "./cmd_electron.js";
  5. /**
  6.  * frontend class for cablesElectron
  7.  * initializes the ui, starts the editor and adds functions custom to this platform
  8.  */
  9. export default class CablesElectron
  10. {
  11.     constructor()
  12.     {
  13.         this._logger = new Logger("electron");
  14.         this._electron = window.nodeRequire("electron");
  15.         this._importSync = window.nodeRequire("import-sync");
  17.         window.ipcRenderer = this._electron.ipcRenderer; // needed to have ipcRenderer in electron_editor.js
  18.         this._settings = this._electron.ipcRenderer.sendSync("platformSettings") || {};
  19.         this._usersettings = this._settings.userSettings;
  20.         delete this._settings.userSettings;
  21.         this._config = this._electron.ipcRenderer.sendSync("cablesConfig") || {};
  22.         this.editorIframe = null;
  24.         this._startUpLogItems = this._electron.ipcRenderer.sendSync("getStartupLog") || [];
  26.         if (!this._config.isPackaged) window.ELECTRON_DISABLE_SECURITY_WARNINGS = true;
  28.         this._loadedModules = {};
  29.     }
  31.     /**
  32.      * the `gui` object of the current editor, if initialized
  33.      *
  34.      * @type {Gui|null}
  35.      */
  36.     get gui()
  37.     {
  38.         return this.editorWindow ? this.editorWindow.gui : null;
  39.     }
  41.     /**
  42.      * the current editor window, if initialized
  43.      *
  44.      * @type {{}|null}
  45.      */
  46.     get editorWindow()
  47.     {
  48.         return this.editorIframe.contentWindow;
  49.     }
  51.     /**
  52.      * the CABLES core instance of the current editor window, if initialized
  53.      *
  54.      * @type {{}|null}
  55.      */
  56.     get CABLES()
  57.     {
  58.         return this.editorWindow ? this.editorWindow.CABLES : null;
  59.     }
  61.     /**
  62.      *
  63.      * @type {Logger}
  64.      */
  65.     get _log()
  66.     {
  67.         CABLES.UI = this.CABLES.UI;
  68.         return this._logger;
  69.     }
  71.     /**
  72.      * initialize the editor, wait for core and ui to be ready, add
  73.      * custom functionality
  74.      */
  75.     init()
  76.     {
  77.         this.editorIframe = document.getElementById("editorIframe");
  78.         let src = this._config.uiIndexHtml + window.location.search;
  79.         if (window.location.hash)
  80.         {
  81.             src += window.location.hash;
  82.         }
  83.         this.editorIframe.src = src;
  84.         this.editorIframe.onload = () =>
  85.         {
  86.             if (this.editorWindow)
  87.             {
  88.                 const waitForUi = this.editorWindow.waitForAce;
  89.                 this.editorWindow.waitForAce = () =>
  90.                 {
  91.                     this._logStartup("loading", this._settings.patchFile);
  93.                     this._incrementStartup();
  94.                     this._logStartup("checking/installing op dependencies...");
  95.                     this._electron.ipcRenderer.invoke("talkerMessage", "installProjectDependencies").then((npmResult) =>
  96.                     {
  97.                         this.editorWindow.CABLESUILOADER.cfg.patchConfig.onError = (...args) =>
  98.                         {
  99.                             // npm runtime error...
  100.                             if (args && args[0] === "core_patch" && args[2] && args[2].message && args[2].message.includes("was compiled against a different Node.js version"))
  101.                             {
  102.                                 const dirParts = args[2].message.split("/");
  103.                                 const opNameIndex = dirParts.findIndex((part) => { return part.startsWith("Ops."); });
  104.                                 const opName = dirParts[opNameIndex];
  105.                                 const packageName = dirParts[opNameIndex + 2];
  106.                                 const onClick = "CABLES.CMD.ELECTRON.openOpDir('', '" + opName + "');";
  108.                                 const msg = "try running this <a onclick=\"" + onClick + "\" > in the op dir</a>:";
  109.                                 this._log.error(msg);
  110.                                 this._log.error("`npm --prefix ./ install " + packageName + "`");
  111.                                 this._log.error("`npx \"@electron/rebuild\" -v " + process.versions.electron);
  112.                             }
  113.                         };
  114.                         waitForUi();
  115.                         if (this.gui)
  116.                         {
  117.                             this.gui.on("uiloaded", () =>
  118.                             {
  119.                                 if (this.editor && this.editor.config && !this.editor.config.patchFile) this.gui.setStateUnsaved();
  120.                             });
  122.                             const corePatch = this.gui.corePatch();
  123.                             corePatch.on("onOpAdd", (op) =>
  124.                             {
  125.                                 this._electron.ipcRenderer.invoke("documentChanged");
  126.                             });
  128.                         }
  130.                         if (npmResult.error && npmResult.data && npmResult.msg !== "UNSAVED_PROJECT")
  131.                         {
  132.                             npmResult.data.forEach((msg) =>
  133.                             {
  134.                                 const opName = msg.opName ? " for " + msg.opName : "";
  135.                                 this._log.error("failed dependency" + opName + ": " + msg.stderr);
  136.                             });
  137.                         }
  138.                         else if (npmResult.msg !== "EMPTY" && npmResult.msg !== "UNSAVED_PROJECT")
  139.                         {
  140.                             npmResult.data.forEach((result) =>
  141.                             {
  142.                                 const npmText = result.stderr || result.stdout;
  143.                                 this._logStartup(result.opName + ": " + npmText);
  144.                             });
  145.                         }
  147.                         if (this.gui)
  148.                         {
  149.                             this.gui.on("uiloaded", () =>
  150.                             {
  151.                                 if (this._settings.maximizeRenderer) this.gui.toggleMaximizeCanvas();
  152.                             });
  153.                         }
  154.                     });
  155.                 };
  156.                 if (this._settings.uiLoadStart) this.editorWindow.CABLESUILOADER.uiLoadStart -= this._settings.uiLoadStart;
  157.                 this._startUpLogItems.forEach((logEntry) =>
  158.                 {
  159.                     this._logStartup(logEntry.title);
  160.                 });
  161.                 if (this.editorWindow.loadjs)
  162.                 {
  163.                     this.editorWindow.loadjs.ready("cablesuinew", this._uiReady.bind(this));
  164.                 }
  165.             }
  166.         };
  168.         window.addEventListener("message", (event) =>
  169.         {
  170.             if (event.data && event.data.type === "hashchange")
  171.             {
  172.                 window.location.hash = event.data.data;
  173.             }
  174.         }, false);
  176.         window.addEventListener("hashchange", () =>
  177.         {
  178.             if (this.editorWindow)
  179.             {
  180.                 this.editorWindow.postMessage({ "type": "hashchange", "data": window.location.hash }, "*");
  181.             }
  182.         }, false);
  184.         this.editor = new ElectronEditor({
  185.             "config": {
  186.                 ...this._settings,
  187.                 "isTrustedPatch": true,
  188.                 "platformClass": "PlatformElectron",
  189.                 "urlCables": "cables://",
  190.                 "urlSandbox": "cables://",
  191.                 "communityUrl": this._config.communityUrl,
  192.                 "user": this._settings.currentUser,
  193.                 "usersettings": { "settings": this._usersettings },
  194.                 "isDevEnv": !this._config.isPackaged,
  195.                 "env": this._config.env,
  196.                 "patchId": this._settings.patchId,
  197.                 "patchVersion": "",
  198.                 "socketcluster": {},
  199.                 "remoteClient": false,
  200.                 "buildInfo": this._settings.buildInfo,
  201.                 "patchConfig": {
  202.                     "allowEdit": true,
  203.                     "prefixAssetPath": this._settings.currentPatchDir,
  204.                     "assetPath": this._settings.paths.assetPath,
  205.                     "paths": this._settings.paths
  206.                 },
  207.             }
  208.         });
  209.     }
  211.     openOpDirsTab()
  212.     {
  213.         if (this.CABLES) this.CABLES.platform.openOpDirsTab();
  214.     }
  216.     _uiReady()
  217.     {
  218.         if (this.CABLES)
  219.         {
  220.             if (this.CABLES.Op)
  221.             {
  222.                 const cablesElectron = this;
  223.                 this.CABLES.Op.prototype.require = function (moduleName)
  224.                 {
  225.                     return cablesElectron._opRequire(moduleName, this, cablesElectron);
  226.                 };
  227.             }
  229.             this.CABLES.UI.DEFAULTOPNAMES.defaultOpFallback = this.CABLES.UI.DEFAULTOPNAMES.HttpRequest;
  230.             this.CABLES.CMD.ELECTRON = electronCommands.functions;
  231.             this.CABLES.CMD.commands = this.CABLES.CMD.commands.concat(electronCommands.commands);
  232.             Object.assign(this.CABLES.CMD.UI, electronCommands.functionOverrides.UI);
  233.             Object.assign(this.CABLES.CMD.PATCH, electronCommands.functionOverrides.PATCH);
  234.             Object.assign(this.CABLES.CMD.RENDERER, electronCommands.functionOverrides.RENDERER);
  235.             const commandOverrides = electronCommands.commandOverrides;
  236.             this.CABLES.CMD.commands.forEach((command) =>
  237.             {
  238.                 const commandOverride = commandOverrides.find((override) => { return override.cmd === command.cmd; });
  239.                 if (commandOverride)
  240.                 {
  241.                     Object.assign(command, commandOverride);
  242.                 }
  243.             });
  244.         }
  245.     }
  247.     _opRequire(moduleName, op, thisClass)
  248.     {
  249.         if (op) op.setUiError("oprequire", null);
  250.         if (moduleName === "electron") return thisClass._electron;
  251.         if (this._loadedModules[moduleName]) return this._loadedModules[moduleName];
  253.         let modulePath = null;
  254.         let moduleFile = null;
  256.         try
  257.         {
  258.             // load module by directory name
  259.             modulePath = window.ipcRenderer.sendSync("getOpModuleDir", { "opName": op.objName, "opId": op.opId, "moduleName": moduleName });
  260.             this._loadedModules[moduleName] = window.nodeRequire(modulePath);
  261.             return this._loadedModules[moduleName];
  262.         }
  263.         catch (ePath)
  264.         {
  265.             try
  266.             {
  267.                 // load module by resolved filename from package.json
  268.                 moduleFile = window.ipcRenderer.sendSync("getOpModuleLocation", { "opName": op.objName, "opId": op.opId, "moduleName": moduleName });
  269.                 this._loadedModules[moduleName] = window.nodeRequire(moduleFile);
  270.                 return this._loadedModules[moduleName];
  271.             }
  272.             catch (eFile)
  273.             {
  274.                 try
  275.                 {
  276.                     // load module by module name
  277.                     this._loadedModules[moduleName] = window.nodeRequire(moduleName);
  278.                     return this._loadedModules[moduleName];
  279.                 }
  280.                 catch (eName)
  281.                 {
  282.                     try
  283.                     {
  284.                         moduleFile = window.ipcRenderer.sendSync("getOpModuleLocation", { "opName": op.objName || op.name, "opId": op.opId, "moduleName": moduleName, });
  285.                         this._loadedModules[moduleName] = this._importSync(moduleFile);
  286.                         return this._loadedModules[moduleName];
  287.                     }
  288.                     catch (eImport)
  289.                     {
  290.                         let errorMessage = "failed to load node module: " + moduleName + "\n\n";
  291.                         if (op) op.setUiError("oprequire", errorMessage);
  292.                         this._log.error(errorMessage, modulePath, moduleFile);
  293.                         return { };
  294.                     }
  295.                 }
  296.             }
  297.         }
  298.     }
  300.     _logStartup(title)
  301.     {
  302.         if (this.editorWindow && this.editorWindow.logStartup) this.editorWindow.logStartup(title);
  303.     }
  305.     _incrementStartup()
  306.     {
  307.         if (this.editorWindow && this.editorWindow.logStartup) this.editorWindow.incrementStartup();
  308.     }
  309. }