@fto-consult/expo-ui 1.0.9 → 1.0.10

package/edit-json-file.js

@@ -0,0 +1,41 @@
+/*** met à jour dynamiquement la version de l'application */
+const jsonfile = require('jsonfile');
+const fs = require('fs')
+
+function recursiveUpdate(initial, update,recursiveArray){
+  initial = initial && typeof initial == 'object'? initial : {};
+  for(prop in update){
+      if({}.hasOwnProperty.call(update, prop)){
+          if(update[prop] && typeof update[prop] === 'object'){
+              if(Array.isArray(update[prop]) && recursiveArray !==false){
+                initial[prop] = update[prop];
+              } else {
+                recursiveUpdate(initial[prop], update[prop],recursiveArray);
+              }
+          } else if(typeof update[prop] == 'string' && update[prop] ) {
+              initial[prop] = update[prop].toString().replace(/\+/g, ' ');
+          }
+      }
+  }
+  return initial;
+}
+
+function  editJsonFile(packagePath,config){
+  if(!fs.existsSync(packagePath)) return;
+  try {
+      let packaged = jsonfile.readFileSync(packagePath);
+      if(!config || typeof config != 'object') return false;
+      recursiveUpdate(packaged,config);
+      jsonfile.writeFileSync(packagePath, packaged, {spaces: 4})
+      return true;
+  }
+  catch (e) {
+      process.stdout.write('An exception occurred:\n')
+      process.stdout.write('    ' + e.message)
+      process.stdout.write('\n')
+      process.exit(1)
+  }
+}
+
+
+module.exports = editJsonFile;

package/electron/index.js

