@fto-consult/expo-ui 7.5.10 → 7.5.12

package/bin/index.js

@@ -182,20 +182,10 @@ program.command('electron')
               });
                 
             } else {
-              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"));
-              platform = platform || process.platform;
-              console.log("packaing app from ",electronProjectRoot);
-              return require("./package")({
-                  src : electronProjectRoot,
-                  dist : path.resolve(outDir,platform),
-                  platform,
-                  arch : arch || undefined,
-                  projectRoot : electronProjectRoot,
-             });
+              cmd = `npx electron-forge package ${platform? `--platform="${platform}"`:""} ${arch?`--arch="${arch}"`:""}`;
+              return exec({cmd,projectRoot:electronProjectRoot}).then(()=>{
+                console.log("application package avec succèss");
+              });
             }
            break;
       }

package/bin/init.js

@@ -31,6 +31,7 @@ module.exports = ({projectRoot,electronProjectRoot,paths,pathsJSON})=>{
             "start" : `npx ${mainPackageName} electron start`,
             "run-dev" : `npx ${mainPackageName} electron start`,
             "compile2start" : `npx ${mainPackageName} electron start --build`,
+            ...Object.assign({},electronPackageJSON.scripts)
         }
         projectRootPackage.name = projectRootPackage.name;
         projectRootPackage.realAppName = typeof projectRootPackage.realAppName =="string" && projectRootPackage.realAppName || projectRootPackage.name;

package/electron/index.js

@@ -3,7 +3,6 @@ const session = require("./utils/session");
 const path = require("path");
 const fs = require("fs");
 const { program } = require('commander');
-const getPaths = require("../electron/utils/paths");
 
 program
   .option('-u, --url <url>', 'L\'adresse url à ouvrir au lancement de l\'application')
@@ -12,26 +11,12 @@ program
   .parse();
 
 const programOptions = program.opts();
-const {url:pUrl,paths:pathsJSON,root:mainProjectRoot} = programOptions
-const cPaths = path.resolve("./paths.json");
-const pathsJ = pathsJSON && fs.existsSync(pathsJSON) && pathsJSON.endsWith("paths.json")? pathsJSON  : null;
-let paths = pathsJ ? require(`${pathsJ}`) : fs.existsSync(cPaths) ? require(cPaths) : '';
-const projectRoot = mainProjectRoot && fs.existsSync(mainProjectRoot) ? mainProjectRoot : paths.projectRoot || process.cwd();
+const {url:pUrl,root:mainProjectRoot} = programOptions
+const projectRoot = mainProjectRoot && fs.existsSync(mainProjectRoot) ? mainProjectRoot : process.cwd();
 const electronProjectRoot = projectRoot && fs.existsSync(path.resolve(projectRoot,"electron")) && path.resolve(projectRoot,"electron") || '';
-const ePathsJSON = path.resolve(electronProjectRoot,"paths.json");
 const packageJSONPath = path.resolve(projectRoot,"package.json");
 const isValidUrl = require("./utils/isValidUrl");
 const packageJSON = fs.existsSync(packageJSONPath) ? require(`${packageJSONPath}`) : {};
-const eePaths = path.resolve(getPaths(projectRoot));
-if(!paths){
-  if(fs.existsSync(ePathsJSON)){
-    paths = require(ePathsJSON);
-  } else if(fs.existsSync(eePaths)){
-    path = require(eePaths);
-  } else {
-    throw {message : 'Chemin de noms, fichier paths.json introuvable!! Exécutez l\'application en enviornnement web|mobile|android|ios puis re-essayez'}
-  }
-}
 
 const mainProcessPath = path.resolve('processes',"main","index.js");
 const mainProcessIndex = electronProjectRoot && fs.existsSync(path.resolve(electronProjectRoot,mainProcessPath)) && path.resolve(electronProjectRoot,mainProcessPath);
@@ -369,7 +354,7 @@ ipcMain.on("get-project-root",(event)=>{
   event.returnValue  = projectRoot;
   return projectRoot;
 });
