@fto-consult/expo-ui 3.6.1 → 4.0.1

package/electron/createDir.js

@@ -1,14 +1,30 @@
 const getDirName = require('path').dirname;
 const fs = require("fs");
-module.exports = function createDir(path) {
+module.exports = function createDir(path,cb) {
     if(!path || typeof path !='string') return false;
     const p = getDirName(path);
     if(!fs.existsSync(p)){
        try {
           fs.mkdirSync(p,{ recursive: true});
        } catch(e){
-         console.log(e," making write file directory")
+          if (e.code === 'EEXIST') { // p already exists!
+            return p;
+          }
+          // To avoid `EISDIR` error on Mac and `EACCES`-->`ENOENT` and `EPERM` on Windows.
+          if (e.code === 'ENOENT') { // Throw the original parentDir error on curDir `ENOENT` failure.
+            throw new Error(`EACCES: permission denied, mkdir '${path.resolve(p,"..")}'`);
+          } else {
+            console.log(e," making write file directory")
+          }
+          /*const caughtErr = ['EACCES', 'EPERM', 'EISDIR'].indexOf(e.code) > -1;
+          if (!caughtErr || caughtErr && curDir === path.resolve(targetDir)) {
+            throw err; // Throw if it's just the last created dir.
+          }*/
        }
     }
-    return fs.existsSync(p);
+    const ex = fs.existsSync(p);
+    if(ex && typeof cb =='function'){
+      cb(p);
+    }
+    return ex ? p : false;
 }

package/electron/createDirSync.js

@@ -0,0 +1,31 @@
+const path = require("path");
+const getDirName = require('path').dirname;
+const fs = require("fs");
+module.exports = 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);
+}

package/electron/exec.js

@@ -31,7 +31,7 @@ const loaderTimer = function(timout) {
     var P = ["\\", "|", "/", "-"];
     var x = 0;
     return setInterval(function() {
-      process.stdout.write("\r"+text+" "+P[x++]);
+      process.stdout.write("\r "+text+P[x++]);
       x &= 3;
     }, timout);
   };

package/electron/index.js

@@ -1,13 +1,23 @@
 const {app, BrowserWindow,Tray,Menu,MenuItem,systemPreferences,powerMonitor,dialog, nativeTheme} = require('electron')
-const appConfig  = {}//require("../src/app/config");
-const session = require("./src/session");
+const appConfig  = {}//require("../app/config");
+const session = require("./session");
 const path = require("path");
+const fs = require("fs");
+const ePath = path.resolve(__dirname);
+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 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
+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;
-let fs = require("fs");
 const isWindow = process.platform =="win32",
 isMac = process.platform =='darwin',
 isLinux = process.platform =="linux";