@@ -0,0 +1,449 @@
+const {app, BrowserWindow,Tray,Menu,MenuItem,systemPreferences,powerMonitor,dialog, nativeTheme} = require('electron')
+let appConfig  = require("../src/app/config");
+let appReady = false;
+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;
+let fs = require("fs");
+let icon = undefined;
+const imagesPath = path.join(__dirname,"assets/images")
+if(process.platform =="win32" && fs.existsSync(path.join(imagesPath, "icon.ico"))){
+   icon = path.join(imagesPath, "icon.ico");
+} else if(process.platform =="linux" && fs.existsSync(path.join(imagesPath, "icon.png"))){
+   icon = path.join(imagesPath, "icon.png");
+} else if(process.platform =='darwin' && fs.existsSync(path.join(imagesPath, "icon.incs"))){
+  icon = path.join(imagesPath, "icon.incs");
+}
+
+Menu.setApplicationMenu(null);
+let clipboadContextMenu = (_, props) => {
+  if (props.isEditable || props.selectionText) {
+    const menu = new Menu();
+    if(props.selectionText){
+      menu.append(new MenuItem({ label: 'Copier', role: 'copy' }));
+      if(props.isEditable){
+         menu.append(new MenuItem({ label: 'Couper', role: 'cut' }));
+      }
+    }
+    if(props.isEditable){
+      menu.append(new MenuItem({ label: 'Coller', role: 'paste' }));
+    }
+    menu.popup();
+  } 
+};
+
+let Conf = require('./src/config');
+let session = new Conf({cwd:app.getPath('userData')});
+
+const setOSTheme = (theme) => {
+  theme = theme && typeof theme == "string"? theme : "light";
+  theme = theme.toLowerCase().trim();
+  if(theme !== 'system' && theme !=='dark'){
+    theme = "light";
+  }
+  nativeTheme.themeSource = theme;
+  session.set("electron-os-theme",theme);
+  return nativeTheme.shouldUseDarkColors
+}
+setOSTheme(session.get("electron-os-theme"));
+let isObj = x => x && typeof x =='object';
+function createBrowserWindow (options){
+  options = options && typeof options =='object'? options : {};
+  let menu = options.menu;
+  options.webPreferences = isObj(options.webPreferences)? options.webPreferences : {}
+  options.webPreferences = {
+    ...options.webPreferences,
+    devTools: typeof options.webPreferences.devTools === 'boolean'? options.webPreferences.devTools : false,
+    icon,
+    contextIsolation: false,
+    webSecurity : true,
+    autoHideMenuBar: true,
+    allowRunningInsecureContent: false,
+    nodeIntegration: false,
+    preload: options.preload ? options.preload : null,
+    plugin:false,
+    contentSecurityPolicy: `
+        default-src 'none';
+        script-src 'self';
+        img-src 'self' data:;
+        style-src 'self';
+        font-src 'self';
+      `
+  }
+  if(options.modal && !options.parent && win){
+    options.parent = win;
+  }
+  if(typeof options.show ==='undefined'){
+    options.show = false;
+  }
+  let showOnLoad = options.showOnLoad ===true ? true : undefined;
+  if(showOnLoad){
+     options.show = false;
+  }
+  let _win = new BrowserWindow(options);
+  if(!menu){
+      _win.setMenu(null);
+      _win.removeMenu();
+      _win.setMenuBarVisibility(false)
+      _win.setAutoHideMenuBar(true)
+  }
+  let url = options.loadURL && typeof options.loadURL ==='string'? options.loadURL : undefined;
+  if(url){
+    _win.loadURL(url);
+  }
+  if(showOnLoad){
+    _win.once('ready-to-show', () => {
+        _win.show();
+    });
+  }
+  _win.on('closed', function() {
+      _win = null;
+  });
+  return _win;
+}
+
+
+function createWindow () {
+  // Créer le browser window
+  win = createBrowserWindow({
+    showOnLoad : false,
+    loadURL : undefined,
+    preload : path.resolve(__dirname,'src/preload.js'),
+    webPreferences : {
+      devTools : true,
+    }
+  });
+  // 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}/src/splash/index.html?copyRight=${copyRight}`);
+  let hasInitWindows = false;
+  win.on('show', () => {
+    //win.blur();
+    setTimeout(() => {
+      win.focus();
+      win.moveTop();
+      win.webContents.focus(); 
+      if(!hasInitWindows){
+        hasInitWindows = true; 
+        win.webContents.send('appReady');
+      } 
+    }, 200);
+  });
+
+  win.on("focus",()=>{
+    if(win && hasInitWindows){
+      win.webContents.send("main-window-focus");
+    }
+  });
+  win.on("blur",()=>{
+    if(win && hasInitWindows){
+      win.webContents.send("main-window-blur");
+    }
+  });
+
+
+  win.once("ready-to-show",function(){
+      win.minimize()
+      if(splash !== null)splash.destroy();
+      splash = null;
+      win.restore();
+      win.show();
+  })    
+ 
+  win.on('close', (e) => {
+      if (win) {
+        e.preventDefault();
+        win.webContents.send('before-app-exit');
+      }
+  });
+  win.loadFile(path.resolve(path.join(__dirname,"dist",'index.html')))
+
+  win.on('unresponsive', async () => {
+    const { response } = await dialog.showMessageBox({
+      title: "L'application a cessé de répondre",
+      message : 'Voulez vous relancer l\'application?',
+      buttons: ['Relancer', 'Arrêter'],
+      cancelId: 1
+    })
+    if (response === 0) {
+      win.forcefullyCrashRenderer()
+      win.reload()
+    } else {
+      win.forcefullyCrashRenderer()
+      app.exit();
+    }
+  })
+
+ // Ouvre les DevTools.
+ win.webContents.openDevTools()
+  
+  // Émit lorsque la fenêtre est fermée.
+  win.on('closed', () => {
+    win = null
+  })
+  win.webContents.on('context-menu',clipboadContextMenu);
+  win.setMenu(null);
+
+  /*** les dimenssions de la fenêtre principale */
+  let mWindowSessinName = "mainWindowSizes";
+  let mWindowPositionSName = mWindowSessinName+"-positions";
+  let sizeW = session.get(mWindowSessinName);
+  if(!sizeW || typeof sizeW !== 'object'){
+    sizeW = {};
+  }
+  let sPositions = session.get(mWindowPositionSName);
+  if(!sPositions || typeof sPositions !=='object'){
+    sPositions = {};
+  }
+  let isNumber = x => typeof x =="number";
+  if(isNumber(sizeW.width) && isNumber(sizeW.height)){
+      win.setSize(sizeW.width,sizeW.height);
+      if(isNumber(sPositions.x) && isNumber(sPositions.y)){
+          win.setPosition(sPositions.x,sPositions.y);
+      }
+  }
+  let onWinResizeEv =  debounce(function () {
+      if(win){
+          let wSize = win.getSize();
+          if(Array.isArray(wSize) && wSize.length == 2){
+              let [width,height] = wSize;
+              if(width && height){
+                  session.set(mWindowSessinName,{width,height});
+              }
+              let [x,y] = win.getPosition();
+              session.set(mWindowPositionSName,{x,y});
+          }
+      }
+  }, 100);
+  win.off('resize',onWinResizeEv);
+  win.on('resize',onWinResizeEv);
+  win.off('move',onWinResizeEv);
+  win.on('move',onWinResizeEv);
+}
+let quit = ()=>{
+  try {
+    app.quit();
+  } catch(e){
+    console.log(e," triing kit app")
+  }
+}
+// Quitte l'application quand toutes les fenêtres sont fermées.
+app.on('window-all-closed', () => {
+  // Sur macOS, il est commun pour une application et leur barre de menu
+  // de rester active tant que l'utilisateur ne quitte pas explicitement avec Cmd + Q
+  if (process.platform !== 'darwin') {
+    quit();
+  }
+})
+
+app.whenReady().then(() => {
+  appReady = true;
+  createWindow();
+  app.on('activate', function () {
+    if (win == null || (BrowserWindow.getAllWindows().length === 0)) createWindow()
+  });
+})
+
+let {ipcMain} = require("electron");
+
+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;
+  var text = json_string;
+  return !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(text.replace(/"(\\.|[^"\\])*"/g, '')));
+}
+ipcMain.on("update-system-tray",(event,opts)=>{
+  opts = opts && typeof opts == 'object'? opts : {};
+  let {contextMenu,tooltip} = opts;
+  if(tray){
+  } else {
+    tray = new Tray(icon? icon : undefined);
+  }        
+  if(!tooltip || typeof tooltip !=="string"){
+      tooltip = ""
+  }
+  tray.setToolTip(tooltip);
+  if(isJSON(contextMenu)){
+      contextMenu = JSON.parse(contextMenu);
+  } 
+  if(Array.isArray(contextMenu) && contextMenu.length) {
+    let tpl = []
+    contextMenu.map((m,index)=>{
+       if(!m || typeof m !=='object') return;
+       m.click = (e)=>{
+         if(win && win.webContents) win.webContents.send("click-on-system-tray-menu-item",{
+            action : m.action && typeof m.action =='string'? m.action : undefined,
+            index,
+            menuItem : JSON.stringify(m),
+         })
+       }
+       tpl.push(m);
+    })
+    contextMenu = Menu.buildFromTemplate(tpl);
+  } else contextMenu = null;
+  tray.setContextMenu(contextMenu) 
+})
+ipcMain.on("electron-get-path",(event,pathName)=>{
+  let p = app.getPath(pathName);
+  event.returnValue = p;
+  return p;
+});
+
+ipcMain.on("electron-get-media-access-status",(event,mediaType)=>{
+  let p = systemPreferences.getMediaAccessStatus(mediaType);
+  event.returnValue = p;
+  return p;
+});
+
+ipcMain.on("electron-ask-for-media-access",(event,mediaType)=>{
+  systemPreferences.askForMediaAccess(mediaType);
+});
+
+ipcMain.on("electron-get-app-icon",(event)=>{
+  event.returnValue = icon;
+  return icon;
+});
+
+ipcMain.on('minimize-main-window', () => {
+  if(win !== null && win){
+     win.blur();
+     win.minimize();
+  }
+})
+ipcMain.on('restore-main-window', () => {
+  if(win && win !== null){
+    win.restore()
+    win.blur();
+    setTimeout(() => {
+      win.focus();
+      win.moveTop();
+      win.webContents.focus();   
+    }, 200);
+  }
+})
+ipcMain.on('close-main-render-process', _ => {
+  if(win){
+    win.destroy();
+  }
+  win = null;
+  if(typeof gc =="function"){
+    gc();
+  }
+  quit();
+});
+
+
+function debounce(func, wait, immediate) {
+  var timeout;
+
+  return function executedFunction() {
+    var context = this;
+    var args = arguments;
+	    
+    var later = function() {
+      timeout = null;
+      if (!immediate) func.apply(context, args);
+    };
+
+    var callNow = immediate && !timeout;
+	
+    clearTimeout(timeout);
+
+    timeout = setTimeout(later, wait);
+	
+    if (callNow) func.apply(context, args);
+  };
+};
+//app.disableHardwareAcceleration();
+
+
+const gotTheLock = app.requestSingleInstanceLock()
+
+if (!gotTheLock) {
+  quit()
+} else {
+  app.on('second-instance', (event, commandLine, workingDirectory) => {
+    // Someone tried to run a second instance, we should focus our window.
+    //pour plus tard il sera possible d'afficher la gestion multi fenêtre en environnement electron
+    if (win) {
+        if (win.isMinimized()) win.restore()
+        win.focus()
+    }
+  })
+}
+
+const powerMonitorCallbackEvent = (action)=>{
+  if(!win || !win.webContents) return;
+  if(action =="suspend" || action =="lock-screen"){
+      win.webContents.send("main-app-suspended",action);
+      return;
+  }
+  win.webContents.send("main-app-restaured",action);
+  win.webContents.focus();  
+  return null;
+}
+if(powerMonitor){
+  ["suspend","resume","lock-screen","unlock-screen"].map((action)=>{
+      powerMonitor.on(action,(event)=>{
+          powerMonitorCallbackEvent(action,event);
+      })
+  })
+}
+ipcMain.on("electron-set-main-window-title",(event,title)=>{
+  if(win !== null){
+      win.setTitle(title);
+  }
+})
+
+
+ipcMain.handle("electron-create-browser-windows",function(event,options){
+  if(!isObj(options)){
+     options = {};
+  }
+  createBrowserWindow(options);
+})
+
+ipcMain.handle("electron-show-open-dialog",function(event,options){
+  if(!isObj(options)){
+     options = {};
+  }
+  return dialog.showOpenDialog(win,options)
+})
+
+ipcMain.handle("electron-show-save-dialog",function(event,options){
+  if(!isObj(options)){
+     options = {};
+  }
+  return dialog.showSaveDialog(win,options)
+})
+ipcMain.on("electron-toggle-dev-tools",function(event,value) {
+  if(win !==null && win.webContents){
+    if(value){
+        if(!win.webContents.isDevToolsOpened()) win.webContents.openDevTools();
+    } else {
+        if(win.webContents.isDevToolsOpened()) win.webContents.closeDevTools();
+    }
+  }
+})
+
+ipcMain.on("electron-window-set-progressbar",(event,interval)=>{
+   if(typeof interval !="number" || interval <0) interval = 0;
+   interval = Math.floor(interval);
+   if(win){
+     win.setProgressBar(interval);
+   }
+})
+
+/**** customisation des thèmes de l'application */
+ipcMain.handle('electron-set-system-theme:toggle', (event,theme) => {
+  return setOSTheme(theme);
+});

