@fto-consult/expo-ui 3.0.1 → 3.1.1

package/babel.config.alias.js

@@ -1,4 +1,5 @@
 const path = require("path");
+const fs = require("fs");
 module.exports = (opts)=>{
     const dir = path.resolve(__dirname);
     const base = opts.base || process.cwd();
@@ -110,5 +111,23 @@ module.exports = (opts)=>{
         nodeModulesPath : path.resolve(root,"node_modules"),
         outputPath
     });
+    const $assets = r.$assets;
+    const electronPaths = {
+        ...r,
+        assets : $assets,
+        images : r.$images,
+        projectRoot : base,//la racine au projet
+    };
+    const electronAssetsPath = path.resolve(dir,"electron","assets");
+    if($assets){
+        const l1 = path.resolve($assets,"logo.png"), l2 = path.resolve($assets,"images","logo.png");
+        const logoPath = fs.existsSync(l1)? l1 : fs.existsSync(l2)? l2 : undefined;
+        if(logoPath){
+            fs.copyFileSync(logoPath,path.resolve(electronAssetsPath,"images","logo.png"),fs.constants.COPYFILE_FICLONE);
+            electronPaths.logo = logoPath;
+        }
+    }
+    ///on sauvegarde les chemins des fichiers utiles, qui seront utilisées par la variable electron plus tard
+    require("./writeFile")(path.resolve(dir,"electron","paths.json"),JSON.stringify(electronPaths));
     return r;
 }

package/bin/electron/index copy.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**@see : https://blog.shahednasser.com/how-to-create-a-npx-tool/ */
+'use strict';
+process.on('unhandledRejection', err => {
+  throw err;
+});
+const spawnAsync = require('cross-spawn').spawn;
+const { realpathSync } = require('fs-extra');
+
+//const { ensureMinProjectSetupAsync } = require('../build/Config');
+
+const args = process.argv.slice(2);
+
+const scriptIndex = args.findIndex(x => x === 'start' || x === 'customize');
+const script = scriptIndex === -1 ? args[0] : args[scriptIndex];
+const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : [];
+console.log(args," is argggggg",script);
+if (['start', 'customize'].includes(script)) {
+  spawnAsync(
+    'node',
+    nodeArgs.concat(require.resolve('./scripts/' + script)).concat(args.slice(scriptIndex + 1)),
+    { stdio: 'inherit' }
+  ).then(result => {
+    if (result.signal) {
+      if (result.signal === 'SIGKILL') {
+        console.log(
+          'The build failed because the process exited too early. ' +
+            'This probably means the system ran out of memory or someone called ' +
+            '`kill -9` on the process.'
+        );
+      } else if (result.signal === 'SIGTERM') {
+        console.log(
+          'The build failed because the process exited too early. ' +
+            'Someone might have called `kill` or `killall`, or the system could ' +
+            'be shutting down.'
+        );
+      }
+      process.exit(1);
+    }
+    process.exit(result.status);
+  });
+} else if (script === undefined) {
+  const projectRoot = realpathSync(process.cwd());
+
+  //ensureMinProjectSetupAsync(projectRoot);
+} else {
+  console.log('Invalid command "' + script + '".');
+}

package/bin/electron/index.js

@@ -4,45 +4,8 @@
 process.on('unhandledRejection', err => {
   throw err;
 });
-const spawnAsync = require('cross-spawn').spawn;
-const { realpathSync } = require('fs-extra');
-
-//const { ensureMinProjectSetupAsync } = require('../build/Config');
-
 const args = process.argv.slice(2);
 
