@fto-consult/expo-ui 7.5.34 → 7.5.36

package/bin/index.js

@@ -53,13 +53,13 @@ program.command('electron')
   .option('-b, --build [boolean]', 'si ce flag est spécfifié alors l\'application sera compilée; combinée avec la commande start|package pour indiquer que l\'application sera à nouveau exportée ou pas.')
   .option('-a, --arch [architecture]', 'l\'architecture de la plateforme; Commande package')
   .option('-p, --platform [platform]', 'la plateforme à utiliser pour la compilation; commande package')
-  .option('-l, --logo [logoPath]', 'le chemin vers le logo de l\'application : (.ico pour window, .incs pour mac et .png pour linux)')
+  .option('-l, --icon [iconPath]', 'le chemin vers l\'icon de l\'application : (.ico pour window, .incs pour mac et .png pour linux)')
   .option('-i, --import [boolean]', 'la commande d\'initialisation du package electron forge, utile pour le packaging de l\'application. Elle permet d\'exécuter le cli electron package, pour l\'import d\'un projet existant. Commande package. exemple : expo-ui electron package --import')
   
   .action((script, options) => {
     const electronProjectRoot = path.resolve(projectRoot,"electron");
     const opts = Object.assign({},typeof options.opts =='function'? options.opts() : options);
-    let {out,arch,url,build,platform,import:packageImport,logo} = opts;
+    let {out,arch,url,build,platform,import:packageImport,icon} = opts;
     //let {projectRoot} = opts;
     if(projectRoot == dir){
         throwError(`Invalid project root ${projectRoot}; project root must be different to ${dir}`);
@@ -78,8 +78,8 @@ program.command('electron')
     const packageObj = require(`${packagePath}`);
     const homepage = packageObj.homepage;
     let cmd = undefined;
-    logo = logo && typeof logo =="string" && fs.existsSync(path.resolve(logo)) && logo || undefined;
-    require("../electron/create-index-file")({electronProjectRoot,appName:packageObj.name,logo});
+    icon = icon && typeof icon =="string" && fs.existsSync(path.resolve(icon)) && icon || undefined;
+    require("../electron/create-index-file")({electronProjectRoot,appName:packageObj.name,icon});
     if(!isElectionInitialized || script =='init'){
         if(script !=='init'){
             console.log("initializing electron application before ....");
@@ -96,7 +96,7 @@ program.command('electron')
     }
     const start = x=>{
        return new Promise((resolve,reject)=>{
-        cmd = `electron "${electronProjectRoot}" --root ${electronProjectRoot} ${isValidUrl(url)? ` --url ${url}`:''}`;
+        cmd = `electron "${electronProjectRoot}" --root ${electronProjectRoot} ${isValidUrl(url)? ` --url ${url}`:''} ${icon ? `--icon ${path.resolve(icon)}`:""}`;
           exec({
             cmd, 
             projectRoot : electronProjectRoot,

package/bin/init.js

@@ -22,7 +22,7 @@ module.exports = ({projectRoot,electronProjectRoot})=>{
         const projectRootPackage = {...mPackageJSON,...electronPackageJSON};
         const dependencies = require("../electron/dependencies");
         const electronProjectRootPackage = path.resolve(electronProjectRoot,"package.json");
-        projectRootPackage.main = `node_modules/${mainPackageName}/electron/index.js`;
+        projectRootPackage.main = `index.js`;
         projectRootPackage.dependencies = {...dependencies.main,...Object.assign(electronPackageJSON.dependencies)};
         projectRootPackage.dependencies[mainPackage.name] = mainPackage.version;
         projectRootPackage.devDependencies = {...dependencies.dev,...Object.assign({},electronPackageJSON.devDependencies)};

package/electron/create-index-file.js

@@ -10,12 +10,11 @@ module.exports = ({electronProjectRoot,force,logo,appName})=>{
     const indexPath = path.resolve(electronProjectRoot,"index.js");
     if(!fs.existsSync(indexPath) || force === true){
         writeFile(indexPath,`
-require("${packageJSON.name}/electron/index.js")({
+require("${packageJSON.name}/electron")({
     projectRoot : __dirname,
     appName : "${appName}",
     logo : ${logo ? `"${logo}"` : undefined},
-})        
-`);
-    }
+});`);
+}
     return indexPath;
 }

package/electron/index.js

@@ -1,57 +1,546 @@
 const { program } = require('commander');
-const mainApp = require("./main-app");
+const path = require("path");
+const fs = require("fs");
+const isValidUrl = require("./utils/isValidUrl");
+
+const debounce = require("./utils/debounce");
+const {app, BrowserWindow,Tray,Menu,MenuItem,globalShortcut,systemPreferences,powerMonitor,ipcMain,dialog, nativeTheme} = require('electron')
+const session = require("./utils/session");
+const {isJSON} = require("./utils/json");
+
+const isObj = x => x && typeof x =='object';
 
 program
   .option('-u, --url <url>', 'L\'adresse url à ouvrir au lancement de l\'application')
   .option('-r, --root <projectRoot>', 'le chemin du project root de l\'application')
+  .option('-l, --icon [iconPath]', 'le chemin vers le icon de l\'application : (.ico pour window, .incs pour mac et .png pour linux)')
   .parse();
 
 const programOptions = program.opts();
-const {url,root:mainProjectRoot} = programOptions;
+const {url:pUrl,root:mainProjectRoot,icon} = programOptions;
+const iconPath = icon && typeof icon =="string" && fs.existsSync(path.resolve(icon)) && path.resolve(icon) || undefined; 
 
 const isAsar = (typeof require.main =="string" && require.main ||"").indexOf('app.asar') !== -1;
-const path = require("path");
-const fs = require("fs");
-const isValidUrl = require("./utils/isValidUrl");
 const distPath = path.join("dist",'index.html');
 
 const processCWD = process.cwd();
 const electronProjectRoot = mainProjectRoot && typeof mainProjectRoot =='string' && fs.existsSync(path.resolve(mainProjectRoot)) && fs.existsSync(path.resolve(mainProjectRoot,distPath)) && path.resolve(mainProjectRoot)  || null;
-const projectRoot =  electronProjectRoot || fs.existsSync(path.resolve(processCWD,"electron")) && fs.existsSync(path.resolve(processCWD,"electron",distPath)) && path.resolve(processCWD,"electron") || undefined;
+const projectRoot =  electronProjectRoot || fs.existsSync(path.resolve(processCWD,"electron")) && fs.existsSync(path.resolve(processCWD,"electron",distPath)) && path.resolve(processCWD,"electron") 
+|| fs.existsSync(path.resolve(processCWD,distPath)) && path.resolve(processCWD) || undefined;
 const packageJSONPath = fs.existsSync(processCWD,"package.json")? path.resolve(processCWD,"package.json") : path.resolve(projectRoot,"package.json");
-const packageJSON = fs.existsSync(packageJSONPath) ? require(`${packageJSONPath}`) : {};
+const packageJSON = fs.existsSync(packageJSONPath) ? Object.assign({},require(`${packageJSONPath}`)) : {};
+const appName = typeof packageJSON.realAppName =='string' && packageJSON.realAppName || typeof packageJSON.name =="string" && packageJSON.name || "";  
+
+// fermee automatiquement quand l'objet JavaScript sera garbage collected.
+let mainWindow = undefined;
+
+Menu.setApplicationMenu(null);
+
+const indexFilePath = path.resolve(path.join(projectRoot,distPath));
+const mainProcessPath = path.resolve('processes',"main","index.js");
+const mainProcessIndex = projectRoot && fs.existsSync(path.resolve(projectRoot,mainProcessPath)) && path.resolve(projectRoot,mainProcessPath);
+const mainProcessRequired = mainProcessIndex && require(`${mainProcessIndex}`);
+//pour étendre les fonctionnalités au niveau du main proceess, bien vouloir écrire dans le fichier projectRoot/electron/main/index.js
+const mainProcess = mainProcessRequired && typeof mainProcessRequired =='object'? mainProcessRequired : {};
 
-const ObjectSize = (object)=>{
-    if(!object || typeof object !=='object' || Array.isArray(object)) return false;
-    for(let i in object){
-        if(object?.hasOwnProperty(i)) return true;
+
+const quit = ()=>{
+    try {
+      app.quit();
+    } catch(e){
+      console.log(e," triing kit app")
     }
-    return false;
 }
 
-function mainExportedApp (options){
+// Gardez une reference globale de l'objet window, si vous ne le faites pas, la fenetre sera
+if(!isValidUrl(pUrl) && !fs.existsSync(indexFilePath)){
+    throw {message:`Unable to start the application: index file located at [${indexFilePath}] does not exists : projectRoot = [${projectRoot}], isAsar:[${require.main}]`}
+}
+
+//app.disableHardwareAcceleration();
+
+function createBrowserWindow (options){
+    const {isMainWindow} = options;
     options = Object.assign({},options);
-    options.isAsar = isAsar;
-    options.url = isValidUrl(options.url)? options.url : isValidUrl(url)? url : undefined;
-    if(!options.projectRoot || typeof options.projectRoot !=='string' || !fs.existsSync(options.projectRoot) || !fs.existsSync(path.resolve(options.projectRoot,distPath))){
-        options.projectRoot = projectRoot;
-    }
-    options.packageJSON = ObjectSize(options.packageJSON) && options.packageJSON || packageJSON;
-    if(!ObjectSize(options.packageJSON)){
-        if(options.projectRoot && typeof options.projectRoot =='string' && fs.existsSync(path.resolve(options.projectRoot,"package.json"))){
-            options.packageJSON = require(path.resolve(options.projectRoot,"package.json"));
-        }
+    const menu = options.menu;
+    options.webPreferences = isObj(options.webPreferences)? options.webPreferences : {};
+    options.webPreferences = {
+      sandbox: false,
+      webSecurity : true,
+      plugin:false,
+      autoHideMenuBar: true,
+      contextIsolation: true,
+      contentSecurityPolicy: `
+        default-src 'none';
+        script-src 'self';
+        img-src 'self' data:;
+        style-src 'self';
+        font-src 'self';
+      `,
+      ...options.webPreferences,
+      devTools: typeof options.webPreferences.devTools === 'boolean'? options.webPreferences.devTools : false,
+      allowRunningInsecureContent: false,
+      nodeIntegration: false,
+      preload: options.preload ? options.preload : null,
+    }
+    if(options.modal && !options.parent && mainWindow){
+      options.parent = mainWindow;
+    }
+    if(typeof options.show ==='undefined'){
+      options.show = false;
+    }
+    let showOnLoad = options.showOnLoad ===true ? true : undefined;
+    if(showOnLoad){
+       options.show = false;
+    }
+    if(typeof mainProcess?.beforeCreateWindow =='function'){
+       const opts = Object.assign({},mainProcess.beforeCreateWindow(options));
+       options = {...options,...opts};
     }
-    options.appName = typeof options.appName =="string" && options.appName || 
-    typeof options.packageJSON?.realAppName =='string' && options?.packageJSON?.realAppName || typeof packageJSON?.realAppName =="string" && packageJSON?.realAppName ||  
-    typeof option?.packageJSON?.name =="string" && options?.packageJSON?.name || typeof packageJSON.name =="string" && packageJSON.name || undefined;
-    return mainApp(options);
+    options.icon = options.icon || iconPath;
+    const window = new BrowserWindow(options);
+    if(!menu){
+        window.setMenu(null);
+        window.removeMenu();
+        window.setMenuBarVisibility(false)
+        window.setAutoHideMenuBar(true)
+    }
+    if(showOnLoad){
+      window.once('ready-to-show', () => {
+          window.show();
+          window.webContents.send("window-ready-to-show",JSON.stringify(options.readyToShowOptions));
+      });
+    }
+    window.on('closed', function() {
+        if(isMainWindow && typeof mainProcess?.onMainWindowClosed == "function"){
+          mainProcess.onMainWindowClosed(window);
+        }
+        window = null;
+    });
+    window.webContents.on('context-menu',clipboadContextMenu);
+    const url = isValidUrl(options.loadURL) || typeof options.loadURL ==='string' && options.loadURL.trim().startsWith("file://") ? options.loadURL : undefined;
+    if(url){
+      window.loadURL(url);
+    } else if(options.file && fs.existsSync(path.resolve(options.file))){
+      window.loadFile(path.resolve(options.file));
+    } 
+    return window;
 }
+  
+app.whenReady().then(() => {
+    createWindow();
+    const readOpts = {toggleDevTools,browserWindow:mainWindow,mainWindow:mainWindow};
+    if(typeof mainProcess.whenAppReady =='function'){
+       mainProcess.whenAppReady(readOpts);
+    }
+    globalShortcut.register('CommandOrControl+F12', () => {
+      return toggleDevTools();
+    });
+    app.on('activate', function () {
+      if (mainWindow == null || (BrowserWindow.getAllWindows().length === 0)) createWindow()
+    });
+});
 
-module.exports = mainExportedApp;
-
-if(isValidUrl(url) || electronProjectRoot){
-    mainExportedApp({url:url,projectRoot,packageJSON});
+function createWindow () {
+    // Créer le browser window
+    mainWindow = createBrowserWindow({
+      showOnLoad : false,
+      loadURL : undefined,
+      isMainWindow : true,
+      registerDevToolsCommand : false,
+      file : indexFilePath,
+      url : pUrl,
+      preload : path.resolve(__dirname,'preload.js'),
+      webPreferences : {
+        devTools : true,
+      }
+    });
+   const sOptions = {width: 500, height: 400, transparent: true, frame: false, alwaysOnTop: true};
+    const splash = typeof mainProcess.splashScreen ==='function'&& mainProcess.splashScreen(sOptions) 
+      || typeof mainProcess.splash ==='function' && mainProcess.splash(sOptions) 
+      || (mainProcess.splash instanceof BrowserWindow) && mainProcess.splash
+      || (mainProcess.splashScreen instanceof BrowserWindow) && mainProcess.splashScreen;
+      null;
+    let hasInitWindows = false;
+    mainWindow.on('show', () => {
+      //mainWindow.blur();
+      setTimeout(() => {
+        mainWindow.focus();
+        mainWindow.moveTop();
+        mainWindow.webContents.focus(); 
+        if(!hasInitWindows){
+          hasInitWindows = true; 
+          mainWindow.webContents.send('appReady');
+        } 
+      }, 200);
+    });
+  
+    mainWindow.on("focus",()=>{
+      if(mainWindow && hasInitWindows){
+        mainWindow.webContents.send("main-window-focus");
+      }
+    });
+    mainWindow.on("blur",()=>{
+      if(mainWindow && hasInitWindows){
+        mainWindow.webContents.send("main-window-blur");
+      }
+    });
+    mainWindow.once("ready-to-show",function(){
+        if(typeof mainProcess.onMainWindowReadyToShow ==='function'){
+            mainProcess.onMainWindowReadyToShow(mainWindow);
+        }
+        mainWindow.minimize()
+        try {
+          if(splash && splash instanceof BrowserWindow){
+            splash.destroy();
+          }
+        } catch{ }
+        mainWindow.restore();
+        mainWindow.show();
+    })    
+   
+    mainWindow.on('close', (e) => {
+        if (mainWindow) {
+          if(typeof mainProcess.onMainWindowClose == "function"){
+            mainProcess.onMainWindowClose(mainWindow);
+          }
+          e.preventDefault();
+          mainWindow.webContents.send('before-app-exit');
+        }
+    });
+    
+    mainWindow.on('unresponsive', async () => {
+      const { response } = await dialog.showMessageBox({
+        title: "L'application a cessé de répondre",
+        message : 'Voulez vous relancer l\'application?',
+        buttons: ['Relancer', 'Arrêter'],
+        cancelId: 1
+      });
+      if (response === 0) {
+        mainWindow.forcefullyCrashRenderer()
+        mainWindow.reload()
+      } else {
+        mainWindow.forcefullyCrashRenderer()
+        app.exit();
+      }
+    });
+    
+    // Émit lorsque la fenêtre est fermée.
+    mainWindow.on('closed', () => {
+      mainWindow = null
+    })
+    mainWindow.setMenu(null);
+  
+    /*** les dimenssions de la fenêtre principale */
+    let mWindowSessinName = "mainWindowSizes";
+    let mWindowPositionSName = mWindowSessinName+"-positions";
+    let sizeW = session.get(mWindowSessinName);
+    if(!sizeW || typeof sizeW !== 'object'){
+      sizeW = {};
+    }
+    let sPositions = session.get(mWindowPositionSName);
+    if(!sPositions || typeof sPositions !=='object'){
+      sPositions = {};
+    }
+    let isNumber = x => typeof x =="number";
+    if(isNumber(sizeW.width) && isNumber(sizeW.height)){
+        mainWindow.setSize(sizeW.width,sizeW.height);
+        if(isNumber(sPositions.x) && isNumber(sPositions.y)){
+            mainWindow.setPosition(sPositions.x,sPositions.y);
+        }
+    }
+    const onWinResizeEv =  debounce(function () {
+        if(mainWindow){
+            let wSize = mainWindow.getSize();
+            if(Array.isArray(wSize) && wSize.length == 2){
+                let [width,height] = wSize;
+                if(width && height){
+                    session.set(mWindowSessinName,{width,height});
+                }
+                let [x,y] = mainWindow.getPosition();
+                session.set(mWindowPositionSName,{x,y});
+            }
+        }
+    }, 100);
+    mainWindow.off('resize',onWinResizeEv);
+    mainWindow.on('resize',onWinResizeEv);
+    mainWindow.off('move',onWinResizeEv);
+    mainWindow.on('move',onWinResizeEv);
+    if(typeof mainProcess.onCreateMainWindow =='function'){
+       mainProcess.onCreateMainWindow(mainWindow);
+    }
+    return mainWindow;
 }
+  
+  const toggleDevTools = (value)=>{
+    if(mainWindow !==null && mainWindow.webContents){
+      const isOpen= mainWindow.webContents.isDevToolsOpened();
+      value = value === undefined ? !isOpen : value;
+      if(value && !isOpen){
+          mainWindow.webContents.openDevTools();
+          return mainWindow.webContents.isDevToolsOpened();
+      } else {
+          if(isOpen) mainWindow.webContents.closeDevTools();
+      }
+      return mainWindow.webContents.isDevToolsOpened();
+    }
+    return false;
+  }
+  ipcMain.on("toggle-dev-tools",function(event,value) {
+    return toggleDevTools(value);
+  });
+  
+  ipcMain.handle("create-browser-windows",function(event,options){
+    if(typeof options =='string'){
+      try {
+        const t = JSON.parse(options);
+        options = t;
+      } catch{}
+    }
+    options = Object.assign({},options);
+    createBrowserWindow(options);
+  });
+  
+  ipcMain.on("restart-app",x =>{
+    app.relaunch();
+  });
+  let tray = null;
+  ipcMain.on("update-system-tray",(event,opts)=>{
+    opts = opts && typeof opts == 'object'? opts : {};
+    let {contextMenu,tooltip} = opts;
+    if(tray){
+    } else {
+      tray = new Tray();
+    }        
+    if(!tooltip || typeof tooltip !=="string"){
+        tooltip = ""
+    }
+    tray.setToolTip(tooltip);
+    if(isJSON(contextMenu)){
+        contextMenu = JSON.parse(contextMenu);
+    } 
+    if(Array.isArray(contextMenu) && contextMenu.length) {
+      let tpl = []
+      contextMenu.map((m,index)=>{
+         if(!m || typeof m !=='object') return;
+         m.click = (e)=>{
+           if(mainWindow && mainWindow.webContents) mainWindow.webContents.send("click-on-system-tray-menu-item",{
+              action : m.action && typeof m.action =='string'? m.action : undefined,
+              index,
+              menuItem : JSON.stringify(m),
+           })
+         }
+         tpl.push(m);
+      })
+      contextMenu = Menu.buildFromTemplate(tpl);
+    } else contextMenu = null;
+    tray.setContextMenu(contextMenu) 
+  });
+  
+  ipcMain.on("get-path",(event,pathName)=>{
+    const p = app.getPath(pathName);
+    event.returnValue = p;
+    return p;
+  });
+  ipcMain.on("get-project-root",(event)=>{
+    event.returnValue  = projectRoot;
+    return event.returnValue;
+  });
+  ipcMain.on("get-electron-project-root",(event)=>{
+    event.returnValue = projectRoot;
+    return event.returnValue ;
+  });
+  
+  ipcMain.on("get-package.json",(event)=>{
+    event.returnValue = JSON.stringify(packageJSON);
+    return event.returnValue ;
+  });
+    
+  ipcMain.on("get-app-name",(event)=>{
+    event.returnValue = appName;
+    return event.returnValue ;
+  });
+    
+  ipcMain.on("get-media-access-status",(event,mediaType)=>{
+    let p = systemPreferences.getMediaAccessStatus(mediaType);
+    event.returnValue = p;
+    return p;
+  });
+  
+  ipcMain.on("ask-for-media-access",(event,mediaType)=>{
+    systemPreferences.askForMediaAccess(mediaType);
+  });
+    
+  ipcMain.on("get-app-icon",(event)=>{
+    event.returnValue = mainWindow != mainWindow && mainWindow.getIcon && mainWindow.getIcon();
+  });
+  ipcMain.on("set-app-icon",(event,iconPath)=>{
+     if(iconPath && mainWindow != null){
+        mainWindow.setIcon(iconPath);
+        event.returnValue = iconPath;
+     } else {
+        event.returnValue = null;
+     }
+  });
+    
+  ipcMain.on('minimize-main-window', () => {
+    if(mainWindow !== null && mainWindow){
+       mainWindow.blur();
+       mainWindow.minimize();
+    }
+  })
+  ipcMain.on('restore-main-window', () => {
+    if(mainWindow && mainWindow !== null){
+      mainWindow.restore()
+      mainWindow.blur();
+      setTimeout(() => {
+        mainWindow.focus();
+        mainWindow.moveTop();
+        mainWindow.webContents.focus();   
+      }, 200);
+    }
+  })
+  ipcMain.on('close-main-render-process', _ => {
+    if(mainWindow){
+      mainWindow.destroy();
+    }
+    mainWindow = null;
+    if(typeof gc =="function"){
+      gc();
+    }
+    quit();
+  });
+  
+  const powerMonitorCallbackEvent = (action)=>{
+    if(!mainWindow || !mainWindow.webContents) return;
+    if(action =="suspend" || action =="lock-screen"){
+        mainWindow.webContents.send("main-app-suspended",action);
+        return;
+    }
+    mainWindow.webContents.send("main-app-restaured",action);
+    mainWindow.webContents.focus();  
+    return null;
+  }
+  if(powerMonitor){
+    ["suspend","resume","lock-screen","unlock-screen"].map((action)=>{
+        powerMonitor.on(action,(event)=>{
+            powerMonitorCallbackEvent(action,event);
+        })
+    })
+  }
+  ipcMain.on("set-main-window-title",(event,title)=>{
+    if(mainWindow !== null){
+        mainWindow.setTitle(title);
+    }
+  });
+  
+  ipcMain.handle("show-open-dialog",function(event,options){
+    if(typeof options =="string"){
+      try {
+         const t = JSON.parse(options);
+         options = t;
+      } catch{}
+    }
+    if(!isObj(options)){
+       options = {};
+    }
+    return dialog.showOpenDialog(mainWindow,options)
+  })
+  
+  ipcMain.handle("show-save-dialog",function(event,options){
+    if(!isObj(options)){
+       options = {};
+    }
+    return dialog.showSaveDialog(mainWindow,options)
+  });
+  
+  ipcMain.on("is-dev-tools-open",function(event,value) {
+    if(mainWindow !==null && mainWindow.webContents){
+      return mainWindow.webContents.isDevToolsOpened();
+    }
+    return false;
+  });
+  
+  ipcMain.on("window-set-progressbar",(event,interval)=>{
+     if(typeof interval !="number" || interval <0) interval = 0;
+     interval = Math.floor(interval);
+     if(mainWindow){
+       mainWindow.setProgressBar(interval);
+     }
+  });
+  
+  /**** customisation des thèmes de l'application */
+  ipcMain.handle('set-system-theme:toggle', (event,theme) => {
+    theme = theme && typeof theme == "string"? theme : "light";
+    theme = theme.toLowerCase().trim();
+    if(theme !== 'system' && theme !=='dark'){
+      theme = "light";
+    }
+    nativeTheme.themeSource = theme;
+    session.set("os-theme",theme);
+    return nativeTheme.shouldUseDarkColors
+  });
+  
+  ipcMain.handle('set-system-theme:dark-mode', (event) => {
+      nativeTheme.themeSource = 'dark';
+      return nativeTheme.shouldUseDarkColors;
+  });
+  ipcMain.handle('set-system-theme:light-mode', (event) => {
+    nativeTheme.themeSource = 'light';
+    return nativeTheme.shouldUseDarkColors;
+  });
+  
+  
+  ipcMain.handle('dark-mode:toggle', () => {
+    if (nativeTheme.shouldUseDarkColors) {
+      nativeTheme.themeSource = 'light'
+    } else {
+      nativeTheme.themeSource = 'dark'
+    }
+    return nativeTheme.shouldUseDarkColors
+  })
+  
+  ipcMain.handle('dark-mode:system', () => {
+    nativeTheme.themeSource = 'system'
+  });
+  
+  const clipboadContextMenu = (_, props) => {
+    if (props.isEditable || props.selectionText) {
+      const menu = new Menu();
+      if(props.selectionText){
+        menu.append(new MenuItem({ label: 'Copier', role: 'copy' }));
+        if(props.isEditable){
+           menu.append(new MenuItem({ label: 'Couper', role: 'cut' }));
+        }
+      }
+      if(props.isEditable){
+        menu.append(new MenuItem({ label: 'Coller', role: 'paste' }));
+      }
+      menu.popup();
+    } 
+  };
+  
+// Quitte l'application quand toutes les fenêtres sont fermées.
+app.on('window-all-closed', () => {
+    // Sur macOS, il est commun pour une application et leur barre de menu
+    // de rester active tant que l'utilisateur ne quitte pas explicitement avec Cmd + Q
+    if (process.platform !== 'darwin') {
+      quit();
+    }
+});
 
-module.exports.createBrowserWindow = mainApp.createBrowserWindow;
+if(mainProcess.enableSingleInstance !== false){
+    const gotTheLock = app.requestSingleInstanceLock()
+    if (!gotTheLock) {
+      quit()
+    } else {
+      app.on('second-instance', (event, commandLine, workingDirectory) => {
+        // Someone tried to run a second instance, we should focus our window.
+        //pour plus tard il sera possible d'afficher la gestion multi fenêtre en environnement electron
+        if (mainWindow) {
+            if (mainWindow.isMinimized()) mainWindow.restore()
+            mainWindow.focus()
+        }
+      })
+    }
+}

package/electron/init/main.js

@@ -8,6 +8,7 @@
 */
 
 module.exports = {
+    enableSingleInstance: true, // si l'application n'autorise qu'une seule instance active. ça sous entend qu'à l'instant t, une seule instance de l'application ne peut être exécutée sur le profil de l'utilisateur lambda
     /**** cette fonction est appelée à chaque fois que l'on désire créer une instance du BrowserWindow
         @param {object} BrowserWindowOptions
         Lors de la création de la fenêtre principal, BrowserWindowOptions continent la propriété isMainWindow à true