package/electron/webpack.config.js

@@ -0,0 +1,45 @@
+const createExpoWebpackConfigAsync = require('@expo/webpack-config');
+const envManager = require("@expo/webpack-config/env");
+const addons = require("@expo/webpack-config/addons");
+const jsonfile = require('jsonfile');
+const path = require("path");
+const mode = 'development';
+const isObj = x => x && typeof x =='object' && !Array.isArray(x);
+/***@see : https://www.npmjs.com/package/@expo/webpack-config */
+module.exports = async function(env, argv) {
+  const projectRoot = process.cwd()
+  const electronPath = path.join(projectRoot,'electron');
+  env = env || {};
+  env.projectRoot = projectRoot;
+  env.platform = "electron";//isObj(env.platform)? env.platform : {};//'web'///electron;
+  //env.platform.type = "electron";
+  env.locations = (0, envManager.getPaths)(projectRoot)
+  env.pwa = false;
+  let config = (0, addons.withAlias)({}, (0, envManager.getAliases)(projectRoot));
+  if(argv && typeof argv =='object' && (argv.mode =='production' || argv.mode =="development")){
+    env.mode = argv.mode;
+  } else {
+      env.mode = mode;
+  }
+  config = await createExpoWebpackConfigAsync(env, argv);
+  config.output = config.output || {};
+  config.output.publicPath = "./";
+  config.output.path = path.join(electronPath,"dist");
+  if (!config.plugins) config.plugins = [];
+  if (!config.resolve) config.resolve = {}; 
+  for(let i in config.plugins){
+      let pl = config.plugins[i];
+      //on recherche le fichier html build de webpack
+      if(pl && typeof pl =='object' && pl.options && typeof pl.options =='object'){
+          if(typeof pl.options.filename =="string" && pl.options.filename.toLowerCase().includes("index.html")){
+               pl.options.filename = path.join(config.output.path,"index.html");
+               break;
+          }
+      }
+  }
+  //console.log(config.resolve.extensions, "is r extensions")
+  config.resolve.extensions = (0, envManager.getModuleFileExtensions)('electron', 'web');
+  //jsonfile.writeFileSync("electron/config.back.json", config, {spaces: 4});
+  console.log("******electron config file generated**********");
+  return config;
+};

