feat: Enhance event handling with new READY_TO_PATCH event and related hooks

Author: TheKing-OfTime

forge.config.js

@@ -1,5 +1,5 @@
-const {FusesPlugin} = require('@electron-forge/plugin-fuses');
-const {FuseV1Options, FuseVersion} = require('@electron/fuses');
+const { FusesPlugin } = require('@electron-forge/plugin-fuses');
+const { FuseV1Options, FuseVersion } = require('@electron/fuses');
 
 module.exports = {
     packagerConfig: {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "yandexmusicmodpatcher",
   "productName": "YandexMusicModPatcher",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Patcher for YandexMusicModClient",
   "main": ".webpack/main",
   "scripts": {

src/app/components/App.jsx

@@ -7,7 +7,7 @@ import LogCard from './layout/LogCard.jsx';
 import SettingsPage from "./pages/Settings.jsx";
 import ModalsContainer from "./layout/modals/ModalsContainer.jsx";
 import { StateProvider } from "./StateContext.jsx";
-import { useSendReady } from "./Events.jsx";
+import { useOnIsInstallPossibleResponse, useSendReady, useSendReadyToPatch } from "./Events.jsx";
 
 
 function App() {
@@ -17,6 +17,13 @@ function App() {
 
     useEffect(() => {
         useSendReady({});
+        const OffIsInstallPossibleResponse = useOnIsInstallPossibleResponse(() =>{
+            useSendReadyToPatch();
+        })
+
+        return () => {
+            OffIsInstallPossibleResponse();
+        }
     }, []);
 
     return (

src/app/components/Events.jsx

@@ -51,6 +51,10 @@ export function useSendDeleteLegacyYmApp() {
     return window.desktopEvents.send(Events.DELETE_LEGACY_YM_APP);
 }
 
+export function useSendReadyToPatch() {
+    return window.desktopEvents.send(Events.READY_TO_PATCH);
+}
+
 export function useOnPatchProgress(callback) {
     return window.desktopEvents.on(Events.PATCH_PROGRESS, (event, args) => {
         callback(event, args)

src/main/events.js

@@ -159,6 +159,9 @@ export const handleApplicationEvents = (window) => {
     electron.ipcMain.on(Events.READY, (event, args) => {
         console.log('Received READY', args);
         sendStateInitiated(undefined, State.state);
+    })
+    electron.ipcMain.on(Events.READY_TO_PATCH, (event, args) => {
+        console.log('Received READY_TO_PATCH', args);
         State.get('onReadyEventsQueue').forEach((event) => {
             event();
         })

src/main/modules/deeplinkCommands/index.js

@@ -1,24 +1,26 @@
 import { promises as fsp } from 'fs';
 import fs from 'fs';
+import patch from './patch';
 
 
 export default class deeplinkCommands {
 
     static async loadCommands() {
-        let commands = [];
+        let commands = [{ name: 'patch', run: patch }];
 
-        // Получаем список всех папок в src/main/deeplinkCommands/
-        const dirPath = __dirname;
-        const entries = await fsp.readdir(dirPath, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const indexPath = `${dirPath}/${entry.name}/index.js`;
-                if (fs.existsSync(indexPath)) {
-                    const command = await import(indexPath);
-                    commands.push(command.default || command.run || command);
-                }
-            }
-        }
+        // TODO Разобраться с вебпаком чтобы main не бандлился а копировался.
+        // // Получаем список всех папок в src/main/deeplinkCommands/
+        // const dirPath = __dirname;
+        // const entries = await fsp.readdir(dirPath, { withFileTypes: true });
+        // for (const entry of entries) {
+        //     if (entry.isDirectory()) {
+        //         const indexPath = `${dirPath}/${entry.name}/index.js`;
+        //         if (fs.existsSync(indexPath)) {
+        //             const command = await import(indexPath);
+        //             commands.push({ name: entry.name, run: command.default || command.run || command});
+        //         }
+        //     }
+        // }
 
         return commands;
     }

src/main/modules/deeplinkCommands/patch/index.js

@@ -6,11 +6,20 @@ import { getState } from '../../state.js';
 const State = getState();
 
 export default function run(...args) {
-    const patchType = PatchTypes[args?.[0]] ?? PatchTypes.DEFAULT;
-    State.onReadyEventsQueue.push(()=> {
-        ipcMain.emit(Events.PATCH, {
+    const params = args?.[0];
+    const window = args?.[1];
+    const patchType = Object.values(PatchTypes).includes(params?.[0]) ? params?.[0] : PatchTypes.DEFAULT;
+    if (!window) {
+        State.state.onReadyEventsQueue.push(() => {
+            ipcMain.emit(Events.PATCH, undefined, {
+                patchType: patchType,
+                fromAsarSrc: args?.[0]?.[1] ? decodeURI(args?.[0]?.[1]) : undefined
+            })
+        });
+    } else {
+        ipcMain.emit(Events.PATCH, undefined, {
             patchType: patchType,
-            fromAsarSrc: args?.[1] ? decodeURI(args?.[1]) : undefined
+            fromAsarSrc: args?.[0]?.[1] ? decodeURI(args?.[0]?.[1]) : undefined
         })
-    });
+    }
 }

src/main/modules/handleDeeplinks.js

@@ -3,8 +3,9 @@ import electron from 'electron';
 import config from '../config.js';
 
 
+
 const transformUrl = (url) => {
-    return url.replace(`${config.deeplinkProtocol}://`, "/").split('/');
+    return url.replace(`${config.deeplinkProtocol}://`, "").split('/');
 };
 
 const deeplinkCommandsHandler = await new deeplinkCommands();
@@ -13,7 +14,7 @@ export const checkIsDeeplink = (value) => {
     const deeplinkRegexp = new RegExp(`${config.deeplinkProtocol}:\/\/.*`);
     return deeplinkRegexp.test(value);
 };
-export const navigateToDeeplink = (url, window) => {
+export const navigateToDeeplink = (url, window=undefined) => {
     if (!url) {
         return;
     }
@@ -22,7 +23,7 @@ export const navigateToDeeplink = (url, window) => {
 
     if (args) {
         const commandName = args.shift();
-        deeplinkCommandsHandler.runCommand(commandName, args);
+        deeplinkCommandsHandler.runCommand(commandName, args, window);
     }
 
 };

src/main/modules/singleInstance.js

@@ -1,5 +1,5 @@
 import electron from "electron";
-import { handleDeeplink } from "./handleDeeplinks.js";
+import { checkIsDeeplink, navigateToDeeplink } from "./handleDeeplinks.js";
 const isFirstInstance = electron.app.requestSingleInstanceLock();
 export const checkForSingleInstance = () => {
     if (isFirstInstance) {
@@ -11,9 +11,9 @@ export const checkForSingleInstance = () => {
                 }
                 window.focus();
                 const lastCommandLineArg = commandLine.pop();
-                if (lastCommandLineArg && handleDeeplink.checkIsDeeplink(lastCommandLineArg)
+                if (lastCommandLineArg && checkIsDeeplink(lastCommandLineArg)
                 ) {
-                    handleDeeplink.navigateToDeeplink(window, lastCommandLineArg);
+                    navigateToDeeplink(lastCommandLineArg, window);
                 }
             }
         });

src/main/types/Events.js

@@ -21,6 +21,7 @@ const Events = {
     STATE_UPDATED: 'STATE_UPDATED',
     STATE_INITIATED: 'STATE_INITIATED',
     LOG_ENTRY_CREATE: 'LOG_ENTRY_CREATE',
+    READY_TO_PATCH: 'READY_TO_PATCH',
 };
 
 export default Events