@fto-consult/expo-ui 7.5.34 → 7.5.35

package/bin/index.js

@@ -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}" ${isValidUrl(url)? ` --url ${url}`:''}`;
           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,13 +1,20 @@
 const { program } = require('commander');
 const mainApp = require("./main-app");
 
+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')
   .parse();
 
 const programOptions = program.opts();
-const {url,root:mainProjectRoot} = programOptions;
+const {url:pUrl,root:mainProjectRoot} = programOptions;
 
 const isAsar = (typeof require.main =="string" && require.main ||"").indexOf('app.asar') !== -1;
 const path = require("path");
@@ -17,41 +24,526 @@ 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 win = undefined;
+
+Menu.setApplicationMenu(null);
 
-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 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 : {};
+
+// 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}]`}
+}
+  
+const ipcMainHandleEvent  = (event,callback)=>{
+    ipcMain.removeHandler(event,callback);
+    return ipcMain.handle(event,callback);
+}
+const quit = ()=>{
+    try {
+      app.quit();
+    } catch(e){
+      console.log(e," triing kit app")
     }
-    return false;
 }
 
-function mainExportedApp (options){
+//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 && win){
+      options.parent = win;
+    }
+    if(typeof options.show ==='undefined'){
+      options.show = false;
+    }
+    let showOnLoad = options.showOnLoad ===true ? true : undefined;
+    if(showOnLoad){
+       options.show = false;
     }
-    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);
+    if(typeof mainProcess?.beforeCreateWindow =='function'){
+       const opts = Object.assign({},mainProcess.beforeCreateWindow(options));
+       options = {...options,...opts};
+    }
+    let _win = new BrowserWindow(options);
+    if(!menu){
+        _win.setMenu(null);
+        _win.removeMenu();
+        _win.setMenuBarVisibility(false)
+        _win.setAutoHideMenuBar(true)
+    }
+    const url = isValidUrl(options.loadURL) || typeof options.loadURL ==='string' && options.loadURL.trim().startsWith("file://") ? options.loadURL : undefined;
+    if(url){
+      _win.loadURL(url);
+    } else if(options.file && fs.existsSync(path.resolve(options.file))){
+      _win.loadFile(path.resolve(options.file));
+    } 
+    if(showOnLoad){
+      _win.once('ready-to-show', () => {
+          _win.show();
+          _win.webContents.send("window-ready-to-show",JSON.stringify(options.readyToShowOptions));
+      });
+    }
+    _win.on('closed', function() {
+        if(isMainWindow && typeof mainProcess?.onMainWindowClosed == "function"){
+          mainProcess.onMainWindowClosed(_win);
+        }
+        _win = null;
+    });
+    _win.webContents.on('context-menu',clipboadContextMenu);
+    return _win;
 }
 
