@vixoniccom/module-packager 2.11.0 → 2.12.0-dev.1

package/electron.js

@@ -1,50 +0,0 @@
-'use strict'
-const { app, BrowserWindow } = require('electron')
-
-let mainWindow = null
-
-const path = require('path')
-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: 'config', type: String, defaultValue: './webpack.config.js' },
-  { name: 'port', type: Number, defaultValue: 8080 },
-  { name: 'mode', type: String, defaultValue: 'build' }
-]
-const options = commandLineArgs(optionDefinitions)
-
-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,
-      plugins: true,
-      webSecurity: false,
-      enableRemoteModule: true,
-      webviewTag: true
-    }
-  })
-
-  mainWindow.loadURL(`file://${path.join(__dirname, 'index.html')}`)
-
-  mainWindow.webContents.on('did-finish-load', () => {
-    mainWindow.webContents.send('init', options)
-  })
-
-  mainWindow.on('closed', () => {
-    mainWindow = null
-  })
-})

package/index.html

@@ -1,64 +0,0 @@
-<!DOCTYPE html>
-<html style="width: 100%; height: 100%; margin: 0; padding: 0;">
-<head>
-  <title></title>
-</head>
-<body style="width: 100%; height: 100%; margin: 0; padding: 0;">
-<webview style="width: 100%; height: 100%; margin: 0; padding: 0;" id="webview" nodeintegration autosize plugins disablewebsecurity></webview>
-<script type="text/javascript">
-  const path = require('path')
-  const ModuleController = require('@vixoniccom/module-controller')
-  const { ipcRenderer, remote } = require('electron')
-
-  ipcRenderer.on('init', (event, options) => {
-    let webview = document.getElementById('webview')
-    let win = remote.getCurrentWindow()
-
-    webview.addEventListener('did-finish-load', () => {
-      win.show()
-      win.focus()
-    })
-    webview.src = options.mode === 'watch' ? `http://localhost:${options.port}/index.html` : `file://${path.join(options.build, 'index.html')}`
-
-    function getData () {
-      let data = {}
-      try {
-        data.parameters = require(path.join(options.src, '/test/parameters.json')).parameters
-      } catch (err) {
-        console.log('No parameters.')
-      }
-
-      let escaped = path.join(options.mode === 'watch' ? options.src : options.build, 'test', 'downloads')
-      
-      // Add file:// to watch because in this mode the app will be in a localhost hosted environment.
-      if (options.mode === 'watch') escaped = `file://${escaped}`
-      escaped = escaped.replace(/\\/g, '/')
-
-      data.downloadsPath = escaped
-
-      try {
-        data.services = require(path.join(options.src, '/test/services.json')).services
-        console.log(data.services)
-      } catch (err) {
-        console.log('No services.')
-      }
-
-      return data
-    }
-
-    function getSchema () {
-      let data = {}
-      try {
-        data = require(path.join(options.src, '../configuration.json')).schema
-      } catch (err) {
-        console.log('No schema.')
-      }
-      return data
-    }
-
-    ModuleController.init(win, webview, getData(), getSchema(), options.mode === 'watch')
-  })
-</script>
-
-</body>
-</html>

package/main.js

@@ -1,182 +0,0 @@
-#!/usr/bin/env node
-
-'use strict'
-const commandLineArgs = require('command-line-args')
-const optionDefinitions = [
-  { name: 'externals', type: String, defaultValue: [], multiple: true },
-  { 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: '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')
-
-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)
-  })
-
-  archive.on('error', function (err) {
-    throw err
-  })
-  clc.move(-2, 0)
-}
-
-function watch () {
-  var server = new WebpackDevServer(webpack(require(options.config)(options)), {
-    static: path.join(__dirname, options.src, '..')
-  })
-  server.listen(options.port)
-
-  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/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es5",
-    "module": "es2015",
-    "moduleResolution": "node",
-    "jsx": "preserve",
-    "outDir": "dist",
-    "allowJs": true,
-    "checkJs": false,
-    "allowSyntheticDefaultImports": true,
-    "sourceMap": true
-  },
-  "include": [
-    "./src/**/*"
-  ]
-}

package/webpack.config.js