-ipcMain.on("get-project-root",(event)=>{
+ipcMain.on("get-electron-project-root",(event)=>{
   event.returnValue = electronProjectRoot;
   return event.returnValue ;
 });
@@ -379,11 +364,6 @@ ipcMain.on("get-package.json",(event)=>{
   return event.returnValue ;
 });
 
-ipcMain.on("get-paths.json",(event)=>{
-  event.returnValue = JSON.stringify(paths);
-  return event.returnValue ;
-});
-
 ipcMain.on("get-app-name",(event)=>{
   event.returnValue = packageJSON.realAppName || packageJSON.name;
   return event.returnValue ;

package/electron/pload.js

@@ -1,7 +1,7 @@
 const { machineIdSync} = require('node-machine-id');
 const fs = require("fs");
 const path = require("path");
-module.exports = (ELECTRON,paths)=>{
+module.exports = (ELECTRON,{projectRoot,electronProjectRoot})=>{
     const isWin = process.platform === "win32"? true : false;
     const isLinux = process.platform === "linux"? true : false;
     const {ipcRenderer} = require("electron");
@@ -78,8 +78,6 @@ module.exports = (ELECTRON,paths)=>{
         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 mainRendererPath = path.resolve('processes',"renderer","index.js");
     const rendererProcessIndex = electronProjectRoot && fs.existsSync(path.resolve(electronProjectRoot,mainRendererPath)) && path.resolve(electronProjectRoot,mainRendererPath);
     //pour étendre les fonctionnalités au niveau du renderer proceess, bien vouloir écrire dans le fichier projectRoot/electron/processes/renderer/index.js

package/electron/preload.js

@@ -7,10 +7,9 @@ const fs = require("fs");
 const isDataURL = require("./utils/isDataURL");
 const isBase64 = require("./utils/isBase64");
 const isNonNullString = x=>x && typeof x =='string';
-const replaceAll = require("./utils/replaceAll");
-const pathsStr = ipcRenderer.sendSync("get-paths.json");
-const paths = typeof pathsStr ==='string' && pathsStr ? JSON.parse(pathsStr) : {};
+require("./utils/replaceAll");
 const appName = ipcRenderer.sendSync("get-app-name");
+const electronProjectRoot = ipcRenderer.sendSync("get-electron-project-root");
 const sanitize = require("sanitize-filename");
 const uniqid = require("./utils/uniqid");
 if(!appName || typeof appName !=='string'){
@@ -422,7 +421,7 @@ const ELECTRON = {
     },
 };
 
-require("./pload")(ELECTRON,paths || {});
+require("./pload")(ELECTRON,{electronProjectRoot});
 ELECTRON.getBackupPath();
 //require("./app/index")(ELECTRON)
 //require('v8-compile-cache');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fto-consult/expo-ui",
-  "version": "7.5.10",
+  "version": "7.5.12",
   "description": "Bibliothèque de composants UI Expo,react-native",
   "scripts": {
     "clear-npx-cache": "npx clear-npx-cache",

package/bin/index copy.js

@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-
-/**
-  toujours ajouter l'instruction ci-dessus à la première ligne de chaque script npx
-  @see : https://blog.shahednasser.com/how-to-create-a-npx-tool/ 
-  @see : https://www.npmjs.com/package/commander, for command parsing
-*/
-'use strict';
-process.on('unhandledRejection', err => {
-  throw err;
-});
-const createAppScript = "create-app";
-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
-  "generate-getTable" : true,/// script pour la génération de la fonction getTable des tables de l'application
-  [createAppScript] : true,//les script de création de l'application
-}
-const  {createDir,electronDir,copy,exec,throwError} = require("./utils");
-const path= require("path");
-const fs = require("fs");
-const dir = path.resolve(__dirname);
-const projectRoot = path.resolve(process.cwd());
-const parsedArgs = require("../electron/utils/parseArgs")(null,supportedScript);
-parsedArgs.script = typeof parsedArgs.script =='string' && parsedArgs.script && parsedArgs.script.toLowerCase().trim() || "";
-if(!parsedArgs.script || !(parsedArgs.script in supportedScript)){
-   throwError("Erreur : script invalide, vous devez spécifier script figurant parmi les script : ["+Object.keys(supportedScript).join(", ")+"]");
-}
-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] 
- *        splash=[path-to-splashcreen-relative-to-project-root] 
- *        output-dir|out = [path-to-output-dir-relative-to-root-project]
- *        url = [url-to-start-electron-to]
- * */
-if(parsedArgs.electron){
-  if(projectRoot == dir){
-      throwError(`Invalid project root ${projectRoot}; project root must be different to ${dir}`);
-  }
-  const pathsJSON = path.resolve(electronDir,"paths.json");
-  if(!fs.existsSync(pathsJSON)){
-    throwError("Le fichier des chemins d'accès à l'application est innexistant, rassurez vous de tester l'application en environnement web, via la cmde <npx expo start>, avant l'exécution du script electron.");
-  }
-  const paths = require(`${pathsJSON}`);
-  if(typeof paths !=='object' || !paths || !paths.projectRoot){
-      throwError("Fichiers des chemins d'application invalide!!! merci d'exécuter l'application en environnement web|android|ios puis réessayez");
-  }
-  /**** 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){
-     throwError(`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);
-  process.env.isElectron = true;
-  process.env.isElectronScript = true;
-  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(electronProjectRoot,"bin")
-  if(!createDir(outDir)){
-      throwError("Impossible de créer le répertoire <<"+outDir+">> du fichier binaire!!");
-  }
-  const logoPath = paths.logo || paths.$assets && path.resolve(paths.$assets,"logo.png") || paths.$images && path.resolve(paths.$images,"logo.png");
-  if(!logoPath || !fs.existsSync(logoPath)){
-     if(logoPath){
-      console.warn("Logo de l'application innexistant!! Vous devez spécifier le logo de votre application, fichier ["+(logoPath)+"]")
-    }
-  }
-  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 "+electronProjectRoot+" url="+url;
-        exec({
-          cmd, 
-          projectRoot : electronProjectRoot,
-        }).finally(()=>{
-          console.log("ant to exit");
-        })
-        typeof (resolve) =='function' && setTimeout(resolve,1000);
-    })
-  };
-  if(url){
-    return start().then(process.exit);
-  }
-  const promise = new Promise((resolve,reject)=>{
-    const next = ()=>{
-        if(fs.existsSync(webBuildDir)){
-            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);
-      }
-      next();
-  });
-  return promise.then(()=>{
-    if(!fs.existsSync(buildOutDir) || !fs.existsSync(indexFile)){
-       throwError("répertoire d'export web invalide où innexistant ["+buildOutDir+"]");
-    }
-    switch(parsedArgs.script){
-        case "start":
-           return start();
-          break;
-        case "build":
-          break;
-        case "generate-getTable" : 
-          require("./generate-tables")();
-          break;
-        default :
-          if(!fs.existsSync(packagePath)){
-              throwError("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");
-  }).finally(()=>{
-    process.exit();
-  });
-} else {
-  if(script ===createAppScript || script ==="init"){
-    return require("./create-app")(parsedArgs,{projectRoot});
-  }
-  process.exit();
-}

package/bin/package.js

@@ -1,60 +0,0 @@
-const getIcon = require("../electron/utils/getIcon");
-const path = require("path");
-const path = require("../electron/utils/paths");
-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);
-    })
-}