@fto-consult/expo-ui 4.0.4 → 4.2.0

package/babel.config.alias.js

@@ -1,6 +1,6 @@
 const path = require("path");
 const fs = require("fs");
-const writeFile = require("./electron/writeFile");
+const writeFile = require("./electron/utils/writeFile");
 module.exports = (opts)=>{
     const dir = path.resolve(__dirname);
     const base = opts.base || process.cwd();
@@ -133,14 +133,14 @@ module.exports = (opts)=>{
         const l1 = path.resolve($assets,"logo.png"), l2 = path.resolve($assets,"logo.png");
         const logoPath = fs.existsSync(l1)? l1 : fs.existsSync(l2)? l2 : undefined;
         const ePath = path.resolve(electronAssetsPath,"images","logo.png");
-        if(logoPath && require("./electron/createDir")(ePath)){
+        if(logoPath && require("./electron/utils/createDir")(ePath)){
             fs.copyFileSync(logoPath,ePath,fs.constants.COPYFILE_FICLONE);
             electronPaths.logo = logoPath;
         }
     }
     const jsonPath = path.resolve(base,'package.json');
     if(fs.existsSync(jsonPath)){
-        require("./electron/copy")(jsonPath,path.resolve(dir,"electron","package.app.json"));
+        require("./electron/utils/copy")(jsonPath,path.resolve(dir,"electron","package.json"));
     }
     ///on sauvegarde les chemins des fichiers utiles, qui seront utilisées par la variable electron plus tard
     writeFile(path.resolve(dir,"electron","paths.json"),JSON.stringify(electronPaths));

package/bin/index.js

@@ -5,24 +5,31 @@ process.on('unhandledRejection', err => {
   throw err;
 });
 const supportedScript = {
+  "init" : true, //initialize electron app
   "start" : true,//start electron
   "build" : true, //script pour faire un build
+  "package" : true, ///script pour le packagin de l'application
 }
+const createDir = require("../electron/utils/createDir");
+const writeFile = require("../electron/utils/writeFile");
+const copy = require("../electron/utils/copy");
 const path= require("path");
 const fs = require("fs");
 const dir = path.resolve(__dirname);
 const electronDir = path.resolve(dir, "..","electron");
-const exec = require("../electron/exec");
-let projectRoot = process.cwd();
-const createDir = require("../electron/createDir");
-const copyDir = require("../electron/copy");
-const parsedArgs = require("../electron/parseArgs")(null,supportedScript);
+const exec = require("../electron/utils/exec");
+const projectRoot = path.resolve(process.cwd());
+if(projectRoot == dir){
+   throw `Invalid project root ${projectRoot}; project root must be different to ${dir}`
+}
+
+const parsedArgs = require("../electron/utils/parseArgs")(null,supportedScript);
 if(!parsedArgs.script || !(parsedArgs.script in supportedScript)){
    console.error ("Erreur : script invalide, vous devez spécifier script figurant parmi les script : ["+Object.keys(supportedScript).join(", ")+"]");
    process.exit();
 }
-const {script} = parsedArgs;
 let cmd = null;
+const script = parsedArgs.script;
 /**** 
  *    1. installer electron globallement : npm i -g electron@latest
  *  cmde : [cmd] start electron config=[path-to-config-relative-to-project-dir] 
@@ -39,9 +46,26 @@ if(parsedArgs.electron){
   if(typeof paths !=='object' || !paths || !paths.projectRoot){
       throw "Fichiers des chemins d'application invalide!!! merci d'exécuter l'application en environnement web|android|ios puis réessayez"
   }
-  projectRoot = path.resolve(projectRoot);
+  /**** le project root d'où a été lancé le script electron doit être le même que celui de l'application principale */
+  if(projectRoot !== paths.projectRoot){
+     throw `main app project root ${paths.projectRoot} must be equals to ${projectRoot} in which you want to generate electron app`; 
+  }
+  const electronProjectRoot = path.resolve(projectRoot,"electron");
+  const isElectionInitialized = require("../electron/is-initialized")(electronProjectRoot);
+  if(!isElectionInitialized || script =='init'){
+      if(script !=='init'){
+          console.log("initializing electron application before ....");
+      }
+      return require("./init")({
+         projectRoot,
+         electronDir,
+         electronProjectRoot,
+         paths,
+      });
+  }
+  require("../electron/create-index-file")(electronProjectRoot);
   const out = parsedArgs.out || parsedArgs["output-dir"];
-  const outDir = out && path.dirname(out) && path.resolve(projectRoot,path.dirname(out),"electron") || path.resolve(projectRoot,"dist","electron")
+  const outDir = out && path.dirname(out) && path.resolve(projectRoot,path.dirname(out),"electron") || path.resolve(electronProjectRoot,"bin")
   if(!createDir(outDir)){
       throw "Impossible de créer le répertoire <<"+outDir+">> du fichier binaire!!";
   }
@@ -51,16 +75,17 @@ if(parsedArgs.electron){
       console.warn("Logo de l'application innexistant!! Vous devez spécifier le logo de votre application, fichier ["+(logoPath)+"]")
     }
   }
-  const buildOutDir = path.resolve(electronDir,"dist");
+  const buildOutDir = path.resolve(electronProjectRoot,"dist");
   const indexFile = path.resolve(buildOutDir,"index.html");
   const webBuildDir = path.resolve(projectRoot,"web-build");
+  const packagePath = path.resolve(projectRoot,"package.json");
   const url = parsedArgs.url  && parsedArgs.url.trim() || "";
   const start = x=>{
      return new Promise((resolve,reject)=>{
-      cmd = "electron "+electronDir+" url="+url;
+      cmd = "electron "+electronProjectRoot+" url="+url;
         exec({
           cmd, 
-          projectRoot : electronDir,
+          projectRoot : electronProjectRoot,
         }).finally(()=>{
           console.log("ant to exit");
         })
@@ -73,12 +98,13 @@ if(parsedArgs.electron){
   const promise = new Promise((resolve,reject)=>{
     const next = ()=>{
         if(fs.existsSync(webBuildDir)){
-            return copyDir(webBuildDir,buildOutDir).catch(reject).then(resolve);
+            return copy(webBuildDir,buildOutDir).catch(reject).then(resolve);
         } else {
           reject("dossier web-build exporté par electron innexistant!!");
         }
       }
       if(!url && (parsedArgs.compile || !fs.existsSync(path.resolve(webBuildDir,"index.html")))){
+        console.log("exporting expo web app ...");
         cmd = "npx expo export:web";
         return exec({cmd,projectRoot}).then(next).catch(reject);
       }
@@ -88,12 +114,32 @@ if(parsedArgs.electron){
     if(!fs.existsSync(buildOutDir) || !fs.existsSync(indexFile)){
        throw "répertoire d'export web invalide où innexistant ["+buildOutDir+"]"
     }
-    switch(script){
+    switch(parsedArgs.script){
         case "start":
            return start();
           break;
         case "build":
           break;
+        default :
+          if(!fs.existsSync(packagePath)){
+              throw "package.json file does not exist in "+projectRoot+". please make jure that your have running package script in expo root application";
+          }
+          const packageObj = require(`${packagePath}`);
+          const electronPackage = require(`${path.resolve(electronProjectRoot,'package.json')}`);
+          electronPackage.name = packageObj.name;
+          electronPackage.version = packageObj.version;
+          //copying package json in build folder
+          writeFile(path.resolve(electronProjectRoot,"package.json"),JSON.stringify(electronPackage,null,"\t"));
+          const platform = parsedArgs.platform || process.platform;
+          console.log("packaing app from ",electronProjectRoot);
+          return require("./package")({
+              src : electronProjectRoot,
+              dist : path.resolve(outDir,platform),
+              platform,
+              arch : parsedArgs.arch || undefined,
+              projectRoot : electronProjectRoot,
+         });
+         break;
     }
   }).catch((e)=>{
     console.log(e," is cathing ggg");
@@ -102,4 +148,4 @@ if(parsedArgs.electron){
   });
 } else {
   process.exit();
-}
+}

package/bin/init.js

@@ -0,0 +1,82 @@
+const path= require("path");
+const fs = require("fs");
+const dir = path.resolve(__dirname);
+const exec = require("../electron/utils/exec");
+const createDir = require("../electron/utils/createDir");
+const writeFile = require("../electron/utils/writeFile");
+const copy = require("../electron/utils/copy");
+const electronDir = path.resolve(__dirname,"..","electron");
+const createIndexFile = require("../electron/create-index-file");
+
+module.exports = ({
+    projectRoot,
+    electronProjectRoot,
+    paths,
+ })=>{
+    return new Promise((resolve,reject)=>{
+        //make shure electron project root exists
+        if(!createDir(electronProjectRoot)){
+            throw "Unable to create electron project root directory at "+electronProjectRoot;
+        }
+        const projectRootPackage = require(`${path.resolve(projectRoot,'package.json')}`);
+        const dependencies = require("../electron/dependencies");
+        const electronProjectRootPackage = path.resolve(electronProjectRoot,"package.json");
+        projectRootPackage.dependencies = dependencies.main;
+        projectRootPackage.devDependencies = dependencies.dev;
+        projectRootPackage.scripts = {
+            "compile" : "npx expo-ui electron compile",
+            "start" : "npx expo-ui electron start",
+            "compile2start" : "npx expo-ui electron start compile",
+            "package" : "npx expo-ui electron package",
+            "compile2package" : "npx expo-ui electron package compile"
+        }
+        writeFile(electronProjectRootPackage,JSON.stringify(projectRootPackage,null,'\t'));
+        if(!fs.existsSync(electronProjectRootPackage)){
+            throw `unable to create ${electronProjectRootPackage} file`;
+        }
+        const mainFolder = path.resolve(electronProjectRoot,"main");
+        const rendererFolder = path.resolve(electronProjectRoot,"renderer");
+        if(!createDir(mainFolder)){
+            throw `unable to create main process folder at ${mainFolder}`
+        }
+        if(!createDir(rendererFolder)){
+            throw `unable to create renderer process folder at ${rendererFolder}`;
+        }
+        const mainFolderIndex = path.resolve(mainFolder,"index.js");
+        const rendererFolderIndex = path.resolve(rendererFolder,"index.js");
+        if(!fs.existsSync(mainFolderIndex)){
+            copy(path.resolve(electronDir,"init","main.js"),mainFolderIndex);
+        }
+        if(!fs.existsSync(rendererFolderIndex)){
+            copy(path.resolve(electronDir,"init","renderer.js"),rendererFolderIndex);
+        }
+        createIndexFile(electronProjectRoot);
+        /**** copying all electron utils files */
+        const utilsPath = path.resolve(electronProjectRoot,"utils");
+        copy(path.resolve(electronDir,"utils"),utilsPath);
+        console.log("installing package dependencies ...");
+        return exec({
+            cmd : "npm install",// --prefix "+electronProjectRoot,
+            projectRoot : electronProjectRoot,
+        }).then((a)=>{
+            return resolve(a);
+            console.log("initializing with electron-forge ....");
+            return exec({
+                cmd : `npx electron-forge import`,
+            }).then(resolve);
+        }).catch(reject);
+    })
+}
+
+const copyExtra = (path2)=>{
+    fs.readdirSync(path2).forEach((file) => {
+        if(!file || file.toLowerCase() =="dist") return;
+        file = path.join(path2,file);
+        const stat = fs.statSync(file);
+        if(stat.isDirectory()){
+            return copyExtra(file);
+        }
+        if(!stat.isFile() || file === indexFile) return;
+        extraResource.push(file);
+    });
+}

package/bin/package.js

@@ -0,0 +1,59 @@
+const getIcon = require("../electron/utils/getIcon");
+const path = require("path");
+const defaultFunc = (cb,cb2) => typeof cb =='function' ? cb : typeof cb2 ==='function'? cb2 : x=> x;
+const paths = require("../electron/paths.json");
+const images = paths.$images, assets = paths.$assets, logo = paths.logo;
+const createDir = require("../electron/utils/createDir");
+const fs = require("fs");
+const getDirname = require("../electron/utils/getDirname");
+const copy = require("../electron/utils/copy");
+
+/***@see : https://electron.github.io/electron-packager/main/interfaces/electronpackager.options.html */
+module.exports = function package(opts){
+    opts = typeof opts =="object" && !Array.isArray(opts) && opts || {};
+    const {projectRoot:pRoot,...options} = opts;
+    options.dir = typeof options.dir =='string' && options.dir || typeof options.srcDir =='string' && options.srcDir || typeof options.src =='string' && options.src || undefined;
+    const projectRoot = pRoot || options.dir;
+    if(typeof projectRoot !='string' || !projectRoot || !fs.existsSync(projectRoot)){
+        return Promise.reject({
+            message :'projectRoot not defined!! or its invalid '+projectRoot
+        })
+    }
+    const packagerPath = path.resolve(projectRoot,"node_modules","electron-packager");
+    if(!fs.existsSync(packagerPath)){
+        return Promise.reject({
+            message : "packager module not found!! you must initialize your project before to package it; packager path : "+packagerPath,
+        })
+    }
+    const packager = require(`${packagerPath}`);
+    options.afterAsar = defaultFunc(options.afterAsar,()=>{});
+    options.afterComplete = defaultFunc(options.afterComplete,()=>{});
+    options.afterCopy = defaultFunc(options.afterCopy);
+    options.appVersion = typeof options.appVersion =='string' && options.appVersion || typeof options.version =='string' && options.version || undefined;
+    options.arch = typeof options.arch =='string' && options.arch || process.arch;
+    options.asar = typeof options.asar =='boolean'? options.asar : true;
+    return new Promise((resolve,reject)=>{
+        if(!options.dir || !fs.existsSync(options.dir)){
+            return reject({message:"Repertoire source ["+options.dir+"] innexistant!! Veuillez spécifier un répertoire source valide"});
+        }
+        options.out = typeof options.out =="string" && options.out || typeof options.distDir =="string" && options.distDir || typeof options.dist =='string' && options.dist || undefined;
+        if(options.out){
+            createDir(options.out);
+        }
+        options.overwrite = typeof options.overwrite =='boolean'? options.overwrite : true;
+        options.platform = typeof options.platform =='string' && options.platform || process.platform;
+        options.prune = typeof options.prune =='boolean'? options.prune : true;
+        options.quiet = typeof options.quiet =='boolean'? options.quiet : false;
+        options.tmpdir = options.tmpdir === false ? false : typeof options.tmpdir =='string' && options.tmpdir || undefined;
+        options.icon = options.icon && typeof options.icon =='string' && fs.existsSync(options.icon) && options.icon || getIcon([
+            logo && fs.existsSync(logo) && getDirname(logo),
+            images && getDirname(images) || '',
+            assets && getDirname(assets) || '',
+            options.dir && getDirname(options.dir)
+        ]);
+        return packager(options).then((appPaths)=>{
+            console.log(`Electron app bundles created at : ${appPaths.join("\n")}`);
+            resolve(appPaths);
+        }).catch(reject);
+    })
+}

package/electron/app/instance.js

@@ -1,4 +1,4 @@
-const postMessage = require("../postMessage");
+const postMessage = require("../utils/postMessage");
 const callbackRef = {current:null};
 const instanceRef = {current:null};
 const isValid = APP => APP && typeof APP =='object' && typeof APP.trigger =='function';

package/electron/create-index-file.js

@@ -0,0 +1,13 @@
+const fs = require("fs");
+const writeFile = require("../electron/utils/writeFile");
+const path = require("path");
+
+module.exports = (electronProjectRoot)=>{
+    if(!electronProjectRoot || typeof electronProjectRoot !='string' || !fs.existsSync(electronProjectRoot)){
+        return null;
+    }
+    const indexPath = path.resolve(electronProjectRoot,"index.js");
+    const electronDir = path.resolve(__dirname,"..","electron");
+    writeFile(indexPath,`module.exports = require("${path.resolve(electronDir,'index.js').split(path.sep).join("/")}");`);
+    return indexPath;
+}

package/electron/dependencies.js

@@ -0,0 +1,11 @@
+module.exports = {
+    "main" : {
+		"conf": "^10.2.0",
+		"node-machine-id": "latest",
+        "fs-extra" : "latest"
+	},
+	"dev" : {
+		"electron": "^22.2.0",
+		"electron-packager": "^17.1.1",
+	}
+}

package/electron/index.js

@@ -1,31 +1,25 @@
-const {app, BrowserWindow,Tray,Menu,MenuItem,systemPreferences,powerMonitor,dialog, nativeTheme} = require('electron')
-const appConfig  = {}//require("../app/config");
-const session = require("./session");
+const {app, BrowserWindow,Tray,Menu,MenuItem,globalShortcut,systemPreferences,powerMonitor,ipcMain,dialog, nativeTheme} = require('electron')
+const appConfig  = {};
+const session = require("./utils/session");
 const path = require("path");
 const fs = require("fs");
 const ePath = path.resolve(__dirname);
-const getDirname = require("./getDirname");
 if(!fs.existsSync(path.resolve(ePath,"paths.json"))){
   throw {message : 'Chemin de noms, fichier paths.json introuvable!! Exécutez l\'application en enviornnement web|mobile|android|ios puis re-essayez'}
 }
 const paths = require("./paths.json");
-const images = paths.$images, assets = paths.$assets, logo = paths.logo;
 const projectRoot = paths.projectRoot || '';
 const electronProjectRoot = projectRoot && fs.existsSync(path.resolve(projectRoot,"electron")) && path.resolve(projectRoot,"electron") || null;
-const mainProcessIndex = electronProjectRoot && fs.existsSync(path.resolve(electronProjectRoot,"main.process.js")) && path.resolve(electronProjectRoot,"main.process.js");
+const mainProcessIndex = electronProjectRoot && fs.existsSync(path.resolve(electronProjectRoot,"main","index.js")) && path.resolve(electronProjectRoot,"main","index.js");
 const mainProcessRequired = mainProcessIndex && require(`${mainProcessIndex}`);
-//pour étendre les fonctionnalités au niveau du main proceess, bien vouloir écrire dans le fichier projectRoot/electron/main.process.js
+//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
 // fermee automatiquement quand l'objet JavaScript sera garbage collected.
 let win = undefined;
-const icon = require("./getIcon")(
-    logo && fs.existsSync(logo) && getDirname(logo),
-    images && getDirname(images) || '',
-    assets && getDirname(assets) || '',
-);
 Menu.setApplicationMenu(null);
-let clipboadContextMenu = (_, props) => {
+
+const clipboadContextMenu = (_, props) => {
   if (props.isEditable || props.selectionText) {
     const menu = new Menu();
     if(props.selectionText){
@@ -40,9 +34,9 @@ let clipboadContextMenu = (_, props) => {
     menu.popup();
   } 
 };
-
-
-
+const log = (message)=>{
+  return win != null && win && win.webContents.send("console.log",message);
+}
 const setOSTheme = (theme) => {
   theme = theme && typeof theme == "string"? theme : "light";
   theme = theme.toLowerCase().trim();
@@ -64,7 +58,6 @@ function createBrowserWindow (options){
     ...options.webPreferences,
     contextIsolation: true,
     devTools: typeof options.webPreferences.devTools === 'boolean'? options.webPreferences.devTools : false,
-    icon,
     webSecurity : true,
     autoHideMenuBar: true,
     allowRunningInsecureContent: false,
@@ -89,7 +82,7 @@ function createBrowserWindow (options){
   if(showOnLoad){
      options.show = false;
   }
-  if(mainProcess && typeof mainProcess.beforeCreateWindow =='function'){
+  if(typeof mainProcess.beforeCreateWindow =='function'){
      mainProcess.beforeCreateWindow(options);
   }
   let _win = new BrowserWindow(options);
@@ -113,7 +106,7 @@ function createBrowserWindow (options){
   });
   return _win;
 }
-const args = require("./parseArgs")();
+const args = require("./utils/parseArgs")();
 function createWindow () {
   // Créer le browser window
   win = createBrowserWindow({
@@ -124,17 +117,13 @@ function createWindow () {
       devTools : true,
     }
   });
-  
- const log = (message)=>{
-    return win != null && win && win.webContents.send("console.log",message);
-  }
-  // create a new `splash`-Window 
-  /*** @see : http://leftstick.github.io/splash-screen/ */
-  let splash = new BrowserWindow({
-      width: 500, height: 400, transparent: true, frame: false, alwaysOnTop: true});
-  let copyRight = appConfig.name+" version "+appConfig.version+". "+appConfig.copyRight;
-  copyRight = encodeURI(copyRight);
-  //splash.loadURL(`file://${__dirname}/splash/index.html?copyRight=${copyRight}`);
+
+ 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();
@@ -163,8 +152,11 @@ function createWindow () {
 
   win.once("ready-to-show",function(){
       win.minimize()
-      if(splash !== null)splash.destroy();
-      splash = null;
+      try {
+        if(splash && splash instanceof BrowserWindow){
+          splash.destroy();
+        }
+      } catch{ }
       win.restore();
       win.show();
       //log(icon," is consooleeeee")
@@ -179,7 +171,7 @@ function createWindow () {
   if(args.url){
     win.loadURL(args.url);
   } else {
-    win.loadFile(path.resolve(path.join(__dirname,"dist",'index.html')))
+    win.loadFile(path.resolve(path.join(electronProjectRoot,"dist",'index.html')))
   }
 
   win.on('unresponsive', async () => {
@@ -199,7 +191,7 @@ function createWindow () {
   })
 
  // Ouvre les DevTools.
- win.webContents.openDevTools()
+ //win.webContents.openDevTools()
   
   // Émit lorsque la fenêtre est fermée.
   win.on('closed', () => {
@@ -243,8 +235,12 @@ function createWindow () {
   win.on('resize',onWinResizeEv);
   win.off('move',onWinResizeEv);
   win.on('move',onWinResizeEv);
+  if(mainProcess && typeof mainProcess =='object' && typeof mainProcess.onCreateWindow =='function'){
+     mainProcess.onCreateWindow(win);
+  }
 }
-let quit = ()=>{
+
+const quit = ()=>{
   try {
     app.quit();
   } catch(e){
@@ -260,19 +256,42 @@ app.on('window-all-closed', () => {
   }
 })
 
+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("electron-toggle-dev-tools",function(event,value) {
+  return toggleDevTools(value);
+});
+
+
 app.whenReady().then(() => {
-  appReady = true;
+  if(typeof mainProcess.whenReady =='function'){
+     mainProcess.whenReady();
+  } else if(typeof mainProcess.appOnReady =='function'){
+     mainProcess.appOnReady();
+  }
+  globalShortcut.register('CommandOrControl+F12', () => {
+    toggleDevTools();
+  });
+}).then(()=>{
   createWindow();
   app.on('activate', function () {
     if (win == null || (BrowserWindow.getAllWindows().length === 0)) createWindow()
   });
 })
 
-const {ipcMain} = require("electron");
-
-ipcMain.on("electron-restart-app",x =>{
-  app.relaunch();
-})
+ipcMain.on("electron-restart-app",x =>{app.relaunch();})
 let tray = null;
 let isJSON = function (json_string){
   if(!json_string || typeof json_string != 'string') return false;
@@ -284,7 +303,7 @@ ipcMain.on("update-system-tray",(event,opts)=>{
   let {contextMenu,tooltip} = opts;
   if(tray){
   } else {
-    tray = new Tray(icon? icon : undefined);
+    tray = new Tray();
   }        
   if(!tooltip || typeof tooltip !=="string"){
       tooltip = ""
@@ -327,8 +346,15 @@ ipcMain.on("electron-ask-for-media-access",(event,mediaType)=>{
 });
 
 ipcMain.on("electron-get-app-icon",(event)=>{
-  event.returnValue = icon;
-  return icon;
+  event.returnValue = win != win && win.getIcon && win.getIcon();
+});
+ipcMain.on("electron-set-app-icon",(event,iconPath)=>{
+   if(iconPath && win != null){
+      win.setIcon(iconPath);
+      event.returnValue = iconPath;
+   } else {
+      event.returnValue = null;
+   }
 });
 
 ipcMain.on('minimize-main-window', () => {
@@ -449,20 +475,7 @@ ipcMain.on("electron-is-dev-tools-open",function(event,value) {
   }
   return false;
 })
-ipcMain.on("electron-toggle-dev-tools",function(event,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("electron-window-set-progressbar",(event,interval)=>{
    if(typeof interval !="number" || interval <0) interval = 0;

package/electron/init/main.js

@@ -0,0 +1,10 @@
+/**** auto generated file 
+ *  in this file, you can add all main process code you want for your electron application
+ *  @export||@return {object}, with properties like this : 
+ *  {
+ *      splash || splashScreen {function|| instanceOf(BrowserWindow)}, if function, must return an instanceOf BrowserWindow wich will use as application splashcreen
+ *      whenReady || appOnReady {function}, function called when electron app is ready 
+ * }
+*/
+
+module.exports = {}

package/electron/init/renderer.js

@@ -0,0 +1,6 @@
+/**** auto generated file 
+ *  in this file, you can add renderer process code you want for your electron application
+ *  @param ELECTRON {object}, electron object that will be expose on renderer script with contextBridge
+*/
+
+module.exports = (ELECTRON)=>{}

package/electron/is-initialized.js

@@ -0,0 +1,12 @@
+const fs = require("fs");
+const path = require("path");
+/*** check if electron is initialized at project root */
+module.exports = (projectRoot)=>{
+    projectRoot = typeof projectRoot =='string' && projectRoot && fs.existsSync(projectRoot) && projectRoot || process.cwd();
+    return fs.existsSync(path.resolve(projectRoot,"node_modules")) && fs.existsSync(path.resolve(projectRoot,"index.js")) 
+        && fs.existsSync(path.resolve(projectRoot,"package.json")) 
+        && fs.existsSync(path.resolve(projectRoot,"main")) 
+        && fs.existsSync(path.resolve(projectRoot,"renderer"))
+        
+    && true || false;
+}

package/electron/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "sage-ftc",
+	"version": "1.0.0",
+	"description": "Accès distant aux données commerciales et comptables Sage100C de partout",
+	"main": "./index.js",
+	"scripts": {
+		"test": "test",
+		"start": "npx expo start",
+		"start-c": "npx expo start -c",
+		"build": "npx expo export:web",
+		"electron": "node ./expo-ui/bin start electron url=http://localhost:19006/",
+		"build-android": "eas build --clear-cache -p android --profile preview",
+		"delete-node-modules": "rimraf ./**/node_modules",
+		"package": "node ./expo-ui/bin package compile2"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/borispipo/sage-ftc.git"
+	},
+	"keywords": [
+		"XposeFTC",
+		"Sage100C",
+		"Accès",
+		"distant"
+	],
+	"author": "BorisFouomene@fto-consulting",
+	"license": "UNLICENCED",
+	"bugs": {
+		"url": "https://github.com/borispipo/sage-ftc/issues"
+	},
+	"homepage": "./"
+}