package/find-licenses.js

@@ -0,0 +1,71 @@
+const path = require('path');
+const dir = path.resolve(__dirname);
+let filePath = path.resolve(dir,"src/help/openLibraries.js")
+let isObj = x => x && typeof x == 'object';
+const fs = require('fs')
+let openLibraries = {};
+function isValidUrl(str) {
+    if(!str || typeof str !== 'string') return false;
+    var pattern = new RegExp('^(https?:\\/\\/)?'+ // protocol
+      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|'+ // domain name
+      '((\\d{1,3}\\.){3}\\d{1,3}))'+ // OR ip (v4) address
+      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*'+ // port and path
+      '(\\?[;&a-z\\d%_.~+=-]*)?'+ // query string
+      '(\\#[-a-z\\d_]*)?$','i'); // fragment locator
+    return !!pattern.test(str);
+  }
+
+const  loopPackages = (packages,_path)=>{
+    if(!isObj(packages)) return;
+    let p = path.resolve(_path,"node_modules");
+    for(let i in packages){
+        let packagePath = path.resolve(p,i,"package.json");
+        if(fs.existsSync(packagePath)){
+            let package = require(packagePath);
+            if(!isObj(package) || !package.name) return;
+            let op = {};
+            openLibraries[package.name] = op;
+            if(package.version){
+                op.version = package.version;
+            }
+            if(isValidUrl(package.homepage)){
+                op.url = package.homepage
+            } else if(isValidUrl(package.repository)) {
+                op.url = package.repository;
+            } else if(isObj(package.repository) && package.repository.url){
+                op.url = package.repository.url;
+            }
+            if(package.license || package.licence){
+                op.license = typeof package.license =="string"? package.license : typeof package.licence =="string"? package.licence : "";
+            }
+        }
+    }
+}
+
+const findLicences = (_path)=> new Promise((resolve,reject)=>{
+    let pD = path.resolve(_path,"package.json");
+    if(fs.existsSync(pD)){
+        let packages = require(pD);
+        if(isObj(packages)){
+            loopPackages(packages.devDependencies,_path);
+            loopPackages(packages.dependencies,_path);
+        }
+    }
+    resolve(openLibraries);
+})
+const parentPath = require("./parent-package")();
+Promise.all([
+    parentPath ? path.resolve(path.dirname(parentPath)): findLicences(dir),
+]).then(()=>{
+    let s = Object.keys(openLibraries).sort((a,b)=>{
+        if (a.toLowerCase() < b.toLowerCase()) return -1;
+        if (a.toLowerCase() > b.toLowerCase()) return 1;
+        return 0;
+    });
+    let content = {};
+    for(let i in  s){
+        content[s[i]] = openLibraries[s[i]]
+    }
+    content = "export default "+JSON.stringify(content);
+    fs.writeFileSync(filePath, content)
+});