-module.exports = mainExportedApp;
-
-if(isValidUrl(url) || electronProjectRoot){
-    mainExportedApp({url:url,projectRoot,packageJSON});
+function createWindow () {
+    // Créer le browser window
+    win = 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;
+    win.on('show', () => {
+      //win.blur();
+      setTimeout(() => {
+        win.focus();
+        win.moveTop();
+        win.webContents.focus(); 
+        if(!hasInitWindows){
+          hasInitWindows = true; 
+          win.webContents.send('appReady');
+        } 
+      }, 200);
+    });
+  
+    win.on("focus",()=>{
+      if(win && hasInitWindows){
+        win.webContents.send("main-window-focus");
+      }
+    });
+    win.on("blur",()=>{
+      if(win && hasInitWindows){
+        win.webContents.send("main-window-blur");
+      }
+    });
+    win.once("ready-to-show",function(){
+        if(typeof mainProcess.onMainWindowReadyToShow ==='function'){
+            mainProcess.onMainWindowReadyToShow(win);
+        }
+        win.minimize()
+        try {
+          if(splash && splash instanceof BrowserWindow){
+            splash.destroy();
+          }
+        } catch{ }
+        win.restore();
+        win.show();
+    })    
+   
+    win.on('close', (e) => {
+        if (win) {
+          if(typeof mainProcess.onMainWindowClose == "function"){
+            mainProcess.onMainWindowClose(win);
+          }
+          e.preventDefault();
+          win.webContents.send('before-app-exit');
+        }
+    });
+    
+    win.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) {
+        win.forcefullyCrashRenderer()
+        win.reload()
+      } else {
+        win.forcefullyCrashRenderer()
+        app.exit();
+      }
+    });
+    
+    // Émit lorsque la fenêtre est fermée.
+    win.on('closed', () => {
+      win = null
+    })
+    win.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)){
+        win.setSize(sizeW.width,sizeW.height);
+        if(isNumber(sPositions.x) && isNumber(sPositions.y)){
+            win.setPosition(sPositions.x,sPositions.y);
+        }
+    }
+    const onWinResizeEv =  debounce(function () {
+        if(win){
+            let wSize = win.getSize();
+            if(Array.isArray(wSize) && wSize.length == 2){
+                let [width,height] = wSize;
+                if(width && height){
+                    session.set(mWindowSessinName,{width,height});
+                }
+                let [x,y] = win.getPosition();
+                session.set(mWindowPositionSName,{x,y});
+            }
+        }
+    }, 100);
+    win.off('resize',onWinResizeEv);
+    win.on('resize',onWinResizeEv);
+    win.off('move',onWinResizeEv);
+    win.on('move',onWinResizeEv);
+    if(typeof mainProcess.onCreateMainWindow =='function'){
+       mainProcess.onCreateMainWindow(win);
+    }
+    return win;
+  }
+  
+  const toggleDevTools = (value)=>{
+    if(win !==null && win.webContents){
+      const isOpen= win.webContents.isDevToolsOpened();
+      value = value === undefined ? !isOpen : value;
+      if(value && !isOpen){
+          win.webContents.openDevTools();
+          return win.webContents.isDevToolsOpened();
+      } else {
+          if(isOpen) win.webContents.closeDevTools();
+      }
+      return win.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(win && win.webContents) win.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 = win != win && win.getIcon && win.getIcon();
+  });
+  ipcMain.on("set-app-icon",(event,iconPath)=>{
+     if(iconPath && win != null){
+        win.setIcon(iconPath);
+        event.returnValue = iconPath;
+     } else {
+        event.returnValue = null;
+     }
+  });
+    
+  ipcMain.on('minimize-main-window', () => {
+    if(win !== null && win){
+       win.blur();
+       win.minimize();
+    }
+  })
+  ipcMain.on('restore-main-window', () => {
+    if(win && win !== null){
+      win.restore()
+      win.blur();
+      setTimeout(() => {
+        win.focus();
+        win.moveTop();
+        win.webContents.focus();   
+      }, 200);
+    }
+  })
+  ipcMain.on('close-main-render-process', _ => {
+    if(win){
+      win.destroy();
+    }
+    win = null;
+    if(typeof gc =="function"){
+      gc();
+    }
+    quit();
+  });
+  
+  const powerMonitorCallbackEvent = (action)=>{
+    if(!win || !win.webContents) return;
+    if(action =="suspend" || action =="lock-screen"){
+        win.webContents.send("main-app-suspended",action);
+        return;
+    }
+    win.webContents.send("main-app-restaured",action);
+    win.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(win !== null){
+        win.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(win,options)
+  })
+  
+  ipcMain.handle("show-save-dialog",function(event,options){
+    if(!isObj(options)){
+       options = {};
+    }
+    return dialog.showSaveDialog(win,options)
+  });
+  
+  ipcMain.on("is-dev-tools-open",function(event,value) {
+    if(win !==null && win.webContents){
+      return win.webContents.isDevToolsOpened();
+    }
+    return false;
+  });
+  
+  ipcMain.on("window-set-progressbar",(event,interval)=>{
+     if(typeof interval !="number" || interval <0) interval = 0;
+     interval = Math.floor(interval);
+     if(win){
+       win.setProgressBar(interval);
+     }
+  })
+  
+  const setOSTheme = (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
+  }
+  
+  /**** customisation des thèmes de l'application */
+  ipcMain.handle('set-system-theme:toggle', (event,theme) => {
+    return setOSTheme(theme);
+  });
+  
+  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();
+    }
+});
+  
+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 (win) {
+        if (win.isMinimized()) win.restore()
+        win.focus()
+    }
+  })
 }
-
-module.exports.createBrowserWindow = mainApp.createBrowserWindow;
+  
+app.whenReady().then(() => {
+    createWindow();
+    const readOpts = {toggleDevTools,browserWindow:win,mainWindow:win};
+    if(typeof mainProcess.whenAppReady =='function'){
+       mainProcess.whenAppReady(readOpts);
+    }
+    globalShortcut.register('CommandOrControl+F12', () => {
+      return toggleDevTools();
+    });
+    app.on('activate', function () {
+      if (win == null || (BrowserWindow.getAllWindows().length === 0)) createWindow()
+    });
+});