@@ -1,154 +0,0 @@
-'use strict'
-
-const CleanWebpackPlugin = require('clean-webpack-plugin')
-const CopyWebpackPlugin = require('copy-webpack-plugin')
-const HtmlWebpackPlugin = require('html-webpack-plugin')
-const webpack = require('webpack')
-const path = require('path')
-const _ = require('lodash')
-const UglifyJsPlugin = require('uglifyjs-webpack-plugin')
-
-module.exports = (options) => {
-  if (options.target === 'web') {
-    options.externals = [...(options.externals || []), 'electron']
-  }
-
-  let exclude = [path.resolve(options.src, 'static'), path.resolve(options.src, 'test')]
-
-  let config = {
-    mode: 'production',
-    context: __dirname,
-    entry: ['babel-polyfill', path.resolve(options.src, 'main')],
-    output: {
-      path: path.resolve(options.build),
-      filename: 'main.js'
-    },
-    performance: {
-      hints: false,
-      maxAssetSize: 1000000,
-      maxEntrypointSize: 1000000
-    },
-    node: {
-      __dirname: options.mode === 'watch',
-      fs: 'empty',
-      net: 'empty',
-      tls: 'empty'
-    },
-    resolve: {
-      extensions: ['.ts', '.tsx', '.js', '.jsx'],
-      modules: [
-        'node_modules',
-        'src',
-        'static'
-      ]
-    },
-    module: {
-      rules: [
-        {
-          test: /\.(j|t)sx?$/,
-          include: [path.resolve(options.src)],
-          exclude: exclude,
-          rules: [
-            {
-              loader: 'babel-loader?babelrc=false&extends=' + path.join(__dirname, '/.babelrc')
-            },
-            {
-              loader: 'ts-loader',
-              options: {
-                transpileOnly: options.transpileOnly
-              }
-            }
-          ]
-        },
-        {
-          test: /\.scss$/,
-          exclude: exclude,
-          loaders: ['style', 'css', 'sass']
-        },
-        {
-          test: /\.css$/,
-          exclude: exclude,
-          loader: 'style-loader!css-loader'
-        },
-        {
-          test: /\.(png|jpg|jpeg|gif|svg|woff|woff2|ttf|eot|mp4)$/,
-          exclude: exclude,
-          loader: 'file-loader'
-        },
-        {
-          test: /\.html$/,
-          loader: 'raw-loader'
-        }
-      ]
-    },
-    externals: (_context, request, callback) => {
-      if (_.indexOf(options.externals, request) !== -1) {
-        if (options.mode !== 'watch' || request === 'electron') {
-          return callback(null, "require('" + request + "')")
-        } else {
-          return callback(null, "require('" + path.resolve(options.src, '..', 'node_modules', request).replace(/\\/g, '\\\\') + "')")
-        }
-      }
-      callback()
-    },
-    plugins: [
-      new CopyWebpackPlugin([{ from: path.resolve(options.src, 'static'), to: 'static/' }], { copyUnmodified: true }),
-      new HtmlWebpackPlugin({
-        inject: 'head',
-        template: path.resolve(options.src, 'index.html')
-      }),
-      new webpack.LoaderOptionsPlugin({
-        options: {
-          test: /\.tsx?$/,
-          ts: {
-            compiler: 'typescript',
-            configFileName: 'tsconfig.json'
-          },
-          tslint: {
-            emitErrors: true,
-            failOnHint: true
-          }
-        }
-      })
-    ],
-    target: options.target
-  }
-
-  if (options.mode === 'watch') {
-    config.entry.unshift(`webpack-dev-server/client?http://localhost:${options.port}/`, 'webpack/hot/dev-server', path.resolve(options.src, 'index.html'))
-    config.plugins.unshift(new CopyWebpackPlugin([{ from: path.resolve(options.src, 'test'), to: 'test/' }], { copyUnmodified: true }))
-    config.plugins.unshift(new webpack.HotModuleReplacementPlugin())
-    config.output.publicPath = `http://localhost:${options.port}/`
-    config.devtool = 'source-map'
-    config.devServer = {
-      static: path.resolve(options.src),
-      publicPath: `http://localhost:${options.port}/`,
-      inline: true
-    }
-  } else {
-    config.plugins.unshift(
-      new CleanWebpackPlugin([path.basename(options.build), path.basename(options.build) + '.zip'], {
-        root: path.resolve(options.build, '..'),
-        verbose: false
-      }),
-      new webpack.DefinePlugin({
-        'process.env': {
-          NODE_ENV: JSON.stringify('production')
-        }
-      }),
-      new UglifyJsPlugin({
-        uglifyOptions: {
-          warnings: false,
-          mangle: true,
-          extractComments: false
-        }
-      })
-    )
-
-    if (options.mode === 'run') {
-      config.plugins.unshift(new CopyWebpackPlugin([{ from: path.resolve(options.src, 'test'), to: 'test/' }], { copyUnmodified: true }))
-    }
-  }
-
-  return config
-}