@vixoniccom/module-packager 2.9.1-dev.5 → 2.9.1-dev.6

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.9.1-dev.6](https://bitbucket.org/rexmas_cl/module-packager/compare/v2.9.1-dev.5...v2.9.1-dev.6) (2023-12-26)
+
+
+### Bug Fixes
+
+* electron version was reverted to v12 ([173cd53](https://bitbucket.org/rexmas_cl/module-packager/commit/173cd53caf71fb734be61a797c6a25ab635451da))
+
 ### [2.9.1-dev.5](https://bitbucket.org/rexmas_cl/module-packager/compare/v2.9.1-dev.4...v2.9.1-dev.5) (2023-12-26)
 
 

package/electron.js

@@ -1,52 +1,182 @@
-'use strict'
-const { app, BrowserWindow } = require('electron')
-require('@electron/remote/main').initialize()
-
-let mainWindow = null
+#!/usr/bin/env node
 
-const path = require('path')
+'use strict'
 const commandLineArgs = require('command-line-args')
 const optionDefinitions = [
   { name: 'externals', type: String, defaultValue: [], multiple: true },
-  { name: 'src', type: String, defaultValue: '../../src' },
-  { name: 'build', type: String, defaultValue: '../../build' },
+  { name: 'target', type: String, defaultValue: 'web' },
+  { name: 'src', type: String, defaultValue: './src' },
+  { name: 'build', type: String, defaultValue: './build' },
+  { name: 'confDefinition', type: String, defaultValue: './configuration' },
   { name: 'config', type: String, defaultValue: './webpack.config.js' },
   { name: 'port', type: Number, defaultValue: 8080 },
-  { name: 'mode', type: String, defaultValue: 'build' }
+  { name: 'mode', type: String, defaultValue: 'build' },
+  { name: 'transpileOnly', type: Boolean },
+  { name: 'tsOverride', type: Boolean }
 ]
 const options = commandLineArgs(optionDefinitions)
+const path = require('path')
+const webpack = require('webpack')
+const WebpackDevServer = require('webpack-dev-server')
+const { exec } = require('child_process')
+const fs = require('fs')
+const archiver = require('archiver')
+const clc = require('cli-color')
 
-if (options.mode === 'watch') {
-  require('electron-debug')()
-}
-
-app.on('window-all-closed', () => {
-  app.quit()
-})
-
-app.on('ready', () => {
-  mainWindow = new BrowserWindow({
-    show: false,
-    width: 600,
-    height: 400,
-    plugins: true,
-    webPreferences: {
-      nodeIntegration: true,
-      contextIsolation: false,
-      plugins: true,
-      webSecurity: false,
-      enableRemoteModule: true,
-      webviewTag: true
+var pjson = require('./package.json')
+console.log(`VIXONIC PACKAGER: Version ${pjson.version}`)
+
+if (options.target !== 'electron-renderer' && options.externals.length > 0) {
+  throw new Error(`Can't use external dependencies if target is not electron-renderer.`)
+}
+
+if (options.mode === 'build') {
+  pack(() => {
+    // Install externals only if not web.
+    if (options.target === 'electron-renderer') {
+      installExternals(() => {
+        zip()
+      })
+    } else {
+      zip()
     }
   })
+} else if (options.mode === 'watch') {
+  watch()
+} else if (options.mode === 'run') {
+  run()
+} else if (options.mode === 'generate-configuration') {
+  generateConfiguration()
+} else if (options.mode === 'validate-configuration') {
+  validateConfiguration()
+}
+
+function pack (callback) {
+  console.log(clc.blue('Building module...'))
+  validateConfiguration()
+  webpack(require(options.config)(options), function (err, stats) {
+    if (err) {
+      console.log(err)
+      throw err
+    } else {
+      if (stats.hasErrors()) {
+        console.log(clc.red(stats.toJson('errors-only')))
+        callback && callback(stats)
+      } else {
+        console.log(clc.green('Build OK.'))
+        callback && callback(null)
+      }
+    }
+  })
+}
+
+function installExternals (callback) {
+  // Get external versions.
+  let externals = options.externals.map(x => {
+    return `${x}@${JSON.parse(fs.readFileSync(path.resolve(options.src, '..', 'node_modules', x, 'package.json'))).version}`
+  })
+
+  // Install external versions.
+  if (externals.length) {
+    externals = externals.join(' ')
+    console.log(clc.blue(`Installing externals ${externals}...`))
+    exec(`npm install --prefix ./ --production ${externals}`, {
+      cwd: options.build
+    },
+    (err, stdout) => {
+      if (err) throw err
+      console.log(clc.green('Externals installed.'))
+      callback && callback(null)
+    })
+  } else {
+    callback && callback(null)
+  }
+}
+
+function zip (callback) {
+  console.log(clc.blue('Archiving...'))
+  let output = fs.createWriteStream(path.resolve(options.build, '../', 'build.zip'))
+  let archive = archiver('zip')
+  archive.pipe(output)
+  archive.directory(path.resolve(options.build), './')
+  archive.finalize()
+
+  output.on('close', function () {
+    console.log(clc.green('Generated build.zip.'))
+    callback && callback(null)
+  })
 
-  mainWindow.loadURL(`file://${path.join(__dirname, 'index.html')}`)
+  archive.on('error', function (err) {
+    throw err
+  })
+  clc.move(-2, 0)
+}
 
-  mainWindow.webContents.on('did-finish-load', () => {
-    mainWindow.webContents.send('init', options)
+function watch () {
+  var server = new WebpackDevServer(webpack(require(options.config)(options)), {
+    static: path.join(__dirname, options.src, '..')
   })
+  server.listen(options.port)
 
-  mainWindow.on('closed', () => {
-    mainWindow = null
+  var environment = process.env
+  environment.NODE_ENV = 'development'
+
+  exec(`npm start -- ${path.join(__dirname, 'electron.js')} --src ${path.resolve(options.src)} --build ${path.resolve(options.build)} --port ${options.port} --mode ${options.mode} --config ${options.config} --externals ${options.externals}`,
+    {
+      cwd: __dirname,
+      env: environment
+    },
+    (err) => {
+      if (err) throw err
+      process.exit()
+    })
+}
+
+function run () {
+  pack((err) => {
+    if (err) {
+      throw err
+    } else {
+      exec(`npm start -- ${path.join(__dirname, 'electron.js')} --src ${path.resolve(options.src)} --build ${path.resolve(options.build)} --port ${options.port} --mode ${options.mode} --config ${options.config} --externals ${options.externals}`,
+        {
+          cwd: __dirname
+        })
+    }
   })
-})
+}
+
+function loadConfiguration () {
+  require('@vixoniccom/modules')
+  require('ts-node').register({compilerOptions: { moduleResolution: 'node', module: 'commonjs', target: 'es2015', checkJs: false }})
+  return require(path.resolve(options.confDefinition, 'index.ts')).configuration
+}
+
+function generateConfiguration () {
+  try {
+    let configuration = loadConfiguration()
+    fs.writeFileSync(path.resolve(options.src, 'parameters.d.ts'), configuration.declarationFileString)
+    fs.writeFileSync(path.resolve(options.src, '..', 'configuration.json'), JSON.stringify(configuration, undefined, 2))
+    console.log(clc.green(`Configuration generated`))
+  } catch (e) {
+    console.log(clc.red('Configuration generation failed'))
+    throw e
+  }
+}
+
+function validateConfiguration () {
+  try {
+    const { Configuration } = require('@vixoniccom/modules')
+    const json = require(path.resolve(options.src, '../', 'configuration.json'))
+    const conf = Configuration.fromJSON(json)
+    if (conf.durationFormula) {
+      const values = require(path.resolve(options.src, 'test', 'parameters.json'))
+      console.log('Validate duration')
+      console.log('Duration on undefined:', conf.getDuration({}), 'seconds')
+      console.log('Duration:', conf.getDuration(values.parameters), 'seconds')
+    }
+    console.log(clc.green('Valid configuration'))
+  } catch (e) {
+    console.log(clc.red('Invalid configuration'))
+    throw e
+  }
+}

package/index.html

@@ -8,8 +8,7 @@
 <script type="text/javascript">
   const path = require('path')
   const ModuleController = require('@vixoniccom/module-controller')
-  const { ipcRenderer } = require('electron')
-  const { remote } = require('@electron/remote')
+  const { ipcRenderer, remote } = require('electron')
 
   ipcRenderer.on('init', (event, options) => {
     let webview = document.getElementById('webview')

package/package.json

@@ -51,7 +51,6 @@
     "vixonic-module-packager": "main.js"
   },
   "dependencies": {
-    "@vixoniccom/module-controller": "^1.3.0-dev.0",
     "@vixoniccom/modules": "^2.16.2-dev.1",
     "archiver": "^5.3.0",
     "babel-core": "^6.14.0",
@@ -64,7 +63,7 @@
     "command-line-args": "^3.0.1",
     "copy-webpack-plugin": "^4.6.0",
     "css-loader": "^0.24.0",
-    "electron": "^14.2.9",
+    "electron": "^12.2.3",
     "electron-debug": "^3.2.0",
     "file-loader": "^0.9.0",
     "html-loader": "^0.4.3",
@@ -102,8 +101,9 @@
     "prerelease-test": "standard-version --prerelease test",
     "release": "standard-version"
   },
-  "version": "2.9.1-dev.5",
+  "version": "2.9.1-dev.6",
   "devDependencies": {
+    "@vixoniccom/module-controller": "^1.3.0-dev.1",
     "standard-version": "^9.5.0"
   }
 }