-const scriptIndex = args.findIndex(x => x === 'start' || x === 'customize');
-const script = scriptIndex === -1 ? args[0] : args[scriptIndex];
-const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : [];
-console.log(args," is argggggg",script);
-if (['start', 'customize'].includes(script)) {
-  spawnAsync(
-    'node',
-    nodeArgs.concat(require.resolve('./scripts/' + script)).concat(args.slice(scriptIndex + 1)),
-    { stdio: 'inherit' }
-  ).then(result => {
-    if (result.signal) {
-      if (result.signal === 'SIGKILL') {
-        console.log(
-          'The build failed because the process exited too early. ' +
-            'This probably means the system ran out of memory or someone called ' +
-            '`kill -9` on the process.'
-        );
-      } else if (result.signal === 'SIGTERM') {
-        console.log(
-          'The build failed because the process exited too early. ' +
-            'Someone might have called `kill` or `killall`, or the system could ' +
-            'be shutting down.'
-        );
-      }
-      process.exit(1);
-    }
-    process.exit(result.status);
-  });
-} else if (script === undefined) {
-  const projectRoot = realpathSync(process.cwd());
+console.log(args," is arggggg");
 
-  //ensureMinProjectSetupAsync(projectRoot);
-} else {
-  console.log('Invalid command "' + script + '".');
-}
+process.exist();

package/electron/index.js

@@ -1,8 +1,7 @@
 const {app, BrowserWindow,Tray,Menu,MenuItem,systemPreferences,powerMonitor,dialog, nativeTheme} = require('electron')
-let appConfig  = require("../src/app/config");
-let appReady = false;
+const appConfig  = {}//require("../src/app/config");
+const session = require("./session");
 const path = require("path");
-const parentDir = path.resolve(__dirname);
 // 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;
@@ -34,8 +33,7 @@ let clipboadContextMenu = (_, props) => {
   } 
 };
 