@@ -75,10 +85,11 @@ function createBrowserWindow (options){
   let menu = options.menu;
   options.webPreferences = isObj(options.webPreferences)? options.webPreferences : {}
   options.webPreferences = {
+    sandbox: false,
     ...options.webPreferences,
+    contextIsolation: true,
     devTools: typeof options.webPreferences.devTools === 'boolean'? options.webPreferences.devTools : false,
     icon,
-    contextIsolation: false,
     webSecurity : true,
     autoHideMenuBar: true,
     allowRunningInsecureContent: false,
@@ -103,6 +114,9 @@ function createBrowserWindow (options){
   if(showOnLoad){
      options.show = false;
   }
+  if(mainProcess && typeof mainProcess.beforeCreateWindow =='function'){
+     mainProcess.beforeCreateWindow(options);
+  }
   let _win = new BrowserWindow(options);
   if(!menu){
       _win.setMenu(null);
@@ -124,14 +138,13 @@ function createBrowserWindow (options){
   });
   return _win;
 }
-
-
+const args = require("./parseArgs")();
 function createWindow () {
   // Créer le browser window
   win = createBrowserWindow({
     showOnLoad : false,
     loadURL : undefined,
-    //preload : path.resolve(__dirname,'src/preload.js'),
+    preload : path.resolve(__dirname,'preload.js'),
     webPreferences : {
       devTools : true,
     }
@@ -142,7 +155,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}/splash/index.html?copyRight=${copyRight}`);
   let hasInitWindows = false;
   win.on('show', () => {
     //win.blur();
@@ -183,7 +196,11 @@ function createWindow () {
         win.webContents.send('before-app-exit');
       }
   });
-  win.loadFile(path.resolve(path.join(__dirname,"dist",'index.html')))
+  if(args.url){
+    win.loadURL(args.url);
+  } else {
+    win.loadFile(path.resolve(path.join(__dirname,"dist",'index.html')))
+  }
 
   win.on('unresponsive', async () => {
     const { response } = await dialog.showMessageBox({
@@ -446,14 +463,25 @@ ipcMain.handle("electron-show-save-dialog",function(event,options){
   }
   return dialog.showSaveDialog(win,options)
 })
+ipcMain.on("electron-is-dev-tools-open",function(event,value) {
+  if(win !==null && win.webContents){
+    return win.webContents.isDevToolsOpened();
+  }
+  return false;
+})
 ipcMain.on("electron-toggle-dev-tools",function(event,value) {
   if(win !==null && win.webContents){
-    if(value){
-        if(!win.webContents.isDevToolsOpened()) win.webContents.openDevTools();
+    const isOpen= win.webContents.isDevToolsOpened();
+    value = value === undefined ? !isOpen : value;
+    if(value && !isOpen){
+        win.webContents.openDevTools();
+        return win.webContents.isDevToolsOpened();
     } else {
-        if(win.webContents.isDevToolsOpened()) win.webContents.closeDevTools();
+        if(isOpen) win.webContents.closeDevTools();
     }
+    return win.webContents.isDevToolsOpened();
   }
+  return false;
 })
 
 ipcMain.on("electron-window-set-progressbar",(event,interval)=>{

package/electron/package.app.json

@@ -0,0 +1,44 @@
+{
+  "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": "npx ./expo-ui start electron",
+    "build-android": "eas build --clear-cache -p android --profile preview",
+    "delete-node-modules": "rimraf ./**/node_modules"
+  },
+  "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": "./",
+  "dependencies": {
+    "@fto-consult/expo-ui": "^3.2.0",
+    "react-native": "0.70.5"
+  },
+  "devDependencies": {
+    "@babel/plugin-proposal-export-namespace-from": "^7.18.9",
+    "@babel/preset-react": "^7.18.6",
+    "@expo/metro-config": "^0.5.2",
+    "@expo/webpack-config": "^0.17.3",
+    "babel-plugin-inline-dotenv": "^1.7.0",
+    "babel-plugin-module-resolver": "^4.1.0",
+    "babel-plugin-transform-inline-environment-variables": "^0.4.4"
+  }
+}

package/{bin → electron}/parseArgs.js

@@ -1,10 +1,13 @@
 module.exports = (argv,supportedScript)=>{
+    if(!Array.isArray(argv)) {
+      argv = process.argv.slice(2);
+    }
     const args = {};
-    if(!Array.isArray(argv) || !supportedScript || typeof supportedScript !=='object') return {};
+    supportedScript = typeof supportedScript =='object' && supportedScript || null;
     argv.map(arg=>{
       if(!arg || typeof arg != 'string') return;
       arg = arg.trim();
-      if(arg in supportedScript){
+      if(supportedScript && arg in supportedScript){
          args.script = arg;
       } else if(arg.includes("=")){
           const split = arg.split("=");

package/electron/{src/pload.js → pload.js}

@@ -1,13 +1,16 @@
-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");
+const { machineIdSync} = require('node-machine-id');
+const fs = require("fs");
+const path = require("path");
+module.exports = (ELECTRON,paths)=>{
+    const isWin = process.platform === "win32"? true : false;
+    const isLinux = process.platform === "linux"? true : false;
+    const {ipcRenderer} = require("electron");
+    const os = require("os");
     let totalRAM = os.totalmem();
     if(typeof totalRAM !=="number"){
         totalRAM = 0;
     }
-    let getMem = (unit,key)=>{
+    const getMem = (unit,key)=>{
         let memory = 0;
         if(typeof os[key] =="function"){
             memory = os[key]();
@@ -27,7 +30,7 @@ module.exports = (ELECTRON)=>{
         }
         return memory;
     }
-    APP.extend(ELECTRON,{
+    const ext = {
         toggleDevTools : (value)=>{
             ipcRenderer.send("electron-toggle-dev-tools",defaultBool(value,true));
         },
@@ -76,22 +79,32 @@ module.exports = (ELECTRON)=>{
             'download-progress',
             'update-downloaded'
         ],
-    })
-    const username = require('username');
-    let { machineIdSync} = require('node-machine-id');
+    };
+    for(var i in ext){
+        ELECTRON[i] = ext[i];
+    }
     if(process.env && typeof process.env =="object"){
-        let logName = process.env["LOGNAME"] || process.env["USER"];
+        const logName = process.env["LOGNAME"] || process.env["USER"];
         if(logName && typeof logName =="string"){
             ELECTRON.DEVICE.computerUserName = logName;
         }
     }
-    let uuid = machineIdSync({original: true});
+    const 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;
-        }
-    });
+     
+    ELECTRON.DEVICE.computerUserName = process.env.SUDO_USER ||
+        process.env.C9_USER ||
+        process.env.LOGNAME ||
+        process.env.USER ||
+        process.env.LNAME ||
+        process.env.USERNAME || '';
+    
+    const projectRoot = (paths || {}).projectRoot;
+    const electronProjectRoot = projectRoot && fs.existsSync(path.resolve(projectRoot,"electron")) && path.resolve(projectRoot,"electron") || null;
+    const rendererProcessIndex = electronProjectRoot && fs.existsSync(path.resolve(electronProjectRoot,"renderer.process.js")) && path.resolve(electronProjectRoot,"renderer.process.js");
+    //pour étendre les fonctionnalités au niveau du renderer proceess, bien vouloir écrire dans le fichier projectRoot/electron/renderer.process.js
+    // dans lequel exporter une fonction prenant en paramètre l'objet electron, que l'on peut étendre et le rendre accessible depuis l'application
+    const rendererProcess = rendererProcessIndex && require(`${rendererProcessIndex}`);    
+   (typeof rendererProcess ==='function') && rendererProcess(ELECTRON);
    return ELECTRON;
 }

package/electron/postMessage.js

@@ -0,0 +1,19 @@
+/****
+ * envoie un message au client à travers la fonction postMessage de window, le message envoyé sera de la forme : 
+ * {
+ *   message : ELECTRON_MESSAGE/{message en question},
+ *   callback : {function}, la fonction de rappel
+ *   params : {array}, les paramètres supplémentaires à la fonction
+ * }
+ * @param message {string|object} le message à envoyer au client web
+ * @param [...params], le reste des paramètres
+ */
+module.exports = function(message,...params){
+    message = typeof message =='string' ? {message} : message;
+    const opts = message && typeof message =='object' && !Array.isArray(message) ? message : {};
+    message = opts.message;
+    if(!message || typeof message !='string') return null;
+    opts.params = Array.isArray(opts.params) && opts.params || Array.isArray(params) &&  params || [];
+    opts.message = "ELECTRON_MESSAGE/"+message.trim();
+    return window.postMessage(opts);
+}

package/electron/preload.js

@@ -0,0 +1,333 @@
+const createDir = require("./createDir");
+const postMessage = require("./postMessage");
+const { contextBridge, ipcRenderer, shell } = require('electron')
+const appInstance = require("./app/instance");
+const path = require("path");
+const fs = require("fs");
+const isObj = x=>x && typeof x =='object' && !Array.isArray(x);
+const isNonNullString = x=>x && typeof x =='string';
+const ePath = path.resolve(__dirname);
+const packagePath = path.resolve(ePath,"package.app.json");
+if(!fs.existsSync(packagePath)){
+    throw {message : "Chemin du fichier "+packagePath+ " introuvable"};
+}
+const _app = require(`${packagePath}`);
+if(!_app || typeof _app !=='object' || typeof _app.name !=='string'){
+    throw {message : "Contenu du fichier "+packagePath+" invalide!! Veuillez spécifier un nom valide d'application, propriété <<name>> dudit fichier"}
+}
+const paths = require("./paths.json");
+const projectRoot = paths.projectRoot || '';
+const APP_NAME = _app.name.trim().toUpperCase();
+let backupPathField = "_e_backupDataPath";
+let cBackupPathField = "company"+backupPathField;
+let dbPathField = "_electron_DBPathField";
+const getPath = function(pathName){
+    if(typeof pathName !=='string' || !pathName) return;
+    return ipcRenderer.sendSync("electron-get-path",pathName);
+}
+const APP_PATH = path.join(getPath("appData"),APP_NAME).toLowerCase();
+let databasePath = path.join(APP_PATH,"databases");
+let ROOT_APP_FOLDER = undefined;
+const separator = (path.sep)
+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);
+    })();
+}
+const Config = require('./config');
+let confPath = process.env.ProgramData || process.env.ALLUSERSPROFILE;
+if(confPath && typeof confPath =="string"){
+    if(fs.existsSync(confPath)){
+        confPath = path.join(confPath,APP_NAME);
+        if(createDir(confPath)){
+            ROOT_APP_FOLDER = confPath;
+            databasePath = path.join(confPath,"databases");
+            createDir(databasePath);
+            confPath = path.join(confPath,"CONFIG");
+            createDir(confPath);
+        }
+    } else confPath = undefined;
+} else confPath = undefined;
+const config = new Config({cwd:confPath});
+
+const getDatabasePath = ()=>{
+    const p = config.get(dbPathField);
+    if(fs.existsSync(p)){
+        databasePath = p
+    }
+    if(!fs.existsSync(databasePath)){
+        createDir(databasePath);
+    }
+    return databasePath;
+}
+const setDatabasePath =  (newPath)=>{
+    config.set(dbPathField,newPath)
+};
+const setBackupPath = (newPath)=>{
+    newPath = typeof newPath =='string' && newPath || typeof ROOT_APP_FOLDER =='string' && ROOT_APP_FOLDER || path.join(getPath("documents"),APP_NAME);
+    ELECTRON.APP_BACKUP_PATH = newPath;
+    config.set(cBackupPathField,ELECTRON.APP_BACKUP_PATH)
+};
+const APPRef = {
+    current : null,
+};
+///invoke event name
+const ipcInvoke = async (eventName, ...params)=> {
+    return await ipcRenderer.invoke(eventName, ...params);
+}
+const validChannels = ["toMain", "myRenderChannel"];
+const removeListener =  (channel, callback) => {
+    if (isNonNullString(channel) /*&& validChannels.includes(channel)*/) {
+        ipcRenderer.removeListener(channel, callback);
+    }
+}, removeAllListeners = (channel) => {
+    if (isNonNullString(channel) /*&& validChannels.includes(channel)*/) {
+        ipcRenderer.removeAllListeners(channel)
+    }    
+};
+const ELECTRON = {
+    get getPouchdb(){
+        return (PouchDB,sqlPouch)=> {
+            window.sqlitePlugin = {openDatabase:require('websql')};
+            PouchDB.plugin(function CapacitorSqlitePlugin (PouchDB) {
+                PouchDB.adapter('node-sqlite', sqlPouch(), true)
+            });
+            return {adapter:"node-sqlite"};
+        };
+    },
+    get getBackupPath(){
+        return (p)=>{
+            const eePath = config.get(cBackupPathField);
+            const defPath  = ROOT_APP_FOLDER || path.join(getPath("documents"),APP_NAME);
+            ELECTRON.APP_BACKUP_PATH = typeof eePath =='string' && eePath || typeof defPath =='string' && defPath || '';
+            if(!fs.existsSync(ELECTRON.APP_BACKUP_PATH)){
+                ELECTRON.APP_BACKUP_PATH = defPath;
+            }
+            if(p && typeof (p) ==='string'){
+                return path.join(ELECTRON.APP_BACKUP_PATH,p);
+            }
+            return ELECTRON.APP_BACKUP_PATH;
+        };
+    },
+    get databasePath (){
+        return getDatabasePath();
+    },
+    get getDatabasePath(){
+        return getDatabasePath;
+    },
+    set databasePath(dPath){
+        return setDatabasePath(dPath);
+    },
+    get setDatabasePath (){
+        return setDatabasePath;
+    },
+    set backupPath (backupPath){
+        return setBackupPath(backupPath);
+    },
+    get setBackupPath (){
+        return setBackupPath;
+    } ,
+    get CONFIG (){
+        return config;
+    },
+    get showOpenDialog(){
+       return (options)=>{
+        options = typeof options =='object' && options && !Array.isArray(options)? options : {};
+        return ipcRenderer.invoke("electron-show-open-dialog",options);
+       }
+    },
+    get showSaveDialog(){
+        return (options)=>{
+            options = typeof options =='object' && options && !Array.isArray(options)? options : {};
+            return ipcRenderer.invoke("electron-show-save-dialog",options);
+        };
+    },
+    get restartApp(){
+        return ()=>{
+            ipcRenderer.sendSync("electron-restart-app")
+        };
+    },
+    get is() {
+        return true;
+    },
+    get APP_PATH(){
+        return APP_PATH;
+    },
+    get initializeAPPInstance(){
+        return ({APP,notify})=>{
+            ELECTRON.notify = notify;
+            ELECTRON.APP  = APP;
+       }
+    },
+    get PATH (){
+        return {
+            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.
+        }
+    },
+    ///retourne le chemin dont la chaine de caractère est passé en paramètre
+    get getPath(){
+        return getPath;
+    },
+    get updateSystemTheme(){
+        return  (theme)=>{
+            return ipcRenderer.invoke("electron-set-system-theme:toggle",theme);
+        };
+    },
+    get SESSION (){
+        return  {
+            set : (key,value) =>{
+                return config.set(key,value);
+            },
+            get : (key) =>{
+                return config.get(key);
+            }
+        };
+    },
+    get on (){
+        return (eventName, callback)=> {
+            console.log(eventName," is evname eee",callback);
+            return ipcRenderer.on(eventName, callback)
+        };
+    },
+    get  shellOpenExternal(){
+        return async  (url)=> {
+            await shell.openExternal(url)
+        } 
+    },
+    get shellOpenPath(){
+        return async (file)=> {
+            await shell.openPath(file)
+        };
+    },
+    get shellTrashItem(){
+        return async (file)=> {
+            await shell.trashItem(file)
+        };
+    },
+    get trigger (){
+        return (channel, ...data) => {
+            if (isNonNullString(channel) /*&& validChannels.includes(channel)*/) {
+                ipcRenderer.send(channel);
+            }
+        };
+    },
+    get on (){
+        return (channel, callback) => {
+            if (isNonNullString(channel) /*&& validChannels.includes(channel)*/) {
+                // Filtering the event param from ipcRenderer
+                const newCallback = (_, data) => callback(data);
+                ipcRenderer.on(channel, newCallback);
+            }
+        };
+    },
+    get once (){
+        return (channel, callback) => { 
+            if (isNonNullString(channel) /*&& validChannels.includes(channel)*/) {
+                const newCallback = (_, data) => callback(data);
+                ipcRenderer.once(channel, newCallback);
+            }
+        };
+    },
+    get removeListener(){
+        return removeListener;
+    },
+    get removeAllListeners(){
+        return removeAllListeners;
+    },
+    get off (){
+        return removeListener;
+    },
+    get offAll(){
+        return removeAllListeners;
+    },
+    get version(){
+        return process.versions.electron;
+    },
+    get isWindowsStore(){
+        return process.windowsStore;
+    },
+    get versions(){
+        return {
+            node: () => process.versions.node,
+            chrome: () => process.versions.chrome,
+            electron: () => process.versions.electron,
+        };
+    },
+    /****@see : https://www.electronjs.org/docs/latest/tutorial/ipc */
+    get openFile(){
+        return () => ipcRenderer.invoke('dialog:openFile');
+    },
+    get ping(){
+        return () => ipcRenderer.invoke('ping');
+    },
+    get exitApp (){
+        return x=>ipcRenderer.send("close-main-render-process");
+    },
+    get onGetAppInstance(){
+        return (APP)=>{
+            appInstance.set(APP);
+        }
+    },
+    get toggleDevTools(){
+        return async (toggle)=>{
+            return await ipcRenderer.send("electron-toggle-dev-tools",toggle);
+        }
+    } 
+};
+
+require("./pload")(ELECTRON,paths || {});
+ELECTRON.getBackupPath();
+//require("./app/index")(ELECTRON)
+//require('v8-compile-cache');
+//require("v8").setFlagsFromString('--expose_gc'); 
+
+ipcRenderer.on('before-app-exit', () => {
+    return postMessage("BEFORE_EXIT");
+});
+
+ipcRenderer.on("main-app-suspended",()=>{
+    postMessage({
+        message : "STOP_IDLE",
+    });
+})
+ipcRenderer.on("main-app-restaured",()=>{
+    postMessage({
+        message : "TRACK_IDLE",
+    });
+});
+ipcRenderer.on('appReady',()=>{})
+ipcRenderer.on("main-window-focus",()=>{
+    postMessage("WINDOW_FOCUS");
+})
+ipcRenderer.on("main-window-blur",()=>{
+    postMessage("WINDOW_BLUR");
+});
+
+process.once('loaded', () => {
+    contextBridge.exposeInMainWorld('isElectron',true);
+    contextBridge.exposeInMainWorld('ELECTRON',ELECTRON);
+})