package/package.json

@@ -1,11 +1,45 @@
 {
   "name": "@fto-consult/expo-ui",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Bibliothèque de composants UI Expo,react-native",
   "main": "index.js",
   "scripts": {
     "publish": "npm publish --access=public",
-    "unpublish": "npm -f unpublish @fto-consult/expo-ui"
+    "unpublish": "npm -f unpublish @fto-consult/expo-ui",
+    "build-web": "",
+    "dev": "npx expo start -c --no-minify",
+    "start": "npx expo start --dev --no-minify",
+    "start-d": "npx expo start -c --no-dev --no-minify",
+    "start-p": "npm run start-d",
+    "expo-start-client": "npx expo start --dev --no-minify --dev-client",
+    "start-m": "npx expo start - c--dev--no -minify",
+    "android": "npx expo start --android -c",
+    "ios": "npx expo start --ios",
+    "web": "npx expo start --web",
+    "web-c": "npx expo start --web -c",
+    "eject": "expo eject",
+    "emulator": "npm run android-emulator",
+    "web-server": "npx serve web-build",
+    "build-android": "eas build --clear-cache -p android --profile preview",
+    "build-android-local": "eas build --platform android --local",
+    "build-android-dist": "eas build --clear-cache -p android",
+    "build-ios": "eas build --clear-cache -p ios --profile preview",
+    "build-ios-dist": "eas build --clear-cache -p ios",
+    "install-apk": "adb -s emulator-5554 install myapp.apk",
+    "android-emulator": "emulator -avd EMULATOR",
+    "flipper": "npx cross-env METRO_SERVER_PORT=19000 E:\\Studies\\react-native\\debugger\\Flipper-win\\Flipper.exe",
+    "build-electron": "electron-webpack && electron-builder --dir -c.compression=store",
+    "test:build": "electron-webpack && electron-builder --dir -c.compression=store -c.mac.identity=null",
+    "compile-electron": "webpack --config ./electron/webpack.config.js",
+    "compile-electron-p": "webpack --config ./electron/webpack.config.js --mode=production",
+    "electron": "electron ./electron",
+    "logcat": "adb -d logcat com.ftc.apps.salite1:E > errors.txt",
+    "logcat-export": "adb -d logcat com.ftc.apps.salite1 *:S > logcat.txt",
+    "electron-c": "npm run compile-electron && npm run electron",
+    "electron-p": "npm run compile-electron-p && npm run electron",
+    "update-app-version": "node ./update-app-version.js",
+    "find-licenses": "node ./find-licenses.js",
+    "fix-dependencies": "expo doctor --fix-dependencies"
   },
   "repository": {
     "type": "git",
@@ -44,6 +78,7 @@
     "expo-system-ui": "~1.3.0",
     "expo-web-browser": "~11.0.0",
     "google-libphonenumber": "^3.2.31",
+    "parent-package-json": "^2.0.1",
     "prop-types": "^15.8.1",
     "react-content-loader": "^6.2.0",
     "react-dom": "18.0.0",

package/parent-package.js

@@ -0,0 +1,12 @@
+// Copyright 2022 @fto-consult/Boris Fouomene. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/**** cette fonction a pour rôle de retourner le package parent à celui ci */
+module.export = ()=>{
+    const pathToParent = require("parent-package-json"); // Will return false if no parent exists
+    if (pathToParent !== false) {
+        return pathToParent.path;
+    }
+    return "";
+}

package/update-app-version.js

@@ -0,0 +1,19 @@
+const editJsonFile = require("./edit-json-file.js");
+const fs = require("fs");
+/***** le fichier de configuration doit être stocké dans le repertoire /src/config.js où src est le repertoire source du projet parent qui a installé l'application */
+const run = () => {
+  const parentPackage = require("./parent-package")();
+  if(!parentPackage) return;
+  console.log("before updating parent package version ",parentPackage)
+  const srcParent = path.dirname(parentPackage,"src","config.js");
+  if(fs.existsSync(srcParent)){
+    const appConfig = require(srcParent);
+    if(appConfig && typeof appConfig =='object'){
+      console.log("updating parent package version ",parentPackage)
+      let config = {version:appConfig.version};
+      editJsonFile(parentPackage,config);
+    } 
+  }
+}
+
+run();