-let Conf = require('./src/config');
-let session = new Conf({cwd:app.getPath('userData')});
+
 
 const setOSTheme = (theme) => {
   theme = theme && typeof theme == "string"? theme : "light";
@@ -110,7 +108,7 @@ function createWindow () {
   win = createBrowserWindow({
     showOnLoad : false,
     loadURL : undefined,
-    preload : path.resolve(__dirname,'src/preload.js'),
+    //preload : path.resolve(__dirname,'src/preload.js'),
     webPreferences : {
       devTools : true,
     }
@@ -121,7 +119,7 @@ function createWindow () {
       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}/src/splash/index.html?copyRight=${copyRight}`);
+  //splash.loadURL(`file://${__dirname}/src/splash/index.html?copyRight=${copyRight}`);
   let hasInitWindows = false;
   win.on('show', () => {
     //win.blur();

package/electron/src/config.js

@@ -0,0 +1,31 @@
+'use strict';
+const path = require('path');
+const electron = require('electron');
+const Conf = require('conf');
+
+class ElectronStore extends Conf {
+	constructor(options) {
+		const defaultCwd = "";
+
+        options = options && typeof options == 'object' ? options : {}
+		options  =  {
+			name: 'config',
+			...options
+        };
+
+		if (options.cwd) {
+			options.cwd = path.isAbsolute(options.cwd) ? options.cwd : path.join(defaultCwd, options.cwd);
+		} else {
+			options.cwd = defaultCwd;
+		}
+		options.configName = options.name;
+		delete options.name;
+		super(options);
+	}
+
+	openInEditor() {
+		electron.shell.openItem(this.path);
+	}
+}
+
+module.exports = ElectronStore;

package/electron/src/pload.js

@@ -0,0 +1,97 @@
+module.exports = (ELECTRON)=>{
+    let isWin = process.platform === "win32"? true : false;
+    let isLinux = process.platform === "linux"? true : false;
+    let {ipcRenderer} = require("electron");
+    let os = require("os");
+    let totalRAM = os.totalmem();
+    if(typeof totalRAM !=="number"){
+        totalRAM = 0;
+    }
+    let getMem = (unit,key)=>{
+        let memory = 0;
+        if(typeof os[key] =="function"){
+            memory = os[key]();
+        }
+        if(typeof memory !=="number"){
+            memory = 0;
+        }
+        if(!memory) return 0;
+        if(typeof unit !=="string") unit = "gb";
+        switch(unit.toLowerCase()){
+            case "kb" : 
+                return memory / 1024;
+            case "mb" : 
+                return memory / (1024 * 1024);
+            case "gb" : 
+                return memory / (1024 * 1024 * 1024);
+        }
+        return memory;
+    }
+    APP.extend(ELECTRON,{
+        toggleDevTools : (value)=>{
+            ipcRenderer.send("electron-toggle-dev-tools",defaultBool(value,true));
+        },
+        gc : x =>{
+            if(typeof global.gc =='function') return global.gc();
+            return false;
+        },
+        DEVICE : {
+            computerName : os.hostname(),
+            operatingSystem : os.type(),
+            isWindows : isWin,
+            isLinux,
+            isMac : process.platform =='darwin'? true : false,
+            isDarwin : process.platform =='darwin'? true : false,
+            arch : os.arch(),
+            totalRAMInGB : totalRAM / (1024 * 1024 * 1024),
+            getFreeRAM : (unit)=> getMem(unit,"freemem"),
+            getTotalRAM : (unit)=> getMem(unit,'totalmem')
+        },
+        setTitle : (title) =>{
+            if(title && typeof title =="string"){
+               ipcRenderer.send("electron-set-main-window-title",title);
+            }
+        },
+        createWindow : (options)=>{
+            options = defaultObj(options);
+            options.showOnLoad = defaultBool(options.showOnLoad,true);
+            return ipcRenderer.invoke("electron-create-browser-windows",options);
+        },
+        createPDFWindow :(options)=>{
+            options = defaultObj(options);
+            options.modal = true;
+            return ELECTRON.createWindow(options);
+        },
+        createProgressBar : (options)=>{
+            if(!options || typeof options != 'object' || Array.isArray(options)){
+                options = {};
+            }
+            return //new ProgressBar(options,app);
+        },
+        getAutoUpdaterEvents : ()=> [
+            //'checking-for-update',
+            'update-available',
+            'update-not-available',
+            'error',
+            'download-progress',
+            'update-downloaded'
+        ],
+    })
+    const username = require('username');
+    let { machineIdSync} = require('node-machine-id');
+    if(process.env && typeof process.env =="object"){
+        let logName = process.env["LOGNAME"] || process.env["USER"];
+        if(logName && typeof logName =="string"){
+            ELECTRON.DEVICE.computerUserName = logName;
+        }
+    }
+    let uuid = machineIdSync({original: true});
+    if(uuid && typeof uuid =='string') ELECTRON.DEVICE.uuid = uuid;
+      
+    username().then((u)=>{
+        if(u && typeof u =="string"){
+           ELECTRON.DEVICE.computerUserName = u;
+        }
+    });
+   return ELECTRON;
+}

package/electron/src/preload.js

@@ -0,0 +1,456 @@
+(function(window) {
+    let showingExitApp = undefined;
+    let sudo = require('sudo-prompt');
+    const { exec } = require('child_process');
+    if(typeof window.isElectron != 'function'){
+        Object.defineProperties(window,{
+            ELECTRON : {
+                value : {},writable:false,override : false
+            },
+            isElectron : {
+                value : () => true,
+                override : false,
+                writable : false
+            },
+            getPouchdbElectron : {
+                value : (PouchDB,window,sqlPouch)=> {
+                    window.sqlitePlugin = {openDatabase:require('websql')};
+                    PouchDB.plugin(function CapacitorSqlitePlugin (PouchDB) {
+                        PouchDB.adapter('node-sqlite', sqlPouch(), true)
+                    });
+                    return {adapter:"node-sqlite"};
+                },
+            },
+        })
+    } 
+    ELECTRON;
+    let fs = require("fs");
+    let _app = require("./app.config");
+    require("./pload")(ELECTRON);
+    const {ipcRenderer} = require('electron')
+    let APP_NAME = defaultStr(_app.name).toUpperCase();
+    let path = require("path");
+    let getPath = function(pathName){
+        return ipcRenderer.sendSync("electron-get-path",pathName);
+    }
+    let APP_PATH = path.join(getPath("appData"),APP_NAME).toLowerCase();
+    let databasePath = path.join(APP_PATH,"databases");
+    let ROOT_APP_FOLDER = undefined;
+    let separator = (path.sep)
+    let DOWNLOADING_FILES= {};
+    if(typeof separator != 'string' || !separator){
+        separator = (()=>{
+            let filePath = databasePath;
+            var sepIndex = filePath.lastIndexOf('/');
+            if(sepIndex == -1){
+                sepIndex = filePath.lastIndexOf('\\');
+            }
+            // include the trailing separator
+            return filePath.substring(0, sepIndex+1);
+        })();
+    }
+    function createDirSync(targetDir, { isRelativeToScript = false } = {}) {
+        if(!targetDir || typeof targetDir != 'string') return false;
+        const sep = path.sep;
+        const initDir = path.isAbsolute(targetDir) ? sep : '';
+        const baseDir = isRelativeToScript ? __dirname : '.';
+      
+        return targetDir.split(sep).reduce((parentDir, childDir) => {
+          const curDir = path.resolve(baseDir, parentDir, childDir);
+          try {
+            fs.mkdirSync(curDir);
+          } catch (err) {
+            if (err.code === 'EEXIST') { // curDir already exists!
+              return curDir;
+            }
+      
+            // To avoid `EISDIR` error on Mac and `EACCES`-->`ENOENT` and `EPERM` on Windows.
+            if (err.code === 'ENOENT') { // Throw the original parentDir error on curDir `ENOENT` failure.
+              throw new Error(`EACCES: permission denied, mkdir '${parentDir}'`);
+            }
+      
+            const caughtErr = ['EACCES', 'EPERM', 'EISDIR'].indexOf(err.code) > -1;
+            if (!caughtErr || caughtErr && curDir === path.resolve(targetDir)) {
+              throw err; // Throw if it's just the last created dir.
+            }
+          }
+      
+          return curDir;
+        }, initDir);
+    }
+    const Config = require('./config');
+    let confPath = process.env.ProgramData || process.env.ALLUSERSPROFILE;
+    if(confPath && typeof confPath =="string"){
+        if(fs.existsSync(confPath) && (_app.name) && typeof _app.name =='string'){
+            confPath = path.join(confPath,_app.name.toUpperCase());
+            if(!fs.existsSync(confPath)){
+                createDirSync(confPath);
+            }
+            if(fs.existsSync(confPath)){
+                ROOT_APP_FOLDER = confPath;
+                databasePath = path.join(confPath,"databases");
+                createDirSync(databasePath);
+                confPath = path.join(confPath,"CONFIG");
+                createDirSync(confPath);
+            }
+        } else confPath = undefined;
+    } else confPath = undefined;
+    let config = new Config({cwd:confPath});
+    if(typeof ELECTRON.getBackupPath !== 'function'){
+        let backupPathField = "_e_backupDataPath";
+        let cBackupPathField = "company"+backupPathField;
+        let dbPathField = "_electron_DBPathField";
+        
+        Object.defineProperties(ELECTRON,{
+            getBackupPath : {
+                value : (p)=>{
+                    let ePath = config.get(cBackupPathField);
+                    let defPath  = ROOT_APP_FOLDER || path.join(getPath("documents"),APP_NAME);
+                    ELECTRON.COMPANY_BACKUP_PATH = defaultStr(ePath,defPath);
+                    if(!fs.existsSync(ELECTRON.COMPANY_BACKUP_PATH)){
+                        ELECTRON.COMPANY_BACKUP_PATH = defPath;
+                    }
+                    if(isNonNullString(p)){
+                        return path.join(ELECTRON.COMPANY_BACKUP_PATH,p);
+                    }
+                    return ELECTRON.COMPANY_BACKUP_PATH;
+                },override:false,writable:false
+            },
+            getDatabasePath : {
+                value : ()=>{
+                    let folder = APP.FOLDERS_MANAGER.getCurrent();
+                    if(isObj(folder) && fs.existsSync(folder.databasePath)){
+                        return databasePath;
+                    }
+                    let p = config.get(dbPathField);
+                    if(fs.existsSync(p)){
+                        databasePath = p
+                    }
+                    if(!fs.existsSync(databasePath)){
+                        console.log(databasePath,' does not exists');
+                        createDirSync(databasePath);
+                    }
+                    return databasePath;
+                },override:false,writable:false
+            },
+            setDatabasePath : {
+                value : (newPath)=>{
+                    config.set(dbPathField,newPath)
+                },override:false,writable:false
+            },
+            setBackupPath : {
+                value : (newPath)=>{
+                    newPath = defaultStr(newPath,ROOT_APP_FOLDER,path.join(getPath("documents"),APP_NAME));
+                    ELECTRON.COMPANY_BACKUP_PATH = newPath;
+                    config.set(cBackupPathField,ELECTRON.COMPANY_BACKUP_PATH)
+                },override:false,writable:false
+            },
+            showOpenDialog : {
+                value : (options)=>{
+                    options = defaultObj(options);
+                    return ipcRenderer.invoke("electron-show-open-dialog",options);
+                },override:false, writable:false
+            },
+            showSaveDialog : {
+                value : (options)=>{
+                    options = defaultObj(options);
+                    return ipcRenderer.invoke("electron-show-save-dialog",options);
+                },override:false, writable:false
+            },
+            unlinkDownloadingFile : {
+                value : (opts)=>{
+                    opts = defaultObj(opts);
+                    let p = opts.filePath+".download";
+                    if(fs.existsSync(p)){
+                        fs.unlink(p, function(err) {
+                            if(err && err.code == 'ENOENT') {
+                                // file doens't exist
+                                console.info("File doesn't exist, won't remove it.");
+                            } else if (err) {
+                                console.error(err,"Error occurred while trying to remove file");
+                            } else {
+                                console.info(`removed`, p);
+                            }
+                        });
+                    }
+                },override : false, writable : false
+            },
+            DOWNLOADING_FILES : {value : DOWNLOADING_FILES, override : false, writable : false}, 
+            restartApp : {
+                value : ()=>{
+                    ipcRenderer.sendSync("electron-restart-app")
+                }, override : false, writable : false
+            },
+            downloadFile : {
+                value : (opts) =>{
+                    opts = defaultObj(opts);
+                    opts.directory = defaultStr(opts.directory,ELECTRON.PATH.DOWNLOADS);
+                    opts.fileName = defaultStr(opts.fileName,APP.getName().toUpperCase())
+                    opts.filePath = path.join(opts.directory,opts.fileName);
+                    opts.onProgress = defaultFunc(opts.onProgress,(percentage,chunk,remainingSize)=> {})
+                    opts.maxAttempts = defaultDecimal(opts.maxAttempts,4);
+                    opts.onError = defaultFunc(opts.onError,x =>x);
+                    let {onResponse} = opts;
+                    opts.onResponse = function(response){
+                        let length = response.headers['content-length'];
+                        if(!isDecimal(length)){
+                            length = parseFloat(length) || 0;
+                        }
+                        if(isFunction(onResponse)){
+                            onResponse({...response,
+                                length,fileSize:length,
+                                fileSizeInBytes:length,
+                                fileSizeInKiloBytes : length/1024,
+                                fileSizeInMegaBytes : length / (1024*1024)
+                            })
+                        }
+                      }
+                    if(!isNonNullString(opts.url)) return Promise.reject({msg:'Ipossible de télécharger le fichier car l\'url est non définit'});
+                    if(isObj(DOWNLOADING_FILES[opts.url]) && isPromise(DOWNLOADING_FILES[opts.url].promise)) {
+                        return DOWNLOADING_FILES[opts.url];
+                    }
+                    opts.cloneFiles = defaultBool(opts.cloneFiles,false);//This will cause the downloader to re-write an existing file.   
+                    
+                    /*** If you want to completely skip downloading a file, when a file with the same name already exists, use config.skipExistingFileName = true */
+                    opts.skipExistingFileName = defaultBool(opts.skipExistingFileName,false);
+                    let Downloader = require('nodejs-file-downloader');
+                    let downloader = new Downloader(opts);
+                    let promise = downloader.download().then((result)=>{
+                        return result;
+                    }).catch((e)=>{
+                        return e
+                        //console.log(e," downloading file electron");
+                    }).finally(()=>{
+                        delete DOWNLOADING_FILES[opts.url];
+                    });
+                    DOWNLOADING_FILES[opts.url] = {
+                        download : x=> promise,
+                        promise,
+                        context:downloader,
+                        cancel : x => {
+                            try {downloader.cancel();} catch(e){
+                                console.log(e," canceled download");
+                            } finally{ 
+                                ELECTRON.unlinkDownloadingFile(opts);
+                                delete DOWNLOADING_FILES[opts.url];
+                            }
+                        },
+                    } 
+                    return DOWNLOADING_FILES[opts.url];
+                },override : false, writable : false
+            },
+            /*** le gestionnaire des configurations application electron : 
+             *  voir : https://github.com/sindresorhus/electron-store
+             */
+            CONFIG : {
+                value : config, override:false,writable:false
+            },
+            databasePath : {
+                value : ()=>{
+                    let path = ELECTRON.getDatabasePath();
+                    return path;
+                },override:false,writable:false
+            },
+            is : {
+                value : true,override:false,writable : false
+            },
+            APP_PATH : {
+                value : APP_PATH,override:false,writable:false
+            },
+            PATH : {
+                value : {
+                    ...path,
+                    SEPARATOR : separator,
+                    SEP : separator,
+                    get : getPath,
+                    HOME : getPath("home"),
+                    USERDATA : getPath("userData"),
+                    /*** 
+                     * Per-user application data directory, which by default points to:
+                     *  %APPDATA% on Windows
+                     *  $XDG_CONFIG_HOME or ~/.config on Linux
+                     *  ~/Library/Application Support on macOS
+                     */
+                    APPDATA : getPath("appData"),
+                    CACHE : getPath("cache"),
+                    TEMP : getPath("temp"),//Temporary directory.
+                    EXECUTABLE : getPath("exe"),//The current executable file.
+                    EXE : getPath("exe"),//The current executable file.
+                    DOCUMENTS : getPath("documents"),
+                    DOWNLOADS : path.join(APP_PATH,"downloads"),
+                    DESKTOP : getPath("desktop"),//The current user's Desktop directory.
+                }, override:false,writable:false
+            },
+            ///retourne le chemin dont la chaine de caractère est passé en paramètre
+            getPath : {
+                value : getPath, override:false,writable:false
+            },
+            exec : {
+                value : (opts,successCB,errorCB)=>{
+                    if(isNonNullString(opts)){
+                        opts = {cmd:opts};
+                    }
+                    let {cmd} = opts;
+                    opts = defaultObj(opts);
+                    successCB = defaultFunc(successCB,opts.onSuccess)
+                    errorCB = defaultFunc(errorCB,opts.onError);
+                    return new Promise((resolve,reject)=>{
+                        let handle = function(error, stdout, stderr) {
+                            if(error){
+                                errorCB({error,stderr})
+                                return reject({error,stderr})
+                            }
+                            successCB(stdout);
+                            resolve(stdout);
+                        }
+                        if(opts.sudo || opts.runAsAdmin){
+                            sudo.exec(cmd, opts,handle)   
+                        } else {
+                            exec(cmd,handle);
+                        }
+                    })
+                }
+            },
+            installNewAppVersion : {
+                value : (conf,successCB,errorCB)=>{
+                    if(isNonNullString(conf)){
+                        conf = {filePath:conf}
+                    }
+                    conf = defaultObj(conf);
+                    let {notify} = APP.require("$dialog");
+                    
+                    if(isNonNullString(conf.filePath) && fs.existsSync(conf.filePath)){
+                        let cmd = conf.filePath;
+                        if(ELECTRON.DEVICE.isLinux){
+                            cmd = "dpkg -i "+cmd;
+                        }
+                        let rootPath = path.join(__dirname,'..')
+                        let incs = path.join(rootPath, ELECTRON.DEVICE.isWindows?'icon.ico':ELECTRON.DEVICE.isLinux?'icon.png':'incs');
+                        const options = {
+                            title : "Authorisez "+APP.getName()+"",
+                            name: APP.getName(),
+                            incs,
+                            icon : incs,
+                            cmd,
+                            sudo:true,
+                            onSoucces : (stdout)=>{
+                                let message = "Le processus d'installation de la mise à jour de l'application a été exécutée evec succès. Veuillez relancer l'application";
+                                notify.success(message);
+                            },
+                            onError: ({error})=>{
+                                notify.error("Erreur lors de l'exécution du fichier d'installation : "+defaultStr(error.message));
+                            }
+                            //icns: '/Applications/Electron.app/Contents/Resources/Electron.icns'
+                        };
+                        return ELECTRON.exec(options,successCB,errorCB)       
+                    }
+                }, override : false, writable : false
+            },
+            updateSystemTheme : {
+                value : (theme)=>{
+                    return ipcRenderer.invoke("electron-set-system-theme:toggle",theme);
+                },override:false, writable:false
+            },
+        })
+    }   
+    if(!window.APP){
+        Object.defineProperties(window,{
+            APP : {
+                value : {},override:false,writable:false
+            }
+        })
+    }
+    ELECTRON.getBackupPath();
+    require("./app/index")(ELECTRON)
+    require('v8-compile-cache');
+    require("v8").setFlagsFromString('--expose_gc'); 
+
+    let _gc = x =>{
+        if(!isObj(window.APP) || !isFunction(window.APP.isInitialized)){
+            return null;
+        }
+        if(!window.APP.isInitialized()){
+            return null;
+        }
+        return require("vm").runInNewContext('gc');
+    }
+    Object.defineProperties(window,{
+        gc : {value:_gc,override:false,writable:false}
+    })
+    Object.defineProperties(ELECTRON,{
+        gc : {value:_gc,override:false,writable:false}
+    })
+    
+    ipcRenderer.on('before-app-exit', (args) => {
+        let {notify,showConfirm} = APP.require("$dialog");
+        hidePreloader();
+        if(showingExitApp) return;
+        showingExitApp = true;
+        showConfirm({
+            title : 'Quittez l\'application',
+            message : 'Voulez vous vraiment quitter l\'application?',
+            yes : 'Oui',
+            no : 'Non',
+            onCancel : () =>{
+                showingExitApp = false;
+            },
+            onSuccess : ()=>{
+                showingExitApp = false;
+                let backupDataOnClose = true;
+                let promises = []
+                    
+                if(APP.COMPANY && APP.COMPANY.electronBackupDataOnClose !== undefined){
+                    backupDataOnClose = APP.COMPANY.electronBackupDataOnClose;
+                }
+                if(backupDataOnClose){
+                    promises.push(APP.exportData({}).then().catch((e)=>{
+                        console.log(e,' on backup databases before exit');
+                        notify.error("Une erreur est survenue pendant la sauvegarde des données!! : "+JSON.stringify(e))
+                    }))
+                } 
+                if(APP.COMPANY && defaultVal(APP.COMPANY.syncDataOnExit,0)){
+                    let {sync} = APP.require("$database");
+                    promises.push(sync.run({cancel:false}));
+                }
+                let exit = ()=>{
+                    let disconectUserOnExit= true;
+                    if(APP.COMPANY && APP.COMPANY.disconectUserOnExit !== undefined){
+                        disconectUserOnExit = APP.COMPANY.disconectUserOnExit;
+                    }
+                    if(disconectUserOnExit){
+                        Auth.doLogout();
+                    }
+                    let autoUpdater = APP.getAutoUpdater();
+                    let canInstall = autoUpdater.canInstall();
+                    autoUpdater.setInstallOnAppExit(false)
+                    let ex = x=>ipcRenderer.send("close-main-render-process");
+                    if(isObj(canInstall)){
+                        if(canInstall.installOnExit){
+                            return ELECTRON.installNewAppVersion(canInstall).finally(ex);
+                        }
+                    } 
+                    ex();
+                }
+                Promise.all(promises).then(exit).catch((e)=>{
+                    console.log(e,' exiting app');
+                    exit();
+                }).finally(exit);
+            }
+        })
+    });
+
+    ipcRenderer.on("main-app-suspended",()=>{
+        APP.stopIDLE(true,true);
+    })
+    ipcRenderer.on("main-app-restaured",()=>{
+        APP.trackIDLE();
+    });
+    ipcRenderer.on('appReady',()=>{})
+    ipcRenderer.on("main-window-focus",()=>{
+        APP.runElectronAppStateChangedCallback({isActive:true})
+    })
+    ipcRenderer.on("main-window-blur",()=>{
+        APP.runElectronAppStateChangedCallback({});
+    })
+})(window);
+

package/electron/src/session.js

@@ -0,0 +1,5 @@
+const {app} = require('electron');
+let Conf = require('./config');
+const session = new Conf({cwd:app.getPath('userData')});
+
+module.exports = session;

package/metro.config.js

@@ -24,6 +24,6 @@ module.exports = function(opts){
       'jsx', 'js','tsx',
   ]
   // Remove all console logs in production...
-  config.transformer.minifierConfig.compress.drop_console = true;
+  //config.transformer.minifierConfig.compress.drop_console = false;
   return config;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fto-consult/expo-ui",
-  "version": "3.0.1",
+  "version": "3.1.1",
   "description": "Bibliothèque de composants UI Expo,react-native",
   "main": "index.js",
   "scripts": {
@@ -63,7 +63,7 @@
     "@emotion/native": "^11.10.0",
     "@expo/html-elements": "^0.2.0",
     "@expo/vector-icons": "^13.0.0",
-    "@fto-consult/common": "^2.13.2",
+    "@fto-consult/common": "^2.15.0",
     "@gorhom/portal": "^1.0.14",
     "@react-native-async-storage/async-storage": "~1.17.3",
     "@react-native-community/datetimepicker": "6.5.2",
@@ -71,6 +71,7 @@
     "@react-navigation/native": "^6.1.1",
     "@react-navigation/native-stack": "^6.9.7",
     "@shopify/flash-list": "1.3.1",
+    "conf": "^10.2.0",
     "expo": "^47.0.8",
     "expo-camera": "~13.1.0",
     "expo-clipboard": "~4.0.1",

package/writeFile.js

@@ -0,0 +1,16 @@
+const path = require("path");
+const getDirName = require('path').dirname;
+module.exports = function writeFile(path, contents, cb) {
+    const p = getDirName(path);
+    if(!fs.existsSync(p)){
+       try {
+          fs.mkdirSync(p,{ recursive: true});
+       } catch(e){
+         console.log(e," making write file directory")
+       }
+    }
+    if(fs.existsSync(p)){
+      return fs.writeFileSync(path, contents, cb);
+    }
+    throw {message : 'impossible de créer le repertoire '+p};
+  }