From 4161babce106a32fb1ac50034c84d6804206ea86 Mon Sep 17 00:00:00 2001 From: "p.mikolajczak@tkhtechnology.com" Date: Tue, 4 Apr 2023 15:14:23 +0200 Subject: [PATCH 1/3] fix: Mitigate production vulnrabilities --- .gitignore | 1 - dist/bin/cli.js | 224 ++ dist/binaryModulesDetector.js | 80 + dist/defaultDependencies.js | 8 + dist/dependenciesManager.js | 181 ++ dist/desktop.js | 271 ++ dist/electron.js | 61 + dist/electronApp.js | 876 ++++++ dist/electronAppScaffold.js | 142 + dist/electronBuilder.js | 384 +++ dist/env.js | 239 ++ dist/index.js | 247 ++ dist/log.js | 75 + dist/meteorApp.js | 923 ++++++ dist/meteorManager.js | 147 + dist/packager.js | 142 + dist/scripts/addToScripts.js | 24 + dist/scripts/propagateVersion.js | 21 + dist/scripts/utils/addScript.js | 50 + dist/skeletonDependencies.js | 24 + dist/utils.js | 328 +++ lib/electronApp.js | 21 +- lib/meteorApp.js | 10 +- package-lock.json | 2718 +++++++++++------- package.json | 49 +- plugins/bundler/bundler.js | 21 +- tests/functional/electronApp.test.js | 2 +- tests/functional/modules/localServer.test.js | 8 +- tests/unit/meteorApp.test.js | 2 +- 29 files changed, 6164 insertions(+), 1115 deletions(-) create mode 100644 dist/bin/cli.js create mode 100644 dist/binaryModulesDetector.js create mode 100644 dist/defaultDependencies.js create mode 100644 dist/dependenciesManager.js create mode 100644 dist/desktop.js create mode 100644 dist/electron.js create mode 100644 dist/electronApp.js create mode 100644 dist/electronAppScaffold.js create mode 100644 dist/electronBuilder.js create mode 100644 dist/env.js create mode 100644 dist/index.js create mode 100644 dist/log.js create mode 100644 dist/meteorApp.js create mode 100644 dist/meteorManager.js create mode 100644 dist/packager.js create mode 100644 dist/scripts/addToScripts.js create mode 100644 dist/scripts/propagateVersion.js create mode 100644 dist/scripts/utils/addScript.js create mode 100644 dist/skeletonDependencies.js create mode 100644 dist/utils.js diff --git a/.gitignore b/.gitignore index fd027d5c..28f46c1a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,5 @@ node_modules .idea -dist tests/_tmp_ tests/.__tmp_int .npm diff --git a/dist/bin/cli.js b/dist/bin/cli.js new file mode 100644 index 00000000..683607e0 --- /dev/null +++ b/dist/bin/cli.js @@ -0,0 +1,224 @@ +#!/usr/bin/env node + +/* eslint-disable global-require */ +"use strict"; + +var _fs = _interopRequireDefault(require("fs")); + +var _path = _interopRequireDefault(require("path")); + +var _assignIn = _interopRequireDefault(require("lodash/assignIn")); + +var _commander = _interopRequireDefault(require("commander")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _ = _interopRequireDefault(require("../..")); + +var _addScript = _interopRequireDefault(require("../scripts/utils/addScript")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const { + join +} = _path.default; +const cmd = process.argv[2]; +/* eslint-disable no-console */ + +const { + log, + error, + info, + warn +} = console; +/* eslint-enable no-console */ + +/** + * Looks for .meteor directory. + * @param {string} appPath - Meteor app path + */ + +function isMeteorApp(appPath) { + const meteorPath = join(appPath, '.meteor'); + + try { + return _fs.default.statSync(meteorPath).isDirectory(); + } catch (e) { + return false; + } +} +/** + * Just ensures a ddp url is set. + * + * @param {string|null} ddpUrl - the url that Meteor app connects to + * @returns {string|null} + */ + + +function getDdpUrl(ddpUrl = null) { + if (!ddpUrl && _commander.default.buildMeteor) { + info('no ddp_url specified, setting default: http://127.0.0.1:3000'); + return 'http://127.0.0.1:3000'; + } + + return ddpUrl; +} // -------------------------- + + +function collect(val, memo) { + memo.push(val); + return memo; +} + +_commander.default.option('-b, --build-meteor', 'runs meteor to obtain the mobile build, kills it after').option('-t, --build-timeout ', 'timeout value when waiting for ' + 'meteor to build, default 600sec').option('-p, --port ', 'port on which meteor is running, when with -b this will be passed to meteor when obtaining the build').option('--production', 'builds meteor app with the production switch, uglifies contents ' + 'of .desktop, packs app to app.asar').option('-a, --android', 'force adding android as a mobile platform instead of ios').option('-s, --scaffold', 'will scaffold .desktop if not present').option('-i, --ignore-stderr [string]', 'only with -b, strings that when found will not terminate meteor build', collect, []).option('--meteor-settings ', 'only with -b, adds --settings options to meteor').option('--prod-debug', 'forces adding dev tools to a production build').option('--ia32', 'generate 32bit installer/package').option('--all-archs', 'generate 32bit and 64bit installers').option('--win', 'generate Windows installer').option('--linux', 'generate Linux installer').option('--mac', 'generate Mac installer').option('-d, --debug', 'run electron with debug switch'); + +_commander.default.usage('[command] [options]').version(require('./../../package.json').version, '-V, --version').on('--help', () => { + log(' [ddp_url] - pass a ddp url if you want to use different one than used in meteor\'s --mobile-server'); + log(' this will also work with -b'); + log(' '); + log(' Examples:'); + log(''); + log(' ', ['# cd into meteor dir first', 'cd /your/meteor/app', 'meteor --mobile-server=127.0.0.1:3000', '', '# open new terminal, assuming you have done npm install --save-dev @meteor-community/meteor-desktop', 'npm run desktop -- init', 'npm run desktop'].join('\n ')); + log('\n'); +}); + +function verifyArgsSyntax() { + if (process.env.npm_config_argv) { + let npmArgv; + + try { + const args = ['-b', '--build-meteor', '-t', '--build-timeout', '-p', '--port', '--production', '-a', '--android', '-s', '--scaffold', '--ia32', '--win', '--linux', '--all-archs', '--win', '--mac', '--meteor-settings']; + npmArgv = JSON.parse(process.env.npm_config_argv); + + if (npmArgv.remain.length === 0 && npmArgv.original.length > 2) { + if (npmArgv.original.some(arg => !!~args.indexOf(arg))) { + warn('WARNING: seems that you might used the wrong console syntax, no ` --' + ' ` delimiter was found, be sure you are invoking meteor-desktop with' + ' it when passing commands or options -> ' + '`npm run desktop -- command --option`\n'); + } + } + } catch (e) {// Not sure if `npm_config_argv` is always present... + } + } +} + +function meteorDesktopFactory(ddpUrl, production = false) { + info(`METEOR-DESKTOP v${require('./../../package.json').version}\n`); + verifyArgsSyntax(); + const input = process.cwd(); + + if (!isMeteorApp(input)) { + error(`not in a meteor app dir\n ${input}`); + process.exit(); + } + + if (!_commander.default.output) { + _commander.default.output = input; + } + + if (production && !_commander.default.production) { + info('package/build-installer implies setting --production, setting it for you'); + } + + if (!_commander.default.buildMeteor) { + _commander.default.port = _commander.default.port || 3000; + info(`REMINDER: your Meteor project should be running now on port ${_commander.default.port}\n`); + } + + if (_commander.default.prodDebug) { + info('!! WARNING: You are adding devTools to a production build !!\n'); + } + + const options = { + ddpUrl, + skipMobileBuild: _commander.default.buildMeteor ? !_commander.default.buildMeteor : true, + production: _commander.default.production || production + }; + (0, _assignIn.default)(options, _commander.default); + return (0, _.default)(input, _commander.default.output, options); +} + +function run(ddpUrl) { + meteorDesktopFactory(getDdpUrl(ddpUrl)).run(); +} + +function build(ddpUrl) { + meteorDesktopFactory(getDdpUrl(ddpUrl)).build(); +} + +function init() { + meteorDesktopFactory().init(); +} + +function justRun() { + meteorDesktopFactory().justRun(); +} + +function runPackager(ddpUrl) { + meteorDesktopFactory(getDdpUrl(ddpUrl), true).runPackager(); +} + +function buildInstaller(ddpUrl) { + meteorDesktopFactory(getDdpUrl(ddpUrl), true).buildInstaller(); +} + +function initTestsSupport() { + log('installing cross-env, ava, meteor-desktop-test-suite and spectron'); + log('running `meteor npm install --save-dev cross-env ava spectron meteor-desktop-test-suite`'); + + const { + code + } = _shelljs.default.exec('meteor npm install --save-dev cross-env ava spectron meteor-desktop-test-suite'); + + if (code !== 0) { + warn('could not add cross-env, ava and spectron to your `devDependencies`, please do it' + ' manually'); + } + + const test = 'cross-env NODE_ENV=test ava .desktop/**/*.test.js -s --verbose'; + const testWatch = 'cross-env NODE_ENV=test ava .desktop/**/*.test.js -s --verbose' + ' --watch --source .desktop'; + + function fail() { + error('\ncould not add entries to `scripts` in package.json'); + log('please try to add it manually\n'); + log(`test-desktop: ${test}`); + log(`test-desktop-watch: ${testWatch}`); + } + + const packageJsonPath = _path.default.resolve(_path.default.join(process.cwd(), 'package.json')); + + (0, _addScript.default)('test-desktop', test, packageJsonPath, fail); + (0, _addScript.default)('test-desktop-watch', testWatch, packageJsonPath, fail); + log('\nadded test-desktop and test-desktop-watch entries'); + log('run the test with `npm run test-desktop`'); +} + +_commander.default.command('init').description('scaffolds .desktop dir in the meteor app').action(init); + +_commander.default.command('run [ddp_url]').description('(default) builds and runs desktop app').action(run); + +_commander.default.command('build [ddp_url]').description('builds your desktop app').action(build); + +_commander.default.command('build-installer [ddp_url]').description('creates the installer').action(buildInstaller); + +_commander.default.command('just-run').description('alias for running `electron .` in `.meteor/desktop-build`').action(justRun); + +_commander.default.command('package [ddp_url]').description('runs electron packager').action(runPackager); + +_commander.default.command('init-tests-support').description('prepares project for running functional tests of desktop app').action(initTestsSupport); + +if (process.argv.length === 2 || !~'-h|--help|run|init|build|build-installer|just-run|init-tests-support|package'.indexOf(cmd)) { + let { + argv + } = process; + + if (process.argv.length === 2) { + argv.push('run'); + } else { + let command = argv.splice(0, 2); + command = command.concat('run', argv); + argv = command; + } + + _commander.default.parse(argv); +} else { + _commander.default.parse(process.argv); +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","cmd","process","argv","log","error","info","warn","console","isMeteorApp","appPath","meteorPath","fs","statSync","isDirectory","e","getDdpUrl","ddpUrl","program","buildMeteor","collect","val","memo","push","option","usage","version","require","on","verifyArgsSyntax","env","npm_config_argv","npmArgv","args","JSON","parse","remain","length","original","some","arg","indexOf","meteorDesktopFactory","production","input","cwd","exit","output","port","prodDebug","options","skipMobileBuild","assignIn","meteorDesktop","run","build","init","justRun","runPackager","buildInstaller","initTestsSupport","code","shell","exec","test","testWatch","fail","packageJsonPath","resolve","addScript","command","description","action","splice","concat"],"sources":["../../lib/bin/cli.js"],"sourcesContent":["#!/usr/bin/env node\n/* eslint-disable global-require */\nimport fs from 'fs';\nimport path from 'path';\nimport assignIn from 'lodash/assignIn';\nimport program from 'commander';\nimport shell from 'shelljs';\n\nimport meteorDesktop from '../..';\nimport addScript from '../scripts/utils/addScript';\n\nconst { join } = path;\nconst cmd = process.argv[2];\n\n/* eslint-disable no-console */\nconst {\n    log, error, info, warn\n} = console;\n\n/* eslint-enable no-console */\n\n/**\n * Looks for .meteor directory.\n * @param {string} appPath - Meteor app path\n */\nfunction isMeteorApp(appPath) {\n    const meteorPath = join(appPath, '.meteor');\n    try {\n        return fs.statSync(meteorPath).isDirectory();\n    } catch (e) {\n        return false;\n    }\n}\n\n/**\n * Just ensures a ddp url is set.\n *\n * @param {string|null} ddpUrl - the url that Meteor app connects to\n * @returns {string|null}\n */\nfunction getDdpUrl(ddpUrl = null) {\n    if (!ddpUrl && program.buildMeteor) {\n        info('no ddp_url specified, setting default: http://127.0.0.1:3000');\n        return 'http://127.0.0.1:3000';\n    }\n    return ddpUrl;\n}\n\n// --------------------------\n\nfunction collect(val, memo) {\n    memo.push(val);\n    return memo;\n}\n\nprogram\n    .option('-b, --build-meteor', 'runs meteor to obtain the mobile build, kills it after')\n    .option('-t, --build-timeout <timeout_in_sec>', 'timeout value when waiting for ' +\n        'meteor to build, default 600sec')\n    .option('-p, --port <port>', 'port on which meteor is running, when with -b this will be passed to meteor when obtaining the build')\n    .option('--production', 'builds meteor app with the production switch, uglifies contents ' +\n        'of .desktop, packs app to app.asar')\n    .option('-a, --android', 'force adding android as a mobile platform instead of ios')\n    .option('-s, --scaffold', 'will scaffold .desktop if not present')\n    .option('-i, --ignore-stderr [string]', 'only with -b, strings that when found will not terminate meteor build', collect, [])\n    .option('--meteor-settings <path>', 'only with -b, adds --settings options to meteor')\n    .option('--prod-debug', 'forces adding dev tools to a production build')\n    .option('--ia32', 'generate 32bit installer/package')\n    .option('--all-archs', 'generate 32bit and 64bit installers')\n    .option('--win', 'generate Windows installer')\n    .option('--linux', 'generate Linux installer')\n    .option('--mac', 'generate Mac installer')\n    .option('-d, --debug', 'run electron with debug switch');\n\n\nprogram\n    .usage('[command] [options]')\n    .version(require('./../../package.json').version, '-V, --version')\n    .on('--help', () => {\n        log('  [ddp_url] - pass a ddp url if you want to use different one than used in meteor\\'s --mobile-server');\n        log('              this will also work with -b');\n        log('    ');\n        log('  Examples:');\n        log('');\n        log(\n            '   ',\n            [\n                '# cd into meteor dir first',\n                'cd /your/meteor/app',\n                'meteor --mobile-server=127.0.0.1:3000',\n                '',\n                '# open new terminal, assuming you have done npm install --save-dev @meteor-community/meteor-desktop',\n                'npm run desktop -- init',\n                'npm run desktop'\n            ].join('\\n    ')\n        );\n        log('\\n');\n    });\n\n\nfunction verifyArgsSyntax() {\n    if (process.env.npm_config_argv) {\n        let npmArgv;\n        try {\n            const args = ['-b', '--build-meteor', '-t', '--build-timeout', '-p', '--port',\n                '--production', '-a', '--android', '-s', '--scaffold', '--ia32', '--win',\n                '--linux', '--all-archs', '--win', '--mac', '--meteor-settings'];\n            npmArgv = JSON.parse(process.env.npm_config_argv);\n            if (npmArgv.remain.length === 0 && npmArgv.original.length > 2) {\n                if (npmArgv.original.some(arg => !!~args.indexOf(arg))) {\n                    warn('WARNING: seems that you might used the wrong console syntax, no ` --' +\n                        ' ` delimiter was found, be sure you are invoking meteor-desktop with' +\n                        ' it when passing commands or options -> ' +\n                        '`npm run desktop -- command --option`\\n');\n                }\n            }\n        } catch (e) {\n            // Not sure if `npm_config_argv` is always present...\n        }\n    }\n}\n\nfunction meteorDesktopFactory(ddpUrl, production = false) {\n    info(`METEOR-DESKTOP v${require('./../../package.json').version}\\n`);\n\n    verifyArgsSyntax();\n\n    const input = process.cwd();\n\n    if (!isMeteorApp(input)) {\n        error(`not in a meteor app dir\\n ${input}`);\n        process.exit();\n    }\n\n    if (!program.output) {\n        program.output = input;\n    }\n\n    if (production && !program.production) {\n        info('package/build-installer implies setting --production, setting it for you');\n    }\n\n    if (!program.buildMeteor) {\n        program.port = program.port || 3000;\n        info(`REMINDER: your Meteor project should be running now on port ${program.port}\\n`);\n    }\n\n    if (program.prodDebug) {\n        info('!! WARNING: You are adding devTools to a production build !!\\n');\n    }\n\n    const options = {\n        ddpUrl,\n        skipMobileBuild: program.buildMeteor ? !program.buildMeteor : true,\n        production: program.production || production\n    };\n\n    assignIn(options, program);\n\n    return meteorDesktop(\n        input,\n        program.output,\n        options\n    );\n}\n\nfunction run(ddpUrl) {\n    meteorDesktopFactory(getDdpUrl(ddpUrl)).run();\n}\n\nfunction build(ddpUrl) {\n    meteorDesktopFactory(getDdpUrl(ddpUrl)).build();\n}\n\nfunction init() {\n    meteorDesktopFactory().init();\n}\n\nfunction justRun() {\n    meteorDesktopFactory().justRun();\n}\n\nfunction runPackager(ddpUrl) {\n    meteorDesktopFactory(getDdpUrl(ddpUrl), true).runPackager();\n}\n\nfunction buildInstaller(ddpUrl) {\n    meteorDesktopFactory(getDdpUrl(ddpUrl), true).buildInstaller();\n}\n\nfunction initTestsSupport() {\n    log('installing cross-env, ava, meteor-desktop-test-suite and spectron');\n    log('running `meteor npm install --save-dev cross-env ava spectron meteor-desktop-test-suite`');\n\n    const { code } = shell.exec('meteor npm install --save-dev cross-env ava spectron meteor-desktop-test-suite');\n\n    if (code !== 0) {\n        warn('could not add cross-env, ava and spectron to your `devDependencies`, please do it' +\n            ' manually');\n    }\n\n    const test = 'cross-env NODE_ENV=test ava .desktop/**/*.test.js -s --verbose';\n    const testWatch = 'cross-env NODE_ENV=test ava .desktop/**/*.test.js -s --verbose' +\n        ' --watch --source .desktop';\n\n    function fail() {\n        error('\\ncould not add entries to `scripts` in package.json');\n        log('please try to add it manually\\n');\n        log(`test-desktop: ${test}`);\n        log(`test-desktop-watch: ${testWatch}`);\n    }\n\n    const packageJsonPath = path.resolve(\n        path.join(process.cwd(), 'package.json')\n    );\n\n    addScript('test-desktop', test, packageJsonPath, fail);\n    addScript('test-desktop-watch', testWatch, packageJsonPath, fail);\n\n    log('\\nadded test-desktop and test-desktop-watch entries');\n    log('run the test with `npm run test-desktop`');\n}\n\nprogram\n    .command('init')\n    .description('scaffolds .desktop dir in the meteor app')\n    .action(init);\n\nprogram\n    .command('run [ddp_url]')\n    .description('(default) builds and runs desktop app')\n    .action(run);\n\nprogram\n    .command('build [ddp_url]')\n    .description('builds your desktop app')\n    .action(build);\n\nprogram\n    .command('build-installer [ddp_url]')\n    .description('creates the installer')\n    .action(buildInstaller);\n\nprogram\n    .command('just-run')\n    .description('alias for running `electron .` in `.meteor/desktop-build`')\n    .action(justRun);\n\nprogram\n    .command('package [ddp_url]')\n    .description('runs electron packager')\n    .action(runPackager);\n\nprogram\n    .command('init-tests-support')\n    .description('prepares project for running functional tests of desktop app')\n    .action(initTestsSupport);\n\nif (process.argv.length === 2 || !~('-h|--help|run|init|build|build-installer|just-run|init-tests-support|package'.indexOf(cmd))\n) {\n    let { argv } = process;\n    if (process.argv.length === 2) {\n        argv.push('run');\n    } else {\n        let command = argv.splice(0, 2);\n        command = command.concat('run', argv);\n        argv = command;\n    }\n    program.parse(argv);\n} else {\n    program.parse(process.argv);\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/binaryModulesDetector.js b/dist/binaryModulesDetector.js new file mode 100644 index 00000000..a074f7bb --- /dev/null +++ b/dist/binaryModulesDetector.js @@ -0,0 +1,80 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _path = _interopRequireDefault(require("path")); + +var _isbinaryfile = _interopRequireDefault(require("isbinaryfile")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _log = _interopRequireDefault(require("./log")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +_shelljs.default.config.fatal = true; +/** + * Experimental module for detecting modules containing binary files. + * Based on the same functionality from electron-builder. + * + * @property {MeteorDesktop} $ + * @class + */ + +class BinaryModulesDetector { + /** + * @constructor + */ + constructor(nodeModulesPath) { + this.log = new _log.default('binaryModulesDetector'); + this.nodeModulesPath = nodeModulesPath; + } // TODO: make asynchronous + + + detect() { + this.log.verbose('detecting node modules with binary files'); + + const files = _shelljs.default.ls('-RAl', this.nodeModulesPath); + + const extract = []; + files.forEach(file => { + const pathSplit = file.name.split(_path.default.posix.sep); + const dir = pathSplit[0]; + const filename = pathSplit.pop(); + + if (extract.indexOf(dir) === -1 && !BinaryModulesDetector.shouldBeIgnored(dir, filename)) { + if (file.isFile()) { + let shouldUnpack = false; + + if (file.name.endsWith('.dll') || file.name.endsWith('.exe') || file.name.endsWith('.dylib')) { + shouldUnpack = true; + } else if (_path.default.extname(file.name) === '') { + shouldUnpack = _isbinaryfile.default.sync(_path.default.join(this.nodeModulesPath, file.name)); + } + + if (shouldUnpack) { + this.log.debug(`binary file: ${file.name}`); + extract.push(dir); + } + } + } + }); + + if (extract.length > 0) { + this.log.verbose(`detected modules to be extracted: ${extract.join(', ')}`); + } + + return extract; + } + + static shouldBeIgnored(dir, filename) { + return dir === '.bin' || filename === '.DS_Store' || filename === 'LICENSE' || filename === 'README'; + } + +} + +exports.default = BinaryModulesDetector; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/defaultDependencies.js b/dist/defaultDependencies.js new file mode 100644 index 00000000..c5232dcc --- /dev/null +++ b/dist/defaultDependencies.js @@ -0,0 +1,8 @@ +"use strict"; + +module.exports = { + electron: '11.5.0', + 'electron-builder': '23.3.1', + 'electron-packager': '15.4.0' +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJtb2R1bGUiLCJleHBvcnRzIiwiZWxlY3Ryb24iXSwic291cmNlcyI6WyIuLi9saWIvZGVmYXVsdERlcGVuZGVuY2llcy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJtb2R1bGUuZXhwb3J0cyA9IHtcbiAgICBlbGVjdHJvbjogJzExLjUuMCcsXG4gICAgJ2VsZWN0cm9uLWJ1aWxkZXInOiAnMjMuMy4xJyxcbiAgICAnZWxlY3Ryb24tcGFja2FnZXInOiAnMTUuNC4wJ1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7QUFBQUEsTUFBTSxDQUFDQyxPQUFQLEdBQWlCO0VBQ2JDLFFBQVEsRUFBRSxRQURHO0VBRWIsb0JBQW9CLFFBRlA7RUFHYixxQkFBcUI7QUFIUixDQUFqQiJ9 \ No newline at end of file diff --git a/dist/dependenciesManager.js b/dist/dependenciesManager.js new file mode 100644 index 00000000..d5d4ac90 --- /dev/null +++ b/dist/dependenciesManager.js @@ -0,0 +1,181 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _lodash = require("lodash"); + +var _log = _interopRequireDefault(require("./log")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars + +/** + * Utility class designed for merging dependencies list with simple validation and duplicate + * detection. + * + * @class + */ +class DependenciesManager { + /** + * @param {MeteorDesktop} $ - context + * @param {Object} defaultDependencies - core dependencies list + * @constructor + */ + constructor($, defaultDependencies) { + this.log = new _log.default('dependenciesManager'); + this.$ = $; + this.dependencies = defaultDependencies; // Regexes for matching certain types of dependencies version. + // https://docs.npmjs.com/files/package.json#dependencies + + this.regexes = { + local: /^(\.\.\/|~\/|\.\/|\/)/, + git: /^git(\+(ssh|http)s?)?/, + github: /^\w+-?\w+(?!-)\//, + http: /^https?.+tar\.gz/, + file: /^file:/ + }; // Check for commit hashes. + + const gitCheck = { + type: 'regex', + regex: /#[a-f0-9]{7,40}/, + test: 'match', + message: 'git or github link must have a commit hash' + }; // Check for displaying warnings when npm package from local path is used. + + const localCheck = { + onceName: 'localCheck', + type: 'warning', + message: 'using dependencies from local paths is permitted' + ' but dangerous - read more in README.md' + }; + this.checks = { + local: localCheck, + file: localCheck, + git: gitCheck, + github: gitCheck, + version: { + type: 'regex', + // Matches all the semver ranges operators, empty strings and `*`. + regex: /[\^|><= ~-]|\.x|^$|^\*$/, + test: 'do not match', + message: 'semver ranges are forbidden, please specify exact version' + } + }; + } + /** + * Just a public getter. + * @returns {Object} + */ + + + getDependencies() { + return this.dependencies; + } + /** + * Returns local dependencies. + * @returns {Object} + */ + + + getLocalDependencies() { + return Object.keys(this.dependencies).filter(dependency => this.regexes.local.test(this.dependencies[dependency]) || this.regexes.file.test(this.dependencies[dependency])).reduce((localDependencies, currentDependency) => Object.assign(localDependencies, { + [currentDependency]: this.dependencies[currentDependency] + }), {}); + } + /** + * Returns remote dependencies. + * @returns {Object} + */ + + + getRemoteDependencies() { + return Object.keys(this.dependencies).filter(dependency => !this.regexes.local.test(this.dependencies[dependency]) && !this.regexes.file.test(this.dependencies[dependency])).reduce((localDependencies, currentDependency) => Object.assign(localDependencies, { + [currentDependency]: this.dependencies[currentDependency] + }), {}); + } + /** + * Merges dependencies into one list. + * + * @param {string} from - describes where the dependencies were set + * @param {Object} dependencies - dependencies list + */ + + + mergeDependencies(from, dependencies) { + if (this.validateDependenciesVersions(from, dependencies)) { + this.detectDuplicatedDependencies(from, dependencies); + (0, _lodash.assignIn)(this.dependencies, dependencies); + } + } + /** + * Detects dependency version type. + * @param {string} version - version string of the dependency + * @return {string} + */ + + + detectDependencyVersionType(version) { + const type = Object.keys(this.regexes).find(dependencyType => this.regexes[dependencyType].test(version)); + return type || 'version'; + } + /** + * Validates semver and detect ranges. + * + * @param {string} from - describes where the dependencies were set + * @param {Object} dependencies - dependencies list + */ + + + validateDependenciesVersions(from, dependencies) { + const warningsShown = {}; + (0, _lodash.forEach)(dependencies, (version, name) => { + const type = this.detectDependencyVersionType(version); + + if (this.checks[type]) { + const check = this.checks[type]; + + if (check.type === 'regex') { + const checkResult = check.test === 'match' ? this.checks[type].regex.test(version) : !this.checks[type].regex.test(version); + + if (!checkResult) { + throw new Error(`dependency ${name}:${version} from ${from} failed version ` + `check with message: ${this.checks[type].message}`); + } + } + + if (check.type === 'warning' && !warningsShown[check.onceName]) { + warningsShown[check.onceName] = true; + this.log.warn(`dependency ${name}:${version} from ${from} caused a` + ` warning: ${check.message}`); + } + } + }); + return true; + } + /** + * Detects duplicates. + * + * @param {string} from - describes where the dependencies were set + * @param {Object} dependencies - dependencies list + */ + + + detectDuplicatedDependencies(from, dependencies) { + const duplicates = (0, _lodash.intersection)(Object.keys(dependencies), Object.keys(this.dependencies)); + + if (duplicates.length > 0) { + duplicates.forEach(name => { + if (dependencies[name] !== this.dependencies[name]) { + throw new Error(`While processing dependencies from ${from}, a dependency ` + `${name}: ${dependencies[name]} was found to be conflicting with a ` + `dependency (${this.dependencies[name]}) that was already declared in ` + 'other module or it is used in core of the electron app.'); + } + }); + } + } + +} + +exports.default = DependenciesManager; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DependenciesManager","constructor","$","defaultDependencies","log","Log","dependencies","regexes","local","git","github","http","file","gitCheck","type","regex","test","message","localCheck","onceName","checks","version","getDependencies","getLocalDependencies","Object","keys","filter","dependency","reduce","localDependencies","currentDependency","assign","getRemoteDependencies","mergeDependencies","from","validateDependenciesVersions","detectDuplicatedDependencies","assignIn","detectDependencyVersionType","find","dependencyType","warningsShown","forEach","name","check","checkResult","Error","warn","duplicates","intersection","length"],"sources":["../lib/dependenciesManager.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport { forEach, assignIn, intersection } from 'lodash';\n\nimport Log from './log';\n\n/**\n * Utility class designed for merging dependencies list with simple validation and duplicate\n * detection.\n *\n * @class\n */\nexport default class DependenciesManager {\n    /**\n     * @param {MeteorDesktop} $                   - context\n     * @param {Object}        defaultDependencies - core dependencies list\n     * @constructor\n     */\n    constructor($, defaultDependencies) {\n        this.log = new Log('dependenciesManager');\n        this.$ = $;\n        this.dependencies = defaultDependencies;\n\n        // Regexes for matching certain types of dependencies version.\n        // https://docs.npmjs.com/files/package.json#dependencies\n        this.regexes = {\n            local: /^(\\.\\.\\/|~\\/|\\.\\/|\\/)/,\n            git: /^git(\\+(ssh|http)s?)?/,\n            github: /^\\w+-?\\w+(?!-)\\//,\n            http: /^https?.+tar\\.gz/,\n            file: /^file:/\n        };\n\n        // Check for commit hashes.\n        const gitCheck = {\n            type: 'regex',\n            regex: /#[a-f0-9]{7,40}/,\n            test: 'match',\n            message: 'git or github link must have a commit hash'\n        };\n\n        // Check for displaying warnings when npm package from local path is used.\n        const localCheck = {\n            onceName: 'localCheck',\n            type: 'warning',\n            message: 'using dependencies from local paths is permitted' +\n            ' but dangerous - read more in README.md'\n        };\n\n        this.checks = {\n            local: localCheck,\n            file: localCheck,\n            git: gitCheck,\n            github: gitCheck,\n            version: {\n                type: 'regex',\n                // Matches all the semver ranges operators, empty strings and `*`.\n                regex: /[\\^|><= ~-]|\\.x|^$|^\\*$/,\n                test: 'do not match',\n                message: 'semver ranges are forbidden, please specify exact version'\n            }\n        };\n    }\n\n    /**\n     * Just a public getter.\n     * @returns {Object}\n     */\n    getDependencies() {\n        return this.dependencies;\n    }\n\n    /**\n     * Returns local dependencies.\n     * @returns {Object}\n     */\n    getLocalDependencies() {\n        return Object\n            .keys(this.dependencies)\n            .filter(\n                dependency =>\n                    this.regexes.local.test(this.dependencies[dependency]) ||\n                    this.regexes.file.test(this.dependencies[dependency])\n            )\n            .reduce(\n                (localDependencies, currentDependency) =>\n                    Object.assign(\n                        localDependencies,\n                        { [currentDependency]: this.dependencies[currentDependency] }\n                    ),\n                {}\n            );\n    }\n\n    /**\n     * Returns remote dependencies.\n     * @returns {Object}\n     */\n    getRemoteDependencies() {\n        return Object\n            .keys(this.dependencies)\n            .filter(\n                dependency =>\n                    !this.regexes.local.test(this.dependencies[dependency]) &&\n                    !this.regexes.file.test(this.dependencies[dependency])\n            )\n            .reduce(\n                (localDependencies, currentDependency) =>\n                    Object.assign(\n                        localDependencies,\n                        { [currentDependency]: this.dependencies[currentDependency] }\n                    ),\n                {}\n            );\n    }\n\n    /**\n     * Merges dependencies into one list.\n     *\n     * @param {string} from         - describes where the dependencies were set\n     * @param {Object} dependencies - dependencies list\n     */\n    mergeDependencies(from, dependencies) {\n        if (this.validateDependenciesVersions(from, dependencies)) {\n            this.detectDuplicatedDependencies(from, dependencies);\n            assignIn(this.dependencies, dependencies);\n        }\n    }\n\n    /**\n     * Detects dependency version type.\n     * @param {string} version - version string of the dependency\n     * @return {string}\n     */\n    detectDependencyVersionType(version) {\n        const type = Object.keys(this.regexes)\n            .find(dependencyType => this.regexes[dependencyType].test(version));\n        return type || 'version';\n    }\n\n    /**\n     * Validates semver and detect ranges.\n     *\n     * @param {string} from         - describes where the dependencies were set\n     * @param {Object} dependencies - dependencies list\n     */\n    validateDependenciesVersions(from, dependencies) {\n        const warningsShown = {};\n        forEach(dependencies, (version, name) => {\n            const type = this.detectDependencyVersionType(version);\n            if (this.checks[type]) {\n                const check = this.checks[type];\n                if (check.type === 'regex') {\n                    const checkResult = check.test === 'match' ?\n                        this.checks[type].regex.test(version) :\n                        !this.checks[type].regex.test(version);\n                    if (!checkResult) {\n                        throw new Error(`dependency ${name}:${version} from ${from} failed version ` +\n                            `check with message: ${this.checks[type].message}`);\n                    }\n                }\n                if (check.type === 'warning' && !warningsShown[check.onceName]) {\n                    warningsShown[check.onceName] = true;\n                    this.log.warn(`dependency ${name}:${version} from ${from} caused a` +\n                        ` warning: ${check.message}`);\n                }\n            }\n        });\n        return true;\n    }\n\n    /**\n     * Detects duplicates.\n     *\n     * @param {string} from         - describes where the dependencies were set\n     * @param {Object} dependencies - dependencies list\n     */\n    detectDuplicatedDependencies(from, dependencies) {\n        const duplicates = intersection(Object.keys(dependencies), Object.keys(this.dependencies));\n        if (duplicates.length > 0) {\n            duplicates.forEach((name) => {\n                if (dependencies[name] !== this.dependencies[name]) {\n                    throw new Error(`While processing dependencies from ${from}, a dependency ` +\n                        `${name}: ${dependencies[name]} was found to be conflicting with a ` +\n                        `dependency (${this.dependencies[name]}) that was already declared in ` +\n                        'other module or it is used in core of the electron app.');\n                }\n            });\n        }\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/desktop.js b/dist/desktop.js new file mode 100644 index 00000000..3a5f1cd9 --- /dev/null +++ b/dist/desktop.js @@ -0,0 +1,271 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _fs = _interopRequireDefault(require("fs")); + +var _path = _interopRequireDefault(require("path")); + +var _log = _interopRequireDefault(require("./log")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars +_shelljs.default.config.fatal = true; +/** + * Checks if the path is empty. + * @param {string} searchPath + * @returns {boolean} + */ + +function isEmptySync(searchPath) { + let stat; + + try { + stat = _fs.default.statSync(searchPath); + } catch (e) { + return true; + } + + if (stat.isDirectory()) { + const items = _fs.default.readdirSync(searchPath); + + return !items || !items.length; + } + + return false; +} +/** + * Represents the .desktop directory. + * @class + * @property {desktopSettings} settings + */ + + +class Desktop { + /** + * @param {MeteorDesktop} $ - context + * + * @constructor + */ + constructor($) { + this.$ = $; + this.log = new _log.default('desktop'); + this.settings = null; + this.dependencies = null; + } + /** + * Tries to read and returns settings.json contents from .desktop dir. + * + * @returns {desktopSettings|null} + */ + + + getSettings() { + if (!this.settings) { + try { + this.settings = JSON.parse(_fs.default.readFileSync(this.$.env.paths.desktop.settings, 'UTF-8')); + } catch (e) { + this.log.error('error while trying to read \'.desktop/settings.json\': ', e); + process.exit(1); + } + } + + return this.settings; + } + /** + * Returns a version hash representing current .desktop contents. + * @returns {string} + */ + + + async getHashVersion() { + this.log.info('calculating hash version from .desktop contents'); + const version = await this.$.utils.readFilesAndComputeHash(this.$.env.paths.desktop.root); + this.log.verbose(`calculated .desktop hash version is ${version.hash}`); + return version.hash; + } + /** + * Tries to read a module.json file from a module at provided path. + * + * @param {string} modulePath - path to the module dir + * @returns {Object} + */ + + + getModuleConfig(modulePath) { + let moduleConfig = {}; + + try { + moduleConfig = JSON.parse(_fs.default.readFileSync(_path.default.join(modulePath, 'module.json'), 'UTF-8')); + } catch (e) { + this.log.error(`error while trying to read 'module.json' from '${modulePath}' module: `, e); + process.exit(1); + } + + if (!('name' in moduleConfig)) { + this.log.error(`no 'name' field defined in 'module.json' in '${modulePath}' module.`); + process.exit(1); + } + + return moduleConfig; + } + /** + * Scans all modules for module.json and gathers this configuration altogether. + * + * @returns {[]} + */ + + + gatherModuleConfigs() { + const configs = []; + + if (!isEmptySync(this.$.env.paths.desktop.modules)) { + _shelljs.default.ls('-d', _path.default.join(this.$.env.paths.desktop.modules, '*')).forEach(module => { + if (_fs.default.lstatSync(module).isDirectory()) { + const moduleConfig = this.getModuleConfig(module); + moduleConfig.dirName = _path.default.parse(module).name; + configs.push(moduleConfig); + } + }); + } + + return configs; + } + /** + * Summarizes all dependencies defined in .desktop. + * + * @params {Object} settings - settings.json + * @params {boolean} checkModules - whether to gather modules dependencies + * @params {boolean} refresh - recompute + * @returns {{fromSettings: {}, plugins: {}, modules: {}}} + */ + + + getDependencies(settings = null, checkModules = true, refresh = false) { + if (!refresh && this.dependencies) { + return this.dependencies; + } + + const dependencies = { + fromSettings: {}, + plugins: {}, + modules: {} + }; + /** @type {desktopSettings} * */ + + const settingsJson = settings || this.getSettings(); // Settings can have a 'dependencies' field. + + if ('dependencies' in settingsJson) { + dependencies.fromSettings = settingsJson.dependencies; + } // Plugins are also a npm packages. + + + if ('plugins' in settingsJson) { + dependencies.plugins = Object.keys(settingsJson.plugins).reduce((plugins, plugin) => { + /* eslint-disable no-param-reassign */ + if (typeof settingsJson.plugins[plugin] === 'object') { + plugins[plugin] = settingsJson.plugins[plugin].version; + } else { + plugins[plugin] = settingsJson.plugins[plugin]; + } + + return plugins; + }, {}); + } // Each module can have its own dependencies defined. + + + const moduleDependencies = {}; + + if (checkModules) { + const configs = this.gatherModuleConfigs(); + configs.forEach(moduleConfig => { + if (!('dependencies' in moduleConfig)) { + moduleConfig.dependencies = {}; + } + + if (moduleConfig.name in moduleDependencies) { + this.log.error(`duplicate name '${moduleConfig.name}' in 'module.json' in ` + `'${moduleConfig.dirName}' - another module already registered the same name.`); + process.exit(1); + } + + moduleDependencies[moduleConfig.name] = moduleConfig.dependencies; + }); + } + + dependencies.modules = moduleDependencies; + this.dependencies = dependencies; + return dependencies; + } + /** + * Copies the .desktop scaffold into the meteor app dir. + * Adds entry to .meteor/.gitignore. + */ + + + scaffold() { + this.log.info('creating .desktop scaffold in your project'); + + if (this.$.utils.exists(this.$.env.paths.desktop.root)) { + this.log.warn('.desktop already exists - delete it if you want a new one to be ' + 'created'); + return; + } + + _shelljs.default.cp('-r', this.$.env.paths.scaffold, this.$.env.paths.desktop.root); + + _shelljs.default.mkdir(this.$.env.paths.desktop.import); + + this.log.info('.desktop directory prepared'); + } + /** + * Verifies if all mandatory files are present in the .desktop. + * + * @returns {boolean} + */ + + + check() { + this.log.verbose('checking .desktop existence'); + return !!(this.$.utils.exists(this.$.env.paths.desktop.root) && this.$.utils.exists(this.$.env.paths.desktop.settings) && this.$.utils.exists(this.$.env.paths.desktop.desktop)); + } + +} +/** + * @typedef {Object} desktopSettings + * @property {string} name + * @property {string} projectName + * @property {boolean} devTools + * @property {boolean} devtron + * @property {boolean} desktopHCP + * @property {Object} squirrel + * @property {string} squirrel.autoUpdateFeedUrl + * @property {Object} squirrel.autoUpdateFeedHeaders + * @property {Object} squirrel.autoUpdateCheckOnStart + * @property {Object} desktopHCPSettings + * @property {boolean} desktopHCPSettings.ignoreCompatibilityVersion + * @property {boolean} desktopHCPSettings.blockAppUpdateOnDesktopIncompatibility + * @property {number} webAppStartupTimeout + * @property {Array} linkPackages + * @property {Array} exposedModules + * @property {Object} window + * @property {Object} windowDev + * @property {Object} packageJsonFields + * @property {Object} builderOptions + * @property {Object} builderCliOptions + * @property {Object} packagerOptions + * @property {Object} plugins + * @property {Object} dependencies + * @property {boolean} uglify + * @property {string} version + * */ + + +exports.default = Desktop; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["shell","config","fatal","isEmptySync","searchPath","stat","fs","statSync","e","isDirectory","items","readdirSync","length","Desktop","constructor","$","log","Log","settings","dependencies","getSettings","JSON","parse","readFileSync","env","paths","desktop","error","process","exit","getHashVersion","info","version","utils","readFilesAndComputeHash","root","verbose","hash","getModuleConfig","modulePath","moduleConfig","path","join","gatherModuleConfigs","configs","modules","ls","forEach","module","lstatSync","dirName","name","push","getDependencies","checkModules","refresh","fromSettings","plugins","settingsJson","Object","keys","reduce","plugin","moduleDependencies","scaffold","exists","warn","cp","mkdir","import","check"],"sources":["../lib/desktop.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport shell from 'shelljs';\nimport fs from 'fs';\nimport path from 'path';\n\nimport Log from './log';\n\nshell.config.fatal = true;\n\n/**\n * Checks if the path is empty.\n * @param {string} searchPath\n * @returns {boolean}\n */\nfunction isEmptySync(searchPath) {\n    let stat;\n    try {\n        stat = fs.statSync(searchPath);\n    } catch (e) {\n        return true;\n    }\n    if (stat.isDirectory()) {\n        const items = fs.readdirSync(searchPath);\n        return !items || !items.length;\n    }\n    return false;\n}\n\n/**\n * Represents the .desktop directory.\n * @class\n * @property {desktopSettings} settings\n */\nexport default class Desktop {\n    /**\n     * @param {MeteorDesktop} $ - context\n     *\n     * @constructor\n     */\n    constructor($) {\n        this.$ = $;\n        this.log = new Log('desktop');\n        this.settings = null;\n        this.dependencies = null;\n    }\n\n    /**\n     * Tries to read and returns settings.json contents from .desktop dir.\n     *\n     * @returns {desktopSettings|null}\n     */\n    getSettings() {\n        if (!this.settings) {\n            try {\n                this.settings = JSON.parse(\n                    fs.readFileSync(this.$.env.paths.desktop.settings, 'UTF-8')\n                );\n            } catch (e) {\n                this.log.error('error while trying to read \\'.desktop/settings.json\\': ', e);\n                process.exit(1);\n            }\n        }\n        return this.settings;\n    }\n\n    /**\n     * Returns a version hash representing current .desktop contents.\n     * @returns {string}\n     */\n    async getHashVersion() {\n        this.log.info('calculating hash version from .desktop contents');\n\n        const version = await this.$.utils.readFilesAndComputeHash(this.$.env.paths.desktop.root);\n\n        this.log.verbose(`calculated .desktop hash version is ${version.hash}`);\n        return version.hash;\n    }\n\n    /**\n     * Tries to read a module.json file from a module at provided path.\n     *\n     * @param {string} modulePath - path to the module dir\n     * @returns {Object}\n     */\n    getModuleConfig(modulePath) {\n        let moduleConfig = {};\n        try {\n            moduleConfig = JSON.parse(\n                fs.readFileSync(path.join(modulePath, 'module.json'), 'UTF-8')\n            );\n        } catch (e) {\n            this.log.error(\n                `error while trying to read 'module.json' from '${modulePath}' module: `,\n                e\n            );\n            process.exit(1);\n        }\n        if (!('name' in moduleConfig)) {\n            this.log.error(`no 'name' field defined in 'module.json' in '${modulePath}' module.`);\n            process.exit(1);\n        }\n        return moduleConfig;\n    }\n\n    /**\n     * Scans all modules for module.json and gathers this configuration altogether.\n     *\n     * @returns {[]}\n     */\n    gatherModuleConfigs() {\n        const configs = [];\n\n        if (!isEmptySync(this.$.env.paths.desktop.modules)) {\n            shell.ls('-d', path.join(this.$.env.paths.desktop.modules, '*')).forEach(\n                (module) => {\n                    if (fs.lstatSync(module).isDirectory()) {\n                        const moduleConfig = this.getModuleConfig(module);\n                        moduleConfig.dirName = path.parse(module).name;\n                        configs.push(moduleConfig);\n                    }\n                }\n            );\n        }\n        return configs;\n    }\n\n    /**\n     * Summarizes all dependencies defined in .desktop.\n     *\n     * @params {Object} settings      - settings.json\n     * @params {boolean} checkModules - whether to gather modules dependencies\n     * @params {boolean} refresh      - recompute\n     * @returns {{fromSettings: {}, plugins: {}, modules: {}}}\n     */\n    getDependencies(settings = null, checkModules = true, refresh = false) {\n        if (!refresh && this.dependencies) {\n            return this.dependencies;\n        }\n\n        const dependencies = {\n            fromSettings: {},\n            plugins: {},\n            modules: {}\n        };\n        /** @type {desktopSettings} * */\n        const settingsJson = settings || this.getSettings();\n\n        // Settings can have a 'dependencies' field.\n        if ('dependencies' in settingsJson) {\n            dependencies.fromSettings = settingsJson.dependencies;\n        }\n\n        // Plugins are also a npm packages.\n        if ('plugins' in settingsJson) {\n            dependencies.plugins = Object.keys(settingsJson.plugins).reduce((plugins, plugin) => {\n                /* eslint-disable no-param-reassign */\n                if (typeof settingsJson.plugins[plugin] === 'object') {\n                    plugins[plugin] = settingsJson.plugins[plugin].version;\n                } else {\n                    plugins[plugin] = settingsJson.plugins[plugin];\n                }\n                return plugins;\n            }, {});\n        }\n\n        // Each module can have its own dependencies defined.\n        const moduleDependencies = {};\n        if (checkModules) {\n            const configs = this.gatherModuleConfigs();\n\n            configs.forEach(\n                (moduleConfig) => {\n                    if (!('dependencies' in moduleConfig)) {\n                        moduleConfig.dependencies = {};\n                    }\n                    if (moduleConfig.name in moduleDependencies) {\n                        this.log.error(`duplicate name '${moduleConfig.name}' in 'module.json' in ` +\n                            `'${moduleConfig.dirName}' - another module already registered the same name.`);\n                        process.exit(1);\n                    }\n                    moduleDependencies[moduleConfig.name] = moduleConfig.dependencies;\n                }\n            );\n        }\n\n        dependencies.modules = moduleDependencies;\n        this.dependencies = dependencies;\n        return dependencies;\n    }\n\n    /**\n     * Copies the .desktop scaffold into the meteor app dir.\n     * Adds entry to .meteor/.gitignore.\n     */\n    scaffold() {\n        this.log.info('creating .desktop scaffold in your project');\n\n        if (this.$.utils.exists(this.$.env.paths.desktop.root)) {\n            this.log.warn('.desktop already exists - delete it if you want a new one to be ' +\n                'created');\n            return;\n        }\n\n        shell.cp('-r', this.$.env.paths.scaffold, this.$.env.paths.desktop.root);\n        shell.mkdir(this.$.env.paths.desktop.import);\n        this.log.info('.desktop directory prepared');\n    }\n\n    /**\n     * Verifies if all mandatory files are present in the .desktop.\n     *\n     * @returns {boolean}\n     */\n    check() {\n        this.log.verbose('checking .desktop existence');\n        return !!(this.$.utils.exists(this.$.env.paths.desktop.root) &&\n            this.$.utils.exists(this.$.env.paths.desktop.settings) &&\n            this.$.utils.exists(this.$.env.paths.desktop.desktop));\n    }\n}\n\n/**\n * @typedef {Object} desktopSettings\n * @property {string} name\n * @property {string} projectName\n * @property {boolean} devTools\n * @property {boolean} devtron\n * @property {boolean} desktopHCP\n * @property {Object} squirrel\n * @property {string} squirrel.autoUpdateFeedUrl\n * @property {Object} squirrel.autoUpdateFeedHeaders\n * @property {Object} squirrel.autoUpdateCheckOnStart\n * @property {Object} desktopHCPSettings\n * @property {boolean} desktopHCPSettings.ignoreCompatibilityVersion\n * @property {boolean} desktopHCPSettings.blockAppUpdateOnDesktopIncompatibility\n * @property {number} webAppStartupTimeout\n * @property {Array} linkPackages\n * @property {Array} exposedModules\n * @property {Object} window\n * @property {Object} windowDev\n * @property {Object} packageJsonFields\n * @property {Object} builderOptions\n * @property {Object} builderCliOptions\n * @property {Object} packagerOptions\n * @property {Object} plugins\n * @property {Object} dependencies\n * @property {boolean} uglify\n * @property {string} version\n * */\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/electron.js b/dist/electron.js new file mode 100644 index 00000000..4b4a584d --- /dev/null +++ b/dist/electron.js @@ -0,0 +1,61 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _crossSpawn = _interopRequireDefault(require("cross-spawn")); + +var _log = _interopRequireDefault(require("./log")); + +var _defaultDependencies = _interopRequireDefault(require("./defaultDependencies")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Simple Electron runner. Runs the project with the bin provided by the 'electron' package. + * @class + */ +class Electron { + constructor($) { + this.log = new _log.default('electron'); + this.$ = $; + } + + async init() { + this.electron = await this.$.getDependency('electron', _defaultDependencies.default.electron); + } + + run() { + // Until: https://github.com/electron-userland/electron-prebuilt/pull/118 + const { + env + } = process; + env.ELECTRON_ENV = 'development'; + const cmd = []; + + if (this.$.env.options.debug) { + cmd.push('--debug=5858'); + } + + cmd.push('.'); + const child = (0, _crossSpawn.default)(this.electron.dependency, cmd, { + cwd: this.$.env.paths.electronApp.root, + env + }); // TODO: check if we can configure piping in spawn options + + child.stdout.on('data', chunk => { + process.stdout.write(chunk); + }); + child.stderr.on('data', chunk => { + process.stderr.write(chunk); + }); + } + +} + +exports.default = Electron; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/electronApp.js b/dist/electronApp.js new file mode 100644 index 00000000..6e7966c3 --- /dev/null +++ b/dist/electronApp.js @@ -0,0 +1,876 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _asar = _interopRequireDefault(require("@electron/asar")); + +var _assignIn = _interopRequireDefault(require("lodash/assignIn")); + +var _lodash = _interopRequireDefault(require("lodash")); + +var _installLocal = require("install-local"); + +var _core = require("@babel/core"); + +var _crypto = _interopRequireDefault(require("crypto")); + +var _del = _interopRequireDefault(require("del")); + +var _presetEnv = _interopRequireDefault(require("@babel/preset-env")); + +var _fs = _interopRequireDefault(require("fs")); + +var _path = _interopRequireDefault(require("path")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _semver = _interopRequireDefault(require("semver")); + +var _terser = _interopRequireDefault(require("terser")); + +var _log = _interopRequireDefault(require("./log")); + +var _electronAppScaffold = _interopRequireDefault(require("./electronAppScaffold")); + +var _dependenciesManager = _interopRequireDefault(require("./dependenciesManager")); + +var _binaryModulesDetector = _interopRequireDefault(require("./binaryModulesDetector")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars +_shelljs.default.config.fatal = true; +/** + * Represents the .desktop dir scaffold. + * @class + */ + +class ElectronApp { + /** + * @param {MeteorDesktop} $ - context + * @constructor + */ + constructor($) { + this.log = new _log.default('electronApp'); + this.scaffold = new _electronAppScaffold.default($); + this.depsManager = new _dependenciesManager.default($, this.scaffold.getDefaultPackageJson().dependencies); + this.$ = $; + this.meteorApp = this.$.meteorApp; + this.packageJson = null; + this.version = null; + this.compatibilityVersion = null; + this.deprectatedPlugins = ['meteor-desktop-localstorage']; + } + /** + * Makes an app.asar from the skeleton app. + * @property {Array} excludeFromDel - list of paths to exclude from deleting + * @returns {Promise} + */ + + + packSkeletonToAsar(excludeFromDel = []) { + this.log.info('packing skeleton app and node_modules to asar archive'); + return new Promise(resolve => { + const extract = this.getModulesToExtract(); // We want to pack skeleton app and node_modules together, so we need to temporarily + // move node_modules to app dir. + + this.log.debug('moving node_modules to app dir'); + + _fs.default.renameSync(this.$.env.paths.electronApp.nodeModules, _path.default.join(this.$.env.paths.electronApp.appRoot, 'node_modules')); + + let extracted = false; + extracted = this.extractModules(extract); + this.log.debug('packing'); + + _asar.default.createPackage(this.$.env.paths.electronApp.appRoot, this.$.env.paths.electronApp.appAsar).then(() => { + // Lets move the node_modules back. + this.log.debug('moving node_modules back from app dir'); + + _shelljs.default.mv(_path.default.join(this.$.env.paths.electronApp.appRoot, 'node_modules'), this.$.env.paths.electronApp.nodeModules); + + if (extracted) { + // We need to create a full node modules back. In other words we want + // the extracted modules back. + extract.forEach(module => _shelljs.default.cp('-rf', _path.default.join(this.$.env.paths.electronApp.extractedNodeModules, module), _path.default.join(this.$.env.paths.electronApp.nodeModules, module))); // Get the .bin back. + + if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModulesBin)) { + _shelljs.default.cp(_path.default.join(this.$.env.paths.electronApp.extractedNodeModulesBin, '*'), _path.default.join(this.$.env.paths.electronApp.nodeModules, '.bin')); + } + } + + this.log.debug('deleting source files'); + const exclude = [this.$.env.paths.electronApp.nodeModules].concat([this.$.env.paths.electronApp.appAsar, this.$.env.paths.electronApp.packageJson], excludeFromDel); + + _del.default.sync([`${this.$.env.paths.electronApp.root}${_path.default.sep}*`].concat(exclude.map(pathToExclude => `!${pathToExclude}`)), { + force: true + }); + + resolve(); + }); + }); + } + /** + * Moves specified node modules to a separate directory. + * @param {Array} extract + * @returns {boolean} + */ + + + extractModules(extract) { + const ext = ['.js', '.bat', '.sh', '.cmd', '']; + + if (extract.length > 0) { + if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) { + _shelljs.default.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules); + } + + _fs.default.mkdirSync(this.$.env.paths.electronApp.extractedNodeModules); + + _fs.default.mkdirSync(this.$.env.paths.electronApp.extractedNodeModulesBin); + + extract.forEach(module => { + _fs.default.renameSync(_path.default.join(this.$.env.paths.electronApp.appRoot, 'node_modules', module), _path.default.join(this.$.env.paths.electronApp.extractedNodeModules, module)); // Move bins. + + + this.extractBin(module, ext); + }); + return true; + } + + return false; + } + /** + * Extracts the bin files associated with a certain node modules. + * + * @param module + * @param ext + */ + + + extractBin(module, ext) { + let packageJson; + + try { + packageJson = JSON.parse(_fs.default.readFileSync(_path.default.join(this.$.env.paths.electronApp.extractedNodeModules, module, 'package.json'), 'utf8')); + } catch (e) { + packageJson = {}; + } + + const bins = 'bin' in packageJson && typeof packageJson.bin === 'object' ? Object.keys(packageJson.bin) : []; + + if (bins.length > 0) { + bins.forEach(bin => { + ext.forEach(extension => { + const binFilePath = _path.default.join(this.$.env.paths.electronApp.appRoot, 'node_modules', '.bin', `${bin}${extension}`); + + if (this.$.utils.exists(binFilePath) || this.$.utils.symlinkExists(binFilePath)) { + _fs.default.renameSync(binFilePath, _path.default.join(this.$.env.paths.electronApp.extractedNodeModulesBin, `${bin}${extension}`)); + } + }); + }); + } + } + /** + * Merges the `extract` field with automatically detected modules. + */ + + + getModulesToExtract() { + const binaryModulesDetector = new _binaryModulesDetector.default(this.$.env.paths.electronApp.nodeModules); + const toBeExtracted = binaryModulesDetector.detect(); + let { + extract + } = this.$.desktop.getSettings(); + + if (!Array.isArray(extract)) { + extract = []; + } + + const merge = {}; + toBeExtracted.concat(extract).forEach(module => { + merge[module] = true; + }); + extract = Object.keys(merge); + + if (extract.length > 0) { + this.log.verbose(`resultant modules to extract list is: ${extract.join(', ')}`); + } + + return extract; + } + /** + * Calculates a md5 from all dependencies. + */ + + + calculateCompatibilityVersion() { + this.log.verbose('calculating compatibility version'); + const settings = this.$.desktop.getSettings(); + + if ('desktopHCPCompatibilityVersion' in settings) { + this.compatibilityVersion = `${settings.desktopHCPCompatibilityVersion}`; + this.log.warn(`compatibility version overridden to ${this.compatibilityVersion}`); + return; + } + + const md5 = _crypto.default.createHash('md5'); + + let dependencies = this.depsManager.getDependencies(); + const dependenciesSorted = Object.keys(dependencies).sort(); + dependencies = dependenciesSorted.map(dependency => `${dependency}:${dependencies[dependency]}`); + const mainCompatibilityVersion = this.$.getVersion().split('.'); + this.log.debug('meteor-desktop compatibility version is ', `${mainCompatibilityVersion[0]}`); + dependencies.push(`meteor-desktop:${mainCompatibilityVersion[0]}`); + const desktopCompatibilityVersion = settings.version.split('.')[0]; + this.log.debug('.desktop compatibility version is ', desktopCompatibilityVersion); + dependencies.push(`desktop-app:${desktopCompatibilityVersion}`); + + if (process.env.METEOR_DESKTOP_DEBUG_DESKTOP_COMPATIBILITY_VERSION || process.env.METEOR_DESKTOP_DEBUG) { + this.log.debug(`compatibility version calculated from ${JSON.stringify(dependencies)}`); + } + + md5.update(JSON.stringify(dependencies)); + this.compatibilityVersion = md5.digest('hex'); + } + + async init() { + try { + await this.$.electron.init(); + await this.$.electronBuilder.init(); + } catch (e) { + this.log.warn('error occurred while initialising electron and electron-builder integration', e); + process.exit(1); + } + } + /** + * Runs all necessary tasks to build the desktopified app. + */ + + + async build(run = false) { + // TODO: refactor to a task runner + this.log.info('scaffolding'); + + if (!this.$.desktop.check()) { + if (!this.$.env.options.scaffold) { + this.log.error('seems that you do not have a .desktop dir in your project or it is' + ' corrupted. Run \'npm run desktop -- init\' to get a new one.'); // Do not fail, so that npm will not print his error stuff to console. + + process.exit(0); + } else { + this.$.desktop.scaffold(); + this.$.meteorApp.updateGitIgnore(); + } + } + + await this.init(); + + try { + this.$.meteorApp.updateGitIgnore(); + } catch (e) { + this.log.warn(`error occurred while adding ${this.$.env.paths.electronApp.rootName}` + 'to .gitignore: ', e); + } + + try { + await this.$.meteorApp.removeDeprecatedPackages(); + } catch (e) { + this.log.error('error while removing deprecated packages: ', e); + process.exit(1); + } + + try { + await this.$.meteorApp.ensureDesktopHCPPackages(); + } catch (e) { + this.log.error('error while checking for required packages: ', e); + process.exit(1); + } + + try { + await this.scaffold.make(); + } catch (e) { + this.log.error('error while scaffolding: ', e); + process.exit(1); + } + + try { + const fileName = '.npmrc'; + const dirName = '.meteor/desktop-build'; + + if (_fs.default.existsSync(dirName) && _fs.default.existsSync(fileName)) { + _fs.default.copyFileSync(fileName, `${dirName}/${fileName}`); + } + } catch (e) { + this.log.warn('error while copying .npmrc', e); + } + + try { + await this.exposeElectronModules(); + } catch (e) { + this.log.error('error while exposing electron modules: ', e); + process.exit(1); + } + + try { + this.updatePackageJsonFields(); + } catch (e) { + this.log.error('error while updating package.json: ', e); + } + + try { + this.updateDependenciesList(); + } catch (e) { + this.log.error('error while merging dependencies list: ', e); + } + + try { + this.calculateCompatibilityVersion(); + } catch (e) { + this.log.error('error while calculating compatibility version: ', e); + process.exit(1); + } + + try { + await this.handleTemporaryNodeModules(); + } catch (e) { + this.log.error('error occurred while handling temporary node_modules: ', e); + process.exit(1); + } + + let nodeModulesRemoved; + + try { + nodeModulesRemoved = await this.handleStateOfNodeModules(); + } catch (e) { + this.log.error('error occurred while clearing node_modules: ', e); + process.exit(1); + } + + try { + await this.rebuildDeps(true); + } catch (e) { + this.log.error('error occurred while installing node_modules: ', e); + process.exit(1); + } + + if (!nodeModulesRemoved) { + try { + await this.rebuildDeps(); + } catch (e) { + this.log.error('error occurred while rebuilding native node modules: ', e); + process.exit(1); + } + } + + try { + await this.linkNpmPackages(); + } catch (e) { + this.log.error(`linking packages failed: ${e}`); + process.exit(1); + } + + try { + await this.installLocalNodeModules(); + } catch (e) { + this.log.error('error occurred while installing local node modules: ', e); + process.exit(1); + } + + try { + await this.ensureMeteorDependencies(); + } catch (e) { + this.log.error('error occurred while ensuring meteor dependencies are installed: ', e); + process.exit(1); + } + + if (this.$.env.isProductionBuild()) { + try { + await this.packSkeletonToAsar(); + } catch (e) { + this.log.error('error while packing skeleton to asar: ', e); + process.exit(1); + } + } // TODO: find a way to avoid copying .desktop to a temp location + + + try { + this.copyDesktopToDesktopTemp(); + } catch (e) { + this.log.error('error while copying .desktop to a temporary location: ', e); + process.exit(1); + } + + try { + await this.updateSettingsJsonFields(); + } catch (e) { + this.log.error('error while updating settings.json: ', e); + process.exit(1); + } + + try { + await this.excludeFilesFromArchive(); + } catch (e) { + this.log.error('error while excluding files from packing to asar: ', e); + process.exit(1); + } + + try { + await this.transpileAndMinify(); + } catch (e) { + this.log.error('error while transpiling or minifying: ', e); + } + + try { + await this.packDesktopToAsar(); + } catch (e) { + this.log.error('error occurred while packing .desktop to asar: ', e); + process.exit(1); + } + + try { + await this.getMeteorClientBuild(); + } catch (e) { + this.log.error('error occurred during getting meteor mobile build: ', e); + } + + if (run) { + this.log.info('running'); + this.$.electron.run(); + } else { + this.log.info('built'); + } + } + /** + * Copies the `exposedModules` setting from `settings.json` into `preload.js` modifying its code + * so that the script will have it hardcoded. + */ + + + exposeElectronModules() { + const { + exposedModules + } = this.$.desktop.getSettings(); + + if (exposedModules && Array.isArray(exposedModules) && exposedModules.length > 0) { + let preload = _fs.default.readFileSync(this.$.env.paths.electronApp.preload, 'utf8'); + + const modules = this.$.desktop.getSettings().exposedModules.reduce( // eslint-disable-next-line no-return-assign,no-param-reassign + (prev, module) => (prev += `'${module}', `, prev), ''); + preload = preload.replace('const exposedModules = [', `const exposedModules = [${modules}`); + + _fs.default.writeFileSync(this.$.env.paths.electronApp.preload, preload); + } + } + /** + * Ensures all required dependencies are added to the Meteor project. + * @returns {Promise.} + */ + + + async ensureMeteorDependencies() { + let packages = []; + const packagesWithVersion = []; + let plugins = 'plugins ['; + Object.keys(this.$.desktop.getDependencies().plugins).forEach(plugin => { + // Read package.json of the plugin. + const packageJson = JSON.parse(_fs.default.readFileSync(_path.default.join(this.$.env.paths.electronApp.nodeModules, plugin, 'package.json'), 'utf8')); + + if ('meteorDependencies' in packageJson && typeof packageJson.meteorDependencies === 'object') { + plugins += `${plugin}, `; + packages.unshift(...Object.keys(packageJson.meteorDependencies)); + packagesWithVersion.unshift(...packages.map(packageName => { + if (packageJson.meteorDependencies[packageName] === '@version') { + return `${packageName}@${packageJson.version}`; + } + + return `${packageName}@${packageJson.meteorDependencies[packageName]}`; + })); + } + }); + const packagesCount = packages.length; + packages = packages.filter(value => !this.deprectatedPlugins.includes(value)); + + if (packagesCount !== packages.length) { + this.log.warn('you have some deprecated meteor desktop plugins in your settings, please remove ' + `them (deprecated plugins: ${this.deprectatedPlugins.join(', ')})`); + } + + if (packages.length > 0) { + plugins = `${plugins.substr(0, plugins.length - 2)}]`; + + try { + await this.$.meteorApp.meteorManager.ensurePackages(packages, packagesWithVersion, plugins); + } catch (e) { + throw new Error(e); + } + } + } + /** + * Builds meteor app. + */ + + + async getMeteorClientBuild() { + await this.$.meteorApp.build(); + } + /** + * Removes node_modules if needed. + * @returns {Promise} + */ + + + async handleStateOfNodeModules() { + if (this.$.env.isProductionBuild() || this.$.env.options.ia32) { + if (!this.$.env.isProductionBuild()) { + this.log.info('clearing node_modules because we need to have it clear for ia32 rebuild'); + } else { + this.log.info('clearing node_modules because this is a production build'); + } + + try { + await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.nodeModules); + } catch (e) { + throw new Error(e); + } + + return true; + } + + return false; + } + /** + * If there is a temporary node_modules folder and no node_modules folder, we will + * restore it, as it might be a leftover from an interrupted flow. + * @returns {Promise} + */ + + + async handleTemporaryNodeModules() { + if (this.$.utils.exists(this.$.env.paths.electronApp.tmpNodeModules)) { + if (!this.$.utils.exists(this.$.env.paths.electronApp.nodeModules)) { + this.log.debug('moving temp node_modules back'); + + _shelljs.default.mv(this.$.env.paths.electronApp.tmpNodeModules, this.$.env.paths.electronApp.nodeModules); + } else { + // If there is a node_modules folder, we should clear the temporary one. + this.log.debug('clearing temp node_modules because new one is already created'); + + try { + await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.tmpNodeModules); + } catch (e) { + throw new Error(e); + } + } + } + } + /** + * Runs npm link for every package specified in settings.json->linkPackages. + */ + + + async linkNpmPackages() { + if (this.$.env.isProductionBuild()) { + return; + } + + const settings = this.$.desktop.getSettings(); + const promises = []; + + if ('linkPackages' in this.$.desktop.getSettings()) { + if (Array.isArray(settings.linkPackages)) { + settings.linkPackages.forEach(packageName => promises.push(this.$.meteorApp.runNpm(['link', packageName], undefined, this.$.env.paths.electronApp.root))); + } + } + + await Promise.all(promises); + } + /** + * Runs npm in the electron app to get the dependencies installed. + * @returns {Promise} + */ + + + async ensureDeps() { + this.log.info('installing dependencies'); + + if (this.$.utils.exists(this.$.env.paths.electronApp.nodeModules)) { + this.log.debug('running npm prune to wipe unneeded dependencies'); + + try { + await this.runNpm(['prune']); + } catch (e) { + throw new Error(e); + } + } + + try { + await this.runNpm(['install'], this.$.env.stdio); + } catch (e) { + throw new Error(e); + } + } + /** + * Warns if plugins version are outdated in compare to the newest scaffold. + * @param {Object} pluginsVersions - current plugins versions from settings.json + */ + + + checkPluginsVersion(pluginsVersions) { + const settingsJson = JSON.parse(_fs.default.readFileSync(_path.default.join(this.$.env.paths.scaffold, 'settings.json'))); + const scaffoldPluginsVersion = this.$.desktop.getDependencies(settingsJson, false).plugins; + Object.keys(pluginsVersions).forEach(pluginName => { + if (pluginName in scaffoldPluginsVersion && scaffoldPluginsVersion[pluginName] !== pluginsVersions[pluginName] && _semver.default.lt(pluginsVersions[pluginName], scaffoldPluginsVersion[pluginName])) { + this.log.warn(`you are using outdated version ${pluginsVersions[pluginName]} of ` + `${pluginName}, the suggested version to use is ` + `${scaffoldPluginsVersion[pluginName]}`); + } + }); + } + /** + * Merges core dependency list with the dependencies from .desktop. + */ + + + updateDependenciesList() { + this.log.info('updating list of package.json\'s dependencies'); + const desktopDependencies = this.$.desktop.getDependencies(); + this.checkPluginsVersion(desktopDependencies.plugins); + this.log.debug('merging settings.json[dependencies]'); + this.depsManager.mergeDependencies('settings.json[dependencies]', desktopDependencies.fromSettings); + this.log.debug('merging settings.json[plugins]'); + this.depsManager.mergeDependencies('settings.json[plugins]', desktopDependencies.plugins); + this.log.debug('merging dependencies from modules'); + Object.keys(desktopDependencies.modules).forEach(module => this.depsManager.mergeDependencies(`module[${module}]`, desktopDependencies.modules[module])); + this.packageJson.dependencies = this.depsManager.getRemoteDependencies(); + this.packageJson.localDependencies = this.depsManager.getLocalDependencies(); + this.log.debug('writing updated package.json'); + + _fs.default.writeFileSync(this.$.env.paths.electronApp.packageJson, JSON.stringify(this.packageJson, null, 2)); + } + /** + * Install node modules from local paths using local-install. + * + * @param {string} arch + * @returns {Promise} + */ + + + installLocalNodeModules(arch = this.$.env.options.ia32 || process.arch === 'ia32' ? 'ia32' : 'x64') { + const localDependencies = _lodash.default.values(this.packageJson.localDependencies); + + if (localDependencies.length === 0) { + return Promise.resolve(); + } + + this.log.info('installing local node modules'); + const lastRebuild = this.$.electronBuilder.prepareLastRebuildObject(arch); + const env = this.$.electronBuilder.getGypEnv(lastRebuild.frameworkInfo, lastRebuild.platform, lastRebuild.arch); + const installer = new _installLocal.LocalInstaller({ + [this.$.env.paths.electronApp.root]: localDependencies + }, { + npmEnv: env + }); + (0, _installLocal.progress)(installer); + return installer.install(); + } + /** + * Rebuild binary dependencies against Electron's node headers. + * @returns {Promise} + */ + + + rebuildDeps(install = false) { + if (install) { + this.log.info('issuing node_modules install from electron-builder'); + } else { + this.log.info('issuing native modules rebuild from electron-builder'); + } + + const arch = this.$.env.options.ia32 || process.arch === 'ia32' ? 'ia32' : 'x64'; + + if (this.$.env.options.ia32) { + this.log.verbose('forcing rebuild for 32bit'); + } else { + this.log.verbose(`rebuilding for ${arch}`); + } + + return this.$.electronBuilder.installOrRebuild(arch, undefined, install); + } + /** + * Update package.json fields accordingly to what is set in settings.json. + * + * packageJson.name = settings.projectName + * packageJson.version = settings.version + * packageJson.* = settings.packageJsonFields + */ + + + updatePackageJsonFields() { + this.log.verbose('updating package.json fields'); + const settings = this.$.desktop.getSettings(); + /** @type {desktopSettings} */ + + const packageJson = this.scaffold.getDefaultPackageJson(); + packageJson.version = settings.version; + + if ('packageJsonFields' in settings) { + (0, _assignIn.default)(packageJson, settings.packageJsonFields); + } + + (0, _assignIn.default)(packageJson, { + name: settings.projectName + }); + this.log.debug('writing updated package.json'); + + _fs.default.writeFileSync(this.$.env.paths.electronApp.packageJson, JSON.stringify(packageJson, null, 4)); + + this.packageJson = packageJson; + } + /** + * Updates settings.json with env (prod/dev) information and versions. + */ + + + async updateSettingsJsonFields() { + this.log.debug('updating settings.json fields'); + const settings = this.$.desktop.getSettings(); // Save versions. + + settings.compatibilityVersion = this.compatibilityVersion; // Pass information about build type to the settings.json. + + settings.env = this.$.env.isProductionBuild() ? 'prod' : 'dev'; + const version = await this.$.desktop.getHashVersion(); + settings.desktopVersion = `${version}_${settings.env}`; + settings.meteorDesktopVersion = this.$.getVersion(); + + if (this.$.env.options.prodDebug) { + settings.prodDebug = true; + } + + _fs.default.writeFileSync(this.$.env.paths.desktopTmp.settings, JSON.stringify(settings, null, 4)); + } + /** + * Copies files from prepared .desktop to desktop.asar in electron app. + */ + + + packDesktopToAsar() { + this.log.info('packing .desktop to asar'); + return new Promise((resolve, reject) => { + _asar.default.createPackage(this.$.env.paths.desktopTmp.root, this.$.env.paths.electronApp.desktopAsar).then(() => { + this.log.verbose('clearing temporary .desktop'); + this.$.utils.rmWithRetries('-rf', this.$.env.paths.desktopTmp.root).then(() => { + resolve(); + }).catch(e => { + reject(e); + }); + resolve(); + }); + }); + } + /** + * Makes a temporary copy of .desktop. + */ + + + copyDesktopToDesktopTemp() { + this.log.verbose('copying .desktop to temporary location'); + + _shelljs.default.cp('-rf', this.$.env.paths.desktop.root, this.$.env.paths.desktopTmp.root); // Remove test files. + + + _del.default.sync([_path.default.join(this.$.env.paths.desktopTmp.root, '**', '*.test.js')], { + force: true + }); + } + /** + * Runs babel and uglify over .desktop if requested. + */ + + + async transpileAndMinify() { + this.log.info('transpiling and uglifying'); + const settings = this.$.desktop.getSettings(); + const options = 'uglifyOptions' in settings ? settings.uglifyOptions : {}; + const uglifyingEnabled = 'uglify' in settings && !!settings.uglify; + const preset = (0, _presetEnv.default)({ + assertVersion: () => {} + }, { + targets: { + node: '12' + } + }); + const { + data: files + } = await this.$.utils.readDir(this.$.env.paths.desktopTmp.root); + files.forEach(file => { + if (file.endsWith('.js')) { + let { + code + } = (0, _core.transformFileSync)(file, { + presets: [preset] + }); + let error; + + if (settings.env === 'prod' && uglifyingEnabled) { + ({ + code, + error + } = _terser.default.minify(code, options)); + } + + if (error) { + throw new Error(error); + } + + _fs.default.writeFileSync(file, code); + } + }); + } + /** + * Moves all the files that should not be packed into asar into a safe location which is the + * 'extracted' dir in the electron app. + */ + + + async excludeFilesFromArchive() { + this.log.info('excluding files from packing'); // Ensure empty `extracted` dir + + try { + await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.extracted); + } catch (e) { + throw new Error(e); + } + + _shelljs.default.mkdir(this.$.env.paths.electronApp.extracted); + + const configs = this.$.desktop.gatherModuleConfigs(); // Move files that should not be asar'ed. + + configs.forEach(config => { + const moduleConfig = config; + + if ('extract' in moduleConfig) { + if (!Array.isArray(moduleConfig.extract)) { + moduleConfig.extract = [moduleConfig.extract]; + } + + moduleConfig.extract.forEach(file => { + this.log.debug(`excluding ${file} from ${config.name}`); + + const filePath = _path.default.join(this.$.env.paths.desktopTmp.modules, moduleConfig.dirName, file); + + const destinationPath = _path.default.join(this.$.env.paths.electronApp.extracted, moduleConfig.dirName); + + if (!this.$.utils.exists(destinationPath)) { + _shelljs.default.mkdir(destinationPath); + } + + _shelljs.default.mv(filePath, destinationPath); + }); + } + }); + } + +} + +exports.default = ElectronApp; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["shell","config","fatal","ElectronApp","constructor","$","log","Log","scaffold","ElectronAppScaffold","depsManager","DependenciesManager","getDefaultPackageJson","dependencies","meteorApp","packageJson","version","compatibilityVersion","deprectatedPlugins","packSkeletonToAsar","excludeFromDel","info","Promise","resolve","extract","getModulesToExtract","debug","fs","renameSync","env","paths","electronApp","nodeModules","path","join","appRoot","extracted","extractModules","asar","createPackage","appAsar","then","mv","forEach","module","cp","extractedNodeModules","utils","exists","extractedNodeModulesBin","exclude","concat","del","sync","root","sep","map","pathToExclude","force","ext","length","rm","mkdirSync","extractBin","JSON","parse","readFileSync","e","bins","bin","Object","keys","extension","binFilePath","symlinkExists","binaryModulesDetector","BinaryModuleDetector","toBeExtracted","detect","desktop","getSettings","Array","isArray","merge","verbose","calculateCompatibilityVersion","settings","desktopHCPCompatibilityVersion","warn","md5","crypto","createHash","getDependencies","dependenciesSorted","sort","dependency","mainCompatibilityVersion","getVersion","split","push","desktopCompatibilityVersion","process","METEOR_DESKTOP_DEBUG_DESKTOP_COMPATIBILITY_VERSION","METEOR_DESKTOP_DEBUG","stringify","update","digest","init","electron","electronBuilder","exit","build","run","check","options","error","updateGitIgnore","rootName","removeDeprecatedPackages","ensureDesktopHCPPackages","make","fileName","dirName","existsSync","copyFileSync","exposeElectronModules","updatePackageJsonFields","updateDependenciesList","handleTemporaryNodeModules","nodeModulesRemoved","handleStateOfNodeModules","rebuildDeps","linkNpmPackages","installLocalNodeModules","ensureMeteorDependencies","isProductionBuild","copyDesktopToDesktopTemp","updateSettingsJsonFields","excludeFilesFromArchive","transpileAndMinify","packDesktopToAsar","getMeteorClientBuild","exposedModules","preload","modules","reduce","prev","replace","writeFileSync","packages","packagesWithVersion","plugins","plugin","meteorDependencies","unshift","packageName","packagesCount","filter","value","includes","substr","meteorManager","ensurePackages","Error","ia32","rmWithRetries","tmpNodeModules","promises","linkPackages","runNpm","undefined","all","ensureDeps","stdio","checkPluginsVersion","pluginsVersions","settingsJson","scaffoldPluginsVersion","pluginName","semver","lt","desktopDependencies","mergeDependencies","fromSettings","getRemoteDependencies","localDependencies","getLocalDependencies","arch","_","values","lastRebuild","prepareLastRebuildObject","getGypEnv","frameworkInfo","platform","installer","LocalInstaller","npmEnv","progress","install","installOrRebuild","assignIn","packageJsonFields","name","projectName","getHashVersion","desktopVersion","meteorDesktopVersion","prodDebug","desktopTmp","reject","desktopAsar","catch","uglifyOptions","uglifyingEnabled","uglify","preset","presetEnv","assertVersion","targets","node","data","files","readDir","file","endsWith","code","transformFileSync","presets","minify","mkdir","configs","gatherModuleConfigs","moduleConfig","filePath","destinationPath"],"sources":["../lib/electronApp.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport asar from '@electron/asar';\nimport assignIn from 'lodash/assignIn';\nimport _ from 'lodash';\nimport { LocalInstaller, progress } from 'install-local';\nimport { transformFileSync } from '@babel/core';\nimport crypto from 'crypto';\nimport del from 'del';\nimport presetEnv from '@babel/preset-env';\nimport fs from 'fs';\nimport path from 'path';\nimport shell from 'shelljs';\nimport semver from 'semver';\nimport uglify from 'terser';\n\nimport Log from './log';\nimport ElectronAppScaffold from './electronAppScaffold';\nimport DependenciesManager from './dependenciesManager';\nimport BinaryModuleDetector from './binaryModulesDetector';\n\nshell.config.fatal = true;\n\n/**\n * Represents the .desktop dir scaffold.\n * @class\n */\nexport default class ElectronApp {\n    /**\n     * @param {MeteorDesktop} $ - context\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('electronApp');\n        this.scaffold = new ElectronAppScaffold($);\n        this.depsManager = new DependenciesManager(\n            $,\n            this.scaffold.getDefaultPackageJson().dependencies\n        );\n        this.$ = $;\n        this.meteorApp = this.$.meteorApp;\n        this.packageJson = null;\n        this.version = null;\n        this.compatibilityVersion = null;\n        this.deprectatedPlugins = ['meteor-desktop-localstorage'];\n    }\n\n    /**\n     * Makes an app.asar from the skeleton app.\n     * @property {Array} excludeFromDel - list of paths to exclude from deleting\n     * @returns {Promise}\n     */\n    packSkeletonToAsar(excludeFromDel = []) {\n        this.log.info('packing skeleton app and node_modules to asar archive');\n        return new Promise((resolve) => {\n            const extract = this.getModulesToExtract();\n\n            // We want to pack skeleton app and node_modules together, so we need to temporarily\n            // move node_modules to app dir.\n            this.log.debug('moving node_modules to app dir');\n\n            fs.renameSync(\n                this.$.env.paths.electronApp.nodeModules,\n                path.join(this.$.env.paths.electronApp.appRoot, 'node_modules')\n            );\n\n            let extracted = false;\n            extracted = this.extractModules(extract);\n\n            this.log.debug('packing');\n            asar.createPackage(\n                this.$.env.paths.electronApp.appRoot,\n                this.$.env.paths.electronApp.appAsar\n            )\n                .then(() => {\n                    // Lets move the node_modules back.\n                    this.log.debug('moving node_modules back from app dir');\n\n                    shell.mv(\n                        path.join(this.$.env.paths.electronApp.appRoot, 'node_modules'),\n                        this.$.env.paths.electronApp.nodeModules\n                    );\n\n                    if (extracted) {\n                        // We need to create a full node modules back. In other words we want\n                        // the extracted modules back.\n                        extract.forEach(module => shell.cp(\n                            '-rf',\n                            path.join(this.$.env.paths.electronApp.extractedNodeModules, module),\n                            path.join(this.$.env.paths.electronApp.nodeModules, module)\n                        ));\n\n                        // Get the .bin back.\n                        if (this.$.utils.exists(\n                            this.$.env.paths.electronApp.extractedNodeModulesBin\n                        )) {\n                            shell.cp(\n                                path.join(this.$.env.paths.electronApp.extractedNodeModulesBin, '*'),\n                                path.join(this.$.env.paths.electronApp.nodeModules, '.bin')\n                            );\n                        }\n                    }\n\n                    this.log.debug('deleting source files');\n                    const exclude = [this.$.env.paths.electronApp.nodeModules].concat(\n                        [\n                            this.$.env.paths.electronApp.appAsar,\n                            this.$.env.paths.electronApp.packageJson\n                        ],\n                        excludeFromDel\n                    );\n\n                    del.sync(\n                        [`${this.$.env.paths.electronApp.root}${path.sep}*`].concat(\n                            exclude.map(pathToExclude => `!${pathToExclude}`)\n                        ),\n                        { force: true }\n                    );\n                    resolve();\n                });\n        });\n    }\n\n    /**\n     * Moves specified node modules to a separate directory.\n     * @param {Array} extract\n     * @returns {boolean}\n     */\n    extractModules(extract) {\n        const ext = ['.js', '.bat', '.sh', '.cmd', ''];\n\n        if (extract.length > 0) {\n            if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) {\n                shell.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules);\n            }\n            fs.mkdirSync(this.$.env.paths.electronApp.extractedNodeModules);\n            fs.mkdirSync(this.$.env.paths.electronApp.extractedNodeModulesBin);\n\n            extract.forEach((module) => {\n                fs.renameSync(\n                    path.join(this.$.env.paths.electronApp.appRoot, 'node_modules', module),\n                    path.join(this.$.env.paths.electronApp.extractedNodeModules, module),\n                );\n                // Move bins.\n                this.extractBin(module, ext);\n            });\n\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * Extracts the bin files associated with a certain node modules.\n     *\n     * @param module\n     * @param ext\n     */\n    extractBin(module, ext) {\n        let packageJson;\n        try {\n            packageJson = JSON.parse(\n                fs.readFileSync(\n                    path.join(\n                        this.$.env.paths.electronApp.extractedNodeModules, module, 'package.json'\n                    ),\n                    'utf8'\n                )\n            );\n        } catch (e) {\n            packageJson = {};\n        }\n\n\n        const bins = ('bin' in packageJson && typeof packageJson.bin === 'object') ? Object.keys(packageJson.bin) : [];\n\n        if (bins.length > 0) {\n            bins.forEach((bin) => {\n                ext.forEach((extension) => {\n                    const binFilePath = path.join(\n                        this.$.env.paths.electronApp.appRoot,\n                        'node_modules',\n                        '.bin',\n                        `${bin}${extension}`\n                    );\n                    if (this.$.utils.exists(binFilePath) ||\n                        this.$.utils.symlinkExists(binFilePath)\n                    ) {\n                        fs.renameSync(\n                            binFilePath,\n                            path.join(\n                                this.$.env.paths.electronApp.extractedNodeModulesBin,\n                                `${bin}${extension}`\n                            )\n                        );\n                    }\n                });\n            });\n        }\n    }\n\n    /**\n     * Merges the `extract` field with automatically detected modules.\n     */\n    getModulesToExtract() {\n        const binaryModulesDetector =\n            new BinaryModuleDetector(this.$.env.paths.electronApp.nodeModules);\n        const toBeExtracted = binaryModulesDetector.detect();\n\n        let { extract } = this.$.desktop.getSettings();\n\n        if (!Array.isArray(extract)) {\n            extract = [];\n        }\n\n        const merge = {};\n        toBeExtracted.concat(extract).forEach((module) => {\n            merge[module] = true;\n        });\n        extract = Object.keys(merge);\n        if (extract.length > 0) {\n            this.log.verbose(`resultant modules to extract list is: ${extract.join(', ')}`);\n        }\n        return extract;\n    }\n\n    /**\n     * Calculates a md5 from all dependencies.\n     */\n    calculateCompatibilityVersion() {\n        this.log.verbose('calculating compatibility version');\n        const settings = this.$.desktop.getSettings();\n\n        if (('desktopHCPCompatibilityVersion' in settings)) {\n            this.compatibilityVersion = `${settings.desktopHCPCompatibilityVersion}`;\n            this.log.warn(`compatibility version overridden to ${this.compatibilityVersion}`);\n            return;\n        }\n\n        const md5 = crypto.createHash('md5');\n        let dependencies = this.depsManager.getDependencies();\n        const dependenciesSorted = Object.keys(dependencies).sort();\n        dependencies = dependenciesSorted.map(dependency =>\n            `${dependency}:${dependencies[dependency]}`);\n        const mainCompatibilityVersion = this.$.getVersion().split('.');\n        this.log.debug('meteor-desktop compatibility version is ',\n            `${mainCompatibilityVersion[0]}`);\n        dependencies.push(\n            `meteor-desktop:${mainCompatibilityVersion[0]}`\n        );\n\n        const desktopCompatibilityVersion = settings.version.split('.')[0];\n        this.log.debug('.desktop compatibility version is ', desktopCompatibilityVersion);\n        dependencies.push(\n            `desktop-app:${desktopCompatibilityVersion}`\n        );\n\n        if (process.env.METEOR_DESKTOP_DEBUG_DESKTOP_COMPATIBILITY_VERSION ||\n            process.env.METEOR_DESKTOP_DEBUG\n        ) {\n            this.log.debug(`compatibility version calculated from ${JSON.stringify(dependencies)}`);\n        }\n\n        md5.update(JSON.stringify(dependencies));\n\n        this.compatibilityVersion = md5.digest('hex');\n    }\n\n    async init() {\n        try {\n            await this.$.electron.init();\n            await this.$.electronBuilder.init();\n        } catch (e) {\n            this.log.warn('error occurred while initialising electron and electron-builder integration', e);\n            process.exit(1);\n        }\n    }\n\n    /**\n     * Runs all necessary tasks to build the desktopified app.\n     */\n    async build(run = false) {\n        // TODO: refactor to a task runner\n        this.log.info('scaffolding');\n\n        if (!this.$.desktop.check()) {\n            if (!this.$.env.options.scaffold) {\n                this.log.error('seems that you do not have a .desktop dir in your project or it is' +\n                    ' corrupted. Run \\'npm run desktop -- init\\' to get a new one.');\n                // Do not fail, so that npm will not print his error stuff to console.\n                process.exit(0);\n            } else {\n                this.$.desktop.scaffold();\n                this.$.meteorApp.updateGitIgnore();\n            }\n        }\n\n        await this.init();\n\n\n        try {\n            this.$.meteorApp.updateGitIgnore();\n        } catch (e) {\n            this.log.warn(`error occurred while adding ${this.$.env.paths.electronApp.rootName}` +\n                'to .gitignore: ', e);\n        }\n\n        try {\n            await this.$.meteorApp.removeDeprecatedPackages();\n        } catch (e) {\n            this.log.error('error while removing deprecated packages: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.$.meteorApp.ensureDesktopHCPPackages();\n        } catch (e) {\n            this.log.error('error while checking for required packages: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.scaffold.make();\n        } catch (e) {\n            this.log.error('error while scaffolding: ', e);\n            process.exit(1);\n        }\n\n        try {\n            const fileName = '.npmrc';\n            const dirName = '.meteor/desktop-build';\n            if (fs.existsSync(dirName) && fs.existsSync(fileName)) {\n                fs.copyFileSync(fileName, `${dirName}/${fileName}`);\n            }\n        } catch (e) {\n            this.log.warn('error while copying .npmrc', e);\n        }\n\n        try {\n            await this.exposeElectronModules();\n        } catch (e) {\n            this.log.error('error while exposing electron modules: ', e);\n            process.exit(1);\n        }\n\n        try {\n            this.updatePackageJsonFields();\n        } catch (e) {\n            this.log.error('error while updating package.json: ', e);\n        }\n\n        try {\n            this.updateDependenciesList();\n        } catch (e) {\n            this.log.error('error while merging dependencies list: ', e);\n        }\n\n        try {\n            this.calculateCompatibilityVersion();\n        } catch (e) {\n            this.log.error('error while calculating compatibility version: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.handleTemporaryNodeModules();\n        } catch (e) {\n            this.log.error('error occurred while handling temporary node_modules: ', e);\n            process.exit(1);\n        }\n\n        let nodeModulesRemoved;\n        try {\n            nodeModulesRemoved = await this.handleStateOfNodeModules();\n        } catch (e) {\n            this.log.error('error occurred while clearing node_modules: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.rebuildDeps(true);\n        } catch (e) {\n            this.log.error('error occurred while installing node_modules: ', e);\n            process.exit(1);\n        }\n\n        if (!nodeModulesRemoved) {\n            try {\n                await this.rebuildDeps();\n            } catch (e) {\n                this.log.error('error occurred while rebuilding native node modules: ', e);\n                process.exit(1);\n            }\n        }\n\n        try {\n            await this.linkNpmPackages();\n        } catch (e) {\n            this.log.error(`linking packages failed: ${e}`);\n            process.exit(1);\n        }\n\n        try {\n            await this.installLocalNodeModules();\n        } catch (e) {\n            this.log.error('error occurred while installing local node modules: ', e);\n            process.exit(1);\n        }\n\n\n        try {\n            await this.ensureMeteorDependencies();\n        } catch (e) {\n            this.log.error('error occurred while ensuring meteor dependencies are installed: ', e);\n            process.exit(1);\n        }\n\n\n        if (this.$.env.isProductionBuild()) {\n            try {\n                await this.packSkeletonToAsar();\n            } catch (e) {\n                this.log.error('error while packing skeleton to asar: ', e);\n                process.exit(1);\n            }\n        }\n\n        // TODO: find a way to avoid copying .desktop to a temp location\n        try {\n            this.copyDesktopToDesktopTemp();\n        } catch (e) {\n            this.log.error('error while copying .desktop to a temporary location: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.updateSettingsJsonFields();\n        } catch (e) {\n            this.log.error('error while updating settings.json: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.excludeFilesFromArchive();\n        } catch (e) {\n            this.log.error('error while excluding files from packing to asar: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.transpileAndMinify();\n        } catch (e) {\n            this.log.error('error while transpiling or minifying: ', e);\n        }\n\n        try {\n            await this.packDesktopToAsar();\n        } catch (e) {\n            this.log.error('error occurred while packing .desktop to asar: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.getMeteorClientBuild();\n        } catch (e) {\n            this.log.error('error occurred during getting meteor mobile build: ', e);\n        }\n\n        if (run) {\n            this.log.info('running');\n            this.$.electron.run();\n        } else {\n            this.log.info('built');\n        }\n    }\n\n    /**\n     * Copies the `exposedModules` setting from `settings.json` into `preload.js` modifying its code\n     * so that the script will have it hardcoded.\n     */\n    exposeElectronModules() {\n        const { exposedModules } = this.$.desktop.getSettings();\n        if (exposedModules && Array.isArray(exposedModules) && exposedModules.length > 0) {\n            let preload = fs.readFileSync(this.$.env.paths.electronApp.preload, 'utf8');\n            const modules = this.$.desktop.getSettings()\n                .exposedModules\n                .reduce(\n                    // eslint-disable-next-line no-return-assign,no-param-reassign\n                    (prev, module) => (prev += `'${module}', `, prev), ''\n                );\n\n            preload = preload.replace('const exposedModules = [', `const exposedModules = [${modules}`);\n            fs.writeFileSync(this.$.env.paths.electronApp.preload, preload);\n        }\n    }\n\n    /**\n     * Ensures all required dependencies are added to the Meteor project.\n     * @returns {Promise.<void>}\n     */\n    async ensureMeteorDependencies() {\n        let packages = [];\n        const packagesWithVersion = [];\n        let plugins = 'plugins [';\n\n        Object.keys(this.$.desktop.getDependencies().plugins).forEach((plugin) => {\n            // Read package.json of the plugin.\n            const packageJson =\n                JSON.parse(\n                    fs.readFileSync(\n                        path.join(\n                            this.$.env.paths.electronApp.nodeModules, plugin, 'package.json'\n                        ),\n                        'utf8'\n                    )\n                );\n\n            if ('meteorDependencies' in packageJson && typeof packageJson.meteorDependencies === 'object') {\n                plugins += `${plugin}, `;\n                packages.unshift(...Object.keys(packageJson.meteorDependencies));\n                packagesWithVersion.unshift(...packages.map((packageName) => {\n                    if (packageJson.meteorDependencies[packageName] === '@version') {\n                        return `${packageName}@${packageJson.version}`;\n                    }\n                    return `${packageName}@${packageJson.meteorDependencies[packageName]}`;\n                }));\n            }\n        });\n\n        const packagesCount = packages.length;\n        packages = packages.filter(value => !this.deprectatedPlugins.includes(value));\n        if (packagesCount !== packages.length) {\n            this.log.warn('you have some deprecated meteor desktop plugins in your settings, please remove ' +\n                `them (deprecated plugins: ${this.deprectatedPlugins.join(', ')})`);\n        }\n\n        if (packages.length > 0) {\n            plugins = `${plugins.substr(0, plugins.length - 2)}]`;\n            try {\n                await this.$.meteorApp.meteorManager.ensurePackages(\n                    packages, packagesWithVersion, plugins\n                );\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n    }\n\n    /**\n     * Builds meteor app.\n     */\n    async getMeteorClientBuild() {\n        await this.$.meteorApp.build();\n    }\n\n    /**\n     * Removes node_modules if needed.\n     * @returns {Promise<void>}\n     */\n    async handleStateOfNodeModules() {\n        if (this.$.env.isProductionBuild() || this.$.env.options.ia32) {\n            if (!this.$.env.isProductionBuild()) {\n                this.log.info('clearing node_modules because we need to have it clear for ia32 rebuild');\n            } else {\n                this.log.info('clearing node_modules because this is a production build');\n            }\n            try {\n                await this.$.utils.rmWithRetries(\n                    '-rf', this.$.env.paths.electronApp.nodeModules\n                );\n            } catch (e) {\n                throw new Error(e);\n            }\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * If there is a temporary node_modules folder and no node_modules folder, we will\n     * restore it, as it might be a leftover from an interrupted flow.\n     * @returns {Promise<void>}\n     */\n    async handleTemporaryNodeModules() {\n        if (this.$.utils.exists(this.$.env.paths.electronApp.tmpNodeModules)) {\n            if (!this.$.utils.exists(this.$.env.paths.electronApp.nodeModules)) {\n                this.log.debug('moving temp node_modules back');\n                shell.mv(\n                    this.$.env.paths.electronApp.tmpNodeModules,\n                    this.$.env.paths.electronApp.nodeModules\n                );\n            } else {\n                // If there is a node_modules folder, we should clear the temporary one.\n                this.log.debug('clearing temp node_modules because new one is already created');\n                try {\n                    await this.$.utils.rmWithRetries(\n                        '-rf', this.$.env.paths.electronApp.tmpNodeModules\n                    );\n                } catch (e) {\n                    throw new Error(e);\n                }\n            }\n        }\n    }\n\n    /**\n     * Runs npm link for every package specified in settings.json->linkPackages.\n     */\n    async linkNpmPackages() {\n        if (this.$.env.isProductionBuild()) {\n            return;\n        }\n        const settings = this.$.desktop.getSettings();\n        const promises = [];\n        if ('linkPackages' in this.$.desktop.getSettings()) {\n            if (Array.isArray(settings.linkPackages)) {\n                settings.linkPackages.forEach(packageName =>\n                    promises.push(\n                        this.$.meteorApp.runNpm(\n                            ['link', packageName],\n                            undefined,\n                            this.$.env.paths.electronApp.root\n                        )\n                    ));\n            }\n        }\n        await Promise.all(promises);\n    }\n\n    /**\n     * Runs npm in the electron app to get the dependencies installed.\n     * @returns {Promise}\n     */\n    async ensureDeps() {\n        this.log.info('installing dependencies');\n        if (this.$.utils.exists(this.$.env.paths.electronApp.nodeModules)) {\n            this.log.debug('running npm prune to wipe unneeded dependencies');\n            try {\n                await this.runNpm(['prune']);\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n        try {\n            await this.runNpm(['install'], this.$.env.stdio);\n        } catch (e) {\n            throw new Error(e);\n        }\n    }\n\n    /**\n     * Warns if plugins version are outdated in compare to the newest scaffold.\n     * @param {Object} pluginsVersions - current plugins versions from settings.json\n     */\n    checkPluginsVersion(pluginsVersions) {\n        const settingsJson = JSON.parse(\n            fs.readFileSync(path.join(this.$.env.paths.scaffold, 'settings.json'))\n        );\n        const scaffoldPluginsVersion = this.$.desktop.getDependencies(settingsJson, false).plugins;\n        Object.keys(pluginsVersions).forEach((pluginName) => {\n            if (pluginName in scaffoldPluginsVersion &&\n                scaffoldPluginsVersion[pluginName] !== pluginsVersions[pluginName] &&\n                semver.lt(pluginsVersions[pluginName], scaffoldPluginsVersion[pluginName])\n            ) {\n                this.log.warn(`you are using outdated version ${pluginsVersions[pluginName]} of ` +\n                    `${pluginName}, the suggested version to use is ` +\n                    `${scaffoldPluginsVersion[pluginName]}`);\n            }\n        });\n    }\n\n    /**\n     * Merges core dependency list with the dependencies from .desktop.\n     */\n    updateDependenciesList() {\n        this.log.info('updating list of package.json\\'s dependencies');\n        const desktopDependencies = this.$.desktop.getDependencies();\n\n        this.checkPluginsVersion(desktopDependencies.plugins);\n\n        this.log.debug('merging settings.json[dependencies]');\n        this.depsManager.mergeDependencies(\n            'settings.json[dependencies]',\n            desktopDependencies.fromSettings\n        );\n        this.log.debug('merging settings.json[plugins]');\n        this.depsManager.mergeDependencies(\n            'settings.json[plugins]',\n            desktopDependencies.plugins\n        );\n\n        this.log.debug('merging dependencies from modules');\n        Object.keys(desktopDependencies.modules).forEach(module =>\n            this.depsManager.mergeDependencies(\n                `module[${module}]`,\n                desktopDependencies.modules[module]\n            ));\n\n        this.packageJson.dependencies = this.depsManager.getRemoteDependencies();\n        this.packageJson.localDependencies = this.depsManager.getLocalDependencies();\n\n        this.log.debug('writing updated package.json');\n        fs.writeFileSync(\n            this.$.env.paths.electronApp.packageJson, JSON.stringify(this.packageJson, null, 2)\n        );\n    }\n\n    /**\n     * Install node modules from local paths using local-install.\n     *\n     * @param {string} arch\n     * @returns {Promise}\n     */\n    installLocalNodeModules(arch = this.$.env.options.ia32 || process.arch === 'ia32' ? 'ia32' : 'x64') {\n        const localDependencies = _.values(this.packageJson.localDependencies);\n        if (localDependencies.length === 0) {\n            return Promise.resolve();\n        }\n        this.log.info('installing local node modules');\n        const lastRebuild = this.$.electronBuilder.prepareLastRebuildObject(arch);\n        const env = this.$.electronBuilder.getGypEnv(lastRebuild.frameworkInfo, lastRebuild.platform, lastRebuild.arch);\n        const installer = new LocalInstaller(\n            { [this.$.env.paths.electronApp.root]: localDependencies },\n            { npmEnv: env }\n        );\n        progress(installer);\n        return installer.install();\n    }\n\n    /**\n     * Rebuild binary dependencies against Electron's node headers.\n     * @returns {Promise}\n     */\n    rebuildDeps(install = false) {\n        if (install) {\n            this.log.info('issuing node_modules install from electron-builder');\n        } else {\n            this.log.info('issuing native modules rebuild from electron-builder');\n        }\n\n        const arch = this.$.env.options.ia32 || process.arch === 'ia32' ? 'ia32' : 'x64';\n\n        if (this.$.env.options.ia32) {\n            this.log.verbose('forcing rebuild for 32bit');\n        } else {\n            this.log.verbose(`rebuilding for ${arch}`);\n        }\n\n        return this.$.electronBuilder.installOrRebuild(arch, undefined, install);\n    }\n\n    /**\n     * Update package.json fields accordingly to what is set in settings.json.\n     *\n     * packageJson.name = settings.projectName\n     * packageJson.version = settings.version\n     * packageJson.* = settings.packageJsonFields\n     */\n    updatePackageJsonFields() {\n        this.log.verbose('updating package.json fields');\n        const settings = this.$.desktop.getSettings();\n        /** @type {desktopSettings} */\n        const packageJson = this.scaffold.getDefaultPackageJson();\n\n        packageJson.version = settings.version;\n        if ('packageJsonFields' in settings) {\n            assignIn(packageJson, settings.packageJsonFields);\n        }\n        assignIn(packageJson, { name: settings.projectName });\n\n        this.log.debug('writing updated package.json');\n        fs.writeFileSync(\n            this.$.env.paths.electronApp.packageJson, JSON.stringify(packageJson, null, 4)\n        );\n        this.packageJson = packageJson;\n    }\n\n    /**\n     * Updates settings.json with env (prod/dev) information and versions.\n     */\n    async updateSettingsJsonFields() {\n        this.log.debug('updating settings.json fields');\n        const settings = this.$.desktop.getSettings();\n\n        // Save versions.\n        settings.compatibilityVersion = this.compatibilityVersion;\n\n        // Pass information about build type to the settings.json.\n        settings.env = (this.$.env.isProductionBuild()) ?\n            'prod' : 'dev';\n\n        const version = await this.$.desktop.getHashVersion();\n        settings.desktopVersion = `${version}_${settings.env}`;\n\n        settings.meteorDesktopVersion = this.$.getVersion();\n\n        if (this.$.env.options.prodDebug) {\n            settings.prodDebug = true;\n        }\n\n        fs.writeFileSync(\n            this.$.env.paths.desktopTmp.settings, JSON.stringify(settings, null, 4)\n        );\n    }\n\n    /**\n     * Copies files from prepared .desktop to desktop.asar in electron app.\n     */\n    packDesktopToAsar() {\n        this.log.info('packing .desktop to asar');\n        return new Promise((resolve, reject) => {\n            asar.createPackage(\n                this.$.env.paths.desktopTmp.root,\n                this.$.env.paths.electronApp.desktopAsar\n            )\n                .then(() => {\n                    this.log.verbose('clearing temporary .desktop');\n                    this.$.utils\n                        .rmWithRetries('-rf', this.$.env.paths.desktopTmp.root)\n                        .then(() => {\n                            resolve();\n                        })\n                        .catch((e) => {\n                            reject(e);\n                        });\n                    resolve();\n                });\n        });\n    }\n\n    /**\n     * Makes a temporary copy of .desktop.\n     */\n    copyDesktopToDesktopTemp() {\n        this.log.verbose('copying .desktop to temporary location');\n        shell.cp('-rf', this.$.env.paths.desktop.root, this.$.env.paths.desktopTmp.root);\n        // Remove test files.\n        del.sync([\n            path.join(this.$.env.paths.desktopTmp.root, '**', '*.test.js')\n        ], { force: true });\n    }\n\n\n    /**\n     * Runs babel and uglify over .desktop if requested.\n     */\n    async transpileAndMinify() {\n        this.log.info('transpiling and uglifying');\n\n        const settings = this.$.desktop.getSettings();\n        const options = 'uglifyOptions' in settings ? settings.uglifyOptions : {};\n\n        const uglifyingEnabled = 'uglify' in settings && !!settings.uglify;\n\n        const preset = presetEnv({ assertVersion: () => { } }, { targets: { node: '12' } });\n\n        const { data: files } = await this.$.utils.readDir(this.$.env.paths.desktopTmp.root);\n\n        files.forEach((file) => {\n            if (file.endsWith('.js')) {\n                let { code } = transformFileSync(file, {\n                    presets: [preset]\n                });\n                let error;\n                if (settings.env === 'prod' && uglifyingEnabled) {\n                    ({ code, error } = uglify.minify(code, options));\n                }\n                if (error) {\n                    throw new Error(error);\n                }\n                fs.writeFileSync(file, code);\n            }\n        });\n    }\n\n    /**\n     * Moves all the files that should not be packed into asar into a safe location which is the\n     * 'extracted' dir in the electron app.\n     */\n    async excludeFilesFromArchive() {\n        this.log.info('excluding files from packing');\n\n        // Ensure empty `extracted` dir\n\n        try {\n            await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.extracted);\n        } catch (e) {\n            throw new Error(e);\n        }\n\n        shell.mkdir(this.$.env.paths.electronApp.extracted);\n\n        const configs = this.$.desktop.gatherModuleConfigs();\n\n        // Move files that should not be asar'ed.\n        configs.forEach((config) => {\n            const moduleConfig = config;\n            if ('extract' in moduleConfig) {\n                if (!Array.isArray(moduleConfig.extract)) {\n                    moduleConfig.extract = [moduleConfig.extract];\n                }\n                moduleConfig.extract.forEach((file) => {\n                    this.log.debug(`excluding ${file} from ${config.name}`);\n                    const filePath = path.join(\n                        this.$.env.paths.desktopTmp.modules, moduleConfig.dirName, file\n                    );\n                    const destinationPath = path.join(\n                        this.$.env.paths.electronApp.extracted, moduleConfig.dirName\n                    );\n\n                    if (!this.$.utils.exists(destinationPath)) {\n                        shell.mkdir(destinationPath);\n                    }\n                    shell.mv(filePath, destinationPath);\n                });\n            }\n        });\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/electronAppScaffold.js b/dist/electronAppScaffold.js new file mode 100644 index 00000000..d108be14 --- /dev/null +++ b/dist/electronAppScaffold.js @@ -0,0 +1,142 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _fs = _interopRequireDefault(require("fs")); + +var _del = _interopRequireDefault(require("del")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _path = _interopRequireDefault(require("path")); + +var _log = _interopRequireDefault(require("./log")); + +var _skeletonDependencies = _interopRequireDefault(require("./skeletonDependencies")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars +const { + join +} = _path.default; +_shelljs.default.config.fatal = true; +/** + * Represents the .desktop dir scaffold. + */ + +class ElectronAppScaffold { + /** + * @param {MeteorDesktop} $ - context + * @constructor + */ + constructor($) { + this.log = new _log.default('electronAppScaffold'); + this.$ = $; + this.packageJson = { + name: 'MyMeteorApp', + main: this.$.env.isProductionBuild() ? 'app.asar/index.js' : 'app/index.js', + dependencies: Object.assign({}, _skeletonDependencies.default) + }; + + if (!this.$.env.isProductionBuild() || this.$.env.options.prodDebug) { + this.packageJson.dependencies.devtron = '1.4.0'; + this.packageJson.dependencies['electron-debug'] = '1.5.0'; + } + } + /** + * Just a public getter from the default package.json object. + * @returns {Object} + */ + + + getDefaultPackageJson() { + return Object.assign({}, this.packageJson); + } + /** + * Clear the electron app. Removes everything except the node_modules which would be a waste + * to delete. Later `npm prune` will keep it clear. + */ + + + clear() { + if (!this.$.utils.exists(this.$.env.paths.electronApp.root)) { + this.log.verbose(`creating ${this.$.env.paths.electronApp.rootName}`); + + _shelljs.default.mkdir(this.$.env.paths.electronApp.root); + } + + return (0, _del.default)([`${this.$.env.paths.electronApp.root}${_path.default.sep}*`, `!${this.$.env.paths.electronApp.nodeModules}`], { + force: true + }); + } + /** + * Just copies the Skeleton App into the electron app. + */ + + + copySkeletonApp() { + this.log.verbose('copying skeleton app'); + + try { + _shelljs.default.cp('-rf', join(this.$.env.paths.meteorDesktop.skeleton, '*'), this.$.env.paths.electronApp.appRoot + _path.default.sep); + } catch (e) { + this.log.error('error while copying skeleton app:', e); + process.exit(1); + } + } + /** + * After clearing the electron app path, copies a fresh skeleton. + */ + + + async make() { + try { + this.log.verbose(`clearing ${this.$.env.paths.electronApp.rootName}`); + await this.clear(); + } catch (e) { + this.log.error(`error while removing ${this.$.env.paths.electronApp.root}: `, e); + process.exit(1); + } + + this.createAppRoot(); + this.copySkeletonApp(); // TODO: hey, wait, .gitignore is not needed - right? + + /* + this.log.debug('creating .gitignore'); + fs.writeFileSync(this.$.env.paths.electronApp.gitIgnore, [ + 'node_modules' + ].join('\n')); + */ + + this.log.verbose('writing package.json'); + + _fs.default.writeFileSync(this.$.env.paths.electronApp.packageJson, JSON.stringify(this.packageJson, null, 2)); + } + /** + * Creates the app directory in the electron app. + */ + + + createAppRoot() { + try { + this.log.verbose(`creating ${this.$.env.paths.electronApp.appRoot}`); + + _fs.default.mkdirSync(this.$.env.paths.electronApp.appRoot); + } catch (e) { + if (e.code !== 'EEXIST') { + this.log.error(`error while creating dir: ${this.$.env.paths.electronApp.appRoot}: `, e); + process.exit(1); + } + } + } + +} + +exports.default = ElectronAppScaffold; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","shell","config","fatal","ElectronAppScaffold","constructor","$","log","Log","packageJson","name","main","env","isProductionBuild","dependencies","Object","assign","options","prodDebug","devtron","getDefaultPackageJson","clear","utils","exists","paths","electronApp","root","verbose","rootName","mkdir","del","sep","nodeModules","force","copySkeletonApp","cp","meteorDesktop","skeleton","appRoot","e","error","process","exit","make","createAppRoot","fs","writeFileSync","JSON","stringify","mkdirSync","code"],"sources":["../lib/electronAppScaffold.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport fs from 'fs';\nimport del from 'del';\nimport shell from 'shelljs';\nimport path from 'path';\n\nimport Log from './log';\nimport dependencies from './skeletonDependencies';\n\nconst { join } = path;\nshell.config.fatal = true;\n\n/**\n * Represents the .desktop dir scaffold.\n */\nexport default class ElectronAppScaffold {\n    /**\n     * @param {MeteorDesktop} $ - context\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('electronAppScaffold');\n        this.$ = $;\n\n        this.packageJson = {\n            name: 'MyMeteorApp',\n            main: (this.$.env.isProductionBuild()) ?\n                'app.asar/index.js' : 'app/index.js',\n            dependencies: Object.assign({}, dependencies)\n        };\n\n        if (!this.$.env.isProductionBuild() || this.$.env.options.prodDebug) {\n            this.packageJson.dependencies.devtron = '1.4.0';\n            this.packageJson.dependencies['electron-debug'] = '1.5.0';\n        }\n    }\n\n    /**\n     * Just a public getter from the default package.json object.\n     * @returns {Object}\n     */\n    getDefaultPackageJson() {\n        return Object.assign({}, this.packageJson);\n    }\n\n    /**\n     * Clear the electron app. Removes everything except the node_modules which would be a waste\n     * to delete. Later `npm prune` will keep it clear.\n     */\n    clear() {\n        if (!this.$.utils.exists(this.$.env.paths.electronApp.root)) {\n            this.log.verbose(`creating ${this.$.env.paths.electronApp.rootName}`);\n            shell.mkdir(this.$.env.paths.electronApp.root);\n        }\n\n        return del([\n            `${this.$.env.paths.electronApp.root}${path.sep}*`,\n            `!${this.$.env.paths.electronApp.nodeModules}`\n        ], { force: true });\n    }\n\n    /**\n     * Just copies the Skeleton App into the electron app.\n     */\n    copySkeletonApp() {\n        this.log.verbose('copying skeleton app');\n        try {\n            shell.cp(\n                '-rf',\n                join(this.$.env.paths.meteorDesktop.skeleton, '*'),\n                this.$.env.paths.electronApp.appRoot + path.sep\n            );\n        } catch (e) {\n            this.log.error('error while copying skeleton app:', e);\n            process.exit(1);\n        }\n    }\n\n    /**\n     * After clearing the electron app path, copies a fresh skeleton.\n     */\n    async make() {\n        try {\n            this.log.verbose(`clearing ${this.$.env.paths.electronApp.rootName}`);\n            await this.clear();\n        } catch (e) {\n            this.log.error(\n                `error while removing ${this.$.env.paths.electronApp.root}: `, e\n            );\n            process.exit(1);\n        }\n\n        this.createAppRoot();\n\n        this.copySkeletonApp();\n\n        // TODO: hey, wait, .gitignore is not needed - right?\n        /*\n        this.log.debug('creating .gitignore');\n        fs.writeFileSync(this.$.env.paths.electronApp.gitIgnore, [\n            'node_modules'\n        ].join('\\n'));\n        */\n        this.log.verbose('writing package.json');\n        fs.writeFileSync(\n            this.$.env.paths.electronApp.packageJson, JSON.stringify(this.packageJson, null, 2)\n        );\n    }\n\n    /**\n     * Creates the app directory in the electron app.\n     */\n    createAppRoot() {\n        try {\n            this.log.verbose(`creating ${this.$.env.paths.electronApp.appRoot}`);\n            fs.mkdirSync(this.$.env.paths.electronApp.appRoot);\n        } catch (e) {\n            if (e.code !== 'EEXIST') {\n                this.log.error(\n                    `error while creating dir: ${this.$.env.paths.electronApp.appRoot}: `, e\n                );\n                process.exit(1);\n            }\n        }\n    }\n}\n"],"mappings":";;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;;;AARA;AAUA,MAAM;EAAEA;AAAF,IAAWC,aAAjB;AACAC,gBAAA,CAAMC,MAAN,CAAaC,KAAb,GAAqB,IAArB;AAEA;AACA;AACA;;AACe,MAAMC,mBAAN,CAA0B;EACrC;AACJ;AACA;AACA;EACIC,WAAW,CAACC,CAAD,EAAI;IACX,KAAKC,GAAL,GAAW,IAAIC,YAAJ,CAAQ,qBAAR,CAAX;IACA,KAAKF,CAAL,GAASA,CAAT;IAEA,KAAKG,WAAL,GAAmB;MACfC,IAAI,EAAE,aADS;MAEfC,IAAI,EAAG,KAAKL,CAAL,CAAOM,GAAP,CAAWC,iBAAX,EAAD,GACF,mBADE,GACoB,cAHX;MAIfC,YAAY,EAAEC,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkBF,6BAAlB;IAJC,CAAnB;;IAOA,IAAI,CAAC,KAAKR,CAAL,CAAOM,GAAP,CAAWC,iBAAX,EAAD,IAAmC,KAAKP,CAAL,CAAOM,GAAP,CAAWK,OAAX,CAAmBC,SAA1D,EAAqE;MACjE,KAAKT,WAAL,CAAiBK,YAAjB,CAA8BK,OAA9B,GAAwC,OAAxC;MACA,KAAKV,WAAL,CAAiBK,YAAjB,CAA8B,gBAA9B,IAAkD,OAAlD;IACH;EACJ;EAED;AACJ;AACA;AACA;;;EACIM,qBAAqB,GAAG;IACpB,OAAOL,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkB,KAAKP,WAAvB,CAAP;EACH;EAED;AACJ;AACA;AACA;;;EACIY,KAAK,GAAG;IACJ,IAAI,CAAC,KAAKf,CAAL,CAAOgB,KAAP,CAAaC,MAAb,CAAoB,KAAKjB,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6BC,IAAjD,CAAL,EAA6D;MACzD,KAAKnB,GAAL,CAASoB,OAAT,CAAkB,YAAW,KAAKrB,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6BG,QAAS,EAAnE;;MACA3B,gBAAA,CAAM4B,KAAN,CAAY,KAAKvB,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6BC,IAAzC;IACH;;IAED,OAAO,IAAAI,YAAA,EAAI,CACN,GAAE,KAAKxB,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6BC,IAAK,GAAE1B,aAAA,CAAK+B,GAAI,GADzC,EAEN,IAAG,KAAKzB,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6BO,WAAY,EAFtC,CAAJ,EAGJ;MAAEC,KAAK,EAAE;IAAT,CAHI,CAAP;EAIH;EAED;AACJ;AACA;;;EACIC,eAAe,GAAG;IACd,KAAK3B,GAAL,CAASoB,OAAT,CAAiB,sBAAjB;;IACA,IAAI;MACA1B,gBAAA,CAAMkC,EAAN,CACI,KADJ,EAEIpC,IAAI,CAAC,KAAKO,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBY,aAAjB,CAA+BC,QAAhC,EAA0C,GAA1C,CAFR,EAGI,KAAK/B,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6Ba,OAA7B,GAAuCtC,aAAA,CAAK+B,GAHhD;IAKH,CAND,CAME,OAAOQ,CAAP,EAAU;MACR,KAAKhC,GAAL,CAASiC,KAAT,CAAe,mCAAf,EAAoDD,CAApD;MACAE,OAAO,CAACC,IAAR,CAAa,CAAb;IACH;EACJ;EAED;AACJ;AACA;;;EACc,MAAJC,IAAI,GAAG;IACT,IAAI;MACA,KAAKpC,GAAL,CAASoB,OAAT,CAAkB,YAAW,KAAKrB,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6BG,QAAS,EAAnE;MACA,MAAM,KAAKP,KAAL,EAAN;IACH,CAHD,CAGE,OAAOkB,CAAP,EAAU;MACR,KAAKhC,GAAL,CAASiC,KAAT,CACK,wBAAuB,KAAKlC,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6BC,IAAK,IAD9D,EACmEa,CADnE;MAGAE,OAAO,CAACC,IAAR,CAAa,CAAb;IACH;;IAED,KAAKE,aAAL;IAEA,KAAKV,eAAL,GAbS,CAeT;;IACA;AACR;AACA;AACA;AACA;AACA;;IACQ,KAAK3B,GAAL,CAASoB,OAAT,CAAiB,sBAAjB;;IACAkB,WAAA,CAAGC,aAAH,CACI,KAAKxC,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6BhB,WADjC,EAC8CsC,IAAI,CAACC,SAAL,CAAe,KAAKvC,WAApB,EAAiC,IAAjC,EAAuC,CAAvC,CAD9C;EAGH;EAED;AACJ;AACA;;;EACImC,aAAa,GAAG;IACZ,IAAI;MACA,KAAKrC,GAAL,CAASoB,OAAT,CAAkB,YAAW,KAAKrB,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6Ba,OAAQ,EAAlE;;MACAO,WAAA,CAAGI,SAAH,CAAa,KAAK3C,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6Ba,OAA1C;IACH,CAHD,CAGE,OAAOC,CAAP,EAAU;MACR,IAAIA,CAAC,CAACW,IAAF,KAAW,QAAf,EAAyB;QACrB,KAAK3C,GAAL,CAASiC,KAAT,CACK,6BAA4B,KAAKlC,CAAL,CAAOM,GAAP,CAAWY,KAAX,CAAiBC,WAAjB,CAA6Ba,OAAQ,IADtE,EAC2EC,CAD3E;QAGAE,OAAO,CAACC,IAAR,CAAa,CAAb;MACH;IACJ;EACJ;;AA7GoC"} \ No newline at end of file diff --git a/dist/electronBuilder.js b/dist/electronBuilder.js new file mode 100644 index 00000000..d4438f23 --- /dev/null +++ b/dist/electronBuilder.js @@ -0,0 +1,384 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _path = _interopRequireDefault(require("path")); + +var _fs = _interopRequireDefault(require("fs")); + +var _rimraf = _interopRequireDefault(require("rimraf")); + +var _crossSpawn = _interopRequireDefault(require("cross-spawn")); + +var _log = _interopRequireDefault(require("./log")); + +var _defaultDependencies = _interopRequireDefault(require("./defaultDependencies")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars + +/** + * Promisfied rimraf. + * + * @param {string} dirPath - path to the dir to be deleted + * @param {number} delay - delay the task by ms + * @returns {Promise} + */ +function removeDir(dirPath, delay = 0) { + return new Promise((resolve, reject) => { + setTimeout(() => { + (0, _rimraf.default)(dirPath, { + maxBusyTries: 100 + }, err => { + if (err) { + reject(err); + } else { + resolve(); + } + }); + }, delay); + }); +} +/** + * Wrapper for electron-builder. + */ + + +class InstallerBuilder { + /** + * @param {MeteorDesktop} $ - context + * + * @constructor + */ + constructor($) { + this.log = new _log.default('electronBuilder'); + this.$ = $; + this.firstPass = true; + this.lastRebuild = {}; + this.currentContext = null; + this.installerDir = _path.default.join(this.$.env.options.output, this.$.env.paths.installerDir); + this.platforms = []; + } + + async init() { + this.builder = await this.$.getDependency('electron-builder', _defaultDependencies.default['electron-builder']); + const appBuilder = await this.$.getDependency('app-builder-lib', _defaultDependencies.default['electron-builder'], false); + this.yarn = require(_path.default.join(appBuilder.path, 'out', 'util', 'yarn')); + this.getGypEnv = this.yarn.getGypEnv; + this.packageDependencies = require(_path.default.join(appBuilder.path, 'out', 'util', 'packageDependencies')); + } + /** + * Prepares the last rebuild object for electron-builder. + * + * @param {string} arch + * @param {string} platform + * @returns {Object} + */ + + + prepareLastRebuildObject(arch, platform = process.platform) { + const productionDeps = this.packageDependencies.createLazyProductionDeps(this.$.env.paths.electronApp.root); + this.lastRebuild = { + frameworkInfo: { + version: this.$.getElectronVersion(), + useCustomDist: true + }, + platform, + arch, + productionDeps + }; + return this.lastRebuild; + } + /** + * Calls npm rebuild from electron-builder. + * @param {string} arch + * @param {string} platform + * @param {boolean} install + * @returns {Promise} + */ + + + async installOrRebuild(arch, platform = process.platform, install = false) { + this.log.debug(`calling installOrRebuild from electron-builder for arch ${arch}`); + this.prepareLastRebuildObject(arch, platform); + await this.yarn.installOrRebuild(this.$.desktop.getSettings().builderOptions || {}, this.$.env.paths.electronApp.root, this.lastRebuild, install); + } + /** + * Callback invoked before build is made. Ensures that app.asar have the right rebuilt + * node_modules. + * + * @param {Object} context + * @returns {Promise} + */ + + + beforeBuild(context) { + this.currentContext = Object.assign({}, context); + return new Promise((resolve, reject) => { + const platformMatches = process.platform === context.platform.nodeName; + const rebuild = platformMatches && context.arch !== this.lastRebuild.arch; + + if (!platformMatches) { + this.log.warn('skipping dependencies rebuild because platform is different, if you have native ' + 'node modules as your app dependencies you should od the build on the target platform only'); + } + + if (!rebuild) { + this.moveNodeModulesOut().catch(e => reject(e)).then(() => setTimeout(() => resolve(false), 2000)); // Timeout helps on Windows to clear the file locks. + } else { + // Lets rebuild the node_modules for different arch. + this.installOrRebuild(context.arch, context.platform.nodeName).catch(e => reject(e)).then(() => this.$.electronApp.installLocalNodeModules(context.arch)).catch(e => reject(e)).then(() => { + this.$.electronApp.scaffold.createAppRoot(); + this.$.electronApp.scaffold.copySkeletonApp(); + return this.$.electronApp.packSkeletonToAsar([this.$.env.paths.electronApp.meteorAsar, this.$.env.paths.electronApp.desktopAsar, this.$.env.paths.electronApp.extracted]); + }).catch(e => reject(e)).then(() => this.moveNodeModulesOut()).catch(e => reject(e)).then(() => resolve(false)); + } + }); + } + /** + * Callback to be invoked after packing. Restores node_modules to the .desktop-build. + * @returns {Promise} + */ + + + afterPack(context) { + this.platforms = this.platforms.filter(platform => platform !== context.electronPlatformName); + + if (this.platforms.length !== 0) { + return Promise.resolve(); + } + + return new Promise((resolve, reject) => { + _shelljs.default.config.fatal = true; + + if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) { + this.log.debug('injecting extracted modules'); + + _shelljs.default.cp('-Rf', this.$.env.paths.electronApp.extractedNodeModules, _path.default.join(this.getPackagedAppPath(context), 'node_modules')); + } + + this.log.debug('moving node_modules back'); // Move node_modules back. + + try { + _shelljs.default.mv(this.$.env.paths.electronApp.tmpNodeModules, this.$.env.paths.electronApp.nodeModules); + } catch (e) { + reject(e); + return; + } finally { + _shelljs.default.config.reset(); + } + + if (this.firstPass) { + this.firstPass = false; + } + + this.log.debug('node_modules moved back'); + this.wait().catch(e => reject(e)).then(() => resolve()); + }); + } + /** + * This command kills orphaned MSBuild.exe processes. + * Sometime after native node_modules compilation they are still writing some logs, + * prevent node_modules from being deleted. + */ + + + killMSBuild() { + if (this.currentContext.platform.nodeName !== 'win32') { + return; + } + + try { + const out = _crossSpawn.default.sync('wmic', ['process', 'where', 'caption="MSBuild.exe"', 'get', 'processid']).stdout.toString('utf-8').split('\n'); + + const regex = new RegExp(/(\d+)/, 'gm'); // No we will check for those with the matching params. + + out.forEach(line => { + const match = regex.exec(line) || false; + + if (match) { + this.log.debug(`killing MSBuild.exe at pid: ${match[1]}`); + + _crossSpawn.default.sync('taskkill', ['/pid', match[1], '/f', '/t']); + } + + regex.lastIndex = 0; + }); + } catch (e) { + this.log.debug('kill MSBuild failed'); + } + } + /** + * Returns the path to packaged app. + * @returns {string} + */ + + + getPackagedAppPath(context = {}) { + if (this.currentContext.platform.nodeName === 'darwin') { + return _path.default.join(this.installerDir, 'mac', `${context.packager.appInfo.productFilename}.app`, 'Contents', 'Resources', 'app'); + } + + const platformDir = `${this.currentContext.platform.nodeName === 'win32' ? 'win' : 'linux'}-${this.currentContext.arch === 'ia32' ? 'ia32-' : ''}unpacked`; + return _path.default.join(this.installerDir, platformDir, 'resources', 'app'); + } + /** + * On Windows it waits for the app.asar in the packed app to be free (no file locks). + * @returns {*} + */ + + + wait() { + if (this.currentContext.platform.nodeName !== 'win32') { + return Promise.resolve(); + } + + const appAsarPath = _path.default.join(this.getPackagedAppPath(), 'app.asar'); + + let retries = 0; + const self = this; + return new Promise((resolve, reject) => { + function check() { + _fs.default.open(appAsarPath, 'r+', (err, fd) => { + retries += 1; + + if (err) { + if (err.code !== 'ENOENT') { + self.log.debug(`waiting for app.asar to be readable, ${'code' in err ? `currently reading it returns ${err.code}` : ''}`); + + if (retries < 6) { + setTimeout(() => check(), 4000); + } else { + reject(`file is locked: ${appAsarPath}`); + } + } else { + resolve(); + } + } else { + _fs.default.closeSync(fd); + + resolve(); + } + }); + } + + check(); + }); + } + /** + * Prepares the target object passed to the electron-builder. + * + * @returns {Map>>} + */ + + + prepareTargets() { + let arch = this.$.env.options.ia32 ? 'ia32' : 'x64'; + arch = this.$.env.options.allArchs ? 'all' : arch; + const targets = []; + + if (this.$.env.options.win) { + targets.push(this.builder.dependency.Platform.WINDOWS); + } + + if (this.$.env.options.linux) { + targets.push(this.builder.dependency.Platform.LINUX); + } + + if (this.$.env.options.mac) { + targets.push(this.builder.dependency.Platform.MAC); + } + + if (targets.length === 0) { + if (this.$.env.os.isWindows) { + targets.push(this.builder.dependency.Platform.WINDOWS); + } else if (this.$.env.os.isLinux) { + targets.push(this.builder.dependency.Platform.LINUX); + } else { + targets.push(this.builder.dependency.Platform.MAC); + } + } + + return this.builder.dependency.createTargets(targets, null, arch); + } + + async build() { + const settings = this.$.desktop.getSettings(); + + if (!('builderOptions' in settings)) { + this.log.error('no builderOptions in settings.json, aborting'); + process.exit(1); + } + + const builderOptions = Object.assign({}, settings.builderOptions); + builderOptions.asar = false; + builderOptions.npmRebuild = true; + builderOptions.beforeBuild = this.beforeBuild.bind(this); + builderOptions.afterPack = this.afterPack.bind(this); + builderOptions.electronVersion = this.$.getElectronVersion(); + builderOptions.directories = { + app: this.$.env.paths.electronApp.root, + output: _path.default.join(this.$.env.options.output, this.$.env.paths.installerDir) + }; + + if ('mac' in builderOptions && 'target' in builderOptions.mac) { + if (builderOptions.mac.target.includes('mas')) { + this.platforms = ['darwin', 'mas']; + } + } + + try { + this.log.debug('calling build from electron-builder'); + await this.builder.dependency.build(Object.assign({ + targets: this.prepareTargets(), + config: builderOptions + }, settings.builderCliOptions)); + + if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) { + _shelljs.default.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules); + } + } catch (e) { + this.log.error('error while building installer: ', e); + } + } + /** + * Moves node_modules out of the app because while the app will be packaged + * we do not want it to be there. + * @returns {Promise} + */ + + + moveNodeModulesOut() { + return new Promise((resolve, reject) => { + this.log.debug('moving node_modules out, because we have them already in' + ' app.asar'); + this.killMSBuild(); + removeDir(this.$.env.paths.electronApp.tmpNodeModules).catch(e => reject(e)).then(() => { + _shelljs.default.config.fatal = true; + _shelljs.default.config.verbose = true; + + try { + _shelljs.default.mv(this.$.env.paths.electronApp.nodeModules, this.$.env.paths.electronApp.tmpNodeModules); + + _shelljs.default.config.reset(); + + return this.wait(); + } catch (e) { + _shelljs.default.config.reset(); + + return Promise.reject(e); + } + }).catch(e => reject(e)).then(() => removeDir(this.$.env.paths.electronApp.nodeModules, 1000)).catch(e => reject(e)).then(() => this.wait()).catch(reject).then(resolve); + }); + } + +} + +exports.default = InstallerBuilder; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["removeDir","dirPath","delay","Promise","resolve","reject","setTimeout","rimraf","maxBusyTries","err","InstallerBuilder","constructor","$","log","Log","firstPass","lastRebuild","currentContext","installerDir","path","join","env","options","output","paths","platforms","init","builder","getDependency","defaultDependencies","appBuilder","yarn","require","getGypEnv","packageDependencies","prepareLastRebuildObject","arch","platform","process","productionDeps","createLazyProductionDeps","electronApp","root","frameworkInfo","version","getElectronVersion","useCustomDist","installOrRebuild","install","debug","desktop","getSettings","builderOptions","beforeBuild","context","Object","assign","platformMatches","nodeName","rebuild","warn","moveNodeModulesOut","catch","e","then","installLocalNodeModules","scaffold","createAppRoot","copySkeletonApp","packSkeletonToAsar","meteorAsar","desktopAsar","extracted","afterPack","filter","electronPlatformName","length","shell","config","fatal","utils","exists","extractedNodeModules","cp","getPackagedAppPath","mv","tmpNodeModules","nodeModules","reset","wait","killMSBuild","out","spawn","sync","stdout","toString","split","regex","RegExp","forEach","line","match","exec","lastIndex","packager","appInfo","productFilename","platformDir","appAsarPath","retries","self","check","fs","open","fd","code","closeSync","prepareTargets","ia32","allArchs","targets","win","push","dependency","Platform","WINDOWS","linux","LINUX","mac","MAC","os","isWindows","isLinux","createTargets","build","settings","error","exit","asar","npmRebuild","bind","electronVersion","directories","app","target","includes","builderCliOptions","rm","verbose"],"sources":["../lib/electronBuilder.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport shell from 'shelljs';\nimport path from 'path';\nimport fs from 'fs';\nimport rimraf from 'rimraf';\nimport spawn from 'cross-spawn';\nimport Log from './log';\nimport defaultDependencies from './defaultDependencies';\n\n/**\n * Promisfied rimraf.\n *\n * @param {string} dirPath - path to the dir to be deleted\n * @param {number} delay - delay the task by ms\n * @returns {Promise<any>}\n */\nfunction removeDir(dirPath, delay = 0) {\n    return new Promise((resolve, reject) => {\n        setTimeout(() => {\n            rimraf(dirPath, {\n                maxBusyTries: 100\n            }, (err) => {\n                if (err) {\n                    reject(err);\n                } else {\n                    resolve();\n                }\n            });\n        }, delay);\n    });\n}\n\n/**\n * Wrapper for electron-builder.\n */\nexport default class InstallerBuilder {\n    /**\n     * @param {MeteorDesktop} $ - context\n     *\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('electronBuilder');\n        this.$ = $;\n        this.firstPass = true;\n        this.lastRebuild = {};\n        this.currentContext = null;\n        this.installerDir = path.join(this.$.env.options.output, this.$.env.paths.installerDir);\n        this.platforms = [];\n    }\n\n    async init() {\n        this.builder = await this.$.getDependency('electron-builder', defaultDependencies['electron-builder']);\n        const appBuilder = await this.$.getDependency('app-builder-lib', defaultDependencies['electron-builder'], false);\n\n        this.yarn = require(path.join(appBuilder.path, 'out', 'util', 'yarn'));\n        this.getGypEnv = this.yarn.getGypEnv;\n        this.packageDependencies = require(path.join(appBuilder.path, 'out', 'util', 'packageDependencies'));\n    }\n\n    /**\n     * Prepares the last rebuild object for electron-builder.\n     *\n     * @param {string} arch\n     * @param {string} platform\n     * @returns {Object}\n     */\n    prepareLastRebuildObject(arch, platform = process.platform) {\n        const productionDeps = this.packageDependencies\n            .createLazyProductionDeps(this.$.env.paths.electronApp.root);\n        this.lastRebuild = {\n            frameworkInfo: { version: this.$.getElectronVersion(), useCustomDist: true },\n            platform,\n            arch,\n            productionDeps\n        };\n        return this.lastRebuild;\n    }\n\n    /**\n     * Calls npm rebuild from electron-builder.\n     * @param {string} arch\n     * @param {string} platform\n     * @param {boolean} install\n     * @returns {Promise}\n     */\n    async installOrRebuild(arch, platform = process.platform, install = false) {\n        this.log.debug(`calling installOrRebuild from electron-builder for arch ${arch}`);\n        this.prepareLastRebuildObject(arch, platform);\n        await this.yarn.installOrRebuild(this.$.desktop.getSettings().builderOptions || {},\n            this.$.env.paths.electronApp.root, this.lastRebuild, install);\n    }\n\n    /**\n     * Callback invoked before build is made. Ensures that app.asar have the right rebuilt\n     * node_modules.\n     *\n     * @param {Object} context\n     * @returns {Promise}\n     */\n    beforeBuild(context) {\n        this.currentContext = Object.assign({}, context);\n        return new Promise((resolve, reject) => {\n            const platformMatches = process.platform === context.platform.nodeName;\n            const rebuild = platformMatches && context.arch !== this.lastRebuild.arch;\n            if (!platformMatches) {\n                this.log.warn('skipping dependencies rebuild because platform is different, if you have native ' +\n                    'node modules as your app dependencies you should od the build on the target platform only');\n            }\n\n            if (!rebuild) {\n                this.moveNodeModulesOut()\n                    .catch(e => reject(e))\n                    .then(() => setTimeout(() => resolve(false), 2000));\n                // Timeout helps on Windows to clear the file locks.\n            } else {\n                // Lets rebuild the node_modules for different arch.\n                this.installOrRebuild(context.arch, context.platform.nodeName)\n                    .catch(e => reject(e))\n                    .then(() => this.$.electronApp.installLocalNodeModules(context.arch))\n                    .catch(e => reject(e))\n                    .then(() => {\n                        this.$.electronApp.scaffold.createAppRoot();\n                        this.$.electronApp.scaffold.copySkeletonApp();\n                        return this.$.electronApp.packSkeletonToAsar(\n                            [\n                                this.$.env.paths.electronApp.meteorAsar,\n                                this.$.env.paths.electronApp.desktopAsar,\n                                this.$.env.paths.electronApp.extracted\n                            ]\n                        );\n                    })\n                    .catch(e => reject(e))\n                    .then(() => this.moveNodeModulesOut())\n                    .catch(e => reject(e))\n                    .then(() => resolve(false));\n            }\n        });\n    }\n\n    /**\n     * Callback to be invoked after packing. Restores node_modules to the .desktop-build.\n     * @returns {Promise}\n     */\n    afterPack(context) {\n        this.platforms = this.platforms\n            .filter(platform => platform !== context.electronPlatformName);\n        if (this.platforms.length !== 0) {\n            return Promise.resolve();\n        }\n        return new Promise((resolve, reject) => {\n            shell.config.fatal = true;\n\n            if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) {\n                this.log.debug('injecting extracted modules');\n                shell.cp(\n                    '-Rf',\n                    this.$.env.paths.electronApp.extractedNodeModules,\n                    path.join(this.getPackagedAppPath(context), 'node_modules')\n                );\n            }\n\n            this.log.debug('moving node_modules back');\n            // Move node_modules back.\n\n            try {\n                shell.mv(\n                    this.$.env.paths.electronApp.tmpNodeModules,\n                    this.$.env.paths.electronApp.nodeModules\n                );\n            } catch (e) {\n                reject(e);\n                return;\n            } finally {\n                shell.config.reset();\n            }\n\n            if (this.firstPass) {\n                this.firstPass = false;\n            }\n            this.log.debug('node_modules moved back');\n\n            this.wait()\n                .catch(e => reject(e))\n                .then(() => resolve());\n        });\n    }\n\n    /**\n     * This command kills orphaned MSBuild.exe processes.\n     * Sometime after native node_modules compilation they are still writing some logs,\n     * prevent node_modules from being deleted.\n     */\n    killMSBuild() {\n        if (this.currentContext.platform.nodeName !== 'win32') {\n            return;\n        }\n        try {\n            const out = spawn\n                .sync(\n                    'wmic',\n                    ['process', 'where', 'caption=\"MSBuild.exe\"', 'get', 'processid']\n                )\n                .stdout.toString('utf-8')\n                .split('\\n');\n\n            const regex = new RegExp(/(\\d+)/, 'gm');\n            // No we will check for those with the matching params.\n            out.forEach((line) => {\n                const match = regex.exec(line) || false;\n                if (match) {\n                    this.log.debug(`killing MSBuild.exe at pid: ${match[1]}`);\n                    spawn.sync('taskkill', ['/pid', match[1], '/f', '/t']);\n                }\n                regex.lastIndex = 0;\n            });\n        } catch (e) {\n            this.log.debug('kill MSBuild failed');\n        }\n    }\n\n    /**\n     * Returns the path to packaged app.\n     * @returns {string}\n     */\n    getPackagedAppPath(context = {}) {\n        if (this.currentContext.platform.nodeName === 'darwin') {\n            return path.join(\n                this.installerDir,\n                'mac',\n                `${context.packager.appInfo.productFilename}.app`,\n                'Contents', 'Resources', 'app'\n            );\n        }\n        const platformDir =\n            `${this.currentContext.platform.nodeName === 'win32' ? 'win' : 'linux'}-${this.currentContext.arch === 'ia32' ? 'ia32-' : ''}unpacked`;\n        return path.join(\n            this.installerDir,\n            platformDir,\n            'resources', 'app'\n        );\n    }\n\n    /**\n     * On Windows it waits for the app.asar in the packed app to be free (no file locks).\n     * @returns {*}\n     */\n    wait() {\n        if (this.currentContext.platform.nodeName !== 'win32') {\n            return Promise.resolve();\n        }\n        const appAsarPath = path.join(\n            this.getPackagedAppPath(),\n            'app.asar'\n        );\n        let retries = 0;\n        const self = this;\n        return new Promise((resolve, reject) => {\n            function check() {\n                fs.open(appAsarPath, 'r+', (err, fd) => {\n                    retries += 1;\n                    if (err) {\n                        if (err.code !== 'ENOENT') {\n                            self.log.debug(`waiting for app.asar to be readable, ${'code' in err ? `currently reading it returns ${err.code}` : ''}`);\n                            if (retries < 6) {\n                                setTimeout(() => check(), 4000);\n                            } else {\n                                reject(`file is locked: ${appAsarPath}`);\n                            }\n                        } else {\n                            resolve();\n                        }\n                    } else {\n                        fs.closeSync(fd);\n                        resolve();\n                    }\n                });\n            }\n            check();\n        });\n    }\n\n    /**\n     * Prepares the target object passed to the electron-builder.\n     *\n     * @returns {Map<Platform, Map<Arch, Array<string>>>}\n     */\n    prepareTargets() {\n        let arch = this.$.env.options.ia32 ? 'ia32' : 'x64';\n        arch = this.$.env.options.allArchs ? 'all' : arch;\n\n        const targets = [];\n\n        if (this.$.env.options.win) {\n            targets.push(this.builder.dependency.Platform.WINDOWS);\n        }\n        if (this.$.env.options.linux) {\n            targets.push(this.builder.dependency.Platform.LINUX);\n        }\n        if (this.$.env.options.mac) {\n            targets.push(this.builder.dependency.Platform.MAC);\n        }\n\n        if (targets.length === 0) {\n            if (this.$.env.os.isWindows) {\n                targets.push(this.builder.dependency.Platform.WINDOWS);\n            } else if (this.$.env.os.isLinux) {\n                targets.push(this.builder.dependency.Platform.LINUX);\n            } else {\n                targets.push(this.builder.dependency.Platform.MAC);\n            }\n        }\n        return this.builder.dependency.createTargets(targets, null, arch);\n    }\n\n    async build() {\n        const settings = this.$.desktop.getSettings();\n        if (!('builderOptions' in settings)) {\n            this.log.error(\n                'no builderOptions in settings.json, aborting'\n            );\n            process.exit(1);\n        }\n\n        const builderOptions = Object.assign({}, settings.builderOptions);\n\n        builderOptions.asar = false;\n        builderOptions.npmRebuild = true;\n\n        builderOptions.beforeBuild = this.beforeBuild.bind(this);\n        builderOptions.afterPack = this.afterPack.bind(this);\n        builderOptions.electronVersion = this.$.getElectronVersion();\n\n        builderOptions.directories = {\n            app: this.$.env.paths.electronApp.root,\n            output: path.join(this.$.env.options.output, this.$.env.paths.installerDir)\n        };\n\n        if ('mac' in builderOptions && 'target' in builderOptions.mac) {\n            if (builderOptions.mac.target.includes('mas')) {\n                this.platforms = ['darwin', 'mas'];\n            }\n        }\n\n        try {\n            this.log.debug('calling build from electron-builder');\n            await this.builder.dependency.build(Object.assign({\n                targets: this.prepareTargets(),\n                config: builderOptions\n            }, settings.builderCliOptions));\n\n            if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) {\n                shell.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules);\n            }\n        } catch (e) {\n            this.log.error('error while building installer: ', e);\n        }\n    }\n\n    /**\n     * Moves node_modules out of the app because while the app will be packaged\n     * we do not want it to be there.\n     * @returns {Promise<any>}\n     */\n    moveNodeModulesOut() {\n        return new Promise((resolve, reject) => {\n            this.log.debug('moving node_modules out, because we have them already in' +\n                ' app.asar');\n            this.killMSBuild();\n            removeDir(this.$.env.paths.electronApp.tmpNodeModules)\n                .catch(e => reject(e))\n                .then(() => {\n                    shell.config.fatal = true;\n                    shell.config.verbose = true;\n                    try {\n                        shell.mv(\n                            this.$.env.paths.electronApp.nodeModules,\n                            this.$.env.paths.electronApp.tmpNodeModules\n                        );\n                        shell.config.reset();\n                        return this.wait();\n                    } catch (e) {\n                        shell.config.reset();\n                        return Promise.reject(e);\n                    }\n                })\n                .catch(e => reject(e))\n                .then(() => removeDir(this.$.env.paths.electronApp.nodeModules, 1000))\n                .catch(e => reject(e))\n                .then(() => this.wait())\n                .catch(reject)\n                .then(resolve);\n        });\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/env.js b/dist/env.js new file mode 100644 index 00000000..8f8fd133 --- /dev/null +++ b/dist/env.js @@ -0,0 +1,239 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _path = _interopRequireDefault(require("path")); + +var _os = _interopRequireDefault(require("os")); + +var _assignIn = _interopRequireDefault(require("lodash/assignIn")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +const { + join +} = _path.default; +/** + * @class + * @property {packagePaths} paths + */ + +class Env { + constructor(input, output, options) { + this.options = options; + + if (this.isProductionBuild()) { + process.env.NODE_ENV = 'production'; + } + + this.sys = { + platform: process.platform, + arch: process.arch + }; // Operational System. + + this.os = { + isWindows: process.platform === 'win32', + isLinux: process.platform === 'linux', + isOsx: process.platform === 'darwin' + }; + this.stdio = 'inherit'; + this.os.name = this.sys.platform === 'darwin' ? 'osx' : this.sys.platform; + this.os.home = process.env[this.os.isWindows ? 'USERPROFILE' : 'HOME']; + this.os.tmp = _os.default.tmpdir(); + /** @type {packagePaths} */ + + this.paths = {}; + /** @type {meteorDesktopPaths} */ + + this.paths.meteorDesktop = { + root: _path.default.resolve(__dirname, '..') + }; + this.paths.meteorDesktop.skeleton = join(this.paths.meteorDesktop.root, 'skeleton'); + /** @type {meteorAppPaths} */ + + this.paths.meteorApp = { + root: input + }; + /** @type {desktopPaths} */ + + this.paths.desktop = { + rootName: '.desktop', + root: join(this.paths.meteorApp.root, '.desktop') + }; + (0, _assignIn.default)(this.paths.desktop, { + modules: join(this.paths.desktop.root, 'modules'), + import: join(this.paths.desktop.root, 'import'), + assets: join(this.paths.desktop.root, 'assets'), + settings: join(this.paths.desktop.root, 'settings.json'), + desktop: join(this.paths.desktop.root, 'desktop.js') + }); + this.paths.desktop.splashScreen = join(this.paths.desktop.assets, 'splashScreen.png'); + this.paths.desktop.loadingGif = join(this.paths.desktop.assets, 'loading.gif'); + this.paths.desktop.meteorIco = join(this.paths.desktop.assets, 'meteor.ico'); + /** @type {electronAppPaths} */ + + this.paths.electronApp = { + rootName: 'desktop-build' + }; + this.paths.electronApp.root = join(this.paths.meteorApp.root, '.meteor', this.paths.electronApp.rootName); + this.paths.electronApp.tmpNodeModules = join(this.paths.meteorApp.root, '.meteor', '.desktop_node_modules'); + this.paths.cache = join(this.paths.meteorApp.root, '.meteor', 'local', 'desktop-cache'); + this.paths.electronApp.extractedNodeModules = join(this.paths.meteorApp.root, '.meteor', '.desktop_extracted_node_modules'); + this.paths.electronApp.extractedNodeModulesBin = join(this.paths.electronApp.extractedNodeModules, '.bin'); + this.paths.electronApp.appRoot = join(this.paths.electronApp.root, 'app'); + (0, _assignIn.default)(this.paths.electronApp, { + app: join(this.paths.electronApp.appRoot, 'app.js'), + cordova: join(this.paths.electronApp.appRoot, 'cordova.js'), + index: join(this.paths.electronApp.appRoot, 'index.js'), + preload: join(this.paths.electronApp.appRoot, 'preload.js'), + modules: join(this.paths.electronApp.appRoot, 'modules'), + desktopAsar: join(this.paths.electronApp.root, 'desktop.asar'), + extracted: join(this.paths.electronApp.root, 'extracted'), + appAsar: join(this.paths.electronApp.root, 'app.asar'), + import: join(this.paths.electronApp.root, 'import'), + assets: join(this.paths.electronApp.root, 'assets'), + packageJson: join(this.paths.electronApp.root, 'package.json'), + settings: join(this.paths.electronApp.root, 'settings.json'), + desktop: join(this.paths.electronApp.root, 'desktop.js'), + desktopTmp: join(this.paths.electronApp.root, '__desktop'), + nodeModules: join(this.paths.electronApp.root, 'node_modules'), + meteorAsar: join(this.paths.electronApp.root, 'meteor.asar'), + meteorApp: join(this.paths.electronApp.root, 'meteor'), + meteorAppIndex: join(this.paths.electronApp.root, 'meteor', 'index.html'), + meteorAppProgramJson: join(this.paths.electronApp.root, 'meteor', 'program.json'), + skeleton: join(this.paths.electronApp.root, 'skeleton') + }); + (0, _assignIn.default)(this.paths.meteorApp, { + platforms: join(this.paths.meteorApp.root, '.meteor', 'platforms'), + packages: join(this.paths.meteorApp.root, '.meteor', 'packages'), + versions: join(this.paths.meteorApp.root, '.meteor', 'versions'), + release: join(this.paths.meteorApp.root, '.meteor', 'release'), + packageJson: join(this.paths.meteorApp.root, 'package.json'), + gitIgnore: join(this.paths.meteorApp.root, '.meteor', '.gitignore'), + cordovaBuild: join(this.paths.meteorApp.root, '.meteor', 'local', 'cordova-build', 'www', 'application'), + webCordova: join(this.paths.meteorApp.root, '.meteor', 'local', 'build', 'programs', 'web.cordova') + }); + (0, _assignIn.default)(this.paths.meteorApp, { + cordovaBuildIndex: join(this.paths.meteorApp.cordovaBuild, 'index.html'), + cordovaBuildProgramJson: join(this.paths.meteorApp.cordovaBuild, 'program.json') + }); + (0, _assignIn.default)(this.paths.meteorApp, { + webCordovaProgramJson: join(this.paths.meteorApp.webCordova, 'program.json') + }); + /** @type {desktopTmpPaths} */ + + this.paths.desktopTmp = { + root: join(this.paths.electronApp.root, '__desktop') + }; + (0, _assignIn.default)(this.paths.desktopTmp, { + modules: join(this.paths.desktopTmp.root, 'modules'), + settings: join(this.paths.desktopTmp.root, 'settings.json') + }); + this.paths.packageDir = '.desktop-package'; + this.paths.installerDir = '.desktop-installer'; // Scaffold + + this.paths.scaffold = join(__dirname, '..', 'scaffold'); + } + /** + * @returns {boolean|*} + * @public + */ + + + isProductionBuild() { + return !!('production' in this.options && this.options.production); + } + +} + +exports.default = Env; +module.exports = Env; +/** + * @typedef {Object} desktopPaths + * @property {string} rootName + * @property {string} root + * @property {string} modules + * @property {string} import + * @property {string} assets + * @property {string} settings + * @property {string} desktop + * @property {string} splashScreen + * @property {string} loadingGif + * @property {string} meteorIco + */ + +/** + * @typedef {Object} meteorAppPaths + * @property {string} root + * @property {string} platforms + * @property {string} release + * @property {string} packages + * @property {string} versions + * @property {string} gitIgnore + * @property {string} packageJson + * @property {string} cordovaBuild + * @property {string} cordovaBuildIndex + * @property {string} cordovaBuildProgramJson + * @property {string} webCordova + * @property {string} webCordovaIndex + * @property {string} webCordovaProgramJson + */ + +/** + * @typedef {Object} electronAppPaths + * @property {string} rootName + * @property {string} root + * @property {Object} appRoot + * @property {string} appRoot.cordova + * @property {string} appRoot.index + * @property {string} appRoot.app + * @property {string} appRoot.modules + * @property {string} desktopAsar + * @property {string} extracted + * @property {string} appAsar + * @property {string} preload + * @property {string} import + * @property {string} assets + * @property {string} gitIgnore + * @property {string} packageJson + * @property {string} settings + * @property {string} desktop + * @property {string} desktopTmp + * @property {string} nodeModules + * @property {string} meteorAsar + * @property {string} meteorApp + * @property {string} meteorAppIndex + * @property {string} meteorAppProgramJson + * @property {string} skeleton + * @property {string} tmpNodeModules + * @property {string} extractedNodeModules + * @property {string} extractedNodeModulesBin + */ + +/** + * @typedef {Object} desktopTmpPaths + * @property {string} root + * @property {string} modules + * @property {string} settings + */ + +/** + * @typedef {Object} meteorDesktopPaths + * @property {string} root + * @property {string} skeleton + */ + +/** + * @typedef {Object} packagePaths + * @property {meteorAppPaths} meteorApp + * @property {desktopPaths} desktop + * @property {electronAppPaths} electronApp + * @property {desktopTmpPaths} desktopTmp + * @property {meteorDesktopPaths} meteorDesktop + * @property {string} packageDir + * @property {string} scaffold + */ +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","Env","constructor","input","output","options","isProductionBuild","process","env","NODE_ENV","sys","platform","arch","os","isWindows","isLinux","isOsx","stdio","name","home","tmp","tmpdir","paths","meteorDesktop","root","resolve","__dirname","skeleton","meteorApp","desktop","rootName","assignIn","modules","import","assets","settings","splashScreen","loadingGif","meteorIco","electronApp","tmpNodeModules","cache","extractedNodeModules","extractedNodeModulesBin","appRoot","app","cordova","index","preload","desktopAsar","extracted","appAsar","packageJson","desktopTmp","nodeModules","meteorAsar","meteorAppIndex","meteorAppProgramJson","platforms","packages","versions","release","gitIgnore","cordovaBuild","webCordova","cordovaBuildIndex","cordovaBuildProgramJson","webCordovaProgramJson","packageDir","installerDir","scaffold","production","module","exports"],"sources":["../lib/env.js"],"sourcesContent":["import path from 'path';\nimport os from 'os';\nimport assignIn from 'lodash/assignIn';\n\nconst { join } = path;\n\n/**\n * @class\n * @property {packagePaths} paths\n */\nexport default class Env {\n    constructor(input, output, options) {\n        this.options = options;\n\n        if (this.isProductionBuild()) {\n            process.env.NODE_ENV = 'production';\n        }\n\n        this.sys = {\n            platform: process.platform,\n            arch: process.arch\n        };\n\n        // Operational System.\n        this.os = {\n            isWindows: (process.platform === 'win32'),\n            isLinux: (process.platform === 'linux'),\n            isOsx: (process.platform === 'darwin')\n\n        };\n        this.stdio = 'inherit';\n\n        this.os.name = (this.sys.platform === 'darwin' ? 'osx' : this.sys.platform);\n        this.os.home = process.env[(this.os.isWindows ? 'USERPROFILE' : 'HOME')];\n        this.os.tmp = os.tmpdir();\n\n        /** @type {packagePaths} */\n        this.paths = {};\n\n        /** @type {meteorDesktopPaths} */\n        this.paths.meteorDesktop = {\n            root: path.resolve(__dirname, '..')\n        };\n\n        this.paths.meteorDesktop.skeleton = join(this.paths.meteorDesktop.root, 'skeleton');\n\n        /** @type {meteorAppPaths} */\n        this.paths.meteorApp = {\n            root: input\n        };\n\n        /** @type {desktopPaths} */\n        this.paths.desktop = {\n            rootName: '.desktop',\n            root: join(this.paths.meteorApp.root, '.desktop')\n        };\n\n        assignIn(this.paths.desktop, {\n            modules: join(this.paths.desktop.root, 'modules'),\n            import: join(this.paths.desktop.root, 'import'),\n            assets: join(this.paths.desktop.root, 'assets'),\n            settings: join(this.paths.desktop.root, 'settings.json'),\n            desktop: join(this.paths.desktop.root, 'desktop.js')\n        });\n\n        this.paths.desktop.splashScreen = join(this.paths.desktop.assets, 'splashScreen.png');\n        this.paths.desktop.loadingGif = join(this.paths.desktop.assets, 'loading.gif');\n        this.paths.desktop.meteorIco = join(this.paths.desktop.assets, 'meteor.ico');\n\n        /** @type {electronAppPaths} */\n        this.paths.electronApp = {\n            rootName: 'desktop-build',\n        };\n        this.paths.electronApp.root =\n            join(this.paths.meteorApp.root, '.meteor', this.paths.electronApp.rootName);\n\n        this.paths.electronApp.tmpNodeModules =\n            join(this.paths.meteorApp.root, '.meteor', '.desktop_node_modules');\n\n        this.paths.cache =\n            join(this.paths.meteorApp.root, '.meteor', 'local', 'desktop-cache');\n\n        this.paths.electronApp.extractedNodeModules =\n            join(this.paths.meteorApp.root, '.meteor', '.desktop_extracted_node_modules');\n\n        this.paths.electronApp.extractedNodeModulesBin =\n            join(this.paths.electronApp.extractedNodeModules, '.bin');\n\n\n        this.paths.electronApp.appRoot =\n            join(this.paths.electronApp.root, 'app');\n\n        assignIn(this.paths.electronApp, {\n            app: join(this.paths.electronApp.appRoot, 'app.js'),\n            cordova: join(this.paths.electronApp.appRoot, 'cordova.js'),\n            index: join(this.paths.electronApp.appRoot, 'index.js'),\n            preload: join(this.paths.electronApp.appRoot, 'preload.js'),\n            modules: join(this.paths.electronApp.appRoot, 'modules'),\n            desktopAsar: join(this.paths.electronApp.root, 'desktop.asar'),\n            extracted: join(this.paths.electronApp.root, 'extracted'),\n            appAsar: join(this.paths.electronApp.root, 'app.asar'),\n            import: join(this.paths.electronApp.root, 'import'),\n            assets: join(this.paths.electronApp.root, 'assets'),\n            packageJson: join(this.paths.electronApp.root, 'package.json'),\n            settings: join(this.paths.electronApp.root, 'settings.json'),\n            desktop: join(this.paths.electronApp.root, 'desktop.js'),\n            desktopTmp: join(this.paths.electronApp.root, '__desktop'),\n            nodeModules: join(this.paths.electronApp.root, 'node_modules'),\n            meteorAsar: join(this.paths.electronApp.root, 'meteor.asar'),\n            meteorApp: join(this.paths.electronApp.root, 'meteor'),\n            meteorAppIndex: join(this.paths.electronApp.root, 'meteor', 'index.html'),\n            meteorAppProgramJson: join(this.paths.electronApp.root, 'meteor', 'program.json'),\n            skeleton: join(this.paths.electronApp.root, 'skeleton')\n        });\n\n        assignIn(this.paths.meteorApp, {\n            platforms: join(this.paths.meteorApp.root, '.meteor', 'platforms'),\n            packages: join(this.paths.meteorApp.root, '.meteor', 'packages'),\n            versions: join(this.paths.meteorApp.root, '.meteor', 'versions'),\n            release: join(this.paths.meteorApp.root, '.meteor', 'release'),\n            packageJson: join(this.paths.meteorApp.root, 'package.json'),\n            gitIgnore: join(this.paths.meteorApp.root, '.meteor', '.gitignore'),\n            cordovaBuild: join(\n                this.paths.meteorApp.root,\n                '.meteor',\n                'local',\n                'cordova-build',\n                'www',\n                'application'\n            ),\n            webCordova: join(\n                this.paths.meteorApp.root,\n                '.meteor',\n                'local',\n                'build',\n                'programs',\n                'web.cordova'\n            )\n        });\n\n        assignIn(this.paths.meteorApp, {\n            cordovaBuildIndex: join(\n                this.paths.meteorApp.cordovaBuild, 'index.html'\n            ),\n            cordovaBuildProgramJson: join(\n                this.paths.meteorApp.cordovaBuild, 'program.json'\n            )\n        });\n\n        assignIn(this.paths.meteorApp, {\n            webCordovaProgramJson: join(\n                this.paths.meteorApp.webCordova, 'program.json'\n            )\n        });\n\n\n        /** @type {desktopTmpPaths} */\n        this.paths.desktopTmp = {\n            root: join(this.paths.electronApp.root, '__desktop'),\n        };\n\n        assignIn(this.paths.desktopTmp, {\n            modules: join(this.paths.desktopTmp.root, 'modules'),\n            settings: join(this.paths.desktopTmp.root, 'settings.json')\n        });\n\n        this.paths.packageDir = '.desktop-package';\n        this.paths.installerDir = '.desktop-installer';\n\n        // Scaffold\n        this.paths.scaffold = join(__dirname, '..', 'scaffold');\n    }\n\n    /**\n     * @returns {boolean|*}\n     * @public\n     */\n    isProductionBuild() {\n        return !!('production' in this.options && this.options.production);\n    }\n}\n\nmodule.exports = Env;\n\n/**\n * @typedef {Object} desktopPaths\n * @property {string} rootName\n * @property {string} root\n * @property {string} modules\n * @property {string} import\n * @property {string} assets\n * @property {string} settings\n * @property {string} desktop\n * @property {string} splashScreen\n * @property {string} loadingGif\n * @property {string} meteorIco\n */\n\n/**\n * @typedef {Object} meteorAppPaths\n * @property {string} root\n * @property {string} platforms\n * @property {string} release\n * @property {string} packages\n * @property {string} versions\n * @property {string} gitIgnore\n * @property {string} packageJson\n * @property {string} cordovaBuild\n * @property {string} cordovaBuildIndex\n * @property {string} cordovaBuildProgramJson\n * @property {string} webCordova\n * @property {string} webCordovaIndex\n * @property {string} webCordovaProgramJson\n */\n\n/**\n * @typedef {Object} electronAppPaths\n * @property {string} rootName\n * @property {string} root\n * @property {Object} appRoot\n * @property {string} appRoot.cordova\n * @property {string} appRoot.index\n * @property {string} appRoot.app\n * @property {string} appRoot.modules\n * @property {string} desktopAsar\n * @property {string} extracted\n * @property {string} appAsar\n * @property {string} preload\n * @property {string} import\n * @property {string} assets\n * @property {string} gitIgnore\n * @property {string} packageJson\n * @property {string} settings\n * @property {string} desktop\n * @property {string} desktopTmp\n * @property {string} nodeModules\n * @property {string} meteorAsar\n * @property {string} meteorApp\n * @property {string} meteorAppIndex\n * @property {string} meteorAppProgramJson\n * @property {string} skeleton\n * @property {string} tmpNodeModules\n * @property {string} extractedNodeModules\n * @property {string} extractedNodeModulesBin\n */\n\n/**\n * @typedef {Object} desktopTmpPaths\n * @property {string} root\n * @property {string} modules\n * @property {string} settings\n */\n\n/**\n * @typedef {Object} meteorDesktopPaths\n * @property {string} root\n * @property {string} skeleton\n */\n\n/**\n * @typedef {Object} packagePaths\n * @property {meteorAppPaths} meteorApp\n * @property {desktopPaths} desktop\n * @property {electronAppPaths} electronApp\n * @property {desktopTmpPaths} desktopTmp\n * @property {meteorDesktopPaths} meteorDesktop\n * @property {string} packageDir\n * @property {string} scaffold\n */\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 00000000..44c7cecc --- /dev/null +++ b/dist/index.js @@ -0,0 +1,247 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = _exports; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _fs = _interopRequireDefault(require("fs")); + +var _path = _interopRequireDefault(require("path")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _env = _interopRequireDefault(require("./env")); + +var _electron = _interopRequireDefault(require("./electron")); + +var _log = _interopRequireDefault(require("./log")); + +var _desktop = _interopRequireDefault(require("./desktop")); + +var _electronApp = _interopRequireDefault(require("./electronApp")); + +var _meteorApp = _interopRequireDefault(require("./meteorApp")); + +var _electronBuilder = _interopRequireDefault(require("./electronBuilder")); + +var _packager = _interopRequireDefault(require("./packager")); + +var _utils = _interopRequireDefault(require("./utils")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars +_shelljs.default.config.fatal = true; +/** + * Main entity. + * @class + * @property {Env} env + * @property {Electron} electron + * @property {InstallerBuilder} installerBuilder + * @property {ElectronApp} electronApp + * @property {Desktop} desktop + * @property {MeteorApp} meteorApp + */ + +class MeteorDesktop { + /** + * @param {string} input - Meteor app dir + * @param {string} output - output dir for bundle/package/installer + * @param {Object} options - options from cli.js + * @param {Object} dependencies - dependencies object + * @constructor + */ + constructor(input, output, options, dependencies) { + const Log = dependencies.log; + this.log = new Log('index'); + this.version = this.getVersion(); + this.log.info('initializing'); + this.env = new _env.default(input, output, options); + this.electron = new _electron.default(this); + this.electronBuilder = new _electronBuilder.default(this); + this.electronApp = new _electronApp.default(this); + this.desktop = new _desktop.default(this); + this.meteorApp = new _meteorApp.default(this); + this.utils = _utils.default; + } + /** + * Tries to read the version from our own package.json. + * + * @returns {string} + */ + + + getVersion() { + if (this.version) { + return this.version; + } + + let version = null; + + try { + ({ + version + } = JSON.parse(_fs.default.readFileSync(_path.default.join(__dirname, '..', 'package.json'), 'UTF-8'))); + } catch (e) { + this.log.error(`error while trying to read ${_path.default.join(__dirname, 'package.json')}`, e); + process.exit(1); + } + + if (process.env.PLUGIN_VERSION && (version.includes('rc') || version.includes('beta') || version.includes('alpha'))) { + version = process.env.PLUGIN_VERSION; + } + + return version; + } + /** + * Tries to read the version from our own package.json. + * + * @returns {string} + */ + + + getElectronVersion() { + let version = null; + + try { + const { + dependencies = {}, + devDependencies = {} + } = JSON.parse(_fs.default.readFileSync(_path.default.join(this.env.paths.meteorApp.root, 'package.json'), 'UTF-8')); + + if (!('electron' in dependencies) && !('electron' in devDependencies)) { + this.log.error('electron not found in meteor project dependencies'); + process.exit(1); + } + + version = dependencies.electron || devDependencies.electron; + + if (this.electronApp.depsManager.checks.version.regex.test(version)) { + ({ + version + } = JSON.parse(_fs.default.readFileSync(_path.default.join(this.env.paths.meteorApp.root, 'node_modules', 'electron', 'package.json'), 'UTF-8'))); + } + } catch (e) { + this.log.error(`error while trying to read ${_path.default.join(this.env.paths.meteorApp.root, 'package.json')}`, e); + process.exit(1); + } + + return version; + } + + async init() { + this.desktop.scaffold(); + this.meteorApp.updateGitIgnore(); + await this.electronApp.init(); + } + + async buildInstaller(throwError = false) { + this.env.options.installerBuild = true; + await this.electronApp.build(); + + try { + await this.electronBuilder.build(); + } catch (e) { + this.log.error('error occurred while building installer', e); + + if (throwError) { + throw new Error(e); + } + } + } + + async run() { + await this.electronApp.build(true); + } + + async build() { + await this.electronApp.build(); + } + + justRun() { + this.electron.run(); + } + + async runPackager() { + this.packager = new _packager.default(this); + await this.packager.init(); + await this.electronApp.build(); + this.packager.packageApp().catch(e => { + this.log.error(`while trying to build a package an error occurred: ${e}`); + }); + } + + async getDependency(name, version, declarationCheck = true) { + if (declarationCheck) { + try { + const { + dependencies = {}, + devDependencies = {} + } = JSON.parse(_fs.default.readFileSync(_path.default.join(this.env.paths.meteorApp.root, 'package.json'), 'UTF-8')); + + if (!(name in dependencies) && !(name in devDependencies)) { + await this.meteorApp.runNpm(['i', '-D', '-E', '--only=dev', `${name}@${version}`], 'inherit'); + } + } catch (e) { + this.log.error(`could no read ${_path.default.join(this.env.paths.meteorApp.root, 'package.json')}`, e); + process.exit(1); + } + } + + const dependencyPath = _path.default.join(this.env.paths.meteorApp.root, 'node_modules', name); + + let dependency = null; + + try { + dependency = require(dependencyPath); + } catch (e) { + if (declarationCheck) { + this.log.warn(`could not find ${name}, installing the default version for you: ${name}@${version}`); + + try { + await this.meteorApp.runNpm(['i', '-D', '-E', '--only=dev', `${name}@${version}`], 'inherit'); + } catch (err) { + this.log.error(err); + process.exit(1); + } + } else { + this.log.warn(`could not find ${name}, exiting`); + process.exit(1); + } + } finally { + if (!dependency) { + dependency = require(dependencyPath); + } + } + + const dependencyVersion = require(_path.default.join(dependencyPath, 'package.json')).version; + + if (dependencyVersion !== version) { + if (dependencyVersion.split('.')[0] !== version.split('.')[0]) { + this.log.warn(`you are using a ${name}@${dependencyVersion} while the recommended version is ` + `${version}, the compatibility version is different, use at your own risk, be sure to report ` + 'that when submitting issues'); + } else { + this.log.warn(`you are using a ${name}@${dependencyVersion} while the recommended version is ` + `${version}, be sure to report that when submitting issues`); + } + } + + return { + dependency, + path: dependencyPath + }; + } + +} + +function _exports(input, output, options, { + log = _log.default +} = { + log: _log.default +}) { + return new MeteorDesktop(input, output, options, { + log + }); +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["shell","config","fatal","MeteorDesktop","constructor","input","output","options","dependencies","Log","log","version","getVersion","info","env","Env","electron","Electron","electronBuilder","ElectronBuilder","electronApp","ElectronApp","desktop","Desktop","meteorApp","MeteorApp","utils","JSON","parse","fs","readFileSync","path","join","__dirname","e","error","process","exit","PLUGIN_VERSION","includes","getElectronVersion","devDependencies","paths","root","depsManager","checks","regex","test","init","scaffold","updateGitIgnore","buildInstaller","throwError","installerBuild","build","Error","run","justRun","runPackager","packager","Packager","packageApp","catch","getDependency","name","declarationCheck","runNpm","dependencyPath","dependency","require","warn","err","dependencyVersion","split","exports","Logger"],"sources":["../lib/index.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport fs from 'fs';\nimport path from 'path';\nimport shell from 'shelljs';\nimport Env from './env';\nimport Electron from './electron';\nimport Logger from './log';\nimport Desktop from './desktop';\nimport ElectronApp from './electronApp';\nimport MeteorApp from './meteorApp';\nimport ElectronBuilder from './electronBuilder';\nimport Packager from './packager';\nimport utils from './utils';\n\nshell.config.fatal = true;\n\n/**\n * Main entity.\n * @class\n * @property {Env} env\n * @property {Electron} electron\n * @property {InstallerBuilder} installerBuilder\n * @property {ElectronApp} electronApp\n * @property {Desktop} desktop\n * @property {MeteorApp} meteorApp\n */\nclass MeteorDesktop {\n    /**\n     * @param {string} input        - Meteor app dir\n     * @param {string} output       - output dir for bundle/package/installer\n     * @param {Object} options      - options from cli.js\n     * @param {Object} dependencies - dependencies object\n     * @constructor\n     */\n    constructor(input, output, options, dependencies) {\n        const Log = dependencies.log;\n        this.log = new Log('index');\n        this.version = this.getVersion();\n\n        this.log.info('initializing');\n\n        this.env = new Env(input, output, options);\n        this.electron = new Electron(this);\n        this.electronBuilder = new ElectronBuilder(this);\n        this.electronApp = new ElectronApp(this);\n        this.desktop = new Desktop(this);\n        this.meteorApp = new MeteorApp(this);\n        this.utils = utils;\n    }\n\n    /**\n     * Tries to read the version from our own package.json.\n     *\n     * @returns {string}\n     */\n    getVersion() {\n        if (this.version) {\n            return this.version;\n        }\n\n        let version = null;\n        try {\n            ({ version } = JSON.parse(\n                fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'UTF-8')\n            ));\n        } catch (e) {\n            this.log.error(`error while trying to read ${path.join(__dirname, 'package.json')}`, e);\n            process.exit(1);\n        }\n        if (process.env.PLUGIN_VERSION &&\n            (version.includes('rc') || version.includes('beta') || version.includes('alpha'))\n        ) {\n            version = process.env.PLUGIN_VERSION;\n        }\n        return version;\n    }\n\n    /**\n     * Tries to read the version from our own package.json.\n     *\n     * @returns {string}\n     */\n    getElectronVersion() {\n        let version = null;\n        try {\n            const { dependencies = {}, devDependencies = {} } = JSON.parse(\n                fs.readFileSync(path.join(this.env.paths.meteorApp.root, 'package.json'), 'UTF-8')\n            );\n            if (!('electron' in dependencies) && !('electron' in devDependencies)) {\n                this.log.error('electron not found in meteor project dependencies');\n                process.exit(1);\n            }\n            version = dependencies.electron || devDependencies.electron;\n            if (this.electronApp.depsManager.checks.version.regex.test(version)) {\n                ({ version } = JSON.parse(\n                    fs.readFileSync(path.join(this.env.paths.meteorApp.root, 'node_modules', 'electron', 'package.json'), 'UTF-8')\n                ));\n            }\n        } catch (e) {\n            this.log.error(`error while trying to read ${path.join(this.env.paths.meteorApp.root, 'package.json')}`, e);\n            process.exit(1);\n        }\n        return version;\n    }\n\n    async init() {\n        this.desktop.scaffold();\n        this.meteorApp.updateGitIgnore();\n        await this.electronApp.init();\n    }\n\n    async buildInstaller(throwError = false) {\n        this.env.options.installerBuild = true;\n        await this.electronApp.build();\n        try {\n            await this.electronBuilder.build();\n        } catch (e) {\n            this.log.error('error occurred while building installer', e);\n            if (throwError) {\n                throw new Error(e);\n            }\n        }\n    }\n\n    async run() {\n        await this.electronApp.build(true);\n    }\n\n    async build() {\n        await this.electronApp.build();\n    }\n\n    justRun() {\n        this.electron.run();\n    }\n\n    async runPackager() {\n        this.packager = new Packager(this);\n        await this.packager.init();\n        await this.electronApp.build();\n\n        this.packager.packageApp().catch((e) => {\n            this.log.error(`while trying to build a package an error occurred: ${e}`);\n        });\n    }\n\n    async getDependency(name, version, declarationCheck = true) {\n        if (declarationCheck) {\n            try {\n                const { dependencies = {}, devDependencies = {} } = JSON.parse(\n                    fs.readFileSync(path.join(this.env.paths.meteorApp.root, 'package.json'), 'UTF-8')\n                );\n                if (!(name in dependencies) && !(name in devDependencies)) {\n                    await this.meteorApp.runNpm(['i', '-D', '-E', '--only=dev', `${name}@${version}`], 'inherit');\n                }\n            } catch (e) {\n                this.log.error(`could no read ${path.join(this.env.paths.meteorApp.root, 'package.json')}`, e);\n                process.exit(1);\n            }\n        }\n\n        const dependencyPath = path.join(this.env.paths.meteorApp.root, 'node_modules', name);\n        let dependency = null;\n        try {\n            dependency = require(dependencyPath);\n        } catch (e) {\n            if (declarationCheck) {\n                this.log.warn(`could not find ${name}, installing the default version for you: ${name}@${version}`);\n                try {\n                    await this.meteorApp.runNpm(['i', '-D', '-E', '--only=dev', `${name}@${version}`], 'inherit');\n                } catch (err) {\n                    this.log.error(err);\n                    process.exit(1);\n                }\n            } else {\n                this.log.warn(`could not find ${name}, exiting`);\n                process.exit(1);\n            }\n        } finally {\n            if (!dependency) {\n                dependency = require(dependencyPath);\n            }\n        }\n        const dependencyVersion = require(path.join(dependencyPath, 'package.json')).version;\n\n        if (dependencyVersion !== version) {\n            if (dependencyVersion.split('.')[0] !== version.split('.')[0]) {\n                this.log.warn(`you are using a ${name}@${dependencyVersion} while the recommended version is ` +\n                    `${version}, the compatibility version is different, use at your own risk, be sure to report ` +\n                    'that when submitting issues');\n            } else {\n                this.log.warn(`you are using a ${name}@${dependencyVersion} while the recommended version is ` +\n                    `${version}, be sure to report that when submitting issues`);\n            }\n        }\n        return { dependency, path: dependencyPath };\n    }\n}\n\nexport default function exports(input, output, options, { log = Logger } = { log: Logger }) {\n    return new MeteorDesktop(input, output, options, { log });\n}\n"],"mappings":";;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;AAbA;AAeAA,gBAAA,CAAMC,MAAN,CAAaC,KAAb,GAAqB,IAArB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,MAAMC,aAAN,CAAoB;EAChB;AACJ;AACA;AACA;AACA;AACA;AACA;EACIC,WAAW,CAACC,KAAD,EAAQC,MAAR,EAAgBC,OAAhB,EAAyBC,YAAzB,EAAuC;IAC9C,MAAMC,GAAG,GAAGD,YAAY,CAACE,GAAzB;IACA,KAAKA,GAAL,GAAW,IAAID,GAAJ,CAAQ,OAAR,CAAX;IACA,KAAKE,OAAL,GAAe,KAAKC,UAAL,EAAf;IAEA,KAAKF,GAAL,CAASG,IAAT,CAAc,cAAd;IAEA,KAAKC,GAAL,GAAW,IAAIC,YAAJ,CAAQV,KAAR,EAAeC,MAAf,EAAuBC,OAAvB,CAAX;IACA,KAAKS,QAAL,GAAgB,IAAIC,iBAAJ,CAAa,IAAb,CAAhB;IACA,KAAKC,eAAL,GAAuB,IAAIC,wBAAJ,CAAoB,IAApB,CAAvB;IACA,KAAKC,WAAL,GAAmB,IAAIC,oBAAJ,CAAgB,IAAhB,CAAnB;IACA,KAAKC,OAAL,GAAe,IAAIC,gBAAJ,CAAY,IAAZ,CAAf;IACA,KAAKC,SAAL,GAAiB,IAAIC,kBAAJ,CAAc,IAAd,CAAjB;IACA,KAAKC,KAAL,GAAaA,cAAb;EACH;EAED;AACJ;AACA;AACA;AACA;;;EACId,UAAU,GAAG;IACT,IAAI,KAAKD,OAAT,EAAkB;MACd,OAAO,KAAKA,OAAZ;IACH;;IAED,IAAIA,OAAO,GAAG,IAAd;;IACA,IAAI;MACA,CAAC;QAAEA;MAAF,IAAcgB,IAAI,CAACC,KAAL,CACXC,WAAA,CAAGC,YAAH,CAAgBC,aAAA,CAAKC,IAAL,CAAUC,SAAV,EAAqB,IAArB,EAA2B,cAA3B,CAAhB,EAA4D,OAA5D,CADW,CAAf;IAGH,CAJD,CAIE,OAAOC,CAAP,EAAU;MACR,KAAKxB,GAAL,CAASyB,KAAT,CAAgB,8BAA6BJ,aAAA,CAAKC,IAAL,CAAUC,SAAV,EAAqB,cAArB,CAAqC,EAAlF,EAAqFC,CAArF;MACAE,OAAO,CAACC,IAAR,CAAa,CAAb;IACH;;IACD,IAAID,OAAO,CAACtB,GAAR,CAAYwB,cAAZ,KACC3B,OAAO,CAAC4B,QAAR,CAAiB,IAAjB,KAA0B5B,OAAO,CAAC4B,QAAR,CAAiB,MAAjB,CAA1B,IAAsD5B,OAAO,CAAC4B,QAAR,CAAiB,OAAjB,CADvD,CAAJ,EAEE;MACE5B,OAAO,GAAGyB,OAAO,CAACtB,GAAR,CAAYwB,cAAtB;IACH;;IACD,OAAO3B,OAAP;EACH;EAED;AACJ;AACA;AACA;AACA;;;EACI6B,kBAAkB,GAAG;IACjB,IAAI7B,OAAO,GAAG,IAAd;;IACA,IAAI;MACA,MAAM;QAAEH,YAAY,GAAG,EAAjB;QAAqBiC,eAAe,GAAG;MAAvC,IAA8Cd,IAAI,CAACC,KAAL,CAChDC,WAAA,CAAGC,YAAH,CAAgBC,aAAA,CAAKC,IAAL,CAAU,KAAKlB,GAAL,CAAS4B,KAAT,CAAelB,SAAf,CAAyBmB,IAAnC,EAAyC,cAAzC,CAAhB,EAA0E,OAA1E,CADgD,CAApD;;MAGA,IAAI,EAAE,cAAcnC,YAAhB,KAAiC,EAAE,cAAciC,eAAhB,CAArC,EAAuE;QACnE,KAAK/B,GAAL,CAASyB,KAAT,CAAe,mDAAf;QACAC,OAAO,CAACC,IAAR,CAAa,CAAb;MACH;;MACD1B,OAAO,GAAGH,YAAY,CAACQ,QAAb,IAAyByB,eAAe,CAACzB,QAAnD;;MACA,IAAI,KAAKI,WAAL,CAAiBwB,WAAjB,CAA6BC,MAA7B,CAAoClC,OAApC,CAA4CmC,KAA5C,CAAkDC,IAAlD,CAAuDpC,OAAvD,CAAJ,EAAqE;QACjE,CAAC;UAAEA;QAAF,IAAcgB,IAAI,CAACC,KAAL,CACXC,WAAA,CAAGC,YAAH,CAAgBC,aAAA,CAAKC,IAAL,CAAU,KAAKlB,GAAL,CAAS4B,KAAT,CAAelB,SAAf,CAAyBmB,IAAnC,EAAyC,cAAzC,EAAyD,UAAzD,EAAqE,cAArE,CAAhB,EAAsG,OAAtG,CADW,CAAf;MAGH;IACJ,CAdD,CAcE,OAAOT,CAAP,EAAU;MACR,KAAKxB,GAAL,CAASyB,KAAT,CAAgB,8BAA6BJ,aAAA,CAAKC,IAAL,CAAU,KAAKlB,GAAL,CAAS4B,KAAT,CAAelB,SAAf,CAAyBmB,IAAnC,EAAyC,cAAzC,CAAyD,EAAtG,EAAyGT,CAAzG;MACAE,OAAO,CAACC,IAAR,CAAa,CAAb;IACH;;IACD,OAAO1B,OAAP;EACH;;EAES,MAAJqC,IAAI,GAAG;IACT,KAAK1B,OAAL,CAAa2B,QAAb;IACA,KAAKzB,SAAL,CAAe0B,eAAf;IACA,MAAM,KAAK9B,WAAL,CAAiB4B,IAAjB,EAAN;EACH;;EAEmB,MAAdG,cAAc,CAACC,UAAU,GAAG,KAAd,EAAqB;IACrC,KAAKtC,GAAL,CAASP,OAAT,CAAiB8C,cAAjB,GAAkC,IAAlC;IACA,MAAM,KAAKjC,WAAL,CAAiBkC,KAAjB,EAAN;;IACA,IAAI;MACA,MAAM,KAAKpC,eAAL,CAAqBoC,KAArB,EAAN;IACH,CAFD,CAEE,OAAOpB,CAAP,EAAU;MACR,KAAKxB,GAAL,CAASyB,KAAT,CAAe,yCAAf,EAA0DD,CAA1D;;MACA,IAAIkB,UAAJ,EAAgB;QACZ,MAAM,IAAIG,KAAJ,CAAUrB,CAAV,CAAN;MACH;IACJ;EACJ;;EAEQ,MAAHsB,GAAG,GAAG;IACR,MAAM,KAAKpC,WAAL,CAAiBkC,KAAjB,CAAuB,IAAvB,CAAN;EACH;;EAEU,MAALA,KAAK,GAAG;IACV,MAAM,KAAKlC,WAAL,CAAiBkC,KAAjB,EAAN;EACH;;EAEDG,OAAO,GAAG;IACN,KAAKzC,QAAL,CAAcwC,GAAd;EACH;;EAEgB,MAAXE,WAAW,GAAG;IAChB,KAAKC,QAAL,GAAgB,IAAIC,iBAAJ,CAAa,IAAb,CAAhB;IACA,MAAM,KAAKD,QAAL,CAAcX,IAAd,EAAN;IACA,MAAM,KAAK5B,WAAL,CAAiBkC,KAAjB,EAAN;IAEA,KAAKK,QAAL,CAAcE,UAAd,GAA2BC,KAA3B,CAAkC5B,CAAD,IAAO;MACpC,KAAKxB,GAAL,CAASyB,KAAT,CAAgB,sDAAqDD,CAAE,EAAvE;IACH,CAFD;EAGH;;EAEkB,MAAb6B,aAAa,CAACC,IAAD,EAAOrD,OAAP,EAAgBsD,gBAAgB,GAAG,IAAnC,EAAyC;IACxD,IAAIA,gBAAJ,EAAsB;MAClB,IAAI;QACA,MAAM;UAAEzD,YAAY,GAAG,EAAjB;UAAqBiC,eAAe,GAAG;QAAvC,IAA8Cd,IAAI,CAACC,KAAL,CAChDC,WAAA,CAAGC,YAAH,CAAgBC,aAAA,CAAKC,IAAL,CAAU,KAAKlB,GAAL,CAAS4B,KAAT,CAAelB,SAAf,CAAyBmB,IAAnC,EAAyC,cAAzC,CAAhB,EAA0E,OAA1E,CADgD,CAApD;;QAGA,IAAI,EAAEqB,IAAI,IAAIxD,YAAV,KAA2B,EAAEwD,IAAI,IAAIvB,eAAV,CAA/B,EAA2D;UACvD,MAAM,KAAKjB,SAAL,CAAe0C,MAAf,CAAsB,CAAC,GAAD,EAAM,IAAN,EAAY,IAAZ,EAAkB,YAAlB,EAAiC,GAAEF,IAAK,IAAGrD,OAAQ,EAAnD,CAAtB,EAA6E,SAA7E,CAAN;QACH;MACJ,CAPD,CAOE,OAAOuB,CAAP,EAAU;QACR,KAAKxB,GAAL,CAASyB,KAAT,CAAgB,iBAAgBJ,aAAA,CAAKC,IAAL,CAAU,KAAKlB,GAAL,CAAS4B,KAAT,CAAelB,SAAf,CAAyBmB,IAAnC,EAAyC,cAAzC,CAAyD,EAAzF,EAA4FT,CAA5F;QACAE,OAAO,CAACC,IAAR,CAAa,CAAb;MACH;IACJ;;IAED,MAAM8B,cAAc,GAAGpC,aAAA,CAAKC,IAAL,CAAU,KAAKlB,GAAL,CAAS4B,KAAT,CAAelB,SAAf,CAAyBmB,IAAnC,EAAyC,cAAzC,EAAyDqB,IAAzD,CAAvB;;IACA,IAAII,UAAU,GAAG,IAAjB;;IACA,IAAI;MACAA,UAAU,GAAGC,OAAO,CAACF,cAAD,CAApB;IACH,CAFD,CAEE,OAAOjC,CAAP,EAAU;MACR,IAAI+B,gBAAJ,EAAsB;QAClB,KAAKvD,GAAL,CAAS4D,IAAT,CAAe,kBAAiBN,IAAK,6CAA4CA,IAAK,IAAGrD,OAAQ,EAAjG;;QACA,IAAI;UACA,MAAM,KAAKa,SAAL,CAAe0C,MAAf,CAAsB,CAAC,GAAD,EAAM,IAAN,EAAY,IAAZ,EAAkB,YAAlB,EAAiC,GAAEF,IAAK,IAAGrD,OAAQ,EAAnD,CAAtB,EAA6E,SAA7E,CAAN;QACH,CAFD,CAEE,OAAO4D,GAAP,EAAY;UACV,KAAK7D,GAAL,CAASyB,KAAT,CAAeoC,GAAf;UACAnC,OAAO,CAACC,IAAR,CAAa,CAAb;QACH;MACJ,CARD,MAQO;QACH,KAAK3B,GAAL,CAAS4D,IAAT,CAAe,kBAAiBN,IAAK,WAArC;QACA5B,OAAO,CAACC,IAAR,CAAa,CAAb;MACH;IACJ,CAfD,SAeU;MACN,IAAI,CAAC+B,UAAL,EAAiB;QACbA,UAAU,GAAGC,OAAO,CAACF,cAAD,CAApB;MACH;IACJ;;IACD,MAAMK,iBAAiB,GAAGH,OAAO,CAACtC,aAAA,CAAKC,IAAL,CAAUmC,cAAV,EAA0B,cAA1B,CAAD,CAAP,CAAmDxD,OAA7E;;IAEA,IAAI6D,iBAAiB,KAAK7D,OAA1B,EAAmC;MAC/B,IAAI6D,iBAAiB,CAACC,KAAlB,CAAwB,GAAxB,EAA6B,CAA7B,MAAoC9D,OAAO,CAAC8D,KAAR,CAAc,GAAd,EAAmB,CAAnB,CAAxC,EAA+D;QAC3D,KAAK/D,GAAL,CAAS4D,IAAT,CAAe,mBAAkBN,IAAK,IAAGQ,iBAAkB,oCAA7C,GACT,GAAE7D,OAAQ,oFADD,GAEV,6BAFJ;MAGH,CAJD,MAIO;QACH,KAAKD,GAAL,CAAS4D,IAAT,CAAe,mBAAkBN,IAAK,IAAGQ,iBAAkB,oCAA7C,GACT,GAAE7D,OAAQ,iDADf;MAEH;IACJ;;IACD,OAAO;MAAEyD,UAAF;MAAcrC,IAAI,EAAEoC;IAApB,CAAP;EACH;;AA1Ke;;AA6KL,SAASO,QAAT,CAAiBrE,KAAjB,EAAwBC,MAAxB,EAAgCC,OAAhC,EAAyC;EAAEG,GAAG,GAAGiE;AAAR,IAAmB;EAAEjE,GAAG,EAAEiE;AAAP,CAA5D,EAA6E;EACxF,OAAO,IAAIxE,aAAJ,CAAkBE,KAAlB,EAAyBC,MAAzB,EAAiCC,OAAjC,EAA0C;IAAEG;EAAF,CAA1C,CAAP;AACH"} \ No newline at end of file diff --git a/dist/log.js b/dist/log.js new file mode 100644 index 00000000..5677ea1e --- /dev/null +++ b/dist/log.js @@ -0,0 +1,75 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +/* eslint-disable no-console */ + +/* + 0.OFF + 1.INFO + 2.WARN + 3.ERROR + 4.TRACE + 5.DEBUG + 6.ALL + */ +class Log { + constructor(prefix) { + this.prefix = prefix; + } + + static level() { + return process.env.MD_LOG_LEVEL || 'ALL'; + } + + static slice(args) { + return Array.prototype.slice.call(args, 0); + } + + log(type, args) { + console.log.apply(null, [`${type} ${this.prefix}: `].concat(Log.slice(args))); + } + + info(...args) { + if (/INFO|ALL/i.test(Log.level())) { + this.log('INFO', args); + } + } + + warn(...args) { + if (/WARN|ALL/i.test(Log.level())) { + this.log('WARN', args); + } + } + + error(...args) { + if (/ERROR|ALL/i.test(Log.level())) { + this.log('ERROR', args); + } + } + + debug(...args) { + if (/DEBUG|ALL/i.test(Log.level())) { + this.log('DEBUG', args); + } + } + + verbose(...args) { + if (/VERBOSE|ALL/i.test(Log.level())) { + this.log('VERBOSE', args); + } + } + + trace(...args) { + if (/TRACE|ALL/i.test(Log.level())) { + this.log('TRACE', args); + } + } + +} + +exports.default = Log; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/meteorApp.js b/dist/meteorApp.js new file mode 100644 index 00000000..e4508bfe --- /dev/null +++ b/dist/meteorApp.js @@ -0,0 +1,923 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _fs = _interopRequireDefault(require("fs")); + +var _crossSpawn = _interopRequireDefault(require("cross-spawn")); + +var _semver = _interopRequireDefault(require("semver")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _path = _interopRequireDefault(require("path")); + +var _singleLineLog = _interopRequireDefault(require("single-line-log")); + +var _asar = _interopRequireDefault(require("@electron/asar")); + +var _nodeFetch = _interopRequireDefault(require("node-fetch")); + +var _isDesktopInjector = _interopRequireDefault(require("../skeleton/modules/autoupdate/isDesktopInjector")); + +var _log = _interopRequireDefault(require("./log")); + +var _meteorManager = _interopRequireDefault(require("./meteorManager")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars +const { + join +} = _path.default; +const sll = _singleLineLog.default.stdout; // TODO: refactor all strategy ifs to one place + +/** + * Represents the Meteor app. + * @property {MeteorDesktop} $ + * @class + */ + +class MeteorApp { + /** + * @param {MeteorDesktop} $ - context + * @constructor + */ + constructor($) { + this.log = new _log.default('meteorApp'); + this.$ = $; + this.meteorManager = new _meteorManager.default($); + this.mobilePlatform = null; + this.oldManifest = null; + this.injector = new _isDesktopInjector.default(); + this.matcher = new RegExp('__meteor_runtime_config__ = JSON.parse\\(decodeURIComponent\\("([^"]*)"\\)\\)'); + this.replacer = new RegExp('(__meteor_runtime_config__ = JSON.parse\\(decodeURIComponent\\()"([^"]*)"(\\)\\))'); + this.meteorVersion = null; + this.indexHTMLstrategy = null; + this.indexHTMLStrategies = { + INDEX_FROM_CORDOVA_BUILD: 1, + INDEX_FROM_RUNNING_SERVER: 2 + }; + this.deprectatedPackages = ['omega:meteor-desktop-localstorage']; + } + /** + * Remove any deprecated packages from meteor project. + * @returns {Promise} + */ + + + async removeDeprecatedPackages() { + try { + if (this.meteorManager.checkPackages(this.deprectatedPackages)) { + this.log.info('deprecated meteor plugins found, removing them'); + await this.meteorManager.deletePackages(this.deprectatedPackages); + } + } catch (e) { + throw new Error(e); + } + } + /** + * Ensures that required packages are added to the Meteor app. + */ + + + async ensureDesktopHCPPackages() { + const desktopHCPPackages = ['communitypackages:meteor-desktop-watcher', 'communitypackages:meteor-desktop-bundler']; + + if (this.$.desktop.getSettings().desktopHCP) { + this.log.verbose('desktopHCP is enabled, checking for required packages'); + const packagesWithVersion = desktopHCPPackages.map(packageName => `${packageName}@${this.$.getVersion()}`); + + try { + await this.meteorManager.ensurePackages(desktopHCPPackages, packagesWithVersion, 'desktopHCP'); + } catch (e) { + throw new Error(e); + } + } else { + this.log.verbose('desktopHCP is not enabled, removing required packages'); + + try { + if (this.meteorManager.checkPackages(desktopHCPPackages)) { + await this.meteorManager.deletePackages(desktopHCPPackages); + } + } catch (e) { + throw new Error(e); + } + } + } + /** + * Adds entry to .meteor/.gitignore if necessary. + */ + + + updateGitIgnore() { + this.log.verbose('updating .meteor/.gitignore'); // Lets read the .meteor/.gitignore and filter out blank lines. + + const gitIgnore = _fs.default.readFileSync(this.$.env.paths.meteorApp.gitIgnore, 'UTF-8').split('\n').filter(ignoredPath => ignoredPath.trim() !== ''); + + if (!~gitIgnore.indexOf(this.$.env.paths.electronApp.rootName)) { + this.log.verbose(`adding ${this.$.env.paths.electronApp.rootName} to .meteor/.gitignore`); + gitIgnore.push(this.$.env.paths.electronApp.rootName); + + _fs.default.writeFileSync(this.$.env.paths.meteorApp.gitIgnore, gitIgnore.join('\n'), 'UTF-8'); + } + } + /** + * Reads the Meteor release version used in the app. + * @returns {string} + */ + + + getMeteorRelease() { + let release = _fs.default.readFileSync(this.$.env.paths.meteorApp.release, 'UTF-8').replace(/\r/gm, '').split('\n')[0]; + + [, release] = release.split('@'); // We do not care if it is beta. + + if (~release.indexOf('-')) { + [release] = release.split('-'); + } + + return release; + } + /** + * Cast Meteor release to semver version. + * @returns {string} + */ + + + castMeteorReleaseToSemver() { + return `${this.getMeteorRelease()}.0.0`.match(/(^\d+\.\d+\.\d+)/gmi)[0]; + } + /** + * Validate meteor version against a versionRange. + * @param {string} versionRange - semver version range + */ + + + checkMeteorVersion(versionRange) { + const release = this.castMeteorReleaseToSemver(); + + if (!_semver.default.satisfies(release, versionRange)) { + if (this.$.env.options.skipMobileBuild) { + this.log.error(`wrong meteor version (${release}) in project - only ` + `${versionRange} is supported`); + } else { + this.log.error(`wrong meteor version (${release}) in project - only ` + `${versionRange} is supported for automatic meteor builds (you can always ` + 'try with `--skip-mobile-build` if you are using meteor >= 1.2.1'); + } + + process.exit(1); + } + } + /** + * Decides which strategy to use while trying to get client build out of Meteor project. + * @returns {number} + */ + + + chooseStrategy() { + if (this.$.env.options.forceCordovaBuild) { + return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD; + } + + const release = this.castMeteorReleaseToSemver(); + + if (_semver.default.satisfies(release, '> 1.3.4')) { + return this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER; + } + + if (_semver.default.satisfies(release, '1.3.4')) { + const explodedVersion = this.getMeteorRelease().split('.'); + + if (explodedVersion.length >= 4) { + if (explodedVersion[3] > 1) { + return this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER; + } + + return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD; + } + } + + return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD; + } + /** + * Checks required preconditions. + * - Meteor version + * - is mobile platform added + */ + + + async checkPreconditions() { + if (this.$.env.options.skipMobileBuild) { + this.checkMeteorVersion('>= 1.2.1'); + } else { + this.checkMeteorVersion('>= 1.3.3'); + this.indexHTMLstrategy = this.chooseStrategy(); + + if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) { + this.log.debug('meteor version is < 1.3.4.2 so the index.html from cordova-build will' + ' be used'); + } else { + this.log.debug('meteor version is >= 1.3.4.2 so the index.html will be downloaded ' + 'from __cordova/index.html'); + } + } + + if (!this.$.env.options.skipMobileBuild) { + const platforms = _fs.default.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8'); + + if (!~platforms.indexOf('android') && !~platforms.indexOf('ios')) { + if (!this.$.env.options.android) { + this.mobilePlatform = 'ios'; + } else { + this.mobilePlatform = 'android'; + } + + this.log.warn(`no mobile target detected - will add '${this.mobilePlatform}' ` + 'just to get a mobile build'); + + try { + await this.addMobilePlatform(this.mobilePlatform); + } catch (e) { + this.log.error('failed to add a mobile platform - please try to do it manually'); + process.exit(1); + } + } + } + } + /** + * Tries to add a mobile platform to meteor project. + * @param {string} platform - platform to add + * @returns {Promise} + */ + + + addMobilePlatform(platform) { + return new Promise((resolve, reject) => { + this.log.verbose(`adding mobile platform: ${platform}`); + (0, _crossSpawn.default)('meteor', ['add-platform', platform], { + cwd: this.$.env.paths.meteorApp.root, + stdio: this.$.env.stdio + }).on('exit', () => { + const platforms = _fs.default.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8'); + + if (!~platforms.indexOf('android') && !~platforms.indexOf('ios')) { + reject(); + } else { + resolve(); + } + }); + }); + } + /** + * Tries to remove a mobile platform from meteor project. + * @param {string} platform - platform to remove + * @returns {Promise} + */ + + + removeMobilePlatform(platform) { + if (this.$.env.options.skipRemoveMobilePlatform) { + return Promise.resolve(); + } + + return new Promise((resolve, reject) => { + this.log.verbose(`removing mobile platform: ${platform}`); + (0, _crossSpawn.default)('meteor', ['remove-platform', platform], { + cwd: this.$.env.paths.meteorApp.root, + stdio: this.$.env.stdio, + env: Object.assign({ + METEOR_PRETTY_OUTPUT: 0 + }, process.env) + }).on('exit', () => { + const platforms = _fs.default.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8'); + + if (~platforms.indexOf(platform)) { + reject(); + } else { + resolve(); + } + }); + }); + } + /** + * Just checks for index.html and program.json existence. + * @returns {boolean} + */ + + + isCordovaBuildReady() { + if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) { + return this.$.utils.exists(this.$.env.paths.meteorApp.cordovaBuildIndex) && this.$.utils.exists(this.$.env.paths.meteorApp.cordovaBuildProgramJson) && (!this.oldManifest || this.oldManifest && this.oldManifest !== _fs.default.readFileSync(this.$.env.paths.meteorApp.cordovaBuildProgramJson, 'UTF-8')); + } + + return this.$.utils.exists(this.$.env.paths.meteorApp.webCordovaProgramJson) && (!this.oldManifest || this.oldManifest && this.oldManifest !== _fs.default.readFileSync(this.$.env.paths.meteorApp.webCordovaProgramJson, 'UTF-8')); + } + /** + * Fetches index.html from running project. + * @returns {Promise.<*>} + */ + + + async acquireIndex() { + const port = this.$.env.options.port ? this.$.env.options.port : 3080; + this.log.info('acquiring index.html'); + const res = await (0, _nodeFetch.default)(`http://127.0.0.1:${port}/__cordova/index.html`); + const text = await res.text(); // Simple test if we really download index.html for web.cordova. + + if (~text.indexOf('src="/cordova.js"')) { + return text; + } + + return false; + } + /** + * Fetches mainfest.json from running project. + * @returns {Promise.} + */ + + + async acquireManifest() { + const port = this.$.env.options.port ? this.$.env.options.port : 3080; + this.log.info('acquiring manifest.json'); + const res = await (0, _nodeFetch.default)(`http://127.0.0.1:${port}/__cordova/manifest.json?meteor_dont_serve_index=true`); + const text = await res.text(); + return JSON.parse(text); + } + /** + * Tries to get a mobile build from meteor app. + * In case of failure leaves a meteor.log. + * A lot of stuff is happening here - but the main aim is to get a mobile build from + * .meteor/local/cordova-build/www/application and exit as soon as possible. + * + * @returns {Promise} + */ + + + buildMobileTarget() { + const programJson = this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD ? this.$.env.paths.meteorApp.cordovaBuildProgramJson : this.$.env.paths.meteorApp.webCordovaProgramJson; + + if (this.$.utils.exists(programJson)) { + this.oldManifest = _fs.default.readFileSync(programJson, 'UTF-8'); + } + + return new Promise((resolve, reject) => { + const self = this; + let log = ''; + let desiredExit = false; + let buildTimeout = null; + let errorTimeout = null; + let messageTimeout = null; + let killTimeout = null; + let cordovaCheckInterval = null; + let portProblem = false; + + function windowsKill(pid) { + self.log.debug(`killing pid: ${pid}`); + + _crossSpawn.default.sync('taskkill', ['/pid', pid, '/f', '/t']); // We will look for other process which might have been created outside the + // process tree. + // Lets list all node.exe processes. + + + const out = _crossSpawn.default.sync('wmic', ['process', 'where', 'caption="node.exe"', 'get', 'commandline,processid']).stdout.toString('utf-8').split('\n'); + + const args = self.prepareArguments(); // Lets mount regex. + + const regexV1 = new RegExp(`${args.join('\\s+')}\\s+(\\d+)`, 'gm'); + const regexV2 = new RegExp(`"${args.join('"\\s+"')}"\\s+(\\d+)`, 'gm'); // No we will check for those with the matching params. + + out.forEach(line => { + const match = regexV1.exec(line) || regexV2.exec(line) || false; + + if (match) { + self.log.debug(`killing pid: ${match[1]}`); + + _crossSpawn.default.sync('taskkill', ['/pid', match[1], '/f', '/t']); + } + + regexV1.lastIndex = 0; + regexV2.lastIndex = 0; + }); + } + + function writeLog() { + _fs.default.writeFileSync('meteor.log', log, 'UTF-8'); + } + + function clearTimeoutsAndIntervals() { + clearInterval(cordovaCheckInterval); + clearTimeout(buildTimeout); + clearTimeout(errorTimeout); + clearTimeout(messageTimeout); + clearTimeout(killTimeout); + } + + const args = this.prepareArguments(); + this.log.info(`running "meteor ${args.join(' ')}"... this might take a while`); + const env = { + METEOR_PRETTY_OUTPUT: 0, + METEOR_NO_RELEASE_CHECK: 1 + }; + + if (this.$.env.options.prodDebug) { + env.METEOR_DESKOP_PROD_DEBUG = true; + } // Lets spawn meteor. + + + const child = (0, _crossSpawn.default)('meteor', args, { + env: Object.assign(env, process.env), + cwd: this.$.env.paths.meteorApp.root + }, { + shell: true + }); // Kills the currently running meteor command. + + function kill() { + sll(''); + child.kill('SIGKILL'); + + if (self.$.env.os.isWindows) { + windowsKill(child.pid); + } + } + + function exit() { + killTimeout = setTimeout(() => { + clearTimeoutsAndIntervals(); + desiredExit = true; + kill(); + resolve(); + }, 500); + } + + function copyBuild() { + self.copyBuild().then(() => { + exit(); + }).catch(() => { + clearTimeoutsAndIntervals(); + kill(); + writeLog(); + reject('copy'); + }); + } + + cordovaCheckInterval = setInterval(() => { + // Check if we already have cordova-build ready. + if (this.isCordovaBuildReady()) { + // If so, then exit immediately. + if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) { + copyBuild(); + } + } + }, 1000); + child.stderr.on('data', chunk => { + const line = chunk.toString('UTF-8'); + log += `${line}\n`; + + if (errorTimeout) { + clearTimeout(errorTimeout); + } // Do not exit if this is the warning for using --production. + // Output exceeds -> https://github.com/meteor/meteor/issues/8592 + + + if (!~line.indexOf('--production') && !~line.indexOf('Output exceeds ') && !~line.indexOf('Node#moveTo') && !~line.indexOf('Browserslist') && Array.isArray(self.$.env.options.ignoreStderr) && self.$.env.options.ignoreStderr.every(str => !~line.indexOf(str))) { + self.log.warn('STDERR:', line); // We will exit 1s after last error in stderr. + + errorTimeout = setTimeout(() => { + clearTimeoutsAndIntervals(); + kill(); + writeLog(); + reject('error'); + }, 1000); + } + }); + child.stdout.on('data', chunk => { + const line = chunk.toString('UTF-8'); + + if (!desiredExit && line.trim().replace(/[\n\r\t\v\f]+/gm, '') !== '') { + const linesToDisplay = line.trim().split('\n\r'); // Only display last line from the chunk. + + const sanitizedLine = linesToDisplay.pop().replace(/[\n\r\t\v\f]+/gm, ''); + sll(sanitizedLine); + } + + log += `${line}\n`; + + if (~line.indexOf('after_platform_add')) { + sll(''); + this.log.info('done... 10%'); + } + + if (~line.indexOf('Local package version')) { + if (messageTimeout) { + clearTimeout(messageTimeout); + } + + messageTimeout = setTimeout(() => { + sll(''); + this.log.info('building in progress...'); + }, 1500); + } + + if (~line.indexOf('Preparing Cordova project')) { + sll(''); + this.log.info('done... 60%'); + } + + if (~line.indexOf('Can\'t listen on port')) { + portProblem = true; + } + + if (~line.indexOf('Your application has errors')) { + if (errorTimeout) { + clearTimeout(errorTimeout); + } + + errorTimeout = setTimeout(() => { + clearTimeoutsAndIntervals(); + kill(); + writeLog(); + reject('errorInApp'); + }, 1000); + } + + if (~line.indexOf('App running at')) { + copyBuild(); + } + }); // When Meteor exits + + child.on('exit', () => { + sll(''); + clearTimeoutsAndIntervals(); + + if (!desiredExit) { + writeLog(); + + if (portProblem) { + reject('port'); + } else { + reject('exit'); + } + } + }); + buildTimeout = setTimeout(() => { + kill(); + writeLog(); + reject('timeout'); + }, this.$.env.options.buildTimeout ? this.$.env.options.buildTimeout * 1000 : 600000); + }); + } + /** + * Replaces the DDP url that was used originally when Meteor was building the client. + * @param {string} indexHtml - path to index.html from the client + */ + + + updateDdpUrl(indexHtml) { + let content; + let runtimeConfig; + + try { + content = _fs.default.readFileSync(indexHtml, 'UTF-8'); + } catch (e) { + this.log.error(`error loading index.html file: ${e.message}`); + process.exit(1); + } + + if (!this.matcher.test(content)) { + this.log.error('could not find runtime config in index file'); + process.exit(1); + } + + try { + const matches = content.match(this.matcher); + runtimeConfig = JSON.parse(decodeURIComponent(matches[1])); + } catch (e) { + this.log.error('could not find runtime config in index file'); + process.exit(1); + } + + if (this.$.env.options.ddpUrl.substr(-1, 1) !== '/') { + this.$.env.options.ddpUrl += '/'; + } + + runtimeConfig.ROOT_URL = this.$.env.options.ddpUrl; + runtimeConfig.DDP_DEFAULT_CONNECTION_URL = this.$.env.options.ddpUrl; + content = content.replace(this.replacer, `$1"${encodeURIComponent(JSON.stringify(runtimeConfig))}"$3`); + + try { + _fs.default.writeFileSync(indexHtml, content); + } catch (e) { + this.log.error(`error writing index.html file: ${e.message}`); + process.exit(1); + } + + this.log.info('successfully updated ddp string in the runtime config of a mobile build' + ` to ${this.$.env.options.ddpUrl}`); + } + /** + * Prepares the arguments passed to `meteor` command. + * @returns {string[]} + */ + + + prepareArguments() { + const args = ['run', '--verbose', `--mobile-server=${this.$.env.options.ddpUrl}`]; + + if (this.$.env.isProductionBuild()) { + args.push('--production'); + } + + args.push('-p'); + + if (this.$.env.options.port) { + args.push(this.$.env.options.port); + } else { + args.push('3080'); + } + + if (this.$.env.options.meteorSettings) { + args.push('--settings', this.$.env.options.meteorSettings); + } + + return args; + } + /** + * Validates the mobile build and copies it into electron app. + */ + + + async copyBuild() { + this.log.debug('clearing build dir'); + + try { + await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.meteorApp); + } catch (e) { + throw new Error(e); + } + + let prefix = 'cordovaBuild'; + let copyPathPostfix = ''; + + if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) { + prefix = 'webCordova'; + copyPathPostfix = `${_path.default.sep}*`; + let indexHtml; + + try { + _fs.default.mkdirSync(this.$.env.paths.electronApp.meteorApp); + + indexHtml = await this.acquireIndex(); + + _fs.default.writeFileSync(this.$.env.paths.electronApp.meteorAppIndex, indexHtml); + + this.log.info('successfully downloaded index.html from running meteor app'); + } catch (e) { + this.log.error('error while trying to download index.html for web.cordova, ' + 'be sure that you are running a mobile target or with' + ' --mobile-server: ', e); + throw e; + } + } + + const cordovaBuild = this.$.env.paths.meteorApp[prefix]; + const { + cordovaBuildIndex + } = this.$.env.paths.meteorApp; + const cordovaBuildProgramJson = this.$.env.paths.meteorApp[`${prefix}ProgramJson`]; + + if (!this.$.utils.exists(cordovaBuild)) { + this.log.error(`no mobile build found at ${cordovaBuild}`); + this.log.error('are you sure you did run meteor with --mobile-server?'); + throw new Error('required file not present'); + } + + if (!this.$.utils.exists(cordovaBuildProgramJson)) { + this.log.error('no program.json found in mobile build found at ' + `${cordovaBuild}`); + this.log.error('are you sure you did run meteor with --mobile-server?'); + throw new Error('required file not present'); + } + + if (this.indexHTMLstrategy !== this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) { + if (!this.$.utils.exists(cordovaBuildIndex)) { + this.log.error('no index.html found in cordova build found at ' + `${cordovaBuild}`); + this.log.error('are you sure you did run meteor with --mobile-server?'); + throw new Error('required file not present'); + } + } + + this.log.verbose('copying mobile build'); + + _shelljs.default.cp('-R', `${cordovaBuild}${copyPathPostfix}`, this.$.env.paths.electronApp.meteorApp); // Because of various permission problems here we try to clear te path by clearing + // all possible restrictions. + + + _shelljs.default.chmod('-R', '777', this.$.env.paths.electronApp.meteorApp); + + if (this.$.env.os.isWindows) { + _shelljs.default.exec(`attrib -r ${this.$.env.paths.electronApp.meteorApp}${_path.default.sep}*.* /s`); + } + + if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) { + let programJson; + + try { + programJson = await this.acquireManifest(); + + _fs.default.writeFileSync(this.$.env.paths.electronApp.meteorAppProgramJson, JSON.stringify(programJson, null, 4)); + + this.log.info('successfully downloaded manifest.json from running meteor app'); + } catch (e) { + this.log.error('error while trying to download manifest.json for web.cordova,' + ' be sure that you are running a mobile target or with' + ' --mobile-server: ', e); + throw e; + } + } + + this.log.info('mobile build copied to electron app'); + this.log.debug('copy cordova.js to meteor build'); + + _shelljs.default.cp(join(__dirname, '..', 'skeleton', 'cordova.js'), this.$.env.paths.electronApp.meteorApp); + } + /** + * Injects Meteor.isDesktop + */ + + + injectIsDesktop() { + this.log.info('injecting isDesktop'); + let manifestJsonPath = this.$.env.paths.meteorApp.cordovaBuildProgramJson; + + if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) { + manifestJsonPath = this.$.env.paths.meteorApp.webCordovaProgramJson; + } + + try { + const { + manifest + } = JSON.parse(_fs.default.readFileSync(manifestJsonPath, 'UTF-8')); + let injected = false; + let injectedStartupDidComplete = false; + let result = null; // We will search in every .js file in the manifest. + // We could probably detect whether this is a dev or production build and only search in + // the correct files, but for now this should be fine. + + manifest.forEach(file => { + let fileContents; // Hacky way of setting isDesktop. + + if (file.type === 'js') { + fileContents = _fs.default.readFileSync(join(this.$.env.paths.electronApp.meteorApp, file.path), 'UTF-8'); + result = this.injector.processFileContents(fileContents); + ({ + fileContents + } = result); + injectedStartupDidComplete = result.injectedStartupDidComplete ? true : injectedStartupDidComplete; + injected = result.injected ? true : injected; + + _fs.default.writeFileSync(join(this.$.env.paths.electronApp.meteorApp, file.path), fileContents); + } + }); + + if (!injected) { + this.log.error('error injecting isDesktop global var.'); + process.exit(1); + } + + if (!injectedStartupDidComplete) { + this.log.error('error injecting isDesktop for startupDidComplete'); + process.exit(1); + } + } catch (e) { + this.log.error('error occurred while injecting isDesktop: ', e); + process.exit(1); + } + + this.log.info('injected successfully'); + } + /** + * Builds, modifies and copies the meteor app to electron app. + */ + + + async build() { + this.log.info('checking for any mobile platform'); + + try { + await this.checkPreconditions(); + } catch (e) { + this.log.error('error occurred during checking preconditions: ', e); + process.exit(1); + } + + this.log.info('building meteor app'); + + if (!this.$.env.options.skipMobileBuild) { + try { + await this.buildMobileTarget(); + } catch (reason) { + switch (reason) { + case 'timeout': + this.log.error('timeout while building, log has been written to meteor.log'); + break; + + case 'error': + this.log.error('build was terminated by meteor-desktop as some errors were reported to stderr, you ' + 'should see it above, also check meteor.log for more info, to ignore it use the ' + '--ignore-stderr ""'); + break; + + case 'errorInApp': + this.log.error('your meteor app has errors - look into meteor.log for more' + ' info'); + break; + + case 'port': + this.log.error('your port 3080 is currently used (you probably have this or other ' + 'meteor project running?), use `-t` or `--meteor-port` to use ' + 'different port while building'); + break; + + case 'exit': + this.log.error('meteor cmd exited unexpectedly, log has been written to meteor.log'); + break; + + case 'copy': + this.log.error('error encountered when copying the build'); + break; + + default: + this.log.error('error occurred during building mobile target', reason); + } + + if (this.mobilePlatform) { + await this.removeMobilePlatform(this.mobilePlatform); + } + + process.exit(1); + } + } else { + this.indexHTMLstrategy = this.chooseStrategy(); + + try { + await this.copyBuild(); + } catch (e) { + process.exit(1); + } + } + + this.injectIsDesktop(); + this.changeDdpUrl(); + + try { + await this.packToAsar(); + } catch (e) { + this.log.error('error while packing meteor app to asar'); + process.exit(1); + } + + this.log.info('meteor build finished'); + + if (this.mobilePlatform) { + await this.removeMobilePlatform(this.mobilePlatform); + } + } + + changeDdpUrl() { + if (this.$.env.options.ddpUrl !== null) { + try { + this.updateDdpUrl(this.$.env.paths.electronApp.meteorAppIndex); + } catch (e) { + this.log.error(`error while trying to change the ddp url: ${e.message}`); + } + } + } + + packToAsar() { + this.log.info('packing meteor app to asar archive'); + return new Promise((resolve, reject) => _asar.default.createPackage(this.$.env.paths.electronApp.meteorApp, _path.default.join(this.$.env.paths.electronApp.root, 'meteor.asar')).then(() => { + // On Windows some files might still be blocked. Giving a tick for them to be + // ready for deletion. + setImmediate(() => { + this.log.verbose('clearing meteor app after packing'); + this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.meteorApp).then(() => { + resolve(); + }).catch(e => { + reject(e); + }); + }); + })); + } + /** + * Wrapper for spawning npm. + * @param {Array} commands - commands for spawn + * @param {string} stdio + * @param {string} cwd + * @return {Promise} + */ + + + runNpm(commands, stdio = 'ignore', cwd = this.$.env.paths.meteorApp.root) { + return new Promise((resolve, reject) => { + this.log.verbose(`executing meteor npm ${commands.join(' ')}`); + (0, _crossSpawn.default)('meteor', ['npm', ...commands], { + cwd, + stdio + }).on('exit', code => code === 0 ? resolve() : reject(new Error(`npm exit code was ${code}`))); + }); + } + +} + +exports.default = MeteorApp; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","sll","singleLineLog","stdout","MeteorApp","constructor","$","log","Log","meteorManager","MeteorManager","mobilePlatform","oldManifest","injector","IsDesktopInjector","matcher","RegExp","replacer","meteorVersion","indexHTMLstrategy","indexHTMLStrategies","INDEX_FROM_CORDOVA_BUILD","INDEX_FROM_RUNNING_SERVER","deprectatedPackages","removeDeprecatedPackages","checkPackages","info","deletePackages","e","Error","ensureDesktopHCPPackages","desktopHCPPackages","desktop","getSettings","desktopHCP","verbose","packagesWithVersion","map","packageName","getVersion","ensurePackages","updateGitIgnore","gitIgnore","fs","readFileSync","env","paths","meteorApp","split","filter","ignoredPath","trim","indexOf","electronApp","rootName","push","writeFileSync","getMeteorRelease","release","replace","castMeteorReleaseToSemver","match","checkMeteorVersion","versionRange","semver","satisfies","options","skipMobileBuild","error","process","exit","chooseStrategy","forceCordovaBuild","explodedVersion","length","checkPreconditions","debug","platforms","android","warn","addMobilePlatform","platform","Promise","resolve","reject","spawn","cwd","root","stdio","on","removeMobilePlatform","skipRemoveMobilePlatform","Object","assign","METEOR_PRETTY_OUTPUT","isCordovaBuildReady","utils","exists","cordovaBuildIndex","cordovaBuildProgramJson","webCordovaProgramJson","acquireIndex","port","res","fetch","text","acquireManifest","JSON","parse","buildMobileTarget","programJson","self","desiredExit","buildTimeout","errorTimeout","messageTimeout","killTimeout","cordovaCheckInterval","portProblem","windowsKill","pid","sync","out","toString","args","prepareArguments","regexV1","regexV2","forEach","line","exec","lastIndex","writeLog","clearTimeoutsAndIntervals","clearInterval","clearTimeout","METEOR_NO_RELEASE_CHECK","prodDebug","METEOR_DESKOP_PROD_DEBUG","child","shell","kill","os","isWindows","setTimeout","copyBuild","then","catch","setInterval","stderr","chunk","Array","isArray","ignoreStderr","every","str","linesToDisplay","sanitizedLine","pop","updateDdpUrl","indexHtml","content","runtimeConfig","message","test","matches","decodeURIComponent","ddpUrl","substr","ROOT_URL","DDP_DEFAULT_CONNECTION_URL","encodeURIComponent","stringify","isProductionBuild","meteorSettings","rmWithRetries","prefix","copyPathPostfix","sep","mkdirSync","meteorAppIndex","cordovaBuild","cp","chmod","meteorAppProgramJson","__dirname","injectIsDesktop","manifestJsonPath","manifest","injected","injectedStartupDidComplete","result","file","fileContents","type","processFileContents","build","reason","changeDdpUrl","packToAsar","asar","createPackage","setImmediate","runNpm","commands","code"],"sources":["../lib/meteorApp.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport fs from 'fs';\nimport spawn from 'cross-spawn';\nimport semver from 'semver';\nimport shell from 'shelljs';\nimport path from 'path';\nimport singleLineLog from 'single-line-log';\nimport asar from '@electron/asar';\nimport fetch from 'node-fetch';\n\nimport IsDesktopInjector from '../skeleton/modules/autoupdate/isDesktopInjector';\nimport Log from './log';\nimport MeteorManager from './meteorManager';\n\nconst { join } = path;\nconst sll = singleLineLog.stdout;\n\n// TODO: refactor all strategy ifs to one place\n\n/**\n * Represents the Meteor app.\n * @property {MeteorDesktop} $\n * @class\n */\nexport default class MeteorApp {\n    /**\n     * @param {MeteorDesktop} $ - context\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('meteorApp');\n        this.$ = $;\n        this.meteorManager = new MeteorManager($);\n        this.mobilePlatform = null;\n        this.oldManifest = null;\n        this.injector = new IsDesktopInjector();\n        this.matcher = new RegExp(\n            '__meteor_runtime_config__ = JSON.parse\\\\(decodeURIComponent\\\\(\"([^\"]*)\"\\\\)\\\\)'\n        );\n        this.replacer = new RegExp(\n            '(__meteor_runtime_config__ = JSON.parse\\\\(decodeURIComponent\\\\()\"([^\"]*)\"(\\\\)\\\\))'\n        );\n        this.meteorVersion = null;\n        this.indexHTMLstrategy = null;\n\n        this.indexHTMLStrategies = {\n            INDEX_FROM_CORDOVA_BUILD: 1,\n            INDEX_FROM_RUNNING_SERVER: 2\n        };\n\n        this.deprectatedPackages = ['omega:meteor-desktop-localstorage'];\n    }\n\n    /**\n     * Remove any deprecated packages from meteor project.\n     * @returns {Promise<void>}\n     */\n    async removeDeprecatedPackages() {\n        try {\n            if (this.meteorManager.checkPackages(this.deprectatedPackages)) {\n                this.log.info('deprecated meteor plugins found, removing them');\n                await this.meteorManager.deletePackages(this.deprectatedPackages);\n            }\n        } catch (e) {\n            throw new Error(e);\n        }\n    }\n\n    /**\n     * Ensures that required packages are added to the Meteor app.\n     */\n    async ensureDesktopHCPPackages() {\n        const desktopHCPPackages = ['communitypackages:meteor-desktop-watcher', 'communitypackages:meteor-desktop-bundler'];\n        if (this.$.desktop.getSettings().desktopHCP) {\n            this.log.verbose('desktopHCP is enabled, checking for required packages');\n\n            const packagesWithVersion = desktopHCPPackages.map(packageName => `${packageName}@${this.$.getVersion()}`);\n\n            try {\n                await this.meteorManager.ensurePackages(desktopHCPPackages, packagesWithVersion, 'desktopHCP');\n            } catch (e) {\n                throw new Error(e);\n            }\n        } else {\n            this.log.verbose('desktopHCP is not enabled, removing required packages');\n\n            try {\n                if (this.meteorManager.checkPackages(desktopHCPPackages)) {\n                    await this.meteorManager.deletePackages(desktopHCPPackages);\n                }\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n    }\n\n    /**\n     * Adds entry to .meteor/.gitignore if necessary.\n     */\n    updateGitIgnore() {\n        this.log.verbose('updating .meteor/.gitignore');\n        // Lets read the .meteor/.gitignore and filter out blank lines.\n        const gitIgnore = fs.readFileSync(this.$.env.paths.meteorApp.gitIgnore, 'UTF-8')\n            .split('\\n').filter(ignoredPath => ignoredPath.trim() !== '');\n\n        if (!~gitIgnore.indexOf(this.$.env.paths.electronApp.rootName)) {\n            this.log.verbose(`adding ${this.$.env.paths.electronApp.rootName} to .meteor/.gitignore`);\n            gitIgnore.push(this.$.env.paths.electronApp.rootName);\n\n            fs.writeFileSync(this.$.env.paths.meteorApp.gitIgnore, gitIgnore.join('\\n'), 'UTF-8');\n        }\n    }\n\n    /**\n     * Reads the Meteor release version used in the app.\n     * @returns {string}\n     */\n    getMeteorRelease() {\n        let release = fs.readFileSync(this.$.env.paths.meteorApp.release, 'UTF-8')\n            .replace(/\\r/gm, '')\n            .split('\\n')[0];\n        ([, release] = release.split('@'));\n        // We do not care if it is beta.\n        if (~release.indexOf('-')) {\n            ([release] = release.split('-'));\n        }\n        return release;\n    }\n\n    /**\n     * Cast Meteor release to semver version.\n     * @returns {string}\n     */\n    castMeteorReleaseToSemver() {\n        return `${this.getMeteorRelease()}.0.0`.match(/(^\\d+\\.\\d+\\.\\d+)/gmi)[0];\n    }\n\n    /**\n     * Validate meteor version against a versionRange.\n     * @param {string} versionRange - semver version range\n     */\n    checkMeteorVersion(versionRange) {\n        const release = this.castMeteorReleaseToSemver();\n        if (!semver.satisfies(release, versionRange)) {\n            if (this.$.env.options.skipMobileBuild) {\n                this.log.error(`wrong meteor version (${release}) in project - only ` +\n                    `${versionRange} is supported`);\n            } else {\n                this.log.error(`wrong meteor version (${release}) in project - only ` +\n                    `${versionRange} is supported for automatic meteor builds (you can always ` +\n                    'try with `--skip-mobile-build` if you are using meteor >= 1.2.1');\n            }\n            process.exit(1);\n        }\n    }\n\n    /**\n     * Decides which strategy to use while trying to get client build out of Meteor project.\n     * @returns {number}\n     */\n    chooseStrategy() {\n        if (this.$.env.options.forceCordovaBuild) {\n            return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD;\n        }\n\n        const release = this.castMeteorReleaseToSemver();\n        if (semver.satisfies(release, '> 1.3.4')) {\n            return this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER;\n        }\n        if (semver.satisfies(release, '1.3.4')) {\n            const explodedVersion = this.getMeteorRelease().split('.');\n            if (explodedVersion.length >= 4) {\n                if (explodedVersion[3] > 1) {\n                    return this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER;\n                }\n                return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD;\n            }\n        }\n        return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD;\n    }\n\n    /**\n     * Checks required preconditions.\n     * - Meteor version\n     * - is mobile platform added\n     */\n    async checkPreconditions() {\n        if (this.$.env.options.skipMobileBuild) {\n            this.checkMeteorVersion('>= 1.2.1');\n        } else {\n            this.checkMeteorVersion('>= 1.3.3');\n            this.indexHTMLstrategy = this.chooseStrategy();\n            if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) {\n                this.log.debug(\n                    'meteor version is < 1.3.4.2 so the index.html from cordova-build will' +\n                    ' be used'\n                );\n            } else {\n                this.log.debug(\n                    'meteor version is >= 1.3.4.2 so the index.html will be downloaded ' +\n                    'from __cordova/index.html'\n                );\n            }\n        }\n\n        if (!this.$.env.options.skipMobileBuild) {\n            const platforms = fs.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8');\n            if (!~platforms.indexOf('android') && !~platforms.indexOf('ios')) {\n                if (!this.$.env.options.android) {\n                    this.mobilePlatform = 'ios';\n                } else {\n                    this.mobilePlatform = 'android';\n                }\n                this.log.warn(`no mobile target detected - will add '${this.mobilePlatform}' ` +\n                    'just to get a mobile build');\n                try {\n                    await this.addMobilePlatform(this.mobilePlatform);\n                } catch (e) {\n                    this.log.error('failed to add a mobile platform - please try to do it manually');\n                    process.exit(1);\n                }\n            }\n        }\n    }\n\n    /**\n     * Tries to add a mobile platform to meteor project.\n     * @param {string} platform - platform to add\n     * @returns {Promise}\n     */\n    addMobilePlatform(platform) {\n        return new Promise((resolve, reject) => {\n            this.log.verbose(`adding mobile platform: ${platform}`);\n            spawn('meteor', ['add-platform', platform], {\n                cwd: this.$.env.paths.meteorApp.root,\n                stdio: this.$.env.stdio\n            }).on('exit', () => {\n                const platforms = fs.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8');\n                if (!~platforms.indexOf('android') && !~platforms.indexOf('ios')) {\n                    reject();\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n\n    /**\n     * Tries to remove a mobile platform from meteor project.\n     * @param {string} platform - platform to remove\n     * @returns {Promise}\n     */\n    removeMobilePlatform(platform) {\n        if (this.$.env.options.skipRemoveMobilePlatform) {\n            return Promise.resolve();\n        }\n        return new Promise((resolve, reject) => {\n            this.log.verbose(`removing mobile platform: ${platform}`);\n            spawn('meteor', ['remove-platform', platform], {\n                cwd: this.$.env.paths.meteorApp.root,\n                stdio: this.$.env.stdio,\n                env: Object.assign({ METEOR_PRETTY_OUTPUT: 0 }, process.env)\n            }).on('exit', () => {\n                const platforms = fs.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8');\n                if (~platforms.indexOf(platform)) {\n                    reject();\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n\n    /**\n     * Just checks for index.html and program.json existence.\n     * @returns {boolean}\n     */\n    isCordovaBuildReady() {\n        if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) {\n            return this.$.utils.exists(this.$.env.paths.meteorApp.cordovaBuildIndex) &&\n                this.$.utils.exists(this.$.env.paths.meteorApp.cordovaBuildProgramJson) &&\n                (\n                    !this.oldManifest ||\n                    (this.oldManifest &&\n                        this.oldManifest !== fs.readFileSync(\n                            this.$.env.paths.meteorApp.cordovaBuildProgramJson, 'UTF-8'\n                        )\n                    )\n                );\n        }\n        return this.$.utils.exists(this.$.env.paths.meteorApp.webCordovaProgramJson) &&\n            (\n                !this.oldManifest ||\n                (this.oldManifest &&\n                    this.oldManifest !== fs.readFileSync(\n                        this.$.env.paths.meteorApp.webCordovaProgramJson, 'UTF-8'\n                    )\n                )\n            );\n    }\n\n    /**\n     * Fetches index.html from running project.\n     * @returns {Promise.<*>}\n     */\n    async acquireIndex() {\n        const port = (this.$.env.options.port) ? this.$.env.options.port : 3080;\n        this.log.info('acquiring index.html');\n        const res = await fetch(`http://127.0.0.1:${port}/__cordova/index.html`);\n        const text = await res.text();\n        // Simple test if we really download index.html for web.cordova.\n        if (~text.indexOf('src=\"/cordova.js\"')) {\n            return text;\n        }\n        return false;\n    }\n\n    /**\n     * Fetches mainfest.json from running project.\n     * @returns {Promise.<void>}\n     */\n    async acquireManifest() {\n        const port = (this.$.env.options.port) ? this.$.env.options.port : 3080;\n        this.log.info('acquiring manifest.json');\n        const res = await fetch(\n            `http://127.0.0.1:${port}/__cordova/manifest.json?meteor_dont_serve_index=true`\n        );\n        const text = await res.text();\n        return JSON.parse(text);\n    }\n\n    /**\n     * Tries to get a mobile build from meteor app.\n     * In case of failure leaves a meteor.log.\n     * A lot of stuff is happening here - but the main aim is to get a mobile build from\n     * .meteor/local/cordova-build/www/application and exit as soon as possible.\n     *\n     * @returns {Promise}\n     */\n    buildMobileTarget() {\n        const programJson =\n            (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) ?\n                this.$.env.paths.meteorApp.cordovaBuildProgramJson :\n                this.$.env.paths.meteorApp.webCordovaProgramJson;\n\n        if (this.$.utils.exists(programJson)) {\n            this.oldManifest = fs.readFileSync(programJson, 'UTF-8');\n        }\n\n        return new Promise((resolve, reject) => {\n            const self = this;\n            let log = '';\n            let desiredExit = false;\n            let buildTimeout = null;\n            let errorTimeout = null;\n            let messageTimeout = null;\n            let killTimeout = null;\n            let cordovaCheckInterval = null;\n            let portProblem = false;\n\n            function windowsKill(pid) {\n                self.log.debug(`killing pid: ${pid}`);\n                spawn.sync('taskkill', ['/pid', pid, '/f', '/t']);\n\n                // We will look for other process which might have been created outside the\n                // process tree.\n                // Lets list all node.exe processes.\n\n                const out = spawn\n                    .sync(\n                        'wmic',\n                        ['process', 'where', 'caption=\"node.exe\"', 'get', 'commandline,processid']\n                    )\n                    .stdout.toString('utf-8')\n                    .split('\\n');\n                const args = self.prepareArguments();\n                // Lets mount regex.\n                const regexV1 = new RegExp(`${args.join('\\\\s+')}\\\\s+(\\\\d+)`, 'gm');\n                const regexV2 = new RegExp(`\"${args.join('\"\\\\s+\"')}\"\\\\s+(\\\\d+)`, 'gm');\n                // No we will check for those with the matching params.\n                out.forEach((line) => {\n                    const match = regexV1.exec(line) || regexV2.exec(line) || false;\n                    if (match) {\n                        self.log.debug(`killing pid: ${match[1]}`);\n                        spawn.sync('taskkill', ['/pid', match[1], '/f', '/t']);\n                    }\n                    regexV1.lastIndex = 0;\n                    regexV2.lastIndex = 0;\n                });\n            }\n\n            function writeLog() {\n                fs.writeFileSync('meteor.log', log, 'UTF-8');\n            }\n\n            function clearTimeoutsAndIntervals() {\n                clearInterval(cordovaCheckInterval);\n                clearTimeout(buildTimeout);\n                clearTimeout(errorTimeout);\n                clearTimeout(messageTimeout);\n                clearTimeout(killTimeout);\n            }\n\n            const args = this.prepareArguments();\n\n            this.log.info(`running \"meteor ${args.join(' ')}\"... this might take a while`);\n\n            const env = { METEOR_PRETTY_OUTPUT: 0, METEOR_NO_RELEASE_CHECK: 1 };\n            if (this.$.env.options.prodDebug) {\n                env.METEOR_DESKOP_PROD_DEBUG = true;\n            }\n\n            // Lets spawn meteor.\n            const child = spawn(\n                'meteor',\n                args,\n                {\n                    env: Object.assign(env, process.env),\n                    cwd: this.$.env.paths.meteorApp.root\n                },\n                { shell: true }\n            );\n\n            // Kills the currently running meteor command.\n            function kill() {\n                sll('');\n                child.kill('SIGKILL');\n                if (self.$.env.os.isWindows) {\n                    windowsKill(child.pid);\n                }\n            }\n\n            function exit() {\n                killTimeout = setTimeout(() => {\n                    clearTimeoutsAndIntervals();\n                    desiredExit = true;\n                    kill();\n                    resolve();\n                }, 500);\n            }\n\n            function copyBuild() {\n                self.copyBuild().then(() => {\n                    exit();\n                }).catch(() => {\n                    clearTimeoutsAndIntervals();\n                    kill();\n                    writeLog();\n                    reject('copy');\n                });\n            }\n\n            cordovaCheckInterval = setInterval(() => {\n                // Check if we already have cordova-build ready.\n                if (this.isCordovaBuildReady()) {\n                    // If so, then exit immediately.\n                    if (this.indexHTMLstrategy ===\n                        this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) {\n                        copyBuild();\n                    }\n                }\n            }, 1000);\n\n            child.stderr.on('data', (chunk) => {\n                const line = chunk.toString('UTF-8');\n                log += `${line}\\n`;\n                if (errorTimeout) {\n                    clearTimeout(errorTimeout);\n                }\n                // Do not exit if this is the warning for using --production.\n                // Output exceeds -> https://github.com/meteor/meteor/issues/8592\n                if (\n                    !~line.indexOf('--production') &&\n                    !~line.indexOf('Output exceeds ') &&\n                    !~line.indexOf('Node#moveTo') &&\n                    !~line.indexOf('Browserslist') &&\n                    (\n                        Array.isArray(self.$.env.options.ignoreStderr) &&\n                        self.$.env.options.ignoreStderr.every(str => !~line.indexOf(str))\n                    )\n                ) {\n                    self.log.warn('STDERR:', line);\n                    // We will exit 1s after last error in stderr.\n                    errorTimeout = setTimeout(() => {\n                        clearTimeoutsAndIntervals();\n                        kill();\n                        writeLog();\n                        reject('error');\n                    }, 1000);\n                }\n            });\n\n            child.stdout.on('data', (chunk) => {\n                const line = chunk.toString('UTF-8');\n                if (!desiredExit && line.trim().replace(/[\\n\\r\\t\\v\\f]+/gm, '') !== '') {\n                    const linesToDisplay = line.trim()\n                        .split('\\n\\r');\n                    // Only display last line from the chunk.\n                    const sanitizedLine = linesToDisplay.pop().replace(/[\\n\\r\\t\\v\\f]+/gm, '');\n                    sll(sanitizedLine);\n                }\n                log += `${line}\\n`;\n                if (~line.indexOf('after_platform_add')) {\n                    sll('');\n                    this.log.info('done... 10%');\n                }\n\n                if (~line.indexOf('Local package version')) {\n                    if (messageTimeout) {\n                        clearTimeout(messageTimeout);\n                    }\n                    messageTimeout = setTimeout(() => {\n                        sll('');\n                        this.log.info('building in progress...');\n                    }, 1500);\n                }\n\n                if (~line.indexOf('Preparing Cordova project')) {\n                    sll('');\n                    this.log.info('done... 60%');\n                }\n\n                if (~line.indexOf('Can\\'t listen on port')) {\n                    portProblem = true;\n                }\n\n                if (~line.indexOf('Your application has errors')) {\n                    if (errorTimeout) {\n                        clearTimeout(errorTimeout);\n                    }\n                    errorTimeout = setTimeout(() => {\n                        clearTimeoutsAndIntervals();\n                        kill();\n                        writeLog();\n                        reject('errorInApp');\n                    }, 1000);\n                }\n\n                if (~line.indexOf('App running at')) {\n                    copyBuild();\n                }\n            });\n\n            // When Meteor exits\n            child.on('exit', () => {\n                sll('');\n                clearTimeoutsAndIntervals();\n                if (!desiredExit) {\n                    writeLog();\n                    if (portProblem) {\n                        reject('port');\n                    } else {\n                        reject('exit');\n                    }\n                }\n            });\n\n            buildTimeout = setTimeout(() => {\n                kill();\n                writeLog();\n                reject('timeout');\n            }, this.$.env.options.buildTimeout ? this.$.env.options.buildTimeout * 1000 : 600000);\n        });\n    }\n\n    /**\n     * Replaces the DDP url that was used originally when Meteor was building the client.\n     * @param {string} indexHtml - path to index.html from the client\n     */\n    updateDdpUrl(indexHtml) {\n        let content;\n        let runtimeConfig;\n\n        try {\n            content = fs.readFileSync(indexHtml, 'UTF-8');\n        } catch (e) {\n            this.log.error(`error loading index.html file: ${e.message}`);\n            process.exit(1);\n        }\n        if (!this.matcher.test(content)) {\n            this.log.error('could not find runtime config in index file');\n            process.exit(1);\n        }\n\n        try {\n            const matches = content.match(this.matcher);\n            runtimeConfig = JSON.parse(decodeURIComponent(matches[1]));\n        } catch (e) {\n            this.log.error('could not find runtime config in index file');\n            process.exit(1);\n        }\n\n        if (this.$.env.options.ddpUrl.substr(-1, 1) !== '/') {\n            this.$.env.options.ddpUrl += '/';\n        }\n\n        runtimeConfig.ROOT_URL = this.$.env.options.ddpUrl;\n        runtimeConfig.DDP_DEFAULT_CONNECTION_URL = this.$.env.options.ddpUrl;\n\n        content = content.replace(\n            this.replacer, `$1\"${encodeURIComponent(JSON.stringify(runtimeConfig))}\"$3`\n        );\n\n        try {\n            fs.writeFileSync(indexHtml, content);\n        } catch (e) {\n            this.log.error(`error writing index.html file: ${e.message}`);\n            process.exit(1);\n        }\n        this.log.info('successfully updated ddp string in the runtime config of a mobile build' +\n            ` to ${this.$.env.options.ddpUrl}`);\n    }\n\n    /**\n     * Prepares the arguments passed to `meteor` command.\n     * @returns {string[]}\n     */\n    prepareArguments() {\n        const args = ['run', '--verbose', `--mobile-server=${this.$.env.options.ddpUrl}`];\n        if (this.$.env.isProductionBuild()) {\n            args.push('--production');\n        }\n        args.push('-p');\n        if (this.$.env.options.port) {\n            args.push(this.$.env.options.port);\n        } else {\n            args.push('3080');\n        }\n        if (this.$.env.options.meteorSettings) {\n            args.push('--settings', this.$.env.options.meteorSettings);\n        }\n        return args;\n    }\n\n    /**\n     * Validates the mobile build and copies it into electron app.\n     */\n    async copyBuild() {\n        this.log.debug('clearing build dir');\n        try {\n            await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.meteorApp);\n        } catch (e) {\n            throw new Error(e);\n        }\n\n        let prefix = 'cordovaBuild';\n        let copyPathPostfix = '';\n\n        if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) {\n            prefix = 'webCordova';\n            copyPathPostfix = `${path.sep}*`;\n            let indexHtml;\n            try {\n                fs.mkdirSync(this.$.env.paths.electronApp.meteorApp);\n                indexHtml = await this.acquireIndex();\n                fs.writeFileSync(this.$.env.paths.electronApp.meteorAppIndex, indexHtml);\n                this.log.info('successfully downloaded index.html from running meteor app');\n            } catch (e) {\n                this.log.error('error while trying to download index.html for web.cordova, ' +\n                    'be sure that you are running a mobile target or with' +\n                    ' --mobile-server: ', e);\n                throw e;\n            }\n        }\n\n        const cordovaBuild = this.$.env.paths.meteorApp[prefix];\n        const { cordovaBuildIndex } = this.$.env.paths.meteorApp;\n        const cordovaBuildProgramJson = this.$.env.paths.meteorApp[`${prefix}ProgramJson`];\n\n        if (!this.$.utils.exists(cordovaBuild)) {\n            this.log.error(`no mobile build found at ${cordovaBuild}`);\n            this.log.error('are you sure you did run meteor with --mobile-server?');\n            throw new Error('required file not present');\n        }\n\n        if (!this.$.utils.exists(cordovaBuildProgramJson)) {\n            this.log.error('no program.json found in mobile build found at ' +\n                `${cordovaBuild}`);\n            this.log.error('are you sure you did run meteor with --mobile-server?');\n            throw new Error('required file not present');\n        }\n\n        if (this.indexHTMLstrategy !== this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) {\n            if (!this.$.utils.exists(cordovaBuildIndex)) {\n                this.log.error('no index.html found in cordova build found at ' +\n                    `${cordovaBuild}`);\n                this.log.error('are you sure you did run meteor with --mobile-server?');\n                throw new Error('required file not present');\n            }\n        }\n\n        this.log.verbose('copying mobile build');\n        shell.cp(\n            '-R', `${cordovaBuild}${copyPathPostfix}`, this.$.env.paths.electronApp.meteorApp\n        );\n\n        // Because of various permission problems here we try to clear te path by clearing\n        // all possible restrictions.\n        shell.chmod(\n            '-R', '777', this.$.env.paths.electronApp.meteorApp\n        );\n        if (this.$.env.os.isWindows) {\n            shell.exec(`attrib -r ${this.$.env.paths.electronApp.meteorApp}${path.sep}*.* /s`);\n        }\n\n        if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) {\n            let programJson;\n            try {\n                programJson = await this.acquireManifest();\n                fs.writeFileSync(\n                    this.$.env.paths.electronApp.meteorAppProgramJson,\n                    JSON.stringify(programJson, null, 4)\n                );\n                this.log.info('successfully downloaded manifest.json from running meteor app');\n            } catch (e) {\n                this.log.error('error while trying to download manifest.json for web.cordova,' +\n                    ' be sure that you are running a mobile target or with' +\n                    ' --mobile-server: ', e);\n                throw e;\n            }\n        }\n\n        this.log.info('mobile build copied to electron app');\n\n        this.log.debug('copy cordova.js to meteor build');\n        shell.cp(\n            join(__dirname, '..', 'skeleton', 'cordova.js'),\n            this.$.env.paths.electronApp.meteorApp\n        );\n    }\n\n    /**\n     * Injects Meteor.isDesktop\n     */\n    injectIsDesktop() {\n        this.log.info('injecting isDesktop');\n\n        let manifestJsonPath = this.$.env.paths.meteorApp.cordovaBuildProgramJson;\n        if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) {\n            manifestJsonPath = this.$.env.paths.meteorApp.webCordovaProgramJson;\n        }\n\n        try {\n            const { manifest } = JSON.parse(\n                fs.readFileSync(manifestJsonPath, 'UTF-8')\n            );\n            let injected = false;\n            let injectedStartupDidComplete = false;\n            let result = null;\n\n            // We will search in every .js file in the manifest.\n            // We could probably detect whether this is a dev or production build and only search in\n            // the correct files, but for now this should be fine.\n            manifest.forEach((file) => {\n                let fileContents;\n                // Hacky way of setting isDesktop.\n                if (file.type === 'js') {\n                    fileContents = fs.readFileSync(\n                        join(this.$.env.paths.electronApp.meteorApp, file.path),\n                        'UTF-8'\n                    );\n                    result = this.injector.processFileContents(fileContents);\n\n                    ({ fileContents } = result);\n                    injectedStartupDidComplete =\n                        result.injectedStartupDidComplete ? true : injectedStartupDidComplete;\n                    injected = result.injected ? true : injected;\n\n                    fs.writeFileSync(\n                        join(this.$.env.paths.electronApp.meteorApp, file.path), fileContents\n                    );\n                }\n            });\n\n            if (!injected) {\n                this.log.error('error injecting isDesktop global var.');\n                process.exit(1);\n            }\n            if (!injectedStartupDidComplete) {\n                this.log.error('error injecting isDesktop for startupDidComplete');\n                process.exit(1);\n            }\n        } catch (e) {\n            this.log.error('error occurred while injecting isDesktop: ', e);\n            process.exit(1);\n        }\n        this.log.info('injected successfully');\n    }\n\n    /**\n     * Builds, modifies and copies the meteor app to electron app.\n     */\n    async build() {\n        this.log.info('checking for any mobile platform');\n        try {\n            await this.checkPreconditions();\n        } catch (e) {\n            this.log.error('error occurred during checking preconditions: ', e);\n            process.exit(1);\n        }\n\n        this.log.info('building meteor app');\n\n        if (!this.$.env.options.skipMobileBuild) {\n            try {\n                await this.buildMobileTarget();\n            } catch (reason) {\n                switch (reason) {\n                    case 'timeout':\n                        this.log.error(\n                            'timeout while building, log has been written to meteor.log'\n                        );\n                        break;\n                    case 'error':\n                        this.log.error(\n                            'build was terminated by meteor-desktop as some errors were reported to stderr, you ' +\n                            'should see it above, also check meteor.log for more info, to ignore it use the ' +\n                            '--ignore-stderr \"<string>\"'\n                        );\n                        break;\n                    case 'errorInApp':\n                        this.log.error(\n                            'your meteor app has errors - look into meteor.log for more' +\n                            ' info'\n                        );\n                        break;\n                    case 'port':\n                        this.log.error(\n                            'your port 3080 is currently used (you probably have this or other ' +\n                            'meteor project running?), use `-t` or `--meteor-port` to use ' +\n                            'different port while building'\n                        );\n                        break;\n                    case 'exit':\n                        this.log.error(\n                            'meteor cmd exited unexpectedly, log has been written to meteor.log'\n                        );\n                        break;\n                    case 'copy':\n                        this.log.error(\n                            'error encountered when copying the build'\n                        );\n                        break;\n                    default:\n                        this.log.error('error occurred during building mobile target', reason);\n                }\n                if (this.mobilePlatform) {\n                    await this.removeMobilePlatform(this.mobilePlatform);\n                }\n                process.exit(1);\n            }\n        } else {\n            this.indexHTMLstrategy = this.chooseStrategy();\n            try {\n                await this.copyBuild();\n            } catch (e) {\n                process.exit(1);\n            }\n        }\n\n        this.injectIsDesktop();\n\n        this.changeDdpUrl();\n\n        try {\n            await this.packToAsar();\n        } catch (e) {\n            this.log.error('error while packing meteor app to asar');\n            process.exit(1);\n        }\n\n        this.log.info('meteor build finished');\n\n        if (this.mobilePlatform) {\n            await this.removeMobilePlatform(this.mobilePlatform);\n        }\n    }\n\n    changeDdpUrl() {\n        if (this.$.env.options.ddpUrl !== null) {\n            try {\n                this.updateDdpUrl(this.$.env.paths.electronApp.meteorAppIndex);\n            } catch (e) {\n                this.log.error(`error while trying to change the ddp url: ${e.message}`);\n            }\n        }\n    }\n\n    packToAsar() {\n        this.log.info('packing meteor app to asar archive');\n        return new Promise((resolve, reject) =>\n            asar.createPackage(\n                this.$.env.paths.electronApp.meteorApp,\n                path.join(this.$.env.paths.electronApp.root, 'meteor.asar')\n            )\n                .then(() => {\n                    // On Windows some files might still be blocked. Giving a tick for them to be\n                    // ready for deletion.\n                    setImmediate(() => {\n                        this.log.verbose('clearing meteor app after packing');\n                        this.$.utils\n                            .rmWithRetries('-rf', this.$.env.paths.electronApp.meteorApp)\n                            .then(() => {\n                                resolve();\n                            })\n                            .catch((e) => {\n                                reject(e);\n                            });\n                    });\n                }));\n    }\n\n    /**\n     * Wrapper for spawning npm.\n     * @param {Array}  commands - commands for spawn\n     * @param {string} stdio\n     * @param {string} cwd\n     * @return {Promise}\n     */\n    runNpm(commands, stdio = 'ignore', cwd = this.$.env.paths.meteorApp.root) {\n        return new Promise((resolve, reject) => {\n            this.log.verbose(`executing meteor npm ${commands.join(' ')}`);\n\n            spawn('meteor', ['npm', ...commands], {\n                cwd,\n                stdio\n            }).on('exit', code => (\n                (code === 0) ? resolve() : reject(new Error(`npm exit code was ${code}`))\n            ));\n        });\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/meteorManager.js b/dist/meteorManager.js new file mode 100644 index 00000000..098723b3 --- /dev/null +++ b/dist/meteorManager.js @@ -0,0 +1,147 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _fs = _interopRequireDefault(require("fs")); + +var _crossSpawn = _interopRequireDefault(require("cross-spawn")); + +var _log = _interopRequireDefault(require("./log")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars + +/** + * Utility class designed for managing Meteor packages. + * + * @property {MeteorDesktop} $ + * @class + */ +class MeteorManager { + /** + * @param {MeteorDesktop} $ - context + * @constructor + */ + constructor($) { + this.log = new _log.default('meteorManager'); + this.$ = $; + } + /** + * Looks for specified packages in .meteor/packages. In other words checks if the project has + * specified packages added. + * @param {Array} packages + * @returns {boolean} + */ + + + checkPackages(packages) { + const usedPackages = _fs.default.readFileSync(this.$.env.paths.meteorApp.packages, 'UTF-8').replace(/\r/gm, '').split('\n').filter(line => !line.trim().startsWith('#')); + + return !packages.some(packageToFind => !usedPackages.some(meteorPackage => ~meteorPackage.indexOf(packageToFind))); + } + /** + * Looks for specified packages in .meteor/packages. In other words checks if the project has + * specified packages added. + * @param {Array} packages + * @returns {boolean} + */ + + + checkPackagesVersion(packages) { + const usedPackages = _fs.default.readFileSync(this.$.env.paths.meteorApp.versions, 'UTF-8').replace(/\r/gm, '').split('\n'); + + return !packages.some(packageToFind => !usedPackages.some(meteorPackage => meteorPackage === packageToFind)); + } + /** + * Ensures certain packages are added to meteor project and in correct version. + * @param {Array} packages + * @param {Array} packagesWithVersion + * @param {string} who - name of the entity that requests presence of thos packages (can be the + * integration itself or a plugin) + * @returns {Promise.} + */ + + + async ensurePackages(packages, packagesWithVersion, who) { + if (!this.checkPackages(packages)) { + this.log.warn(`${who} requires some packages that are not added to project, will try to add them now`); + + try { + await this.addPackages(packages, packagesWithVersion); + } catch (e) { + throw new Error(e); + } + } + + if (!this.checkPackagesVersion(packagesWithVersion)) { + this.log.warn(`${who} required packages version is different, fixing it`); + + try { + await this.addPackages(packages, packagesWithVersion); + } catch (e) { + throw new Error(e); + } + } + } + /** + * Removes packages from the meteor app. + * @param {Array} packages - array with names of the packages to remove + */ + + + deletePackages(packages) { + this.log.warn('removing packages from meteor project', ...packages); + return new Promise((resolve, reject) => { + (0, _crossSpawn.default)('meteor', ['remove'].concat(packages), { + cwd: this.$.env.paths.meteorApp.root, + stdio: ['pipe', 'pipe', process.stderr], + env: Object.assign({ + METEOR_PRETTY_OUTPUT: 0, + METEOR_NO_RELEASE_CHECK: 1 + }, process.env) + }).on('exit', code => { + if (code !== 0 || this.checkPackages(packages)) { + reject('removing packages failed'); + } else { + resolve(); + } + }); + }); + } + /** + * Adds packages to the meteor app. + * @param {Array} packages - array with names of the packages to add + * @param {Array} packagesWithVersion - array with names and versions of the packages to add + */ + + + addPackages(packages, packagesWithVersion) { + this.log.info('adding packages to meteor project', ...packagesWithVersion); + return new Promise((resolve, reject) => { + (0, _crossSpawn.default)('meteor', ['add'].concat(packagesWithVersion.map(packageName => packageName.replace('@', '@='))), { + cwd: this.$.env.paths.meteorApp.root, + stdio: ['pipe', 'pipe', process.stderr], + env: Object.assign({ + METEOR_PRETTY_OUTPUT: 0, + METEOR_NO_RELEASE_CHECK: 1 + }, process.env) + }).on('exit', code => { + if (code !== 0 || !this.checkPackages(packages)) { + reject('adding packages failed'); + } else { + resolve(); + } + }); + }); + } + +} + +exports.default = MeteorManager; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["MeteorManager","constructor","$","log","Log","checkPackages","packages","usedPackages","fs","readFileSync","env","paths","meteorApp","replace","split","filter","line","trim","startsWith","some","packageToFind","meteorPackage","indexOf","checkPackagesVersion","versions","ensurePackages","packagesWithVersion","who","warn","addPackages","e","Error","deletePackages","Promise","resolve","reject","spawn","concat","cwd","root","stdio","process","stderr","Object","assign","METEOR_PRETTY_OUTPUT","METEOR_NO_RELEASE_CHECK","on","code","info","map","packageName"],"sources":["../lib/meteorManager.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport fs from 'fs';\nimport spawn from 'cross-spawn';\n\nimport Log from './log';\n\n/**\n * Utility class designed for managing Meteor packages.\n *\n * @property {MeteorDesktop} $\n * @class\n */\nexport default class MeteorManager {\n    /**\n     * @param {MeteorDesktop} $ - context\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('meteorManager');\n        this.$ = $;\n    }\n\n    /**\n     * Looks for specified packages in .meteor/packages. In other words checks if the project has\n     * specified packages added.\n     * @param {Array} packages\n     * @returns {boolean}\n     */\n    checkPackages(packages) {\n        const usedPackages = fs\n            .readFileSync(this.$.env.paths.meteorApp.packages, 'UTF-8')\n            .replace(/\\r/gm, '')\n            .split('\\n')\n            .filter(line => !line.trim().startsWith('#'));\n        return !packages.some(\n            packageToFind =>\n                !usedPackages.some(meteorPackage => ~meteorPackage.indexOf(packageToFind))\n        );\n    }\n\n    /**\n     * Looks for specified packages in .meteor/packages. In other words checks if the project has\n     * specified packages added.\n     * @param {Array} packages\n     * @returns {boolean}\n     */\n    checkPackagesVersion(packages) {\n        const usedPackages = fs.readFileSync(this.$.env.paths.meteorApp.versions, 'UTF-8')\n            .replace(/\\r/gm, '')\n            .split('\\n');\n        return !packages.some(\n            packageToFind => !usedPackages.some(meteorPackage => meteorPackage === packageToFind)\n        );\n    }\n\n    /**\n     * Ensures certain packages are added to meteor project and in correct version.\n     * @param {Array} packages\n     * @param {Array} packagesWithVersion\n     * @param {string} who - name of the entity that requests presence of thos packages (can be the\n     *                       integration itself or a plugin)\n     * @returns {Promise.<void>}\n     */\n    async ensurePackages(packages, packagesWithVersion, who) {\n        if (!this.checkPackages(packages)) {\n            this.log.warn(`${who} requires some packages that are not added to project, will try to add them now`);\n            try {\n                await this.addPackages(packages, packagesWithVersion);\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n        if (!this.checkPackagesVersion(packagesWithVersion)) {\n            this.log.warn(`${who} required packages version is different, fixing it`);\n            try {\n                await this.addPackages(packages, packagesWithVersion);\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n    }\n\n    /**\n     * Removes packages from the meteor app.\n     * @param {Array} packages            - array with names of the packages to remove\n     */\n    deletePackages(packages) {\n        this.log.warn('removing packages from meteor project', ...packages);\n        return new Promise((resolve, reject) => {\n            spawn(\n                'meteor',\n                ['remove'].concat(packages), {\n                    cwd: this.$.env.paths.meteorApp.root,\n                    stdio: ['pipe', 'pipe', process.stderr],\n                    env: Object.assign(\n                        { METEOR_PRETTY_OUTPUT: 0, METEOR_NO_RELEASE_CHECK: 1 }, process.env\n                    )\n                }\n            ).on('exit', (code) => {\n                if (code !== 0 || this.checkPackages(packages)) {\n                    reject('removing packages failed');\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n\n    /**\n     * Adds packages to the meteor app.\n     * @param {Array} packages            - array with names of the packages to add\n     * @param {Array} packagesWithVersion - array with names and versions of the packages to add\n     */\n    addPackages(packages, packagesWithVersion) {\n        this.log.info('adding packages to meteor project', ...packagesWithVersion);\n        return new Promise((resolve, reject) => {\n            spawn(\n                'meteor',\n                ['add'].concat(\n                    packagesWithVersion.map(packageName => packageName.replace('@', '@='))\n                ),\n                {\n                    cwd: this.$.env.paths.meteorApp.root,\n                    stdio: ['pipe', 'pipe', process.stderr],\n                    env: Object.assign(\n                        { METEOR_PRETTY_OUTPUT: 0, METEOR_NO_RELEASE_CHECK: 1 }, process.env\n                    )\n                }\n            ).on('exit', (code) => {\n                if (code !== 0 || !this.checkPackages(packages)) {\n                    reject('adding packages failed');\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/packager.js b/dist/packager.js new file mode 100644 index 00000000..5dc2f01f --- /dev/null +++ b/dist/packager.js @@ -0,0 +1,142 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); + +var _assignIn = _interopRequireDefault(require("lodash/assignIn")); + +var _path = _interopRequireDefault(require("path")); + +var _fs = _interopRequireDefault(require("fs")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +var _log = _interopRequireDefault(require("./log")); + +var _defaultDependencies = _interopRequireDefault(require("./defaultDependencies")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// eslint-disable-next-line no-unused-vars +const { + join +} = _path.default; +/** + * Wrapper around electron-packager. + * @class + */ + +class ElectronPackager { + constructor($) { + this.log = new _log.default('electron-packager'); + this.$ = $; + } + + async init() { + this.packager = (await this.$.getDependency('electron-packager', _defaultDependencies.default['electron-packager'])).dependency; + } + /** + * Runs the packager with provided arguments. + * + * @param {Object} args + * @returns {Promise} + */ + + + runPackager(args) { + return new Promise((resolve, reject) => { + this.packager(args, err => { + if (err) { + reject(err); + } else { + this.log.info(`wrote packaged app to ${this.$.env.paths.packageDir}`); + resolve(); + } + }); + }); + } + + async packageApp() { + const { + version + } = JSON.parse(_fs.default.readFileSync(join(this.$.env.paths.meteorApp.root, 'node_modules', 'electron', 'package.json'), 'UTF-8')); + const settings = this.$.desktop.getSettings(); + const { + name + } = settings; + + if (!name) { + this.log.error('`name` field in settings.json not set'); + process.exit(1); + } + + const arch = this.$.env.options.ia32 ? 'ia32' : 'x64'; + this.log.info(`packaging '${name}' for platform '${this.$.env.sys.platform}-${arch}'` + ` using electron v${version}`); + + try { + await this.$.utils.rmWithRetries('-rf', _path.default.join(this.$.env.options.output, this.$.env.paths.packageDir)); + } catch (e) { + throw new Error(e); + } + + const args = { + name, + arch, + prune: false, + electronVersion: version, + platform: this.$.env.sys.platform, + dir: this.$.env.paths.electronApp.root, + out: _path.default.join(this.$.env.options.output, this.$.env.paths.packageDir) + }; + + if ('packagerOptions' in settings) { + const { + packagerOptions + } = settings; + ['windows', 'linux', 'osx'].forEach(system => { + if (this.$.env.os[`is${system[0].toUpperCase()}${system.substring(1)}`] && `_${system}` in packagerOptions) { + (0, _assignIn.default)(packagerOptions, packagerOptions[`_${system}`]); + } + }); + Object.keys(packagerOptions).forEach(field => { + if (packagerOptions[field] === '@version') { + packagerOptions[field] = settings.version; + } + }); + (0, _assignIn.default)(args, packagerOptions); + } // Move node_modules away. We do not want to delete it, just temporarily remove it from + // our way. + + + _fs.default.renameSync(this.$.env.paths.electronApp.nodeModules, this.$.env.paths.electronApp.tmpNodeModules); + + let extracted = false; + + if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) { + _fs.default.renameSync(this.$.env.paths.electronApp.extractedNodeModules, this.$.env.paths.electronApp.nodeModules); + + extracted = true; + } + + try { + await this.runPackager(args); + } finally { + if (extracted) { + _shelljs.default.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules); + + _shelljs.default.rm('-rf', this.$.env.paths.electronApp.nodeModules); + } // Move node_modules back. + + + _fs.default.renameSync(this.$.env.paths.electronApp.tmpNodeModules, this.$.env.paths.electronApp.nodeModules); + } + } + +} + +exports.default = ElectronPackager; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","ElectronPackager","constructor","$","log","Log","init","packager","getDependency","defaultDependencies","dependency","runPackager","args","Promise","resolve","reject","err","info","env","paths","packageDir","packageApp","version","JSON","parse","fs","readFileSync","meteorApp","root","settings","desktop","getSettings","name","error","process","exit","arch","options","ia32","sys","platform","utils","rmWithRetries","output","e","Error","prune","electronVersion","dir","electronApp","out","packagerOptions","forEach","system","os","toUpperCase","substring","assignIn","Object","keys","field","renameSync","nodeModules","tmpNodeModules","extracted","exists","extractedNodeModules","shell","rm"],"sources":["../lib/packager.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport assignIn from 'lodash/assignIn';\nimport path from 'path';\nimport fs from 'fs';\nimport shell from 'shelljs';\n\nimport Log from './log';\nimport defaultDependencies from './defaultDependencies';\n\nconst { join } = path;\n\n/**\n * Wrapper around electron-packager.\n * @class\n */\nexport default class ElectronPackager {\n    constructor($) {\n        this.log = new Log('electron-packager');\n        this.$ = $;\n    }\n\n    async init() {\n        this.packager = (await this.$.getDependency('electron-packager', defaultDependencies['electron-packager'])).dependency;\n    }\n\n    /**\n     * Runs the packager with provided arguments.\n     *\n     * @param {Object} args\n     * @returns {Promise}\n     */\n    runPackager(args) {\n        return new Promise((resolve, reject) => {\n            this.packager(args, (err) => {\n                if (err) {\n                    reject(err);\n                } else {\n                    this.log.info(`wrote packaged app to ${this.$.env.paths.packageDir}`);\n                    resolve();\n                }\n            });\n        });\n    }\n\n    async packageApp() {\n        const { version } = JSON.parse(fs.readFileSync(\n            join(\n                this.$.env.paths.meteorApp.root,\n                'node_modules',\n                'electron',\n                'package.json'\n            ), 'UTF-8'\n        ));\n\n        const settings = this.$.desktop.getSettings();\n        const { name } = settings;\n        if (!name) {\n            this.log.error('`name` field in settings.json not set');\n            process.exit(1);\n        }\n\n        const arch = this.$.env.options.ia32 ? 'ia32' : 'x64';\n\n        this.log.info(\n            `packaging '${name}' for platform '${this.$.env.sys.platform}-${arch}'` +\n            ` using electron v${version}`\n        );\n\n        try {\n            await this.$.utils.rmWithRetries(\n                '-rf', path.join(this.$.env.options.output, this.$.env.paths.packageDir)\n            );\n        } catch (e) {\n            throw new Error(e);\n        }\n\n        const args = {\n            name,\n            arch,\n            prune: false,\n            electronVersion: version,\n            platform: this.$.env.sys.platform,\n            dir: this.$.env.paths.electronApp.root,\n            out: path.join(this.$.env.options.output, this.$.env.paths.packageDir)\n        };\n\n        if ('packagerOptions' in settings) {\n            const { packagerOptions } = settings;\n\n            ['windows', 'linux', 'osx'].forEach((system) => {\n                if (\n                    this.$.env.os[`is${system[0].toUpperCase()}${system.substring(1)}`] &&\n                    (`_${system}`) in packagerOptions\n                ) {\n                    assignIn(packagerOptions, packagerOptions[`_${system}`]);\n                }\n            });\n\n            Object.keys(packagerOptions).forEach((field) => {\n                if (packagerOptions[field] === '@version') {\n                    packagerOptions[field] = settings.version;\n                }\n            });\n\n            assignIn(args, packagerOptions);\n        }\n\n        // Move node_modules away. We do not want to delete it, just temporarily remove it from\n        // our way.\n        fs.renameSync(\n            this.$.env.paths.electronApp.nodeModules,\n            this.$.env.paths.electronApp.tmpNodeModules\n        );\n\n        let extracted = false;\n\n        if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) {\n            fs.renameSync(\n                this.$.env.paths.electronApp.extractedNodeModules,\n                this.$.env.paths.electronApp.nodeModules\n            );\n            extracted = true;\n        }\n\n        try {\n            await this.runPackager(args);\n        } finally {\n            if (extracted) {\n                shell.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules);\n                shell.rm('-rf', this.$.env.paths.electronApp.nodeModules);\n            }\n            // Move node_modules back.\n            fs.renameSync(\n                this.$.env.paths.electronApp.tmpNodeModules,\n                this.$.env.paths.electronApp.nodeModules\n            );\n        }\n    }\n}\n"],"mappings":";;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;;;AARA;AAUA,MAAM;EAAEA;AAAF,IAAWC,aAAjB;AAEA;AACA;AACA;AACA;;AACe,MAAMC,gBAAN,CAAuB;EAClCC,WAAW,CAACC,CAAD,EAAI;IACX,KAAKC,GAAL,GAAW,IAAIC,YAAJ,CAAQ,mBAAR,CAAX;IACA,KAAKF,CAAL,GAASA,CAAT;EACH;;EAES,MAAJG,IAAI,GAAG;IACT,KAAKC,QAAL,GAAgB,CAAC,MAAM,KAAKJ,CAAL,CAAOK,aAAP,CAAqB,mBAArB,EAA0CC,4BAAA,CAAoB,mBAApB,CAA1C,CAAP,EAA4FC,UAA5G;EACH;EAED;AACJ;AACA;AACA;AACA;AACA;;;EACIC,WAAW,CAACC,IAAD,EAAO;IACd,OAAO,IAAIC,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;MACpC,KAAKR,QAAL,CAAcK,IAAd,EAAqBI,GAAD,IAAS;QACzB,IAAIA,GAAJ,EAAS;UACLD,MAAM,CAACC,GAAD,CAAN;QACH,CAFD,MAEO;UACH,KAAKZ,GAAL,CAASa,IAAT,CAAe,yBAAwB,KAAKd,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiBC,UAAW,EAAnE;UACAN,OAAO;QACV;MACJ,CAPD;IAQH,CATM,CAAP;EAUH;;EAEe,MAAVO,UAAU,GAAG;IACf,MAAM;MAAEC;IAAF,IAAcC,IAAI,CAACC,KAAL,CAAWC,WAAA,CAAGC,YAAH,CAC3B3B,IAAI,CACA,KAAKI,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiBQ,SAAjB,CAA2BC,IAD3B,EAEA,cAFA,EAGA,UAHA,EAIA,cAJA,CADuB,EAMxB,OANwB,CAAX,CAApB;IASA,MAAMC,QAAQ,GAAG,KAAK1B,CAAL,CAAO2B,OAAP,CAAeC,WAAf,EAAjB;IACA,MAAM;MAAEC;IAAF,IAAWH,QAAjB;;IACA,IAAI,CAACG,IAAL,EAAW;MACP,KAAK5B,GAAL,CAAS6B,KAAT,CAAe,uCAAf;MACAC,OAAO,CAACC,IAAR,CAAa,CAAb;IACH;;IAED,MAAMC,IAAI,GAAG,KAAKjC,CAAL,CAAOe,GAAP,CAAWmB,OAAX,CAAmBC,IAAnB,GAA0B,MAA1B,GAAmC,KAAhD;IAEA,KAAKlC,GAAL,CAASa,IAAT,CACK,cAAae,IAAK,mBAAkB,KAAK7B,CAAL,CAAOe,GAAP,CAAWqB,GAAX,CAAeC,QAAS,IAAGJ,IAAK,GAArE,GACC,oBAAmBd,OAAQ,EAFhC;;IAKA,IAAI;MACA,MAAM,KAAKnB,CAAL,CAAOsC,KAAP,CAAaC,aAAb,CACF,KADE,EACK1C,aAAA,CAAKD,IAAL,CAAU,KAAKI,CAAL,CAAOe,GAAP,CAAWmB,OAAX,CAAmBM,MAA7B,EAAqC,KAAKxC,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiBC,UAAtD,CADL,CAAN;IAGH,CAJD,CAIE,OAAOwB,CAAP,EAAU;MACR,MAAM,IAAIC,KAAJ,CAAUD,CAAV,CAAN;IACH;;IAED,MAAMhC,IAAI,GAAG;MACToB,IADS;MAETI,IAFS;MAGTU,KAAK,EAAE,KAHE;MAITC,eAAe,EAAEzB,OAJR;MAKTkB,QAAQ,EAAE,KAAKrC,CAAL,CAAOe,GAAP,CAAWqB,GAAX,CAAeC,QALhB;MAMTQ,GAAG,EAAE,KAAK7C,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6BrB,IANzB;MAOTsB,GAAG,EAAElD,aAAA,CAAKD,IAAL,CAAU,KAAKI,CAAL,CAAOe,GAAP,CAAWmB,OAAX,CAAmBM,MAA7B,EAAqC,KAAKxC,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiBC,UAAtD;IAPI,CAAb;;IAUA,IAAI,qBAAqBS,QAAzB,EAAmC;MAC/B,MAAM;QAAEsB;MAAF,IAAsBtB,QAA5B;MAEA,CAAC,SAAD,EAAY,OAAZ,EAAqB,KAArB,EAA4BuB,OAA5B,CAAqCC,MAAD,IAAY;QAC5C,IACI,KAAKlD,CAAL,CAAOe,GAAP,CAAWoC,EAAX,CAAe,KAAID,MAAM,CAAC,CAAD,CAAN,CAAUE,WAAV,EAAwB,GAAEF,MAAM,CAACG,SAAP,CAAiB,CAAjB,CAAoB,EAAjE,KACE,IAAGH,MAAO,EAAZ,IAAkBF,eAFtB,EAGE;UACE,IAAAM,iBAAA,EAASN,eAAT,EAA0BA,eAAe,CAAE,IAAGE,MAAO,EAAZ,CAAzC;QACH;MACJ,CAPD;MASAK,MAAM,CAACC,IAAP,CAAYR,eAAZ,EAA6BC,OAA7B,CAAsCQ,KAAD,IAAW;QAC5C,IAAIT,eAAe,CAACS,KAAD,CAAf,KAA2B,UAA/B,EAA2C;UACvCT,eAAe,CAACS,KAAD,CAAf,GAAyB/B,QAAQ,CAACP,OAAlC;QACH;MACJ,CAJD;MAMA,IAAAmC,iBAAA,EAAS7C,IAAT,EAAeuC,eAAf;IACH,CA7Dc,CA+Df;IACA;;;IACA1B,WAAA,CAAGoC,UAAH,CACI,KAAK1D,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6Ba,WADjC,EAEI,KAAK3D,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6Bc,cAFjC;;IAKA,IAAIC,SAAS,GAAG,KAAhB;;IAEA,IAAI,KAAK7D,CAAL,CAAOsC,KAAP,CAAawB,MAAb,CAAoB,KAAK9D,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6BiB,oBAAjD,CAAJ,EAA4E;MACxEzC,WAAA,CAAGoC,UAAH,CACI,KAAK1D,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6BiB,oBADjC,EAEI,KAAK/D,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6Ba,WAFjC;;MAIAE,SAAS,GAAG,IAAZ;IACH;;IAED,IAAI;MACA,MAAM,KAAKrD,WAAL,CAAiBC,IAAjB,CAAN;IACH,CAFD,SAEU;MACN,IAAIoD,SAAJ,EAAe;QACXG,gBAAA,CAAMC,EAAN,CAAS,KAAT,EAAgB,KAAKjE,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6BiB,oBAA7C;;QACAC,gBAAA,CAAMC,EAAN,CAAS,KAAT,EAAgB,KAAKjE,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6Ba,WAA7C;MACH,CAJK,CAKN;;;MACArC,WAAA,CAAGoC,UAAH,CACI,KAAK1D,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6Bc,cADjC,EAEI,KAAK5D,CAAL,CAAOe,GAAP,CAAWC,KAAX,CAAiB8B,WAAjB,CAA6Ba,WAFjC;IAIH;EACJ;;AA1HiC"} \ No newline at end of file diff --git a/dist/scripts/addToScripts.js b/dist/scripts/addToScripts.js new file mode 100644 index 00000000..aa8d2507 --- /dev/null +++ b/dist/scripts/addToScripts.js @@ -0,0 +1,24 @@ +"use strict"; + +var _path = _interopRequireDefault(require("path")); + +var _addScript = _interopRequireDefault(require("./utils/addScript")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/* eslint-disable no-console */ + +/** + * This script adds a 'desktop' entry to 'scripts' in package.json. If the entry already exists + * it leaves it untouched. + */ +function fail() { + console.error('[meteor-desktop] failed to add meteor-desktop to your package.json scripts, ' + 'please add it manually as \'desktop\': \'meteor-desktop\''); + process.exit(0); +} + +const packageJsonPath = _path.default.resolve(_path.default.join(__dirname, '..', '..', '..', '..', 'package.json')); + +(0, _addScript.default)('desktop', 'meteor-desktop', packageJsonPath, fail); +console.log('[meteor-desktop] successfully added a \'desktop\' entry to your package.json' + ' scripts section.'); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmYWlsIiwiY29uc29sZSIsImVycm9yIiwicHJvY2VzcyIsImV4aXQiLCJwYWNrYWdlSnNvblBhdGgiLCJwYXRoIiwicmVzb2x2ZSIsImpvaW4iLCJfX2Rpcm5hbWUiLCJhZGRTY3JpcHQiLCJsb2ciXSwic291cmNlcyI6WyIuLi8uLi9saWIvc2NyaXB0cy9hZGRUb1NjcmlwdHMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgbm8tY29uc29sZSAqL1xuaW1wb3J0IHBhdGggZnJvbSAncGF0aCc7XG5cbmltcG9ydCBhZGRTY3JpcHQgZnJvbSAnLi91dGlscy9hZGRTY3JpcHQnO1xuLyoqXG4gKiBUaGlzIHNjcmlwdCBhZGRzIGEgJ2Rlc2t0b3AnIGVudHJ5IHRvICdzY3JpcHRzJyBpbiBwYWNrYWdlLmpzb24uIElmIHRoZSBlbnRyeSBhbHJlYWR5IGV4aXN0c1xuICogaXQgbGVhdmVzIGl0IHVudG91Y2hlZC5cbiAqL1xuZnVuY3Rpb24gZmFpbCgpIHtcbiAgICBjb25zb2xlLmVycm9yKCdbbWV0ZW9yLWRlc2t0b3BdIGZhaWxlZCB0byBhZGQgbWV0ZW9yLWRlc2t0b3AgdG8geW91ciBwYWNrYWdlLmpzb24gc2NyaXB0cywgJyArXG4gICAgICAgICdwbGVhc2UgYWRkIGl0IG1hbnVhbGx5IGFzIFxcJ2Rlc2t0b3BcXCc6IFxcJ21ldGVvci1kZXNrdG9wXFwnJyk7XG4gICAgcHJvY2Vzcy5leGl0KDApO1xufVxuXG5jb25zdCBwYWNrYWdlSnNvblBhdGggPSBwYXRoLnJlc29sdmUoXG4gICAgcGF0aC5qb2luKF9fZGlybmFtZSwgJy4uJywgJy4uJywgJy4uJywgJy4uJywgJ3BhY2thZ2UuanNvbicpXG4pO1xuXG5hZGRTY3JpcHQoJ2Rlc2t0b3AnLCAnbWV0ZW9yLWRlc2t0b3AnLCBwYWNrYWdlSnNvblBhdGgsIGZhaWwpO1xuXG5jb25zb2xlLmxvZygnW21ldGVvci1kZXNrdG9wXSBzdWNjZXNzZnVsbHkgYWRkZWQgYSBcXCdkZXNrdG9wXFwnIGVudHJ5IHRvIHlvdXIgcGFja2FnZS5qc29uJyArXG4gICAgJyBzY3JpcHRzIHNlY3Rpb24uJyk7XG4iXSwibWFwcGluZ3MiOiI7O0FBQ0E7O0FBRUE7Ozs7QUFIQTs7QUFJQTtBQUNBO0FBQ0E7QUFDQTtBQUNBLFNBQVNBLElBQVQsR0FBZ0I7RUFDWkMsT0FBTyxDQUFDQyxLQUFSLENBQWMsaUZBQ1YsMkRBREo7RUFFQUMsT0FBTyxDQUFDQyxJQUFSLENBQWEsQ0FBYjtBQUNIOztBQUVELE1BQU1DLGVBQWUsR0FBR0MsYUFBQSxDQUFLQyxPQUFMLENBQ3BCRCxhQUFBLENBQUtFLElBQUwsQ0FBVUMsU0FBVixFQUFxQixJQUFyQixFQUEyQixJQUEzQixFQUFpQyxJQUFqQyxFQUF1QyxJQUF2QyxFQUE2QyxjQUE3QyxDQURvQixDQUF4Qjs7QUFJQSxJQUFBQyxrQkFBQSxFQUFVLFNBQVYsRUFBcUIsZ0JBQXJCLEVBQXVDTCxlQUF2QyxFQUF3REwsSUFBeEQ7QUFFQUMsT0FBTyxDQUFDVSxHQUFSLENBQVksaUZBQ1IsbUJBREoifQ== \ No newline at end of file diff --git a/dist/scripts/propagateVersion.js b/dist/scripts/propagateVersion.js new file mode 100644 index 00000000..eb548ed1 --- /dev/null +++ b/dist/scripts/propagateVersion.js @@ -0,0 +1,21 @@ +"use strict"; + +// This propagates the version from package.json to Meteor plugins. +const { + version +} = require('../../package.json'); + +const fs = require('fs'); + +const paths = ['./plugins/bundler/package.js', './plugins/watcher/package.js']; +paths.forEach(path => { + let packageJs = fs.readFileSync(path, 'UTF-8'); + packageJs = packageJs.replace(/(version: ')([^']+)'/, `$1${version}'`); + + if (~path.indexOf('watcher')) { + packageJs = packageJs.replace(/(communitypackages:meteor-desktop-bundler@)([^']+)'/, `$1${version}'`); + } + + fs.writeFileSync(path, packageJs); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ2ZXJzaW9uIiwicmVxdWlyZSIsImZzIiwicGF0aHMiLCJmb3JFYWNoIiwicGF0aCIsInBhY2thZ2VKcyIsInJlYWRGaWxlU3luYyIsInJlcGxhY2UiLCJpbmRleE9mIiwid3JpdGVGaWxlU3luYyJdLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9zY3JpcHRzL3Byb3BhZ2F0ZVZlcnNpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gVGhpcyBwcm9wYWdhdGVzIHRoZSB2ZXJzaW9uIGZyb20gcGFja2FnZS5qc29uIHRvIE1ldGVvciBwbHVnaW5zLlxuXG5jb25zdCB7IHZlcnNpb24gfSA9IHJlcXVpcmUoJy4uLy4uL3BhY2thZ2UuanNvbicpO1xuY29uc3QgZnMgPSByZXF1aXJlKCdmcycpO1xuXG5jb25zdCBwYXRocyA9IFsnLi9wbHVnaW5zL2J1bmRsZXIvcGFja2FnZS5qcycsICcuL3BsdWdpbnMvd2F0Y2hlci9wYWNrYWdlLmpzJ107XG5wYXRocy5mb3JFYWNoKChwYXRoKSA9PiB7XG4gICAgbGV0IHBhY2thZ2VKcyA9IGZzLnJlYWRGaWxlU3luYyhwYXRoLCAnVVRGLTgnKTtcbiAgICBwYWNrYWdlSnMgPSBwYWNrYWdlSnMucmVwbGFjZSgvKHZlcnNpb246ICcpKFteJ10rKScvLCBgJDEke3ZlcnNpb259J2ApO1xuICAgIGlmICh+cGF0aC5pbmRleE9mKCd3YXRjaGVyJykpIHtcbiAgICAgICAgcGFja2FnZUpzID0gcGFja2FnZUpzLnJlcGxhY2UoLyhjb21tdW5pdHlwYWNrYWdlczptZXRlb3ItZGVza3RvcC1idW5kbGVyQCkoW14nXSspJy8sIGAkMSR7dmVyc2lvbn0nYCk7XG4gICAgfVxuICAgIGZzLndyaXRlRmlsZVN5bmMocGF0aCwgcGFja2FnZUpzKTtcbn0pO1xuIl0sIm1hcHBpbmdzIjoiOztBQUFBO0FBRUEsTUFBTTtFQUFFQTtBQUFGLElBQWNDLE9BQU8sQ0FBQyxvQkFBRCxDQUEzQjs7QUFDQSxNQUFNQyxFQUFFLEdBQUdELE9BQU8sQ0FBQyxJQUFELENBQWxCOztBQUVBLE1BQU1FLEtBQUssR0FBRyxDQUFDLDhCQUFELEVBQWlDLDhCQUFqQyxDQUFkO0FBQ0FBLEtBQUssQ0FBQ0MsT0FBTixDQUFlQyxJQUFELElBQVU7RUFDcEIsSUFBSUMsU0FBUyxHQUFHSixFQUFFLENBQUNLLFlBQUgsQ0FBZ0JGLElBQWhCLEVBQXNCLE9BQXRCLENBQWhCO0VBQ0FDLFNBQVMsR0FBR0EsU0FBUyxDQUFDRSxPQUFWLENBQWtCLHNCQUFsQixFQUEyQyxLQUFJUixPQUFRLEdBQXZELENBQVo7O0VBQ0EsSUFBSSxDQUFDSyxJQUFJLENBQUNJLE9BQUwsQ0FBYSxTQUFiLENBQUwsRUFBOEI7SUFDMUJILFNBQVMsR0FBR0EsU0FBUyxDQUFDRSxPQUFWLENBQWtCLHFEQUFsQixFQUEwRSxLQUFJUixPQUFRLEdBQXRGLENBQVo7RUFDSDs7RUFDREUsRUFBRSxDQUFDUSxhQUFILENBQWlCTCxJQUFqQixFQUF1QkMsU0FBdkI7QUFDSCxDQVBEIn0= \ No newline at end of file diff --git a/dist/scripts/utils/addScript.js b/dist/scripts/utils/addScript.js new file mode 100644 index 00000000..3e6b47e5 --- /dev/null +++ b/dist/scripts/utils/addScript.js @@ -0,0 +1,50 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = addScript; + +var _fs = _interopRequireDefault(require("fs")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function readJsonFile(jsonFilePath) { + try { + return JSON.parse(_fs.default.readFileSync(jsonFilePath, 'UTF-8')); + } catch (e) { + return false; + } +} + +function writeJsonFile(jsonFilePath, jsonContents) { + try { + _fs.default.writeFileSync(jsonFilePath, JSON.stringify(jsonContents, null, 2)); + } catch (e) { + return false; + } + + return true; +} + +function addScript(name, script, packageJsonPath, fail) { + const packageJson = readJsonFile(packageJsonPath); + + if (!(packageJson && packageJson.name)) { + fail(); + return; + } + + if (!('scripts' in packageJson)) { + packageJson.scripts = {}; + } + + if (!(name in packageJson.scripts)) { + packageJson.scripts[name] = script; + } + + if (!writeJsonFile(packageJsonPath, packageJson)) { + fail(); + } +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/skeletonDependencies.js b/dist/skeletonDependencies.js new file mode 100644 index 00000000..31e6e13d --- /dev/null +++ b/dist/skeletonDependencies.js @@ -0,0 +1,24 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _default = { + connect: '3.6.6', + 'server-destroy': '1.0.1', + winston: '2.3.0', + 'find-port': '2.0.1', + rimraf: '2.6.2', + shelljs: '0.7.5', + lodash: '4.17.15', + request: '2.88.0', + queue: '4.0.1', + reify: '0.17.3', + send: '0.16.2', + mime: '2.0.3', + 'fs-extra': '3.0.1', + 'fs-plus': '2.9.3' +}; +exports.default = _default; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjb25uZWN0Iiwid2luc3RvbiIsInJpbXJhZiIsInNoZWxsanMiLCJsb2Rhc2giLCJyZXF1ZXN0IiwicXVldWUiLCJyZWlmeSIsInNlbmQiLCJtaW1lIl0sInNvdXJjZXMiOlsiLi4vbGliL3NrZWxldG9uRGVwZW5kZW5jaWVzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IHtcbiAgICBjb25uZWN0OiAnMy42LjYnLFxuICAgICdzZXJ2ZXItZGVzdHJveSc6ICcxLjAuMScsXG4gICAgd2luc3RvbjogJzIuMy4wJyxcbiAgICAnZmluZC1wb3J0JzogJzIuMC4xJyxcbiAgICByaW1yYWY6ICcyLjYuMicsXG4gICAgc2hlbGxqczogJzAuNy41JyxcbiAgICBsb2Rhc2g6ICc0LjE3LjE1JyxcbiAgICByZXF1ZXN0OiAnMi44OC4wJyxcbiAgICBxdWV1ZTogJzQuMC4xJyxcbiAgICByZWlmeTogJzAuMTcuMycsXG4gICAgc2VuZDogJzAuMTYuMicsXG4gICAgbWltZTogJzIuMC4zJyxcbiAgICAnZnMtZXh0cmEnOiAnMy4wLjEnLFxuICAgICdmcy1wbHVzJzogJzIuOS4zJ1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O2VBQWU7RUFDWEEsT0FBTyxFQUFFLE9BREU7RUFFWCxrQkFBa0IsT0FGUDtFQUdYQyxPQUFPLEVBQUUsT0FIRTtFQUlYLGFBQWEsT0FKRjtFQUtYQyxNQUFNLEVBQUUsT0FMRztFQU1YQyxPQUFPLEVBQUUsT0FORTtFQU9YQyxNQUFNLEVBQUUsU0FQRztFQVFYQyxPQUFPLEVBQUUsUUFSRTtFQVNYQyxLQUFLLEVBQUUsT0FUSTtFQVVYQyxLQUFLLEVBQUUsUUFWSTtFQVdYQyxJQUFJLEVBQUUsUUFYSztFQVlYQyxJQUFJLEVBQUUsT0FaSztFQWFYLFlBQVksT0FiRDtFQWNYLFdBQVc7QUFkQSxDIn0= \ No newline at end of file diff --git a/dist/utils.js b/dist/utils.js new file mode 100644 index 00000000..f931f672 --- /dev/null +++ b/dist/utils.js @@ -0,0 +1,328 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.computeHashForHashesSet = computeHashForHashesSet; +exports.default = void 0; +exports.exists = exists; +exports.getFileList = getFileList; +exports.readAndGetFileHash = readAndGetFileHash; +exports.readAndHashFiles = readAndHashFiles; +exports.readDir = readDir; +exports.readFilesAndComputeHash = readFilesAndComputeHash; +exports.rmWithRetries = rmWithRetries; +exports.symlinkExists = symlinkExists; + +var _path = _interopRequireDefault(require("path")); + +var _fs = _interopRequireDefault(require("fs")); + +var _crypto = _interopRequireDefault(require("crypto")); + +var _shelljs = _interopRequireDefault(require("shelljs")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/* eslint-disable consistent-return */ + +/** + * Exists + * @param {string} pathToCheck + * @returns {boolean} + */ +function exists(pathToCheck) { + try { + _fs.default.accessSync(pathToCheck); + + return true; + } catch (e) { + return false; + } +} +/** + * Simple wrapper for shelljs.rm with additional retries in case of failure. + * It is useful when something is concurrently reading the dir you want to remove. + */ + + +function rmWithRetries(...args) { + let retries = 0; + return new Promise((resolve, reject) => { + function rm(...rmArgs) { + try { + _shelljs.default.config.fatal = true; + + _shelljs.default.rm(...rmArgs); + + _shelljs.default.config.reset(); + + resolve(); + } catch (e) { + retries += 1; + + if (retries < 5) { + setTimeout(() => { + rm(...rmArgs); + }, 100); + } else { + _shelljs.default.config.reset(); + + reject(e); + } + } + } + + rm(...args); + }); +} + +function readDir(dir, callback) { + if (!callback) { + return new Promise((resolve, reject) => { + readDir(dir, (err, data, stats) => { + if (err) { + reject(err); + } else { + resolve({ + data, + stats + }); + } + }); + }); + } + + let list = []; + let allStats = {}; + + _fs.default.readdir(dir, (err, files) => { + if (err) { + return callback(err); + } + + let pending = files.length; + + if (!pending) { + return callback(null, list, allStats); + } + + files.forEach(file => { + const filePath = _path.default.join(dir, file); + + _fs.default.stat(filePath, (_err, stats) => { + if (_err) { + return callback(_err); + } + + if (stats.isDirectory()) { + readDir(filePath, (__err, res, _allStats) => { + if (__err) { + return callback(__err); + } + + list = list.concat(res); + allStats = Object.assign(allStats, _allStats); + pending -= 1; + + if (!pending) { + return callback(null, list, allStats); + } + }); + } else { + list.push(filePath); + allStats[filePath] = { + size: stats.size, + dates: [stats.birthtime.getTime(), stats.ctime.getTime(), stats.mtime.getTime()] + }; + pending -= 1; + + if (!pending) { + return callback(null, list, allStats); + } + } + }); + }); + }); +} +/** + * Returns a file list from a directory. + * @param {string} dir - dir path + * @param {boolean} sort - whether to apply sort + * @returns {Promise} + */ + + +function getFileList(dir, sort = false) { + return new Promise((resolve, reject) => { + readDir(dir, (error, files) => { + if (error) { + reject(error); + return; + } // eslint-disable-next-line no-param-reassign + + + let resultantFilesList; + + if (sort) { + const stripLength = dir.substr(0, 2) === './' ? dir.length - 1 : dir.length + 1; + let pathsUnified = files.map(pth => pth.substr(stripLength).replace(/[\\/]/gm, '-')); + const temporaryIndex = {}; + files.forEach((file, i) => { + temporaryIndex[pathsUnified[i]] = file; + }); + pathsUnified = pathsUnified.sort(); + const filesSorted = []; + pathsUnified.forEach(key => { + filesSorted.push(temporaryIndex[key]); + }); + resultantFilesList = filesSorted; + } else { + resultantFilesList = files; + } + + resolve(resultantFilesList); + }); + }); +} +/** + * Returns file's hash. + * @param {string} file - file path + * @param {boolean} returnFileContents - include file contents in the resultant object + * @returns {Promise} + */ + + +function readAndGetFileHash(file, returnFileContents = false) { + return new Promise((resolve, reject) => { + _fs.default.readFile(file, (err, data) => { + if (err) { + reject(err); + return; + } + + const hash = _crypto.default.createHash('sha1'); + + hash.update(data); + const returnObject = { + hash: hash.digest('hex') + }; + + if (returnFileContents) { + returnObject.contents = data.toString('utf8'); + } + + resolve(returnObject); + }); + }); +} +/** + * Calculates a hash from objects values in specified order. + * @param {Array} orderOfKeys + * @param {Object} hashSet + * @param {Function} keyFilter + * @returns {string} + */ + + +function computeHashForHashesSet(orderOfKeys, hashSet, keyFilter = key => key) { + const hash = _crypto.default.createHash('sha1'); + + const hashesJoined = orderOfKeys.reduce( // eslint-disable-next-line no-param-reassign,no-return-assign + (tmpHash, key) => (tmpHash += hashSet[keyFilter(key)], tmpHash), ''); + hash.update(hashesJoined); + return hash.digest('hex'); +} +/** + * Reads files from disk and computes hashes for them. + * @param {Array} files - array with file paths + * @returns {Promise} + */ + + +function readAndHashFiles(files, fileFilter) { + const fileHashes = {}; + const fileContents = {}; + const promises = []; + + function readSingleFile(file) { + return new Promise((resolve, reject) => { + readAndGetFileHash(file, file.endsWith('.js') && !file.endsWith('.test.js')).then(result => { + let fileName = file; + + if (fileFilter) { + fileName = fileFilter(fileName); + } + + fileHashes[fileName] = result.hash; + + if (result.contents) { + fileContents[fileName] = result.contents; + } + + resolve(); + }).catch(reject); + }); + } + + files.forEach(file => { + promises.push(readSingleFile(file)); + }); + return new Promise((resolve, reject) => { + Promise.all(promises).then(() => { + resolve({ + files, + fileContents, + fileHashes + }); + }).catch(reject); + }); +} +/** + * Reads files from .desktop and computes a version hash. + * + * @param {string} dir - path + * @param {Function} fileFilter + * @returns {Promise} + */ + + +function readFilesAndComputeHash(dir, fileFilter) { + return new Promise((resolve, reject) => { + getFileList(dir, true).catch(reject).then(files => readAndHashFiles(files, fileFilter)).catch(reject).then(result => { + // eslint-disable-next-line no-param-reassign + result.hash = computeHashForHashesSet(result.files, result.fileHashes, fileFilter); + resolve(result); + }); + }); +} +/** + * Symlink exists + * @param {string} pathToCheck + * @returns {boolean} + */ + + +function symlinkExists(pathToCheck) { + try { + _fs.default.readlinkSync(pathToCheck); + + return true; + } catch (e) { + return false; + } +} + +var _default = { + getFileList, + rmWithRetries, + exists, + readDir, + readAndGetFileHash, + computeHashForHashesSet, + readAndHashFiles, + readFilesAndComputeHash, + symlinkExists +}; +exports.default = _default; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["exists","pathToCheck","fs","accessSync","e","rmWithRetries","args","retries","Promise","resolve","reject","rm","rmArgs","shell","config","fatal","reset","setTimeout","readDir","dir","callback","err","data","stats","list","allStats","readdir","files","pending","length","forEach","file","filePath","path","join","stat","_err","isDirectory","__err","res","_allStats","concat","Object","assign","push","size","dates","birthtime","getTime","ctime","mtime","getFileList","sort","error","resultantFilesList","stripLength","substr","pathsUnified","map","pth","replace","temporaryIndex","i","filesSorted","key","readAndGetFileHash","returnFileContents","readFile","hash","crypto","createHash","update","returnObject","digest","contents","toString","computeHashForHashesSet","orderOfKeys","hashSet","keyFilter","hashesJoined","reduce","tmpHash","readAndHashFiles","fileFilter","fileHashes","fileContents","promises","readSingleFile","endsWith","then","result","fileName","catch","all","readFilesAndComputeHash","symlinkExists","readlinkSync"],"sources":["../lib/utils.js"],"sourcesContent":["/* eslint-disable consistent-return */\nimport path from 'path';\nimport fs from 'fs';\nimport crypto from 'crypto';\nimport shell from 'shelljs';\n\n/**\n * Exists\n * @param {string} pathToCheck\n * @returns {boolean}\n */\nexport function exists(pathToCheck) {\n    try {\n        fs.accessSync(pathToCheck);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\n/**\n * Simple wrapper for shelljs.rm with additional retries in case of failure.\n * It is useful when something is concurrently reading the dir you want to remove.\n */\nexport function rmWithRetries(...args) {\n    let retries = 0;\n    return new Promise((resolve, reject) => {\n        function rm(...rmArgs) {\n            try {\n                shell.config.fatal = true;\n                shell.rm(...rmArgs);\n                shell.config.reset();\n                resolve();\n            } catch (e) {\n                retries += 1;\n                if (retries < 5) {\n                    setTimeout(() => {\n                        rm(...rmArgs);\n                    }, 100);\n                } else {\n                    shell.config.reset();\n                    reject(e);\n                }\n            }\n        }\n        rm(...args);\n    });\n}\n\nexport function readDir(dir, callback) {\n    if (!callback) {\n        return new Promise((resolve, reject) => {\n            readDir(dir, (err, data, stats) => {\n                if (err) {\n                    reject(err);\n                } else {\n                    resolve({ data, stats });\n                }\n            });\n        });\n    }\n    let list = [];\n    let allStats = {};\n\n    fs.readdir(dir, (err, files) => {\n        if (err) {\n            return callback(err);\n        }\n        let pending = files.length;\n        if (!pending) {\n            return callback(null, list, allStats);\n        }\n        files.forEach((file) => {\n            const filePath = path.join(dir, file);\n            fs.stat(filePath, (_err, stats) => {\n                if (_err) {\n                    return callback(_err);\n                }\n                if (stats.isDirectory()) {\n                    readDir(filePath, (__err, res, _allStats) => {\n                        if (__err) {\n                            return callback(__err);\n                        }\n                        list = list.concat(res);\n                        allStats = Object.assign(allStats, _allStats);\n                        pending -= 1;\n                        if (!pending) {\n                            return callback(null, list, allStats);\n                        }\n                    });\n                } else {\n                    list.push(filePath);\n                    allStats[filePath] = {\n                        size: stats.size,\n                        dates: [\n                            stats.birthtime.getTime(),\n                            stats.ctime.getTime(),\n                            stats.mtime.getTime()\n                        ]\n                    };\n                    pending -= 1;\n                    if (!pending) {\n                        return callback(null, list, allStats);\n                    }\n                }\n            });\n        });\n    });\n}\n\n/**\n * Returns a file list from a directory.\n * @param {string} dir - dir path\n * @param {boolean} sort - whether to apply sort\n * @returns {Promise<Array>}\n */\nexport function getFileList(dir, sort = false) {\n    return new Promise((resolve, reject) => {\n        readDir(dir, (error, files) => {\n            if (error) {\n                reject(error);\n                return;\n            }\n            // eslint-disable-next-line no-param-reassign\n            let resultantFilesList;\n\n            if (sort) {\n                const stripLength = (dir.substr(0, 2) === './') ? dir.length - 1 : dir.length + 1;\n                let pathsUnified = files.map((pth => pth.substr(stripLength).replace(/[\\\\/]/gm, '-')));\n                const temporaryIndex = {};\n                files.forEach((file, i) => {\n                    temporaryIndex[pathsUnified[i]] = file;\n                });\n                pathsUnified = pathsUnified.sort();\n                const filesSorted = [];\n                pathsUnified.forEach((key) => {\n                    filesSorted.push(temporaryIndex[key]);\n                });\n                resultantFilesList = filesSorted;\n            } else {\n                resultantFilesList = files;\n            }\n            resolve(resultantFilesList);\n        });\n    });\n}\n\n/**\n * Returns file's hash.\n * @param {string} file - file path\n * @param {boolean} returnFileContents - include file contents in the resultant object\n * @returns {Promise<Object>}\n */\nexport function readAndGetFileHash(file, returnFileContents = false) {\n    return new Promise((resolve, reject) => {\n        fs.readFile(file, (err, data) => {\n            if (err) {\n                reject(err);\n                return;\n            }\n            const hash = crypto.createHash('sha1');\n            hash.update(data);\n            const returnObject = { hash: hash.digest('hex') };\n            if (returnFileContents) {\n                returnObject.contents = data.toString('utf8');\n            }\n            resolve(returnObject);\n        });\n    });\n}\n\n/**\n * Calculates a hash from objects values in specified order.\n * @param {Array} orderOfKeys\n * @param {Object} hashSet\n * @param {Function} keyFilter\n * @returns {string}\n */\nexport function computeHashForHashesSet(orderOfKeys, hashSet, keyFilter = key => key) {\n    const hash = crypto.createHash('sha1');\n    const hashesJoined = orderOfKeys.reduce(\n        // eslint-disable-next-line no-param-reassign,no-return-assign\n        (tmpHash, key) => (tmpHash += hashSet[keyFilter(key)], tmpHash), ''\n    );\n    hash.update(hashesJoined);\n    return hash.digest('hex');\n}\n\n\n/**\n * Reads files from disk and computes hashes for them.\n * @param {Array} files - array with file paths\n * @returns {Promise<Object>}\n */\nexport function readAndHashFiles(files, fileFilter) {\n    const fileHashes = {};\n    const fileContents = {};\n    const promises = [];\n\n    function readSingleFile(file) {\n        return new Promise((resolve, reject) => {\n            readAndGetFileHash(file, file.endsWith('.js') && !file.endsWith('.test.js'))\n                .then((result) => {\n                    let fileName = file;\n                    if (fileFilter) {\n                        fileName = fileFilter(fileName);\n                    }\n                    fileHashes[fileName] = result.hash;\n                    if (result.contents) {\n                        fileContents[fileName] = result.contents;\n                    }\n                    resolve();\n                })\n                .catch(reject);\n        });\n    }\n\n    files.forEach((file) => {\n        promises.push(readSingleFile(file));\n    });\n\n    return new Promise((resolve, reject) => {\n        Promise.all(promises)\n            .then(() => {\n                resolve({ files, fileContents, fileHashes });\n            })\n            .catch(reject);\n    });\n}\n\n/**\n * Reads files from .desktop and computes a version hash.\n *\n * @param {string} dir - path\n * @param {Function} fileFilter\n * @returns {Promise<Object>}\n */\nexport function readFilesAndComputeHash(dir, fileFilter) {\n    return new Promise((resolve, reject) => {\n        getFileList(dir, true)\n            .catch(reject)\n            .then(files => readAndHashFiles(files, fileFilter))\n            .catch(reject)\n            .then((result) => {\n                // eslint-disable-next-line no-param-reassign\n                result.hash = computeHashForHashesSet(result.files, result.fileHashes, fileFilter);\n                resolve(result);\n            });\n    });\n}\n\n/**\n * Symlink exists\n * @param {string} pathToCheck\n * @returns {boolean}\n */\nexport function symlinkExists(pathToCheck) {\n    try {\n        fs.readlinkSync(pathToCheck);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\n\nexport default {\n    getFileList,\n    rmWithRetries,\n    exists,\n    readDir,\n    readAndGetFileHash,\n    computeHashForHashesSet,\n    readAndHashFiles,\n    readFilesAndComputeHash,\n    symlinkExists\n};\n"],"mappings":"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"} \ No newline at end of file diff --git a/lib/electronApp.js b/lib/electronApp.js index b46f084e..0e59d40e 100644 --- a/lib/electronApp.js +++ b/lib/electronApp.js @@ -1,6 +1,6 @@ // eslint-disable-next-line no-unused-vars import regeneratorRuntime from 'regenerator-runtime/runtime'; -import asar from 'asar'; +import asar from '@electron/asar'; import assignIn from 'lodash/assignIn'; import _ from 'lodash'; import { LocalInstaller, progress } from 'install-local'; @@ -70,8 +70,9 @@ export default class ElectronApp { this.log.debug('packing'); asar.createPackage( this.$.env.paths.electronApp.appRoot, - this.$.env.paths.electronApp.appAsar, - () => { + this.$.env.paths.electronApp.appAsar + ) + .then(() => { // Lets move the node_modules back. this.log.debug('moving node_modules back from app dir'); @@ -116,8 +117,7 @@ export default class ElectronApp { { force: true } ); resolve(); - } - ); + }); }); } @@ -621,8 +621,7 @@ export default class ElectronApp { undefined, this.$.env.paths.electronApp.root ) - ) - ); + )); } } await Promise.all(promises); @@ -812,8 +811,9 @@ export default class ElectronApp { return new Promise((resolve, reject) => { asar.createPackage( this.$.env.paths.desktopTmp.root, - this.$.env.paths.electronApp.desktopAsar, - () => { + this.$.env.paths.electronApp.desktopAsar + ) + .then(() => { this.log.verbose('clearing temporary .desktop'); this.$.utils .rmWithRetries('-rf', this.$.env.paths.desktopTmp.root) @@ -824,8 +824,7 @@ export default class ElectronApp { reject(e); }); resolve(); - } - ); + }); }); } diff --git a/lib/meteorApp.js b/lib/meteorApp.js index 1e6e04e5..1b133638 100644 --- a/lib/meteorApp.js +++ b/lib/meteorApp.js @@ -6,7 +6,7 @@ import semver from 'semver'; import shell from 'shelljs'; import path from 'path'; import singleLineLog from 'single-line-log'; -import asar from 'asar'; +import asar from '@electron/asar'; import fetch from 'node-fetch'; import IsDesktopInjector from '../skeleton/modules/autoupdate/isDesktopInjector'; @@ -892,8 +892,9 @@ export default class MeteorApp { return new Promise((resolve, reject) => asar.createPackage( this.$.env.paths.electronApp.meteorApp, - path.join(this.$.env.paths.electronApp.root, 'meteor.asar'), - () => { + path.join(this.$.env.paths.electronApp.root, 'meteor.asar') + ) + .then(() => { // On Windows some files might still be blocked. Giving a tick for them to be // ready for deletion. setImmediate(() => { @@ -907,8 +908,7 @@ export default class MeteorApp { reject(e); }); }); - } - )); + })); } /** diff --git a/package-lock.json b/package-lock.json index 270cde7a..2cb4d7f5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -14,12 +14,12 @@ } }, "@babel/cli": { - "version": "7.18.10", - "resolved": "https://registry.npmjs.org/@babel/cli/-/cli-7.18.10.tgz", - "integrity": "sha512-dLvWH+ZDFAkd2jPBSghrsFBuXrREvFwjpDycXbmUoeochqKYe4zNSLEJYErpLg8dvxvZYe79/MkN461XCwpnGw==", + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/cli/-/cli-7.21.0.tgz", + "integrity": "sha512-xi7CxyS8XjSyiwUGCfwf+brtJxjW1/ZTcBUkP10xawIEXLX5HzLn+3aXkgxozcP2UhRhtKTmQurw9Uaes7jZrA==", "dev": true, "requires": { - "@jridgewell/trace-mapping": "^0.3.8", + "@jridgewell/trace-mapping": "^0.3.17", "@nicolo-ribaudo/chokidar-2": "2.1.8-no-fsevents.3", "chokidar": "^3.4.0", "commander": "^4.0.1", @@ -30,6 +30,16 @@ "slash": "^2.0.0" }, "dependencies": { + "@jridgewell/trace-mapping": { + "version": "0.3.17", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz", + "integrity": "sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g==", + "dev": true, + "requires": { + "@jridgewell/resolve-uri": "3.1.0", + "@jridgewell/sourcemap-codec": "1.4.14" + } + }, "commander": { "version": "4.1.1", "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", @@ -227,9 +237,9 @@ "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==" }, "json5": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.1.tgz", - "integrity": "sha512-1hqLFMSrGHRHxav9q9gNjJ5EXznIxGVO09xQRrwplcS8qs28pZ8s8hupZAmqDwZUmVZ2Qb2jnyPOWcDH8m8dlA==" + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==" }, "ms": { "version": "2.1.2", @@ -2586,9 +2596,9 @@ } }, "@babel/register": { - "version": "7.18.9", - "resolved": "https://registry.npmjs.org/@babel/register/-/register-7.18.9.tgz", - "integrity": "sha512-ZlbnXDcNYHMR25ITwwNKT88JiaukkdVj/nG7r3wnuXkOTHc60Uy05PwMCPre0hSkY68E6zK3xz+vUJSP2jWmcw==", + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/register/-/register-7.21.0.tgz", + "integrity": "sha512-9nKsPmYDi5DidAqJaQooxIhsLJiNMkGr8ypQ8Uic7cIox7UCDsM7HuUGxdGT7mSDTYbqzIdsOWzfBton/YJrMw==", "dev": true, "requires": { "clone-deep": "^4.0.1", @@ -2668,6 +2678,48 @@ "to-fast-properties": "^2.0.0" } }, + "@electron/asar": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.2.3.tgz", + "integrity": "sha512-wmOfE6szYyqZhRIiLH+eyZEp+bGcJI0OD/SCvSUrfBE0jvauyGYO2ZhpWxmNCcDojKu5DYrsVqT5BOCZZ01XIg==", + "requires": { + "@types/glob": "^7.1.1", + "chromium-pickle-js": "^0.2.0", + "commander": "^5.0.0", + "glob": "^7.1.6", + "minimatch": "^3.0.4" + }, + "dependencies": { + "commander": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz", + "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==" + }, + "glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "dependencies": { + "minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "requires": { + "brace-expansion": "^1.1.7" + } + } + } + } + } + }, "@electron/get": { "version": "1.14.1", "resolved": "https://registry.npmjs.org/@electron/get/-/get-1.14.1.tgz", @@ -2926,6 +2978,37 @@ "dev": true, "optional": true }, + "@npmcli/fs": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.0.tgz", + "integrity": "sha512-7kZUAaLscfgbwBQRbvdMYaZOWyMEcPTH/tJjnyAWJ/dvvs9Ef+CERx/qJb9GExJpl1qipaDGn7KqHnFGGixd0w==", + "requires": { + "semver": "^7.3.5" + }, + "dependencies": { + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "requires": { + "yallist": "^4.0.0" + } + }, + "semver": { + "version": "7.3.8", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.8.tgz", + "integrity": "sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==", + "requires": { + "lru-cache": "^6.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, "@sindresorhus/is": { "version": "0.14.0", "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz", @@ -2953,6 +3036,16 @@ "@types/responselike": "*" } }, + "@types/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==", + "optional": true, + "requires": { + "@types/minimatch": "*", + "@types/node": "*" + } + }, "@types/http-cache-semantics": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.1.tgz", @@ -2980,11 +3073,38 @@ "@types/node": "*" } }, + "@types/linkify-it": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-3.0.2.tgz", + "integrity": "sha512-HZQYqbiFVWufzCwexrvh694SOim8z2d+xJl5UNamcvQFejLY/2YUtzXHYi3cHdI7PMlS8ejH2slRAOJQ32aNbA==", + "dev": true + }, + "@types/markdown-it": { + "version": "12.2.3", + "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-12.2.3.tgz", + "integrity": "sha512-GKMHFfv3458yYy+v/N8gjufHO6MSZKCOXpZc5GXIWWy8uldwfmPn98vp81gZ5f9SVw8YYBctgfJ22a2d7AOMeQ==", + "dev": true, + "requires": { + "@types/linkify-it": "*", + "@types/mdurl": "*" + } + }, + "@types/mdurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-1.0.2.tgz", + "integrity": "sha512-eC4U9MlIcu2q0KQmXszyn5Akca/0jrQmwDRgpAMJai7qBWq4amIQhZyNau4VYGtCeALvW1/NtjzJJ567aZxfKA==", + "dev": true + }, + "@types/minimatch": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz", + "integrity": "sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==", + "optional": true + }, "@types/node": { "version": "18.7.13", "resolved": "https://registry.npmjs.org/@types/node/-/node-18.7.13.tgz", - "integrity": "sha512-46yIhxSe5xEaJZXWdIBP7GU4HDTG8/eo0qd9atdiL+lFpA03y8KS+lkTN834TWJj5767GbWv4n/P6efyTFt1Dw==", - "dev": true + "integrity": "sha512-46yIhxSe5xEaJZXWdIBP7GU4HDTG8/eo0qd9atdiL+lFpA03y8KS+lkTN834TWJj5767GbWv4n/P6efyTFt1Dw==" }, "@types/puppeteer": { "version": "5.4.6", @@ -3161,15 +3281,16 @@ "@wdio/logger": "6.10.10" } }, - "abbrev": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", - "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==" - }, "acorn": { - "version": "5.7.3", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.3.tgz", - "integrity": "sha512-T/zvzYRfbVojPWahDsE5evJdHb3oJoQfFbsrKM7w5Zcs++Tr257tia3BmMP8XYVjp1S9RZXQMh7gao96BlqZOw==", + "version": "5.7.4", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.4.tgz", + "integrity": "sha512-1D++VG7BhrtvQpNbBzovKNc1FLGGEE/oGe7b9xJm/RFHMBeUaUGpluV9RLjZa47YFdPcDAenEYuq9pQPcMdLJg==", + "dev": true + }, + "acorn-dynamic-import": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-4.0.0.tgz", + "integrity": "sha512-d3OEjQV4ROpoflsnUA8HozoIR504TFxNivYEUi6uwz0IYhBkTDXGuWlNdMtybRt3nqVx/L6XqMt0FxkXuWKZhw==", "dev": true }, "acorn-jsx": { @@ -3195,6 +3316,15 @@ "integrity": "sha512-TMeqbNl2fMW0nMjTEPOwe3J/PRFP4vqeoNuQMG0HlMrtm5QxKqdvAkZ1pRBQ/ulIyDD5Yq0nJ7YbdD8ey0TO3g==", "dev": true }, + "aggregate-error": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", + "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "requires": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + } + }, "ajv": { "version": "5.5.2", "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz", @@ -3226,6 +3356,14 @@ "dev": true, "requires": { "array-back": "^3.0.1" + }, + "dependencies": { + "array-back": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz", + "integrity": "sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==", + "dev": true + } } }, "ansi-escapes": { @@ -3268,23 +3406,14 @@ "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==" }, "anymatch": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz", - "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==", + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", "dev": true, "optional": true, "requires": { "normalize-path": "^3.0.0", "picomatch": "^2.0.4" - }, - "dependencies": { - "normalize-path": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", - "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", - "dev": true, - "optional": true - } } }, "append-transform": { @@ -3296,11 +3425,6 @@ "default-require-extensions": "^2.0.0" } }, - "aproba": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz", - "integrity": "sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==" - }, "archiver": { "version": "5.3.1", "resolved": "https://registry.npmjs.org/archiver/-/archiver-5.3.1.tgz", @@ -3439,11 +3563,21 @@ "dev": true }, "array-back": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz", - "integrity": "sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-4.0.2.tgz", + "integrity": "sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==", "dev": true }, + "array-buffer-byte-length": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz", + "integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "is-array-buffer": "^3.0.1" + } + }, "array-differ": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/array-differ/-/array-differ-1.0.0.tgz", @@ -3728,35 +3862,11 @@ "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=" }, - "asar": { - "version": "0.14.3", - "resolved": "https://registry.npmjs.org/asar/-/asar-0.14.3.tgz", - "integrity": "sha512-+hNnVVDmYbv05We/a9knj/98w171+A94A9DNHj+3kXUr3ENTQoSEcfbJRvBBRHyOh4vukBYWujmHvvaMmQoQbg==", - "requires": { - "chromium-pickle-js": "^0.2.0", - "commander": "^2.9.0", - "cuint": "^0.2.1", - "glob": "^6.0.4", - "minimatch": "^3.0.3", - "mkdirp": "^0.5.0", - "mksnapshot": "^0.3.0", - "tmp": "0.0.28" - }, - "dependencies": { - "commander": { - "version": "2.9.0", - "resolved": "http://registry.npmjs.org/commander/-/commander-2.9.0.tgz", - "integrity": "sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q=", - "requires": { - "graceful-readlink": ">= 1.0.0" - } - } - } - }, "asn1": { "version": "0.2.4", "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz", "integrity": "sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==", + "dev": true, "requires": { "safer-buffer": "~2.1.0" } @@ -3764,7 +3874,8 @@ "assert-plus": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", - "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=", + "dev": true }, "assertion-error": { "version": "1.1.0", @@ -3787,7 +3898,8 @@ "asynckit": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", - "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=" + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=", + "dev": true }, "at-least-node": { "version": "1.0.0", @@ -3801,15 +3913,23 @@ "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==", "dev": true }, + "available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "dev": true + }, "aws-sign2": { "version": "0.7.0", "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", - "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=" + "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=", + "dev": true }, "aws4": { "version": "1.8.0", "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.8.0.tgz", - "integrity": "sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==" + "integrity": "sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==", + "dev": true }, "babel-code-frame": { "version": "6.26.0", @@ -4198,6 +4318,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", "integrity": "sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=", + "dev": true, "requires": { "tweetnacl": "^0.14.3" } @@ -4208,15 +4329,6 @@ "integrity": "sha1-5tXqjF2tABMEpwsiY4RH9pyy+Ak=", "dev": true }, - "binary": { - "version": "0.3.0", - "resolved": "https://registry.npmjs.org/binary/-/binary-0.3.0.tgz", - "integrity": "sha1-n2BVO8XOjDOG87VTz/R0Yq3sqnk=", - "requires": { - "buffers": "~0.1.1", - "chainsaw": "~0.1.0" - } - }, "binary-extensions": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", @@ -4272,7 +4384,8 @@ "bluebird": { "version": "3.7.2", "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz", - "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==" + "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==", + "dev": true }, "boolean": { "version": "3.2.0", @@ -4332,66 +4445,69 @@ "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.0.0.tgz", "integrity": "sha512-83apNb8KK0Se60UE1+4Ukbe3HbfELJ6UlI4ldtOGs7So4KD26orJM8hIY9lxdzP+UpItH1Yh/Y8GUvNFWFFRxA==" }, - "buffers": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/buffers/-/buffers-0.1.1.tgz", - "integrity": "sha1-skV5w77U1tOWru5tmorn9Ugqt7s=" - }, "cacache": { - "version": "10.0.4", - "resolved": "https://registry.npmjs.org/cacache/-/cacache-10.0.4.tgz", - "integrity": "sha512-Dph0MzuH+rTQzGPNT9fAnrPmMmjKfST6trxJeK7NQuHRaVw24VzPRWTmg9MpcwOVQZO0E1FBICUlFeNaKPIfHA==", - "requires": { - "bluebird": "^3.5.1", - "chownr": "^1.0.1", - "glob": "^7.1.2", - "graceful-fs": "^4.1.11", - "lru-cache": "^4.1.1", - "mississippi": "^2.0.0", - "mkdirp": "^0.5.1", - "move-concurrently": "^1.0.1", + "version": "17.0.5", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-17.0.5.tgz", + "integrity": "sha512-Y/PRQevNSsjAPWykl9aeGz8Pr+OI6BYM9fYDNMvOkuUiG9IhG4LEmaYrZZZvioMUEQ+cBCxT0v8wrnCURccyKA==", + "requires": { + "@npmcli/fs": "^3.1.0", + "fs-minipass": "^3.0.0", + "glob": "^9.3.1", + "lru-cache": "^7.7.1", + "minipass": "^4.0.0", + "minipass-collect": "^1.0.2", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "p-map": "^4.0.0", "promise-inflight": "^1.0.1", - "rimraf": "^2.6.2", - "ssri": "^5.2.4", - "unique-filename": "^1.1.0", - "y18n": "^4.0.0" + "ssri": "^10.0.0", + "tar": "^6.1.11", + "unique-filename": "^3.0.0" }, "dependencies": { + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "requires": { + "balanced-match": "^1.0.0" + } + }, "glob": { - "version": "7.1.2", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", - "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "version": "9.3.4", + "resolved": "https://registry.npmjs.org/glob/-/glob-9.3.4.tgz", + "integrity": "sha512-qaSc49hojMOv1EPM4EuyITjDSgSKI0rthoHnvE81tcOi1SCVndHko7auqxdQ14eiQG2NDBJBE86+2xIrbIvrbA==", "requires": { "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" + "minimatch": "^8.0.2", + "minipass": "^4.2.4", + "path-scurry": "^1.6.1" + } + }, + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + }, + "minimatch": { + "version": "8.0.3", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-8.0.3.tgz", + "integrity": "sha512-tEEvU9TkZgnFDCtpnrEYnPsjT7iUx42aXfs4bzmQ5sMA09/6hZY0jeZcGkXyDagiBOvkUjNo8Viom+Me6+2x7g==", + "requires": { + "brace-expansion": "^2.0.1" } } } }, "cache-point": { - "version": "0.4.1", - "resolved": "https://registry.npmjs.org/cache-point/-/cache-point-0.4.1.tgz", - "integrity": "sha512-4TgWfe9SF+bUy5cCql8gWHqKNrviufNwSYxLjf2utB0pY4+bdcuFwMmY1hDB+67Gz/L1vmhFNhePAjJTFBtV+Q==", + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/cache-point/-/cache-point-1.0.0.tgz", + "integrity": "sha512-ZqrZp9Hi5Uq7vfSGmNP2bUT/9DzZC2Y/GXjHB8rUJN1a+KLmbV05+vxHipNsg8+CSVgjcVVzLV8VZms6w8ZeRw==", "dev": true, "requires": { - "array-back": "^2.0.0", + "array-back": "^4.0.0", "fs-then-native": "^2.0.0", - "mkdirp2": "^1.0.3" - }, - "dependencies": { - "array-back": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/array-back/-/array-back-2.0.0.tgz", - "integrity": "sha512-eJv4pLLufP3g5kcZry0j6WXpIbzYw9GUB4mVJZno9wfwiBxbizTnHCw3VJb07cBihbFX48Y7oSrW9y+gt4glyw==", - "dev": true, - "requires": { - "typical": "^2.6.1" - } - } + "mkdirp2": "^1.0.4" } }, "cacheable-lookup": { @@ -4495,6 +4611,12 @@ "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=", "dev": true }, + "camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true + }, "caniuse-lite": { "version": "1.0.30001384", "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001384.tgz", @@ -4503,15 +4625,16 @@ "caseless": { "version": "0.12.0", "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", - "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=", + "dev": true }, "catharsis": { - "version": "0.8.11", - "resolved": "https://registry.npmjs.org/catharsis/-/catharsis-0.8.11.tgz", - "integrity": "sha512-a+xUyMV7hD1BrDQA/3iPV7oc+6W26BgVJO05PGEoatMyIuPScQKsde6i3YorWX1qs+AZjnJ18NqdKoCtKiNh1g==", + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/catharsis/-/catharsis-0.9.0.tgz", + "integrity": "sha512-prMTQVpcns/tzFgFVkVp6ak6RykZyWb3gu8ckUpd6YkTlacOd3DXGJjIpD4Q6zJirizvaiAjSSHlOsA+6sNh2A==", "dev": true, "requires": { - "lodash": "^4.17.14" + "lodash": "^4.17.15" } }, "chai": { @@ -4534,14 +4657,6 @@ "check-error": "^1.0.2" } }, - "chainsaw": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/chainsaw/-/chainsaw-0.1.0.tgz", - "integrity": "sha1-XqtQsor+WAdNDVgpE4iCi15fvJg=", - "requires": { - "traverse": ">=0.3.0 <0.4" - } - }, "chalk": { "version": "2.4.1", "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", @@ -4584,21 +4699,12 @@ "is-glob": "~4.0.1", "normalize-path": "~3.0.0", "readdirp": "~3.6.0" - }, - "dependencies": { - "normalize-path": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", - "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", - "dev": true, - "optional": true - } } }, "chownr": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.0.1.tgz", - "integrity": "sha1-4qdQQqlVGQi+vSW4Uj1fl2nXkYE=" + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==" }, "chrome-launcher": { "version": "0.13.4", @@ -4674,6 +4780,11 @@ "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==", "dev": true }, + "clean-stack": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", + "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==" + }, "cli-cursor": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz", @@ -4701,9 +4812,9 @@ }, "dependencies": { "ansi-regex": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", - "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz", + "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==", "dev": true }, "is-fullwidth-code-point": { @@ -4790,9 +4901,9 @@ } }, "collect-all": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/collect-all/-/collect-all-1.0.3.tgz", - "integrity": "sha512-0y0rBgoX8IzIjBAUnO73SEtSb4Mhk3IoceWJq5zZSxb9mWORhWH8xLYo4EDSOE1jRBk1LhmfjqWFFt10h/+MEA==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/collect-all/-/collect-all-1.0.4.tgz", + "integrity": "sha512-RKZhRwJtJEP5FWul+gkSMEnaK6H3AGPTTWOiRimCcs+rc/OmQE3Yhy1Q7A7KsdkG3ZXVdZq68Y6ONSdvkeEcKA==", "dev": true, "requires": { "stream-connect": "^1.0.2", @@ -4822,22 +4933,29 @@ "version": "1.0.8", "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dev": true, "requires": { "delayed-stream": "~1.0.0" } }, "command-line-args": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/command-line-args/-/command-line-args-5.1.1.tgz", - "integrity": "sha512-hL/eG8lrll1Qy1ezvkant+trihbGnaKaeEjj6Scyr3DN+RC7iQ5Rz84IeLERfAWDGo0HBSNAakczwgCilDXnWg==", + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/command-line-args/-/command-line-args-5.2.1.tgz", + "integrity": "sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==", "dev": true, "requires": { - "array-back": "^3.0.1", + "array-back": "^3.1.0", "find-replace": "^3.0.0", "lodash.camelcase": "^4.3.0", "typical": "^4.0.0" }, "dependencies": { + "array-back": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz", + "integrity": "sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==", + "dev": true + }, "typical": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/typical/-/typical-4.0.0.tgz", @@ -4894,14 +5012,14 @@ } }, "commander": { - "version": "2.17.1", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.17.1.tgz", - "integrity": "sha512-wPMUt6FnH2yzG95SA6mzjQOEKUU3aLaDEmzs1ti+1E9h+CsrZghRlqEM/EJ4KscsQVG8uNN4uVreUeT8+drlgg==" + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==" }, "common-sequence": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/common-sequence/-/common-sequence-2.0.0.tgz", - "integrity": "sha512-f0QqPLpRTgMQn/pQIynf+SdE73Lw5Q1jn4hjirHLgH/NJ71TiHjXusV16BmOyuK5rRQ1W2f++II+TFZbQOh4hA==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/common-sequence/-/common-sequence-2.0.2.tgz", + "integrity": "sha512-jAg09gkdkrDO9EWTdXfv80WWH3yeZl5oT69fGfedBNS9pXUKYInVJ1bJ+/ht2+Moeei48TmSbQDYMc8EOx9G0g==", "dev": true }, "commondir": { @@ -4977,6 +5095,7 @@ "version": "1.6.2", "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "dev": true, "requires": { "buffer-from": "^1.0.0", "inherits": "^2.0.3", @@ -4988,6 +5107,7 @@ "version": "2.3.6", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "dev": true, "requires": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", @@ -5002,6 +5122,7 @@ "version": "1.1.1", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, "requires": { "safe-buffer": "~5.1.0" } @@ -5022,7 +5143,7 @@ "config-master": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/config-master/-/config-master-3.1.0.tgz", - "integrity": "sha1-ZnZjWQUFooO/JqSE1oSJ10xUhdo=", + "integrity": "sha512-n7LBL1zBzYdTpF1mx5DNcZnZn05CWIdsdvtPL4MosvqbBUK3Rq6VWEtGUuF3Y0s9/CIhMejezqlSkP6TnCJ/9g==", "dev": true, "requires": { "walk-back": "^2.0.1" @@ -5031,7 +5152,7 @@ "walk-back": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/walk-back/-/walk-back-2.0.1.tgz", - "integrity": "sha1-VU4qnYdPrEeoywBr9EwvDEmYoKQ=", + "integrity": "sha512-Nb6GvBR8UWX1D+Le+xUq0+Q1kFmRBIWVrfLnQAOmcpEzA9oAxwJ9gIr36t9TWYfzvWRvuMtjHiVsJYEkXWaTAQ==", "dev": true } } @@ -5060,12 +5181,12 @@ } }, "connect-modrewrite": { - "version": "0.9.0", - "resolved": "https://registry.npmjs.org/connect-modrewrite/-/connect-modrewrite-0.9.0.tgz", - "integrity": "sha1-dHsqtlxEqlG3ah4sEWihkABjkBw=", + "version": "0.10.2", + "resolved": "https://registry.npmjs.org/connect-modrewrite/-/connect-modrewrite-0.10.2.tgz", + "integrity": "sha512-37+kS9t26vxjW5ErNrr8d04F7Us1EH7XhHtxSm8yE8kO2uDF2DsPI+qI2wCeBSaoakXKit0/88sg4vL2Wl8tDw==", "dev": true, "requires": { - "qs": "^1.2.2" + "qs": "^6.3.1" } }, "convert-source-map": { @@ -5074,19 +5195,6 @@ "integrity": "sha1-uCeAl7m8IpNl3lxiz1/K7YtVmeU=", "dev": true }, - "copy-concurrently": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/copy-concurrently/-/copy-concurrently-1.0.5.tgz", - "integrity": "sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==", - "requires": { - "aproba": "^1.1.1", - "fs-write-stream-atomic": "^1.0.8", - "iferr": "^0.1.5", - "mkdirp": "^0.5.1", - "rimraf": "^2.5.4", - "run-queue": "^1.0.0" - } - }, "core-js": { "version": "2.5.6", "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.5.6.tgz", @@ -5112,7 +5220,8 @@ "core-util-is": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", - "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=", + "dev": true }, "coveralls": { "version": "3.1.1", @@ -5251,21 +5360,23 @@ } }, "cross-env": { - "version": "3.1.4", - "resolved": "https://registry.npmjs.org/cross-env/-/cross-env-3.1.4.tgz", - "integrity": "sha1-Vui8qW8XkIpusbwgEsoSb5KEITA=", + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/cross-env/-/cross-env-3.2.4.tgz", + "integrity": "sha512-T8AFEAiuJ0w53ou6rnu3Fipaiu1W6ZO9GYfd33uxe1kAIiXM0fD8QnIm7orcJBOt7WQC5Ply63E7WZW/jSM+FA==", "dev": true, "requires": { - "cross-spawn": "^3.0.1" + "cross-spawn": "^5.1.0", + "is-windows": "^1.0.0" }, "dependencies": { "cross-spawn": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-3.0.1.tgz", - "integrity": "sha1-ElYDfsufDF9549bvE14wdwGEuYI=", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz", + "integrity": "sha512-pTgQJ5KC0d2hcY8eyL1IzlBPYjTkyH72XRZPnLyKus2mBfNjQs3klqbJU2VILqZryAZUt9JOb3h/mWMy23/f5A==", "dev": true, "requires": { "lru-cache": "^4.0.1", + "shebang-command": "^1.2.0", "which": "^1.2.9" } } @@ -5298,20 +5409,11 @@ "integrity": "sha512-FUV3xaJ63buRLgHrLQVlVgQnQdR4yqdLGaDu7g8CQcWjInDfM9plBTPI9FRfpahju1UBSaMckeb2/46ApS/V1Q==", "dev": true }, - "cuint": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/cuint/-/cuint-0.2.2.tgz", - "integrity": "sha512-d4ZVpCW31eWwCMe1YT3ur7mUDnTXbgwyzaL320DrcRT45rfjYxkt5QWLrmOJ+/UEAI2+fQgKe/fCjR8l4TpRgw==" - }, - "cyclist": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/cyclist/-/cyclist-0.2.2.tgz", - "integrity": "sha1-GzN5LhHpFKL9bW7WRHRkRE5fpkA=" - }, "dashdash": { "version": "1.14.1", "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "dev": true, "requires": { "assert-plus": "^1.0.0" } @@ -5334,7 +5436,7 @@ "decamelize": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", - "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=", + "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", "dev": true }, "decompress-response": { @@ -5346,20 +5448,6 @@ "mimic-response": "^1.0.0" } }, - "decompress-zip": { - "version": "0.3.2", - "resolved": "https://registry.npmjs.org/decompress-zip/-/decompress-zip-0.3.2.tgz", - "integrity": "sha512-Ab1QY4LrWMrUuo53lLnmGOby7v8ryqxJ+bKibKSiPisx+25mhut1dScVBXAYx14i/PqSrFZvR2FRRazhLbvL+g==", - "requires": { - "binary": "^0.3.0", - "graceful-fs": "^4.1.3", - "mkpath": "^0.1.0", - "nopt": "^3.0.1", - "q": "^1.1.2", - "readable-stream": "^1.1.8", - "touch": "0.0.3" - } - }, "deep-eql": { "version": "0.1.3", "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-0.1.3.tgz", @@ -5444,18 +5532,19 @@ "delayed-stream": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", - "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=", + "dev": true }, "depd": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", - "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", "dev": true }, "destroy": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz", - "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA=", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", "dev": true }, "detect-indent": { @@ -5543,57 +5632,10 @@ "walk-back": "^4.0.0" }, "dependencies": { - "array-back": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/array-back/-/array-back-4.0.1.tgz", - "integrity": "sha512-Z/JnaVEXv+A9xabHzN43FiiiWEE7gPCRXMrVmRm00tWbjZRul1iHm7ECzlyNq1p4a4ATXz+G9FJ3GqGOkOV3fg==", - "dev": true - }, - "cache-point": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/cache-point/-/cache-point-1.0.0.tgz", - "integrity": "sha512-ZqrZp9Hi5Uq7vfSGmNP2bUT/9DzZC2Y/GXjHB8rUJN1a+KLmbV05+vxHipNsg8+CSVgjcVVzLV8VZms6w8ZeRw==", - "dev": true, - "requires": { - "array-back": "^4.0.0", - "fs-then-native": "^2.0.0", - "mkdirp2": "^1.0.4" - } - }, - "file-set": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/file-set/-/file-set-3.0.0.tgz", - "integrity": "sha512-B/SdeSIeRv7VlOgIjtH3dkxMI+tEy5m+OeCXfAUsirBoVoY+bGtsmvmmTFPm/G23TBY4RiTtjpcgePCfwXRjqA==", - "dev": true, - "requires": { - "array-back": "^4.0.0", - "glob": "^7.1.5" - } - }, - "glob": { - "version": "7.1.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", - "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", - "dev": true, - "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - }, - "reduce-flatten": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/reduce-flatten/-/reduce-flatten-3.0.0.tgz", - "integrity": "sha512-eczl8wAYBxJ6Egl6I1ECIF+8z6sHu+KE7BzaEDZTpPXKXfy9SUDQlVYwkRcNTjJLC3Iakxbhss50KuT/R6SYfg==", - "dev": true - }, - "walk-back": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/walk-back/-/walk-back-4.0.0.tgz", - "integrity": "sha512-kudCA8PXVQfrqv2mFTG72vDBRi8BKWxGgFLwPpzHcpZnSwZk93WMwUDVcLHWNsnm+Y0AC4Vb6MUNRgaHfyV2DQ==", + "reduce-flatten": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/reduce-flatten/-/reduce-flatten-3.0.1.tgz", + "integrity": "sha512-bYo+97BmUUOzg09XwfkwALt4PQH1M5L0wzKerBt6WLm3Fhdd43mMS89HiT1B9pJIqko/6lWx3OnV4J9f2Kqp5Q==", "dev": true } } @@ -5622,45 +5664,11 @@ "integrity": "sha512-1A8za6ws41LQgv9HrE/66jyC5yuSjQ3L/KOpFtoBilsAK2iA2wuS5rTt1OCzIvtS2V7nVmedsUU+DGRcjBmOYA==", "dev": true }, - "duplexify": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.6.0.tgz", - "integrity": "sha512-fO3Di4tBKJpYTFHAxTU00BcfWMY9w24r/x21a6rZRbsD/ToUgGxsMbiGRmB7uVAXeGKXD9MwiLZa5E97EVgIRQ==", - "requires": { - "end-of-stream": "^1.0.0", - "inherits": "^2.0.1", - "readable-stream": "^2.0.0", - "stream-shift": "^1.0.0" - }, - "dependencies": { - "readable-stream": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", - "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - } - }, - "string_decoder": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", - "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", - "requires": { - "safe-buffer": "~5.1.0" - } - } - } - }, "ecc-jsbn": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", "integrity": "sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=", + "dev": true, "requires": { "jsbn": "~0.1.0", "safer-buffer": "^2.1.0" @@ -5724,6 +5732,7 @@ "version": "1.4.1", "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.1.tgz", "integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==", + "dev": true, "requires": { "once": "^1.4.0" } @@ -5738,9 +5747,9 @@ } }, "entities": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/entities/-/entities-1.1.2.tgz", - "integrity": "sha512-f2LZMYl1Fzu7YSBKg+RoROelpOaNrcGmE9AZubeDfrCEia483oW4MI4VyFd5VNHIgQ/7qm1I0wUHK1eJnn2y2w==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.1.0.tgz", + "integrity": "sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w==", "dev": true }, "env-paths": { @@ -5881,6 +5890,45 @@ } } }, + "es-set-tostringtag": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", + "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "dev": true, + "requires": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "has-tostringtag": "^1.0.0" + }, + "dependencies": { + "get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + } + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + } + } + }, + "es-shim-unscopables": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz", + "integrity": "sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==", + "dev": true, + "requires": { + "has": "^1.0.3" + } + }, "es-to-primitive": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", @@ -6046,13 +6094,14 @@ "dev": true }, "eslint-import-resolver-node": { - "version": "0.3.6", - "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.6.tgz", - "integrity": "sha512-0En0w03NRVMn9Uiyn8YRPDKvWjxCWkslUEhGNTdGx15RvPJYQ+lbOlqrlNI2vEAs4pDYK4f/HN2TbDmk5TP0iw==", + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.7.tgz", + "integrity": "sha512-gozW2blMLJCeFpBwugLTGyvVjNoeo1knonXAcatC6bjPBZitotxdWf7Gimr25N4c0AAOo4eOUfaG82IJPDpqCA==", "dev": true, "requires": { "debug": "^3.2.7", - "resolve": "^1.20.0" + "is-core-module": "^2.11.0", + "resolve": "^1.22.1" }, "dependencies": { "debug": { @@ -6065,9 +6114,9 @@ } }, "is-core-module": { - "version": "2.10.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.10.0.tgz", - "integrity": "sha512-Erxj2n/LDAZ7H8WNJXd9tw38GYM3dv8rk8Zcs+jJuxYTW7sozH+SS8NtrSjVL1/vpLvWi1hxy96IzjJ3EHTJJg==", + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", "dev": true, "requires": { "has": "^1.0.3" @@ -6143,33 +6192,173 @@ } }, "eslint-plugin-import": { - "version": "2.26.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.26.0.tgz", - "integrity": "sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA==", + "version": "2.27.5", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.27.5.tgz", + "integrity": "sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==", "dev": true, "requires": { - "array-includes": "^3.1.4", - "array.prototype.flat": "^1.2.5", - "debug": "^2.6.9", + "array-includes": "^3.1.6", + "array.prototype.flat": "^1.3.1", + "array.prototype.flatmap": "^1.3.1", + "debug": "^3.2.7", "doctrine": "^2.1.0", - "eslint-import-resolver-node": "^0.3.6", - "eslint-module-utils": "^2.7.3", + "eslint-import-resolver-node": "^0.3.7", + "eslint-module-utils": "^2.7.4", "has": "^1.0.3", - "is-core-module": "^2.8.1", + "is-core-module": "^2.11.0", "is-glob": "^4.0.3", "minimatch": "^3.1.2", - "object.values": "^1.1.5", - "resolve": "^1.22.0", + "object.values": "^1.1.6", + "resolve": "^1.22.1", + "semver": "^6.3.0", "tsconfig-paths": "^3.14.1" }, "dependencies": { + "array-includes": { + "version": "3.1.6", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.6.tgz", + "integrity": "sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "get-intrinsic": "^1.1.3", + "is-string": "^1.0.7" + } + }, + "array.prototype.flat": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz", + "integrity": "sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + } + }, + "array.prototype.flatmap": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.1.tgz", + "integrity": "sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-shim-unscopables": "^1.0.0" + } + }, "debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", "dev": true, "requires": { - "ms": "2.0.0" + "ms": "^2.1.1" + } + }, + "define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "dev": true, + "requires": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + } + }, + "es-abstract": { + "version": "1.21.2", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.2.tgz", + "integrity": "sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==", + "dev": true, + "requires": { + "array-buffer-byte-length": "^1.0.0", + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.2.0", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.5", + "is-array-buffer": "^3.0.2", + "is-callable": "^1.2.7", + "is-negative-zero": "^2.0.2", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "is-string": "^1.0.7", + "is-typed-array": "^1.1.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.3", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trim": "^1.2.7", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + } + }, + "get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + } + }, + "has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "dev": true + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + }, + "internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dev": true, + "requires": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + } + }, + "is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "dev": true + }, + "is-core-module": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", + "dev": true, + "requires": { + "has": "^1.0.3" } }, "is-glob": { @@ -6181,10 +6370,19 @@ "is-extglob": "^2.1.1" } }, + "is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2" + } + }, "json5": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz", - "integrity": "sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", + "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", "dev": true, "requires": { "minimist": "^1.2.0" @@ -6200,17 +6398,51 @@ } }, "minimist": { - "version": "1.2.6", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz", - "integrity": "sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==", + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true + }, + "ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + }, + "object-inspect": { + "version": "1.12.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", "dev": true }, + "object.values": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz", + "integrity": "sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, "path-parse": { "version": "1.0.7", "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "dev": true }, + "regexp.prototype.flags": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz", + "integrity": "sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "functions-have-names": "^1.2.2" + } + }, "resolve": { "version": "1.22.1", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz", @@ -6220,36 +6452,59 @@ "is-core-module": "^2.9.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" - }, - "dependencies": { - "is-core-module": { - "version": "2.10.0", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.10.0.tgz", - "integrity": "sha512-Erxj2n/LDAZ7H8WNJXd9tw38GYM3dv8rk8Zcs+jJuxYTW7sozH+SS8NtrSjVL1/vpLvWi1hxy96IzjJ3EHTJJg==", - "dev": true, - "requires": { - "has": "^1.0.3" - } - } } }, - "strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", "dev": true }, + "string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, "tsconfig-paths": { - "version": "3.14.1", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.1.tgz", - "integrity": "sha512-fxDhWnFSLt3VuTwtvJt5fpwxBHg5AdKWMsgcPOOIilyjymcYVZoCQF8fvFRezCNfblEXmi+PcM1eYHeOAgXCOQ==", + "version": "3.14.2", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.2.tgz", + "integrity": "sha512-o/9iXgCYc5L/JxCHPe3Hvh8Q/2xm5Z+p18PESBU6Ff33695QnCHBEjcytY2q19ua7Mbl/DavtBOLq+oG0RCL+g==", "dev": true, "requires": { "@types/json5": "^0.0.29", - "json5": "^1.0.1", + "json5": "^1.0.2", "minimist": "^1.2.6", "strip-bom": "^3.0.0" } + }, + "unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + } } } }, @@ -6453,7 +6708,8 @@ "extend": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", - "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==" + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "dev": true }, "external-editor": { "version": "2.2.0", @@ -6528,7 +6784,8 @@ "extsprintf": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", - "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" + "integrity": "sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==", + "dev": true }, "fancy-log": { "version": "1.3.3", @@ -6551,7 +6808,8 @@ "fast-json-stable-stringify": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", - "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=", + "dev": true }, "fast-levenshtein": { "version": "2.0.6", @@ -6588,37 +6846,37 @@ } }, "file-set": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/file-set/-/file-set-2.0.1.tgz", - "integrity": "sha512-XgOUUpgR6FbbfYcniLw0qm1Am7PnNYIAkd+eXxRt42LiYhjaso0WiuQ+VmrNdtwotyM+cLCfZ56AZrySP3QnKA==", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/file-set/-/file-set-3.0.0.tgz", + "integrity": "sha512-B/SdeSIeRv7VlOgIjtH3dkxMI+tEy5m+OeCXfAUsirBoVoY+bGtsmvmmTFPm/G23TBY4RiTtjpcgePCfwXRjqA==", "dev": true, "requires": { - "array-back": "^2.0.0", - "glob": "^7.1.3" + "array-back": "^4.0.0", + "glob": "^7.1.5" }, "dependencies": { - "array-back": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/array-back/-/array-back-2.0.0.tgz", - "integrity": "sha512-eJv4pLLufP3g5kcZry0j6WXpIbzYw9GUB4mVJZno9wfwiBxbizTnHCw3VJb07cBihbFX48Y7oSrW9y+gt4glyw==", - "dev": true, - "requires": { - "typical": "^2.6.1" - } - }, "glob": { - "version": "7.1.4", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.4.tgz", - "integrity": "sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==", + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", "dev": true, "requires": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", - "minimatch": "^3.0.4", + "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } + }, + "minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "requires": { + "brace-expansion": "^1.1.7" + } } } }, @@ -6749,6 +7007,14 @@ "dev": true, "requires": { "array-back": "^3.0.1" + }, + "dependencies": { + "array-back": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz", + "integrity": "sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==", + "dev": true + } } }, "find-up": { @@ -6778,37 +7044,13 @@ "integrity": "sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==", "dev": true }, - "flush-write-stream": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.0.3.tgz", - "integrity": "sha512-calZMC10u0FMUqoiunI2AiGIIUtUIvifNwkHhNupZH4cbNnW1Itkoh/Nf5HFYmDrwWPjrUxpkZT0KhuCq0jmGw==", + "for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dev": true, "requires": { - "inherits": "^2.0.1", - "readable-stream": "^2.0.4" - }, - "dependencies": { - "readable-stream": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", - "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - } - }, - "string_decoder": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", - "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", - "requires": { - "safe-buffer": "~5.1.0" - } - } + "is-callable": "^1.1.3" } }, "foreground-child": { @@ -6836,12 +7078,14 @@ "forever-agent": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", - "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=", + "dev": true }, "form-data": { "version": "2.3.3", "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz", "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==", + "dev": true, "requires": { "asynckit": "^0.4.0", "combined-stream": "^1.0.6", @@ -6863,39 +7107,6 @@ "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac=", "dev": true }, - "from2": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz", - "integrity": "sha512-OMcX/4IC/uqEPVgGeyfN22LJk6AZrMkRZHxcHBMBvHScDGgwTm2GT2Wkgtocyd3JfZffjj2kYUDXXII0Fk9W0g==", - "requires": { - "inherits": "^2.0.1", - "readable-stream": "^2.0.0" - }, - "dependencies": { - "readable-stream": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", - "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - } - }, - "string_decoder": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", - "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", - "requires": { - "safe-buffer": "~5.1.0" - } - } - } - }, "fs-constants": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", @@ -6903,20 +7114,20 @@ "dev": true }, "fs-extra": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-4.0.1.tgz", - "integrity": "sha1-f8DGyJV/mD9X8waiTlud3Y0N2IA=", + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-4.0.3.tgz", + "integrity": "sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==", "dev": true, "requires": { "graceful-fs": "^4.1.2", - "jsonfile": "^3.0.0", + "jsonfile": "^4.0.0", "universalify": "^0.1.0" }, "dependencies": { "jsonfile": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-3.0.1.tgz", - "integrity": "sha1-pezG9l9T9mLEQVx2daAzHQmS7GY=", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", "dev": true, "requires": { "graceful-fs": "^4.1.6" @@ -6924,28 +7135,30 @@ } } }, + "fs-minipass": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.1.tgz", + "integrity": "sha512-MhaJDcFRTuLidHrIttu0RDGyyXs/IYHVmlcxfLAEFIWjc1vdLAkdwT7Ace2u7DbitWC0toKMl5eJZRYNVreIMw==", + "requires": { + "minipass": "^4.0.0" + } + }, "fs-plus": { - "version": "2.9.3", - "resolved": "https://registry.npmjs.org/fs-plus/-/fs-plus-2.9.3.tgz", - "integrity": "sha1-debXxX5FNklVoc+/xWP8WCDgz/I=", + "version": "2.10.1", + "resolved": "https://registry.npmjs.org/fs-plus/-/fs-plus-2.10.1.tgz", + "integrity": "sha512-AaKbqqBM2p+Z5NSFhW/LU0sPD3cOnXwQ4kfM/JRX47ehwx+pxz0LuYYdpA/SeHV2i7lMQp+tA9OWBYBC/BYcfw==", "dev": true, "requires": { - "async": "~0.2.9", - "mkdirp": "~0.3.5", - "rimraf": "~2.2.2", + "async": "^1.5.2", + "mkdirp": "^0.5.1", + "rimraf": "^2.5.2", "underscore-plus": "1.x" }, "dependencies": { - "mkdirp": { - "version": "0.3.5", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.3.5.tgz", - "integrity": "sha1-3j5fiWHIjHh+4TaN+EmsRBPsqNc=", - "dev": true - }, - "rimraf": { - "version": "2.2.8", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.2.8.tgz", - "integrity": "sha1-5Dm+Kq7jJzIZUnMPmaiSnk/FBYI=", + "async": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w==", "dev": true } } @@ -6959,20 +7172,9 @@ "fs-then-native": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/fs-then-native/-/fs-then-native-2.0.0.tgz", - "integrity": "sha1-GaEk2U2QwiyOBF8ujdbr6jbUjGc=", + "integrity": "sha512-X712jAOaWXkemQCAmWeg5rOT2i+KOpWz1Z/txk/cW0qlOu2oQ9H61vc5w3X/iyuUEfq/OyaFJ78/cZAQD1/bgA==", "dev": true }, - "fs-write-stream-atomic": { - "version": "1.0.10", - "resolved": "https://registry.npmjs.org/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz", - "integrity": "sha512-gehEzmPn2nAwr39eay+x3X34Ra+M2QlVUTLhkXPjWdeO8RF9kszk116avgBJM3ZyNHgHXBNx+VmPaFC36k0PzA==", - "requires": { - "graceful-fs": "^4.1.2", - "iferr": "^0.1.5", - "imurmurhash": "^0.1.4", - "readable-stream": "1 || 2" - } - }, "fs.realpath": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", @@ -7083,22 +7285,11 @@ "version": "0.1.7", "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "dev": true, "requires": { "assert-plus": "^1.0.0" } }, - "glob": { - "version": "6.0.4", - "resolved": "https://registry.npmjs.org/glob/-/glob-6.0.4.tgz", - "integrity": "sha512-MKZeRNyYZAVVVG1oZeLaWie1uweH40m9AZwIwxyPbTSX4hHrVYSzLg0Ro5Z5R7XKkIX+Cc6oD1rqeDJnwsB8/A==", - "requires": { - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "2 || 3", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - }, "glob-parent": { "version": "5.1.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", @@ -7176,7 +7367,6 @@ "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", "dev": true, - "optional": true, "requires": { "define-properties": "^1.1.3" } @@ -7218,6 +7408,34 @@ "sparkles": "^1.0.0" } }, + "gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dev": true, + "requires": { + "get-intrinsic": "^1.1.3" + }, + "dependencies": { + "get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + } + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + } + } + }, "got": { "version": "9.6.0", "resolved": "https://registry.npmjs.org/got/-/got-9.6.0.tgz", @@ -7240,12 +7458,8 @@ "graceful-fs": { "version": "4.2.9", "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.9.tgz", - "integrity": "sha512-NtNxqUcXgpW2iMrfqSfR73Glt39K+BLwWsPs94yR63v45T0Wbej7eRmL5cWfwEgqXnmjQp3zaJTshdRW/qC2ZQ==" - }, - "graceful-readlink": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz", - "integrity": "sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=" + "integrity": "sha512-NtNxqUcXgpW2iMrfqSfR73Glt39K+BLwWsPs94yR63v45T0Wbej7eRmL5cWfwEgqXnmjQp3zaJTshdRW/qC2ZQ==", + "dev": true }, "grapheme-splitter": { "version": "1.0.4", @@ -7334,17 +7548,24 @@ } }, "handlebars": { - "version": "4.7.2", - "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.2.tgz", - "integrity": "sha512-4PwqDL2laXtTWZghzzCtunQUTLbo31pcCJrd/B/9JP8XbhVzpS5ZXuKqlOzsd1rtcaLo4KqAn8nl8mkknS4MHw==", + "version": "4.7.7", + "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.7.tgz", + "integrity": "sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==", "dev": true, "requires": { + "minimist": "^1.2.5", "neo-async": "^2.6.0", - "optimist": "^0.6.1", "source-map": "^0.6.1", - "uglify-js": "^3.1.4" + "uglify-js": "^3.1.4", + "wordwrap": "^1.0.0" }, "dependencies": { + "minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true + }, "source-map": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", @@ -7356,12 +7577,14 @@ "har-schema": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", - "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=" + "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=", + "dev": true }, "har-validator": { "version": "5.1.3", "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.3.tgz", "integrity": "sha512-sNvOCzEQNr/qrvJgc3UG/kD4QtlHycrzwS+6mfTrrSq97BvaYcPZZI1ZSqGSPR73Cxn4LKTD4PttRwfU7jWq5g==", + "dev": true, "requires": { "ajv": "^6.5.5", "har-schema": "^2.0.0" @@ -7371,6 +7594,7 @@ "version": "6.10.2", "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.10.2.tgz", "integrity": "sha512-TXtUUEYHuaTEbLZWIKUr5pmBuhDLy+8KYtPYdcV8qC+pOZL+NKqYwvWSRrVXHn+ZmRRAu8vJTAznH7Oag6RVRw==", + "dev": true, "requires": { "fast-deep-equal": "^2.0.1", "fast-json-stable-stringify": "^2.0.0", @@ -7381,12 +7605,14 @@ "fast-deep-equal": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz", - "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=" + "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=", + "dev": true }, "json-schema-traverse": { "version": "0.4.1", "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", - "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==" + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true } } }, @@ -7435,6 +7661,12 @@ "get-intrinsic": "^1.1.1" } }, + "has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "dev": true + }, "has-symbols": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz", @@ -7468,33 +7700,40 @@ } }, "hosted-git-info": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.7.1.tgz", - "integrity": "sha512-7T/BxH19zbcCTa8XkMlbK5lTo1WtgkFi3GvdWEyNuc4Vex7/9Dqbnpsf4JMydcfj9HCg4zUWFTL3Za6lapg5/w==", + "version": "2.8.9", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz", + "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==", "dev": true }, "http-cache-semantics": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz", - "integrity": "sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz", + "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==", "dev": true }, "http-errors": { - "version": "1.6.3", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", - "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", "dev": true, "requires": { - "depd": "~1.1.2", - "inherits": "2.0.3", - "setprototypeof": "1.1.0", - "statuses": ">= 1.4.0 < 2" + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" }, "dependencies": { + "inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, "statuses": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", - "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", "dev": true } } @@ -7503,6 +7742,7 @@ "version": "1.2.0", "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", + "dev": true, "requires": { "assert-plus": "^1.0.0", "jsprim": "^1.2.2", @@ -7561,11 +7801,6 @@ "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", "dev": true }, - "iferr": { - "version": "0.1.5", - "resolved": "https://registry.npmjs.org/iferr/-/iferr-0.1.5.tgz", - "integrity": "sha512-DUNFN5j7Tln0D+TxzloUjKB+CtVu6myn0JEFak6dG18mNt9YkQ6lzGCdafwofISZ1lLF3xRHJ98VKy9ynkcFaA==" - }, "ignore": { "version": "3.3.10", "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.10.tgz", @@ -7604,6 +7839,11 @@ "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=" }, + "indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==" + }, "inflight": { "version": "1.0.6", "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", @@ -7681,9 +7921,9 @@ } }, "install-local": { - "version": "0.6.0", - "resolved": "https://registry.npmjs.org/install-local/-/install-local-0.6.0.tgz", - "integrity": "sha512-O30KcOgAOhreY8TnK8XETXcf6t4V1iXtditIEL6mHueUCA6e+ILVjboieiTYXt615rTP1KllYgqtE0ux7mvp2g==", + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/install-local/-/install-local-0.6.2.tgz", + "integrity": "sha512-jjBHRVO+Yu0mzJZeQ2w5/cvoekmD7T4TN5oB/pVSP8WfbG0rUKOGUdntQcJKuScqdnSgR26IjvZDLkCQJZlU7g==", "requires": { "lodash": "^4.17.10", "mz": "^2.7.0", @@ -7716,6 +7956,36 @@ "loose-envify": "^1.0.0" } }, + "is-array-buffer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", + "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "is-typed-array": "^1.1.10" + }, + "dependencies": { + "get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + } + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + } + } + }, "is-arrayish": { "version": "0.2.1", "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", @@ -7838,9 +8108,9 @@ } }, "is-object": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-object/-/is-object-1.0.1.tgz", - "integrity": "sha1-iVJojF7C/9awPsyF52ngKQMINHA=", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-object/-/is-object-1.0.2.tgz", + "integrity": "sha512-2rRIahhZr2UWb45fIOuvZGpFtz0TyOZLf32KxBbSoUCeZR495zCKlWUKKUByk3geS2eAs7ZAABt0Y/Rx0GiQGA==", "dev": true }, "is-path-cwd": { @@ -7925,10 +8195,24 @@ "has-symbols": "^1.0.0" } }, + "is-typed-array": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz", + "integrity": "sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==", + "dev": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + } + }, "is-typedarray": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", - "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=", + "dev": true }, "is-weakref": { "version": "1.0.2", @@ -7939,6 +8223,12 @@ "call-bind": "^1.0.2" } }, + "is-windows": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", + "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", + "dev": true + }, "is-wsl": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz", @@ -7951,7 +8241,8 @@ "isarray": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", - "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true }, "isbinaryfile": { "version": "3.0.3", @@ -7996,7 +8287,8 @@ "isstream": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", - "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=", + "dev": true }, "istanbul-lib-coverage": { "version": "2.0.5", @@ -8179,41 +8471,49 @@ } }, "js2xmlparser": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/js2xmlparser/-/js2xmlparser-4.0.0.tgz", - "integrity": "sha512-WuNgdZOXVmBk5kUPMcTcVUpbGRzLfNkv7+7APq7WiDihpXVKrgxo6wwRpRl9OQeEBgKCVk9mR7RbzrnNWC8oBw==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/js2xmlparser/-/js2xmlparser-4.0.2.tgz", + "integrity": "sha512-6n4D8gLlLf1n5mNLQPRfViYzu9RATblzPEtm1SthMX1Pjao0r9YI9nw7ZIfRxQMERS87mcswrg+r/OYrPRX6jA==", "dev": true, "requires": { - "xmlcreate": "^2.0.0" + "xmlcreate": "^2.0.4" } }, "jsbn": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", - "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=" + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", + "dev": true }, "jsdoc": { - "version": "3.6.3", - "resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-3.6.3.tgz", - "integrity": "sha512-Yf1ZKA3r9nvtMWHO1kEuMZTlHOF8uoQ0vyo5eH7SQy5YeIiHM+B0DgKnn+X6y6KDYZcF7G2SPkKF+JORCXWE/A==", + "version": "3.6.11", + "resolved": "https://registry.npmjs.org/jsdoc/-/jsdoc-3.6.11.tgz", + "integrity": "sha512-8UCU0TYeIYD9KeLzEcAu2q8N/mx9O3phAGl32nmHlE0LpaJL71mMkP4d+QE5zWfNt50qheHtOZ0qoxVrsX5TUg==", "dev": true, "requires": { - "@babel/parser": "^7.4.4", - "bluebird": "^3.5.4", - "catharsis": "^0.8.11", + "@babel/parser": "^7.9.4", + "@types/markdown-it": "^12.2.3", + "bluebird": "^3.7.2", + "catharsis": "^0.9.0", "escape-string-regexp": "^2.0.0", - "js2xmlparser": "^4.0.0", + "js2xmlparser": "^4.0.2", "klaw": "^3.0.0", - "markdown-it": "^8.4.2", - "markdown-it-anchor": "^5.0.2", - "marked": "^0.7.0", - "mkdirp": "^0.5.1", + "markdown-it": "^12.3.2", + "markdown-it-anchor": "^8.4.1", + "marked": "^4.0.10", + "mkdirp": "^1.0.4", "requizzle": "^0.2.3", - "strip-json-comments": "^3.0.1", + "strip-json-comments": "^3.1.0", "taffydb": "2.6.2", - "underscore": "~1.9.1" + "underscore": "~1.13.2" }, "dependencies": { + "@babel/parser": { + "version": "7.21.4", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.21.4.tgz", + "integrity": "sha512-alVJj7k7zIxqBZ7BTRhz0IqJFxW1VJbm6N8JbcYhQ186df9ZBPbZBmWSqAMXwHGsCJdYks7z/voa3ibiS5bCIw==", + "dev": true + }, "escape-string-regexp": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", @@ -8230,74 +8530,121 @@ } }, "marked": { - "version": "0.7.0", - "resolved": "https://registry.npmjs.org/marked/-/marked-0.7.0.tgz", - "integrity": "sha512-c+yYdCZJQrsRjTPhUx7VKkApw9bwDkNbHUKo1ovgcfDjb2kc8rLuRbIFyXL5WOEUwzSSKo3IXpph2K6DqB/KZg==", + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/marked/-/marked-4.3.0.tgz", + "integrity": "sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==", + "dev": true + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", "dev": true }, "strip-json-comments": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.0.1.tgz", - "integrity": "sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", "dev": true } } }, "jsdoc-api": { - "version": "5.0.2", - "resolved": "https://registry.npmjs.org/jsdoc-api/-/jsdoc-api-5.0.2.tgz", - "integrity": "sha512-nC5uvd907gbqTRinrHeX5EBNw2Yc/0/7qONbRu5R5wrq/1OaRHtqDWGLDu+6BFI6RyuEgp87IH/IdOz4CdN6RA==", + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/jsdoc-api/-/jsdoc-api-5.0.4.tgz", + "integrity": "sha512-1KMwLnfo0FyhF06TQKzqIm8BiY1yoMIGICxRdJHUjzskaHMzHMmpLlmNFgzoa4pAC8t1CDPK5jWuQTvv1pBsEQ==", "dev": true, "requires": { - "array-back": "^3.1.0", - "cache-point": "^0.4.1", + "array-back": "^4.0.0", + "cache-point": "^1.0.0", "collect-all": "^1.0.3", "file-set": "^2.0.1", "fs-then-native": "^2.0.0", - "jsdoc": "^3.6.2", + "jsdoc": "^3.6.3", "object-to-spawn-args": "^1.1.1", "temp-path": "^1.0.0", "walk-back": "^3.0.1" + }, + "dependencies": { + "file-set": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/file-set/-/file-set-2.0.1.tgz", + "integrity": "sha512-XgOUUpgR6FbbfYcniLw0qm1Am7PnNYIAkd+eXxRt42LiYhjaso0WiuQ+VmrNdtwotyM+cLCfZ56AZrySP3QnKA==", + "dev": true, + "requires": { + "array-back": "^2.0.0", + "glob": "^7.1.3" + }, + "dependencies": { + "array-back": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-2.0.0.tgz", + "integrity": "sha512-eJv4pLLufP3g5kcZry0j6WXpIbzYw9GUB4mVJZno9wfwiBxbizTnHCw3VJb07cBihbFX48Y7oSrW9y+gt4glyw==", + "dev": true, + "requires": { + "typical": "^2.6.1" + } + } + } + }, + "glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "walk-back": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/walk-back/-/walk-back-3.0.1.tgz", + "integrity": "sha512-umiNB2qLO731Sxbp6cfZ9pwURJzTnftxE4Gc7hq8n/ehkuXC//s9F65IEIJA2ZytQZ1ZOsm/Fju4IWx0bivkUQ==", + "dev": true + } } }, "jsdoc-parse": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/jsdoc-parse/-/jsdoc-parse-3.0.1.tgz", - "integrity": "sha512-btZLp4wYl90vcAfgk4hoGQbO17iBVrhh3LJRMKZNtZgniO3F8H2CjxXld0owBIB1XxN+j3bAcWZnZKMnSj3iMA==", + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/jsdoc-parse/-/jsdoc-parse-4.0.1.tgz", + "integrity": "sha512-qIObw8yqYZjrP2qxWROB5eLQFLTUX2jRGLhW9hjo2CC2fQVlskidCIzjCoctwsDvauBp2a/lR31jkSleczSo8Q==", "dev": true, "requires": { - "array-back": "^2.0.0", + "array-back": "^4.0.0", "lodash.omit": "^4.5.0", "lodash.pick": "^4.4.0", "reduce-extract": "^1.0.0", "sort-array": "^2.0.0", "test-value": "^3.0.0" - }, - "dependencies": { - "array-back": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/array-back/-/array-back-2.0.0.tgz", - "integrity": "sha512-eJv4pLLufP3g5kcZry0j6WXpIbzYw9GUB4mVJZno9wfwiBxbizTnHCw3VJb07cBihbFX48Y7oSrW9y+gt4glyw==", - "dev": true, - "requires": { - "typical": "^2.6.1" - } - } } }, "jsdoc-to-markdown": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/jsdoc-to-markdown/-/jsdoc-to-markdown-5.0.0.tgz", - "integrity": "sha512-3gKEnbay7dSdyvtMDDkUf4r7pmBVgs3aqeT0Cg/ngTILPpJUzf8iKgASIo5psF007L45OIJtIuRX5VL/YUXKaA==", + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/jsdoc-to-markdown/-/jsdoc-to-markdown-5.0.3.tgz", + "integrity": "sha512-tQv5tBV0fTYidRQtE60lJKxE98mmuLcYuITFDKQiDPE9hGccpeEGUNFcVkInq1vigyuPnZmt79bQ8wv2GKjY0Q==", "dev": true, "requires": { - "array-back": "^3.1.0", + "array-back": "^4.0.1", "command-line-tool": "^0.8.0", "config-master": "^3.1.0", - "dmd": "^4.0.0", - "jsdoc-api": "^5.0.1", - "jsdoc-parse": "^3.0.1", - "walk-back": "^3.0.1" + "dmd": "^4.0.5", + "jsdoc-api": "^5.0.4", + "jsdoc-parse": "^4.0.1", + "walk-back": "^4.0.0" } }, "jsesc": { @@ -8318,9 +8665,10 @@ "dev": true }, "json-schema": { - "version": "0.2.3", - "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", - "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=" + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", + "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==", + "dev": true }, "json-schema-traverse": { "version": "0.3.1", @@ -8337,7 +8685,8 @@ "json-stringify-safe": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", - "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=", + "dev": true }, "json5": { "version": "0.5.1", @@ -8345,22 +8694,15 @@ "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=", "dev": true }, - "jsonfile": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz", - "integrity": "sha1-NzaitCi4e72gzIO1P6PWM6NcKug=", - "requires": { - "graceful-fs": "^4.1.6" - } - }, "jsprim": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz", - "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=", + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz", + "integrity": "sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==", + "dev": true, "requires": { "assert-plus": "1.0.0", "extsprintf": "1.3.0", - "json-schema": "0.2.3", + "json-schema": "0.4.0", "verror": "1.10.0" } }, @@ -8409,14 +8751,6 @@ "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", "dev": true }, - "klaw": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz", - "integrity": "sha1-QIhDO0azsbolnXh4XY6W9zugJDk=", - "requires": { - "graceful-fs": "^4.1.9" - } - }, "lazystream": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz", @@ -8490,9 +8824,9 @@ } }, "linkify-it": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-2.2.0.tgz", - "integrity": "sha512-GnAl/knGn+i1U/wjBz3akz2stz+HrHLsxMwHQGofCDfPvlf+gDKN58UtfmUquTY4/MXeE2x7k19KQmeoZi94Iw==", + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-3.0.3.tgz", + "integrity": "sha512-ynTsyrFSdE5oZ/O9GEf00kPngmOfVwazR5GKDq6EYfhlpFug3J2zybX56a2PRRpc9P+FuSoGNAwjlbDs9jJBPQ==", "dev": true, "requires": { "uc.micro": "^1.0.1" @@ -8570,7 +8904,7 @@ "lodash.camelcase": { "version": "4.3.0", "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", - "integrity": "sha1-soqmKIorn8ZRA1x3EfZathkDMaY=", + "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==", "dev": true }, "lodash.clonedeep": { @@ -8661,19 +8995,19 @@ "lodash.omit": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/lodash.omit/-/lodash.omit-4.5.0.tgz", - "integrity": "sha1-brGa5aHuHdnfC5aeZs4Lf6MLXmA=", + "integrity": "sha512-XeqSp49hNGmlkj2EJlfrQFIzQ6lXdNro9sddtQzcJY8QaoC2GO0DT7xaIokHeyM+mIT0mPMlPvkYzg2xCuHdZg==", "dev": true }, "lodash.padend": { "version": "4.6.1", "resolved": "https://registry.npmjs.org/lodash.padend/-/lodash.padend-4.6.1.tgz", - "integrity": "sha1-U8y6BH0G4VjTEfRdpiX05J5vFm4=", + "integrity": "sha512-sOQs2aqGpbl27tmCS1QNZA09Uqp01ZzWfDUoD+xzTii0E7dSQfRKcRetFwa+uXaxaqL+TKm7CgD2JdKP7aZBSw==", "dev": true }, "lodash.pick": { "version": "4.4.0", "resolved": "https://registry.npmjs.org/lodash.pick/-/lodash.pick-4.4.0.tgz", - "integrity": "sha1-UvBWEP/53tQiYRRB7R/BI6AwAbM=", + "integrity": "sha512-hXt6Ul/5yWjfklSGvLQl8vM//l3FtyHZeuelpzK6mm99pNvN9yTDruNZPEJZD1oWrqo+izBmB7oUfWgcCX7s4Q==", "dev": true }, "lodash.restparam": { @@ -8775,6 +9109,15 @@ "yallist": "^2.1.2" } }, + "magic-string": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.25.9.tgz", + "integrity": "sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==", + "dev": true, + "requires": { + "sourcemap-codec": "^1.4.8" + } + }, "make-dir": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz", @@ -8800,22 +9143,30 @@ } }, "markdown-it": { - "version": "8.4.2", - "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-8.4.2.tgz", - "integrity": "sha512-GcRz3AWTqSUphY3vsUqQSFMbgR38a4Lh3GWlHRh/7MRwz8mcu9n2IO7HOh+bXHrR9kOPDl5RNCaEsrneb+xhHQ==", + "version": "12.3.2", + "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-12.3.2.tgz", + "integrity": "sha512-TchMembfxfNVpHkbtriWltGWc+m3xszaRD0CZup7GFFhzIgQqxIfn3eGj1yZpfuflzPvfkt611B2Q/Bsk1YnGg==", "dev": true, "requires": { - "argparse": "^1.0.7", - "entities": "~1.1.1", - "linkify-it": "^2.0.0", + "argparse": "^2.0.1", + "entities": "~2.1.0", + "linkify-it": "^3.0.1", "mdurl": "^1.0.1", "uc.micro": "^1.0.5" + }, + "dependencies": { + "argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + } } }, "markdown-it-anchor": { - "version": "5.2.4", - "resolved": "https://registry.npmjs.org/markdown-it-anchor/-/markdown-it-anchor-5.2.4.tgz", - "integrity": "sha512-n8zCGjxA3T+Mx1pG8HEgbJbkB8JFUuRkeTZQuIM8iPY6oQ8sWOPRZJDFC9a/pNg2QkHEjjGkhBEl/RSyzaDZ3A==", + "version": "8.6.7", + "resolved": "https://registry.npmjs.org/markdown-it-anchor/-/markdown-it-anchor-8.6.7.tgz", + "integrity": "sha512-FlCHFwNnutLgVTflOYHPW2pPcl2AACqVzExlkGQNsi4CJgqOHN7YTgDd4LuhgN1BFO3TS0vLAruV1Td6dwWPJA==", "dev": true }, "marked": { @@ -8862,7 +9213,7 @@ "mdurl": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz", - "integrity": "sha1-/oWy7HWlkDfyrf7BAP1sYBdhFS4=", + "integrity": "sha512-/sKlQJCBYVY9Ers9hqzKou4H6V5UWc/M59TH2dvkt+84itfnq7uFOMLpOiOS4ujvHP4etln18fmIxA5R5fll0g==", "dev": true }, "memorystream": { @@ -8901,20 +9252,22 @@ } }, "mime": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/mime/-/mime-2.0.3.tgz", - "integrity": "sha512-TrpAd/vX3xaLPDgVRm6JkZwLR0KHfukMdU2wTEbqMDdCnY6Yo3mE+mjs9YE6oMNw2QRfXVeBEYpmpO94BIqiug==", + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz", + "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==", "dev": true }, "mime-db": { "version": "1.40.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.40.0.tgz", - "integrity": "sha512-jYdeOMPy9vnxEqFRRo6ZvTZ8d9oPb+k18PKoYNYUe2stVEBPPwsln/qWzdbmaIvnhZ9v2P+CuecK+fpUfsV2mA==" + "integrity": "sha512-jYdeOMPy9vnxEqFRRo6ZvTZ8d9oPb+k18PKoYNYUe2stVEBPPwsln/qWzdbmaIvnhZ9v2P+CuecK+fpUfsV2mA==", + "dev": true }, "mime-types": { "version": "2.1.24", "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.24.tgz", "integrity": "sha512-WaFHS3MCl5fapm3oLxU4eYDw77IQM2ACcxQ9RIxfaC3ooc6PFuBMGZZsYpvoXS5D5QTWPieo1jjLdAm3TBP3cQ==", + "dev": true, "requires": { "mime-db": "1.40.0" } @@ -8932,9 +9285,9 @@ "dev": true }, "minimatch": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", - "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "requires": { "brace-expansion": "^1.1.7" } @@ -8942,31 +9295,122 @@ "minimist": { "version": "0.0.8", "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", - "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=", + "dev": true }, - "mississippi": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/mississippi/-/mississippi-2.0.0.tgz", - "integrity": "sha512-zHo8v+otD1J10j/tC+VNoGK9keCuByhKovAvdn74dmxJl9+mWHnx6EMsDN4lgRoMI/eYo2nchAxniIbUPb5onw==", + "minipass": { + "version": "4.2.5", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-4.2.5.tgz", + "integrity": "sha512-+yQl7SX3bIT83Lhb4BVorMAHVuqsskxRdlmO9kTpyukp8vsm2Sn/fUOV9xlnG8/a5JsypJzap21lz/y3FBMJ8Q==" + }, + "minipass-collect": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-1.0.2.tgz", + "integrity": "sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "minipass-flush": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.5.tgz", + "integrity": "sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "minipass-pipeline": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", + "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, + "minizlib": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", + "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", "requires": { - "concat-stream": "^1.5.0", - "duplexify": "^3.4.2", - "end-of-stream": "^1.1.0", - "flush-write-stream": "^1.0.0", - "from2": "^2.1.0", - "parallel-transform": "^1.1.0", - "pump": "^2.0.1", - "pumpify": "^1.3.3", - "stream-each": "^1.1.0", - "through2": "^2.0.0" + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } } }, "mkdirp": { - "version": "0.5.1", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", - "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz", + "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==", + "dev": true, "requires": { - "minimist": "0.0.8" + "minimist": "^1.2.6" + }, + "dependencies": { + "minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true + } } }, "mkdirp-classic": { @@ -8976,40 +9420,11 @@ "dev": true }, "mkdirp2": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/mkdirp2/-/mkdirp2-1.0.4.tgz", - "integrity": "sha512-Q2PKB4ZR4UPtjLl76JfzlgSCUZhSV1AXQgAZa1qt5RiaALFjP/CDrGvFBrOz7Ck6McPcwMAxTsJvWOUjOU8XMw==", + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/mkdirp2/-/mkdirp2-1.0.5.tgz", + "integrity": "sha512-xOE9xbICroUDmG1ye2h4bZ8WBie9EGmACaco8K8cx6RlkJJrxGIqjGqztAI+NMhexXBcdGbSEzI6N3EJPevxZw==", "dev": true }, - "mkpath": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/mkpath/-/mkpath-0.1.0.tgz", - "integrity": "sha1-dVSm+Nhxg0zJe1RisSLEwSTW3pE=" - }, - "mksnapshot": { - "version": "0.3.5", - "resolved": "https://registry.npmjs.org/mksnapshot/-/mksnapshot-0.3.5.tgz", - "integrity": "sha512-PSBoZaj9h9myC3uRRW62RxmX8mrN3XbOkMEyURUD7v5CeJgtYTar50XU738t7Q0LtG1pBPtp5n5QwDGggRnEvw==", - "requires": { - "decompress-zip": "0.3.x", - "fs-extra": "0.26.7", - "request": "2.x" - }, - "dependencies": { - "fs-extra": { - "version": "0.26.7", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-0.26.7.tgz", - "integrity": "sha1-muH92UiXeY7at20JGM9C0MMYT6k=", - "requires": { - "graceful-fs": "^4.1.2", - "jsonfile": "^2.1.0", - "klaw": "^1.0.0", - "path-is-absolute": "^1.0.0", - "rimraf": "^2.2.8" - } - } - } - }, "mocha": { "version": "2.5.3", "resolved": "https://registry.npmjs.org/mocha/-/mocha-2.5.3.tgz", @@ -9075,6 +9490,15 @@ "sigmund": "~1.0.0" } }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha512-SknJC52obPfGQPnjIkXbmA6+5H15E+fR+E4iR2oQ3zzCLbd7/ONua69R/Gw7AgkTLsRG+r5fzksYwWe1AgTyWA==", + "dev": true, + "requires": { + "minimist": "0.0.8" + } + }, "ms": { "version": "0.7.1", "resolved": "https://registry.npmjs.org/ms/-/ms-0.7.1.tgz", @@ -9101,19 +9525,6 @@ "integrity": "sha512-pEk4ECWQXV6z2zjhRZUongnLJNUeGQJ3w6OQ5ctGwD+i5o93qjRQUk2Rt6VdNeu3sEP0AB4LcfvdebpxBRVr4g==", "dev": true }, - "move-concurrently": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/move-concurrently/-/move-concurrently-1.0.1.tgz", - "integrity": "sha512-hdrFxZOycD/g6A6SoI2bB5NA/5NEqD0569+S47WZhPvm46sD50ZHdYaFmnua5lndde9rCHGjmfK7Z8BuCt/PcQ==", - "requires": { - "aproba": "^1.1.1", - "copy-concurrently": "^1.0.0", - "fs-write-stream-atomic": "^1.0.8", - "mkdirp": "^0.5.1", - "rimraf": "^2.5.4", - "run-queue": "^1.0.3" - } - }, "ms": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", @@ -9158,9 +9569,9 @@ "dev": true }, "neo-async": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.1.tgz", - "integrity": "sha512-iyam8fBuCUpWeKPGpaNMetEocMt364qkCsfL9JuhjXX6dRnguRVOfk2GZaDpPjcOKiiXCPINZC1GczQ7iTq3Zw==", + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", "dev": true }, "nested-error-stacks": { @@ -9176,23 +9587,18 @@ "dev": true }, "node-fetch": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.2.0.tgz", - "integrity": "sha512-OayFWziIxiHY8bCUyLX6sTpDH8Jsbp4FfYd1j1f7vZyfgkcOnAyM4oQR16f8a0s7Gl/viMGRey8eScYk4V4EZA==" + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.9.tgz", + "integrity": "sha512-DJm/CJkZkRjKKj4Zi4BsKVZh3ValV5IR5s7LVZnW+6YMh0W1BfNA8XSs6DLMGYlId5F3KnA70uu2qepcR08Qqg==", + "requires": { + "whatwg-url": "^5.0.0" + } }, "node-releases": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.6.tgz", "integrity": "sha512-PiVXnNuFm5+iYkLBNeq5211hvO38y63T0i2KKh2KnUs3RpzJ+JtODFjkD8yjLwnDkTYF1eKXheUwdssR+NRZdg==" }, - "nopt": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", - "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=", - "requires": { - "abbrev": "1" - } - }, "normalize-package-data": { "version": "2.5.0", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", @@ -9206,9 +9612,9 @@ }, "dependencies": { "path-parse": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", - "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "dev": true }, "resolve": { @@ -9595,7 +10001,8 @@ "oauth-sign": { "version": "0.9.0", "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz", - "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==" + "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==", + "dev": true }, "object-assign": { "version": "4.1.1", @@ -9603,9 +10010,9 @@ "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" }, "object-get": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/object-get/-/object-get-2.1.0.tgz", - "integrity": "sha1-ciu9tgA576R8rTxtws5RqFwCxa4=", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/object-get/-/object-get-2.1.1.tgz", + "integrity": "sha512-7n4IpLMzGGcLEMiQKsNR7vCe+N5E9LORFrtNUVy4sO3dj9a3HedZCxEL2T7QuLhcHN1NBuBsMOKaOsAYI9IIvg==", "dev": true }, "object-inspect": { @@ -9622,7 +10029,7 @@ "object-to-spawn-args": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/object-to-spawn-args/-/object-to-spawn-args-1.1.1.tgz", - "integrity": "sha1-d9qIJ/Bz0BHJ4bFz+JV4FHAkZ4U=", + "integrity": "sha512-d6xH8b+QdNj+cdndsL3rVCzwW9PqSSXQBDVj0d8fyaCqMimUEz+sW+Jtxp77bxaSs7C5w7XOH844FG7p2A0cFw==", "dev": true }, "object.assign": { @@ -9936,24 +10343,6 @@ "mimic-fn": "^1.0.0" } }, - "optimist": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz", - "integrity": "sha1-2j6nRob6IaGaERwybpDrFaAZZoY=", - "dev": true, - "requires": { - "minimist": "~0.0.1", - "wordwrap": "~0.0.2" - }, - "dependencies": { - "wordwrap": { - "version": "0.0.3", - "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz", - "integrity": "sha1-o9XabNXAvAAI03I0u68b7WMFkQc=", - "dev": true - } - } - }, "optionator": { "version": "0.8.2", "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", @@ -9977,7 +10366,8 @@ "os-tmpdir": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", - "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=" + "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=", + "dev": true }, "p-cancelable": { "version": "1.1.0", @@ -10003,6 +10393,14 @@ "p-limit": "^1.1.0" } }, + "p-map": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", + "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "requires": { + "aggregate-error": "^3.0.0" + } + }, "p-try": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", @@ -10021,40 +10419,6 @@ "release-zalgo": "^1.0.0" } }, - "parallel-transform": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/parallel-transform/-/parallel-transform-1.1.0.tgz", - "integrity": "sha1-1BDwZbBdojCB/NEPKIVMKb2jOwY=", - "requires": { - "cyclist": "~0.2.2", - "inherits": "^2.0.3", - "readable-stream": "^2.1.5" - }, - "dependencies": { - "readable-stream": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", - "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", - "requires": { - "core-util-is": "~1.0.0", - "inherits": "~2.0.3", - "isarray": "~1.0.0", - "process-nextick-args": "~2.0.0", - "safe-buffer": "~5.1.1", - "string_decoder": "~1.1.1", - "util-deprecate": "~1.0.1" - } - }, - "string_decoder": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", - "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", - "requires": { - "safe-buffer": "~5.1.0" - } - } - } - }, "parent-module": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", @@ -10107,14 +10471,30 @@ "dev": true }, "path-parse": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz", - "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=" + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==" + }, + "path-scurry": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.6.3.tgz", + "integrity": "sha512-RAmB+n30SlN+HnNx6EbcpoDy9nwdpcGPnEKrJnu6GZoDWBdIjo1UQMVtW2ybtC7LC2oKLcMq8y5g8WnKLiod9g==", + "requires": { + "lru-cache": "^7.14.1", + "minipass": "^4.0.2" + }, + "dependencies": { + "lru-cache": { + "version": "7.18.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz", + "integrity": "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==" + } + } }, "path-to-regexp": { - "version": "1.7.0", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.7.0.tgz", - "integrity": "sha1-Wf3g9DW62suhA6hOnTvGTpa5k30=", + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-1.8.0.tgz", + "integrity": "sha512-n43JRhlUKUAlibEJhPeir1ncUID16QnEjNpwzNdO3Lm4ywrBpBZ5oLD0I6br9evr1Y9JTqwRtAh7JLoOzAQdVA==", "dev": true, "requires": { "isarray": "0.0.1" @@ -10123,7 +10503,7 @@ "isarray": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", - "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==", "dev": true } } @@ -10137,7 +10517,8 @@ "performance-now": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", - "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=" + "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=", + "dev": true }, "picocolors": { "version": "1.0.0", @@ -10364,7 +10745,8 @@ "process-nextick-args": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz", - "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==" + "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==", + "dev": true }, "progress": { "version": "2.0.3", @@ -10413,9 +10795,9 @@ "dev": true }, "proxyquire": { - "version": "1.7.11", - "resolved": "https://registry.npmjs.org/proxyquire/-/proxyquire-1.7.11.tgz", - "integrity": "sha1-E7SU6x5x+yHMPr42meY3077Br54=", + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/proxyquire/-/proxyquire-1.8.0.tgz", + "integrity": "sha512-mZZq4F50qaBkngvlf9paNfaSb5gtJ0mFPnBjda4NxCpXpMAaVfSLguRr9y2KXF6koOSBf4AanD2inuEQw3aCcA==", "dev": true, "requires": { "fill-keys": "^1.0.2", @@ -10426,7 +10808,7 @@ "resolve": { "version": "1.1.7", "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", - "integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=", + "integrity": "sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg==", "dev": true } } @@ -10439,31 +10821,14 @@ "psl": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/psl/-/psl-1.2.0.tgz", - "integrity": "sha512-GEn74ZffufCmkDDLNcl3uuyF/aSD6exEyh1v/ZSdAomB82t6G9hzJVRx0jBmLDW+VfZqks3aScmMw9DszwUalA==" - }, - "pump": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz", - "integrity": "sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==", - "requires": { - "end-of-stream": "^1.1.0", - "once": "^1.3.1" - } - }, - "pumpify": { - "version": "1.5.1", - "resolved": "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz", - "integrity": "sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==", - "requires": { - "duplexify": "^3.6.0", - "inherits": "^2.0.3", - "pump": "^2.0.0" - } + "integrity": "sha512-GEn74ZffufCmkDDLNcl3uuyF/aSD6exEyh1v/ZSdAomB82t6G9hzJVRx0jBmLDW+VfZqks3aScmMw9DszwUalA==", + "dev": true }, "punycode": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", - "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=" + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", + "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "dev": true }, "puppeteer-core": { "version": "5.5.0", @@ -10543,21 +10908,16 @@ } } }, - "q": { - "version": "1.5.1", - "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", - "integrity": "sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=" - }, "qs": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/qs/-/qs-1.2.2.tgz", - "integrity": "sha1-GbV/8k3CqZzh+L32r82ln472H4g=", + "version": "6.5.3", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz", + "integrity": "sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==", "dev": true }, "queue": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/queue/-/queue-4.0.1.tgz", - "integrity": "sha1-GLsvTB+NmftkPan+rYmGklYpFhc=", + "version": "4.5.1", + "resolved": "https://registry.npmjs.org/queue/-/queue-4.5.1.tgz", + "integrity": "sha512-AMD7w5hRXcFSb8s9u38acBZ+309u6GsiibP4/0YacJeaurRshogB7v/ZcVPxP5gD5+zIw6ixRHdutiYUJfwKHw==", "dev": true, "requires": { "inherits": "~2.0.0" @@ -10585,6 +10945,7 @@ "version": "1.1.14", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "dev": true, "requires": { "core-util-is": "~1.0.0", "inherits": "~2.0.1", @@ -10595,7 +10956,8 @@ "isarray": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", - "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true } } }, @@ -10649,7 +11011,7 @@ "reduce-extract": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/reduce-extract/-/reduce-extract-1.0.0.tgz", - "integrity": "sha1-Z/I4W+2mUGG19fQxJmLosIDKFSU=", + "integrity": "sha512-QF8vjWx3wnRSL5uFMyCjDeDc5EBMiryoT9tz94VvgjKfzecHAVnqmXAwQDcr7X4JmLc2cjkjFGCVzhMqDjgR9g==", "dev": true, "requires": { "test-value": "^1.0.1" @@ -10658,7 +11020,7 @@ "array-back": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/array-back/-/array-back-1.0.4.tgz", - "integrity": "sha1-ZEun8JX3/898Q7Xw3DnTwfA8Bjs=", + "integrity": "sha512-1WxbZvrmyhkNoeYcizokbmh5oiOCIfyvGtcqbK3Ls1v1fKcquzxnQSceOx6tzq7jmai2kFLWIpGND2cLhH6TPw==", "dev": true, "requires": { "typical": "^2.6.0" @@ -10667,7 +11029,7 @@ "test-value": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/test-value/-/test-value-1.1.0.tgz", - "integrity": "sha1-oJE29y7AQ9J8iTcHwrFZv6196T8=", + "integrity": "sha512-wrsbRo7qP+2Je8x8DsK8ovCGyxe3sYfQwOraIY/09A2gFXU9DYKiTF14W4ki/01AEh56kMzAmlj9CaHGDDUBJA==", "dev": true, "requires": { "array-back": "^1.0.2", @@ -10679,7 +11041,7 @@ "reduce-flatten": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/reduce-flatten/-/reduce-flatten-1.0.1.tgz", - "integrity": "sha1-JYx479FT3fk8tWEjf2EYTzaW4yc=", + "integrity": "sha512-j5WfFJfc9CoXv/WbwVLHq74i/hdTUpy+iNC534LxczMRP67vJeK3V9JOdnL0N1cIRbn9mYhE2yVjvvKXDxvNXQ==", "dev": true }, "reduce-unique": { @@ -10691,7 +11053,7 @@ "reduce-without": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/reduce-without/-/reduce-without-1.0.1.tgz", - "integrity": "sha1-aK0OrRGFXJo31OglbBW7+Hly/Iw=", + "integrity": "sha512-zQv5y/cf85sxvdrKPlfcRzlDn/OqKFThNimYmsS3flmkioKvkUGn2Qg9cJVoQiEvdxFGLE0MQER/9fZ9sUqdxg==", "dev": true, "requires": { "test-value": "^2.0.0" @@ -10700,7 +11062,7 @@ "array-back": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/array-back/-/array-back-1.0.4.tgz", - "integrity": "sha1-ZEun8JX3/898Q7Xw3DnTwfA8Bjs=", + "integrity": "sha512-1WxbZvrmyhkNoeYcizokbmh5oiOCIfyvGtcqbK3Ls1v1fKcquzxnQSceOx6tzq7jmai2kFLWIpGND2cLhH6TPw==", "dev": true, "requires": { "typical": "^2.6.0" @@ -10709,7 +11071,7 @@ "test-value": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/test-value/-/test-value-2.1.0.tgz", - "integrity": "sha1-Edpv9nDzRxpztiXKTz/c97t0gpE=", + "integrity": "sha512-+1epbAxtKeXttkGFMTX9H42oqzOTufR1ceCF+GYA5aOmvaPq9wd4PUS8329fn2RRLGNeUkgRLnVpycjx8DsO2w==", "dev": true, "requires": { "array-back": "^1.0.3", @@ -10794,13 +11156,23 @@ } }, "reify": { - "version": "0.17.3", - "resolved": "https://registry.npmjs.org/reify/-/reify-0.17.3.tgz", - "integrity": "sha512-i0t837UYnWyJPCeesupZjmpThIppOPSs4I/uHmsWzQaiGQqtsYlbeJNN5i+61fe6UEA3Famc3IHnlm511poMnA==", + "version": "0.20.12", + "resolved": "https://registry.npmjs.org/reify/-/reify-0.20.12.tgz", + "integrity": "sha512-4BzKwDWyJJbukwI6xIJRh+BDTitoGzxdgYPiQQ1zbcTZW6I8xgHPw1DnVuEs/mEZQlYm1e09DcFSApb4UaR5bQ==", "dev": true, "requires": { - "acorn": "^5.5.3", + "acorn": "^6.1.1", + "acorn-dynamic-import": "^4.0.0", + "magic-string": "^0.25.3", "semver": "^5.4.1" + }, + "dependencies": { + "acorn": { + "version": "6.4.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.4.2.tgz", + "integrity": "sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==", + "dev": true + } } }, "release-zalgo": { @@ -10828,9 +11200,10 @@ "dev": true }, "request": { - "version": "2.88.0", - "resolved": "https://registry.npmjs.org/request/-/request-2.88.0.tgz", - "integrity": "sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==", + "version": "2.88.2", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz", + "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==", + "dev": true, "requires": { "aws-sign2": "~0.7.0", "aws4": "^1.8.0", @@ -10839,7 +11212,7 @@ "extend": "~3.0.2", "forever-agent": "~0.6.1", "form-data": "~2.3.2", - "har-validator": "~5.1.0", + "har-validator": "~5.1.3", "http-signature": "~1.2.0", "is-typedarray": "~1.0.0", "isstream": "~0.1.2", @@ -10849,16 +11222,9 @@ "performance-now": "^2.1.0", "qs": "~6.5.2", "safe-buffer": "^5.1.2", - "tough-cookie": "~2.4.3", + "tough-cookie": "~2.5.0", "tunnel-agent": "^0.6.0", "uuid": "^3.3.2" - }, - "dependencies": { - "qs": { - "version": "6.5.2", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz", - "integrity": "sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==" - } } }, "require-directory": { @@ -10890,12 +11256,12 @@ } }, "requizzle": { - "version": "0.2.3", - "resolved": "https://registry.npmjs.org/requizzle/-/requizzle-0.2.3.tgz", - "integrity": "sha512-YanoyJjykPxGHii0fZP0uUPEXpvqfBDxWV7s6GKAiiOsiqhX6vHNyW3Qzdmqp/iq/ExbhaGbVrjB4ruEVSM4GQ==", + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/requizzle/-/requizzle-0.2.4.tgz", + "integrity": "sha512-JRrFk1D4OQ4SqovXOgdav+K8EAhSB/LJZqCz8tbX0KObcdeM15Ss59ozWMBWmmINMagCwmqn4ZNryUGpBsl6Jw==", "dev": true, "requires": { - "lodash": "^4.17.14" + "lodash": "^4.17.21" } }, "resolve": { @@ -10971,25 +11337,33 @@ "dev": true }, "rimraf": { - "version": "2.6.2", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", - "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz", + "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==", "requires": { - "glob": "^7.0.5" + "glob": "^7.1.3" }, "dependencies": { "glob": { - "version": "7.1.2", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", - "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", "requires": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", - "minimatch": "^3.0.4", + "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } + }, + "minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "requires": { + "brace-expansion": "^1.1.7" + } } } }, @@ -11026,14 +11400,6 @@ "is-promise": "^2.1.0" } }, - "run-queue": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/run-queue/-/run-queue-1.0.3.tgz", - "integrity": "sha512-ntymy489o0/QQplUDnpYAYUsO50K9SBrIVaKCWDOJzYJts0f9WH9RFJkyagebkw5+y1oi00R7ynNW/d12GBumg==", - "requires": { - "aproba": "^1.1.1" - } - }, "run-sequence": { "version": "1.2.2", "resolved": "https://registry.npmjs.org/run-sequence/-/run-sequence-1.2.2.tgz", @@ -11064,10 +11430,41 @@ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" }, + "safe-regex-test": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", + "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "is-regex": "^1.1.4" + }, + "dependencies": { + "get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + } + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + } + } + }, "safer-buffer": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", - "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true }, "samsam": { "version": "1.3.0", @@ -11780,24 +12177,24 @@ "optional": true }, "send": { - "version": "0.16.2", - "resolved": "https://registry.npmjs.org/send/-/send-0.16.2.tgz", - "integrity": "sha512-E64YFPUssFHEFBvpbbjr44NCLtI1AohxQ8ZSiJjQLskAdKuriYEP6VyGEsRDH8ScozGpkaX1BGvhanqCwkcEZw==", + "version": "0.18.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.18.0.tgz", + "integrity": "sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==", "dev": true, "requires": { "debug": "2.6.9", - "depd": "~1.1.2", - "destroy": "~1.0.4", + "depd": "2.0.0", + "destroy": "1.2.0", "encodeurl": "~1.0.2", "escape-html": "~1.0.3", "etag": "~1.8.1", "fresh": "0.5.2", - "http-errors": "~1.6.2", - "mime": "1.4.1", - "ms": "2.0.0", - "on-finished": "~2.3.0", - "range-parser": "~1.2.0", - "statuses": "~1.4.0" + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" }, "dependencies": { "debug": { @@ -11807,18 +12204,41 @@ "dev": true, "requires": { "ms": "2.0.0" + }, + "dependencies": { + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "dev": true + } } }, "mime": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/mime/-/mime-1.4.1.tgz", - "integrity": "sha512-KI1+qOZu5DcW6wayYHSzR/tXKCDC5Om4s1z2QJjDULzLcmf3DvzS7oluY4HCTrc+9FiKmWUgeNLg7W3uIQvxtQ==", + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "dev": true + }, + "ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", "dev": true }, + "on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "dev": true, + "requires": { + "ee-first": "1.1.1" + } + }, "statuses": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz", - "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==", + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", "dev": true } } @@ -11971,15 +12391,15 @@ "dev": true }, "setprototypeof": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz", - "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", "dev": true }, "sha1-file": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/sha1-file/-/sha1-file-1.0.1.tgz", - "integrity": "sha512-Pa3E81r7AJhrDFx8T3wzgiGV+4WydRehlW/nVaAzPoCK//L0Dy7URtOi6LriOMYBEk8qg7DkFbus4KgjosiEAQ==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/sha1-file/-/sha1-file-1.0.4.tgz", + "integrity": "sha512-IgcUYjTck/UAx0wdtBoTwiy4/yiIZX6do4uaqUtryJY/pBOQC1w3Cb/bZMyC2H3QYnodL5vbX0lY69xlWqeBnA==", "dev": true }, "shallow-clone": { @@ -12067,9 +12487,9 @@ } }, "sinon": { - "version": "2.3.1", - "resolved": "https://registry.npmjs.org/sinon/-/sinon-2.3.1.tgz", - "integrity": "sha1-SMnHWLTQu4YydIaDPxxCmJGc6e4=", + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/sinon/-/sinon-2.4.1.tgz", + "integrity": "sha512-vFTrO9Wt0ECffDYIPSP/E5bBugt0UjcBQOfQUMh66xzkyPEnhl/vM2LRZi2ajuTdkH07sA6DzrM6KvdvGIH8xw==", "dev": true, "requires": { "diff": "^3.1.0", @@ -12097,9 +12517,9 @@ } }, "sinon-chai": { - "version": "2.10.0", - "resolved": "https://registry.npmjs.org/sinon-chai/-/sinon-chai-2.10.0.tgz", - "integrity": "sha1-arMAi7jK6ZKedE12ZXS0zzXzS1s=", + "version": "2.14.0", + "resolved": "https://registry.npmjs.org/sinon-chai/-/sinon-chai-2.14.0.tgz", + "integrity": "sha512-9stIF1utB0ywNHNT7RgiXbdmen8QDCRsrTjw+G9TgKt1Yexjiv8TOWZ6WHsTPz57Yky3DIswZvEqX8fpuHNDtQ==", "dev": true }, "slash": { @@ -12128,7 +12548,7 @@ "sort-array": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/sort-array/-/sort-array-2.0.0.tgz", - "integrity": "sha1-OKnG2if9fRR7QuYFVPKBGHtN9HI=", + "integrity": "sha512-nZI3lq+nPRImxYqQY5iwpOPVLdDEMr2k6rCOAz5hRcpyYFsrR+2m5Kw0tZaTt452nx/9wZrKaMEMrX03I7ChqQ==", "dev": true, "requires": { "array-back": "^1.0.4", @@ -12139,7 +12559,7 @@ "array-back": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/array-back/-/array-back-1.0.4.tgz", - "integrity": "sha1-ZEun8JX3/898Q7Xw3DnTwfA8Bjs=", + "integrity": "sha512-1WxbZvrmyhkNoeYcizokbmh5oiOCIfyvGtcqbK3Ls1v1fKcquzxnQSceOx6tzq7jmai2kFLWIpGND2cLhH6TPw==", "dev": true, "requires": { "typical": "^2.6.0" @@ -12169,6 +12589,12 @@ } } }, + "sourcemap-codec": { + "version": "1.4.8", + "resolved": "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz", + "integrity": "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==", + "dev": true + }, "sparkles": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.1.tgz", @@ -12176,9 +12602,9 @@ "dev": true }, "spawn-wrap": { - "version": "1.4.2", - "resolved": "https://registry.npmjs.org/spawn-wrap/-/spawn-wrap-1.4.2.tgz", - "integrity": "sha512-vMwR3OmmDhnxCVxM8M+xO/FtIp6Ju/mNaDfCMMW7FDcLRTPFWUswec4LXJHTJE2hwTI9O0YBfygu4DalFl7Ylg==", + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/spawn-wrap/-/spawn-wrap-1.4.3.tgz", + "integrity": "sha512-IgB8md0QW/+tWqcavuFgKYR/qIRvJkRLPJDFaoXtLLUaVcCDK0+HeFTkmQHj3eprcYhc+gOl0aEA1w7qZlYezw==", "dev": true, "requires": { "foreground-child": "^1.5.6", @@ -12305,6 +12731,7 @@ "version": "1.16.1", "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.16.1.tgz", "integrity": "sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg==", + "dev": true, "requires": { "asn1": "~0.2.3", "assert-plus": "^1.0.0", @@ -12318,11 +12745,11 @@ } }, "ssri": { - "version": "5.3.0", - "resolved": "https://registry.npmjs.org/ssri/-/ssri-5.3.0.tgz", - "integrity": "sha512-XRSIPqLij52MtgoQavH/x/dU1qVKtWUAAZeOHsR9c2Ddi4XerFy3mc1alf+dLJKl9EUIm/Ht+EowFkTUOA6GAQ==", + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.1.tgz", + "integrity": "sha512-WVy6di9DlPOeBWEjMScpNipeSX2jIZBGEn5Uuo8Q7aIuFEuDX0pw8RxcOjlD1TWP4obi24ki7m/13+nFpcbXrw==", "requires": { - "safe-buffer": "^5.1.1" + "minipass": "^4.0.0" } }, "standard-engine": { @@ -12344,9 +12771,9 @@ "dev": true }, "minimist": { - "version": "1.2.5", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", - "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", "dev": true } } @@ -12360,7 +12787,7 @@ "stream-connect": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/stream-connect/-/stream-connect-1.0.2.tgz", - "integrity": "sha1-GLyB8u2zW4tdmoAJIAqYUxRCipc=", + "integrity": "sha512-68Kl+79cE0RGKemKkhxTSg8+6AGrqBt+cbZAXevg2iJ6Y3zX4JhA/sZeGzLpxW9cXhmqAcE7KnJCisUmIUfnFQ==", "dev": true, "requires": { "array-back": "^1.0.2" @@ -12369,7 +12796,7 @@ "array-back": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/array-back/-/array-back-1.0.4.tgz", - "integrity": "sha1-ZEun8JX3/898Q7Xw3DnTwfA8Bjs=", + "integrity": "sha512-1WxbZvrmyhkNoeYcizokbmh5oiOCIfyvGtcqbK3Ls1v1fKcquzxnQSceOx6tzq7jmai2kFLWIpGND2cLhH6TPw==", "dev": true, "requires": { "typical": "^2.6.0" @@ -12377,20 +12804,6 @@ } } }, - "stream-each": { - "version": "1.2.2", - "resolved": "https://registry.npmjs.org/stream-each/-/stream-each-1.2.2.tgz", - "integrity": "sha512-mc1dbFhGBxvTM3bIWmAAINbqiuAk9TATcfIQC8P+/+HJefgaiTlMn2dHvkX8qlI12KeYKSQ1Ua9RrIqrn1VPoA==", - "requires": { - "end-of-stream": "^1.1.0", - "stream-shift": "^1.0.0" - } - }, - "stream-shift": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz", - "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=" - }, "stream-via": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/stream-via/-/stream-via-1.0.4.tgz", @@ -12509,6 +12922,171 @@ "es-abstract": "^1.19.1" } }, + "string.prototype.trim": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", + "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "dependencies": { + "define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "dev": true, + "requires": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + } + }, + "es-abstract": { + "version": "1.21.2", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.2.tgz", + "integrity": "sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==", + "dev": true, + "requires": { + "array-buffer-byte-length": "^1.0.0", + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.2.0", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.5", + "is-array-buffer": "^3.0.2", + "is-callable": "^1.2.7", + "is-negative-zero": "^2.0.2", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "is-string": "^1.0.7", + "is-typed-array": "^1.1.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.3", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trim": "^1.2.7", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + } + }, + "get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + } + }, + "has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "dev": true + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + }, + "internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dev": true, + "requires": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + } + }, + "is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "dev": true + }, + "is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2" + } + }, + "object-inspect": { + "version": "1.12.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "dev": true + }, + "regexp.prototype.flags": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz", + "integrity": "sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "functions-have-names": "^1.2.2" + } + }, + "string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + } + } + } + }, "string.prototype.trimend": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz", @@ -12532,7 +13110,8 @@ "string_decoder": { "version": "0.10.31", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", - "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", + "dev": true }, "strip-ansi": { "version": "3.0.1", @@ -12542,6 +13121,12 @@ "ansi-regex": "^2.0.0" } }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true + }, "strip-json-comments": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", @@ -12661,9 +13246,52 @@ "taffydb": { "version": "2.6.2", "resolved": "https://registry.npmjs.org/taffydb/-/taffydb-2.6.2.tgz", - "integrity": "sha1-fLy2S1oUG2ou/CxdLGe04VCyomg=", + "integrity": "sha512-y3JaeRSplks6NYQuCOj3ZFMO3j60rTwbuKCvZxsAraGYH2epusatvZ0baZYA01WsGqJBq/Dl6vOrMUJqyMj8kA==", "dev": true }, + "tar": { + "version": "6.1.13", + "resolved": "https://registry.npmjs.org/tar/-/tar-6.1.13.tgz", + "integrity": "sha512-jdIBIN6LTIe2jqzay/2vtYLlBHa3JF42ot3h1dW8Q0PaAG4v8rm0cvpVePtau5C6OKXGGcgO9q2AMNSWxiLqKw==", + "requires": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^4.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "dependencies": { + "fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "requires": { + "minipass": "^3.0.0" + }, + "dependencies": { + "minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "requires": { + "yallist": "^4.0.0" + } + } + } + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==" + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + } + } + }, "tar-fs": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.1.tgz", @@ -12771,17 +13399,17 @@ "temp-path": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/temp-path/-/temp-path-1.0.0.tgz", - "integrity": "sha1-JLFUOXOrRCiW2a02fdnL2/r+kYs=", + "integrity": "sha512-TvmyH7kC6ZVTYkqCODjJIbgvu0FKiwQpZ4D1aknE7xpcDf/qEOB8KZEK5ef2pfbVoiBhNWs3yx4y+ESMtNYmlg==", "dev": true }, "terser": { - "version": "3.8.2", - "resolved": "https://registry.npmjs.org/terser/-/terser-3.8.2.tgz", - "integrity": "sha512-FGSBXiBJe2TSXy6pWwXpY0YcEWEK35UKL64BBbxX3aHqM4Nj0RMqXvqBuoSGfyd80t8MKQ5JwYm5jRRGTSEFNg==", + "version": "4.8.1", + "resolved": "https://registry.npmjs.org/terser/-/terser-4.8.1.tgz", + "integrity": "sha512-4GnLC0x667eJG0ewJTa6z/yXrbLGv80D9Ru6HIpCQmO+Q4PfEtBFi0ObSckqwL6VyQv/7ENJieXHo2ANmdQwgw==", "requires": { - "commander": "~2.17.1", + "commander": "^2.20.0", "source-map": "~0.6.1", - "source-map-support": "~0.5.6" + "source-map-support": "~0.5.12" }, "dependencies": { "source-map": { @@ -12960,9 +13588,9 @@ "dev": true }, "thenify": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.0.tgz", - "integrity": "sha1-5p44obq+lpsBCCB5eLn2K4hgSDk=", + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz", + "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", "requires": { "any-promise": "^1.0.0" } @@ -12985,6 +13613,7 @@ "version": "2.0.3", "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz", "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", + "dev": true, "requires": { "readable-stream": "^2.1.5", "xtend": "~4.0.1" @@ -12994,6 +13623,7 @@ "version": "2.3.6", "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "dev": true, "requires": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", @@ -13008,6 +13638,7 @@ "version": "1.1.1", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, "requires": { "safe-buffer": "~5.1.0" } @@ -13020,14 +13651,6 @@ "integrity": "sha1-dkpaEa9QVhkhsTPztE5hhofg9cM=", "dev": true }, - "tmp": { - "version": "0.0.28", - "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.28.tgz", - "integrity": "sha512-c2mmfiBmND6SOVxzogm1oda0OJ1HZVIk/5n26N59dDTh80MUeavpiCls4PGAdkX1PFkKokLpcf7prSjCeXLsJg==", - "requires": { - "os-tmpdir": "~1.0.1" - } - }, "to-fast-properties": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", @@ -13061,43 +13684,20 @@ "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", "dev": true }, - "touch": { - "version": "0.0.3", - "resolved": "https://registry.npmjs.org/touch/-/touch-0.0.3.tgz", - "integrity": "sha1-Ua7z1ElXHU8oel2Hyci0kYGg2x0=", - "requires": { - "nopt": "~1.0.10" - }, - "dependencies": { - "nopt": { - "version": "1.0.10", - "resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz", - "integrity": "sha1-bd0hvSoxQXuScn3Vhfim83YI6+4=", - "requires": { - "abbrev": "1" - } - } - } - }, "tough-cookie": { - "version": "2.4.3", - "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz", - "integrity": "sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==", + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", + "dev": true, "requires": { - "psl": "^1.1.24", - "punycode": "^1.4.1" + "psl": "^1.1.28", + "punycode": "^2.1.1" } }, "tr46": { "version": "0.0.3", "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", - "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", - "dev": true - }, - "traverse": { - "version": "0.3.9", - "resolved": "https://registry.npmjs.org/traverse/-/traverse-0.3.9.tgz", - "integrity": "sha1-cXuPIgzAu3tE5AUUwisui7xw2Lk=" + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==" }, "trim-right": { "version": "1.0.1", @@ -13127,9 +13727,9 @@ } }, "minimist": { - "version": "1.2.5", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", - "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", "dev": true }, "strip-bom": { @@ -13151,6 +13751,7 @@ "version": "0.6.0", "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "dev": true, "requires": { "safe-buffer": "^5.0.1" } @@ -13158,7 +13759,8 @@ "tweetnacl": { "version": "0.14.5", "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", - "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=" + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", + "dev": true }, "type-check": { "version": "0.3.2", @@ -13181,21 +13783,33 @@ "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", "dev": true }, + "typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dev": true, + "requires": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + } + }, "typedarray": { "version": "0.0.6", "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", - "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", + "dev": true }, "typical": { "version": "2.6.1", "resolved": "https://registry.npmjs.org/typical/-/typical-2.6.1.tgz", - "integrity": "sha1-XAgOXWYcu+OCWdLnCjxyU+hziB0=", + "integrity": "sha512-ofhi8kjIje6npGozTip9Fr8iecmYfEbS06i0JnIg+rh51KakryWF4+jX8lLKZVhy6N+ID45WYSFCxPOdTWCzNg==", "dev": true }, "ua-parser-js": { - "version": "0.7.31", - "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.31.tgz", - "integrity": "sha512-qLK/Xe9E2uzmYI3qLeOmI0tEOt+TBBQyUIAh4aAgU05FVYzeZrKUdkAZfBNVGRaHVgV0TDkdEngJSw/SyQchkQ==", + "version": "0.7.35", + "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.35.tgz", + "integrity": "sha512-veRf7dawaj9xaWEu9HoTVn5Pggtc/qj+kqTOFvNiN1l0YdxwC1kvel57UCjThjGa3BHBihE8/UJAHI+uQHmd/g==", "dev": true }, "uc.micro": { @@ -13205,31 +13819,11 @@ "dev": true }, "uglify-js": { - "version": "3.7.6", - "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.7.6.tgz", - "integrity": "sha512-yYqjArOYSxvqeeiYH2VGjZOqq6SVmhxzaPjJC1W2F9e+bqvFL9QXQ2osQuKUFjM2hGjKG2YclQnRKWQSt/nOTQ==", + "version": "3.17.4", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.17.4.tgz", + "integrity": "sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==", "dev": true, - "optional": true, - "requires": { - "commander": "~2.20.3", - "source-map": "~0.6.1" - }, - "dependencies": { - "commander": { - "version": "2.20.3", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", - "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", - "dev": true, - "optional": true - }, - "source-map": { - "version": "0.6.1", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", - "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", - "dev": true, - "optional": true - } - } + "optional": true }, "unbox-primitive": { "version": "1.0.1", @@ -13262,9 +13856,9 @@ } }, "underscore": { - "version": "1.9.1", - "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", - "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", + "version": "1.13.6", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.6.tgz", + "integrity": "sha512-+A5Sja4HP1M08MaXya7p5LvjuM7K6q/2EaC0+iovj/wOcMsTzMvDFbasi/oSapiwOlt252IqsKqPjCl7huKS0A==", "dev": true }, "underscore-plus": { @@ -13301,22 +13895,22 @@ "integrity": "sha512-5Zfuy9q/DFr4tfO7ZPeVXb1aPoeQSdeFMLpYuFebehDAhbuevLs5yxSZmIFN1tP5F9Wl4IpJrYojg85/zgyZHQ==" }, "uniqid": { - "version": "5.0.3", - "resolved": "https://registry.npmjs.org/uniqid/-/uniqid-5.0.3.tgz", - "integrity": "sha512-R2qx3X/LYWSdGRaluio4dYrPXAJACTqyUjuyXHoJLBUOIfmMcnYOyY2d6Y4clZcIz5lK6ZaI0Zzmm0cPfsIqzQ==" + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/uniqid/-/uniqid-5.4.0.tgz", + "integrity": "sha512-38JRbJ4Fj94VmnC7G/J/5n5SC7Ab46OM5iNtSstB/ko3l1b5g7ALt4qzHFgGciFkyiRNtDXtLNb+VsxtMSE77A==" }, "unique-filename": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-1.1.0.tgz", - "integrity": "sha1-0F8v5AMlYIcfMOk8vnNe6iAVFPM=", + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz", + "integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==", "requires": { - "unique-slug": "^2.0.0" + "unique-slug": "^4.0.0" } }, "unique-slug": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-2.0.0.tgz", - "integrity": "sha1-22Z258fMBimHj/GWCXx4hVrp9Ks=", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz", + "integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==", "requires": { "imurmurhash": "^0.1.4" } @@ -13346,6 +13940,7 @@ "version": "4.2.2", "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz", "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==", + "dev": true, "requires": { "punycode": "^2.1.0" }, @@ -13353,7 +13948,8 @@ "punycode": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", - "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==" + "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==", + "dev": true } } }, @@ -13375,7 +13971,8 @@ "util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", - "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", + "dev": true }, "utils-merge": { "version": "1.0.1", @@ -13386,7 +13983,8 @@ "uuid": { "version": "3.3.2", "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz", - "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==" + "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==", + "dev": true }, "v8-compile-cache": { "version": "2.3.0", @@ -13407,7 +14005,8 @@ "verror": { "version": "1.10.0", "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", - "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", + "integrity": "sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==", + "dev": true, "requires": { "assert-plus": "^1.0.0", "core-util-is": "1.0.2", @@ -13426,9 +14025,9 @@ } }, "walk-back": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/walk-back/-/walk-back-3.0.1.tgz", - "integrity": "sha512-umiNB2qLO731Sxbp6cfZ9pwURJzTnftxE4Gc7hq8n/ehkuXC//s9F65IEIJA2ZytQZ1ZOsm/Fju4IWx0bivkUQ==", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/walk-back/-/walk-back-4.0.0.tgz", + "integrity": "sha512-kudCA8PXVQfrqv2mFTG72vDBRi8BKWxGgFLwPpzHcpZnSwZk93WMwUDVcLHWNsnm+Y0AC4Vb6MUNRgaHfyV2DQ==", "dev": true }, "watch": { @@ -13442,9 +14041,9 @@ }, "dependencies": { "minimist": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", - "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", "dev": true } } @@ -13670,14 +14269,12 @@ "webidl-conversions": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", - "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", - "dev": true + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==" }, "whatwg-url": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", - "dev": true, "requires": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" @@ -13727,6 +14324,20 @@ "integrity": "sha512-B+enWhmw6cjfVC7kS8Pj9pCrKSc5txArRyaYGe088shv/FGWH+0Rjx/xPgtsWfsUtS27FkP697E4DDhgrgoc0Q==", "dev": true }, + "which-typed-array": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz", + "integrity": "sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==", + "dev": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0", + "is-typed-array": "^1.1.10" + } + }, "word-wrap": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", @@ -13761,9 +14372,9 @@ }, "dependencies": { "ansi-regex": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", - "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz", + "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==", "dev": true }, "is-fullwidth-code-point": { @@ -13832,20 +14443,22 @@ "dev": true }, "xmlcreate": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/xmlcreate/-/xmlcreate-2.0.1.tgz", - "integrity": "sha512-MjGsXhKG8YjTKrDCXseFo3ClbMGvUD4en29H2Cev1dv4P/chlpw6KdYmlCWDkhosBVKRDjM836+3e3pm1cBNJA==", + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/xmlcreate/-/xmlcreate-2.0.4.tgz", + "integrity": "sha512-nquOebG4sngPmGPICTS5EnxqhKbCmz5Ox5hsszI2T6U5qdrJizBc+0ilYSEjTSzU0yZcmvppztXe/5Al5fUwdg==", "dev": true }, "xtend": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", - "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=", + "dev": true }, "y18n": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz", - "integrity": "sha512-r9S/ZyXu/Xu9q1tYlpsLIsa3EeLXXk0VwlxqTcFRfg9EhMW+17kbt9G0NrgCmhGb5vT2hyhJZLfDGx+7+5Uj/w==" + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz", + "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==", + "dev": true }, "yallist": { "version": "2.1.2", @@ -13872,8 +14485,7 @@ "dependencies": { "ansi-regex": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz", - "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==", + "resolved": "", "dev": true }, "find-up": { @@ -13954,21 +14566,13 @@ } }, "yargs-parser": { - "version": "13.1.1", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.1.tgz", - "integrity": "sha512-oVAVsHz6uFrg3XQheFII8ESO2ssAf9luWuAd6Wexsu4F3OtIW0o8IribPXYrD4WC24LWtPrJlGy87y5udK+dxQ==", + "version": "13.1.2", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz", + "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==", "dev": true, "requires": { "camelcase": "^5.0.0", "decamelize": "^1.2.0" - }, - "dependencies": { - "camelcase": { - "version": "5.3.1", - "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", - "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", - "dev": true - } } }, "yauzl": { diff --git a/package.json b/package.json index 320fdecf..81dcd6cc 100644 --- a/package.json +++ b/package.json @@ -33,43 +33,43 @@ "author": "Bartosz Wojtkowiak ", "license": "MIT", "devDependencies": { - "@babel/cli": "7.18.10", - "@babel/register": "7.18.9", + "@babel/cli": "7.21.0", + "@babel/register": "7.21.0", "babel-plugin-istanbul": "^5.2.0", "chai": "3.5.0", "chai-as-promised": "6.0.0", "codecov": "1.0.1", "connect": "3.7.0", - "connect-modrewrite": "0.9.0", + "connect-modrewrite": "^0.10.2", "coveralls": "3.1.1", - "cross-env": "3.1.4", + "cross-env": "3.2.4", "dirty-chai": "1.2.2", "eslint": "4.19.1", "eslint-config-airbnb-base": "12.1.0", - "eslint-plugin-import": "2.26.0", + "eslint-plugin-import": "2.27.5", "find-port": "2.0.1", - "fs-extra": "4.0.1", - "fs-plus": "2.9.3", + "fs-extra": "4.0.3", + "fs-plus": "2.10.1", "import-fresh": "2.0.0", - "jsdoc-to-markdown": "5.0.0", - "mime": "2.0.3", + "jsdoc-to-markdown": "5.0.3", + "mime": "2.6.0", "mocha": "2.5.3", "mockery": "2.1.0", "npm-run-all": "4.1.5", "nyc": "14.1.1", - "proxyquire": "1.7.11", - "queue": "4.0.1", - "reify": "0.17.3", - "request": "2.88.0", + "proxyquire": "1.8.0", + "queue": "4.5.1", + "reify": "0.20.12", + "request": "2.88.2", "rewire": "3.0.2", "run-sequence": "1.2.2", "semistandard": "^16.0.1", - "send": "0.16.2", + "send": "0.18.0", "serve-static": "1.15.0", "server-destroy": "1.0.1", - "sha1-file": "1.0.1", - "sinon": "2.3.1", - "sinon-chai": "2.10.0", + "sha1-file": "1.0.4", + "sinon": "2.4.1", + "sinon-chai": "2.14.0", "spectron": "13.0.0", "temp-dir": "2.0.0", "watch": "1.0.2" @@ -78,23 +78,22 @@ "@babel/core": "7.18.13", "@babel/preset-env": "7.18.10", "@babel/runtime": "7.18.9", - "asar": "0.14.3", - "cacache": "10.0.4", - "commander": "2.17.1", + "@electron/asar": "3.2.3", + "cacache": "17.0.5", + "commander": "2.20.3", "cross-spawn": "5.0.1", "del": "2.2.2", - "install-local": "0.6.0", + "install-local": "0.6.2", "isbinaryfile": "3.0.3", "lodash": "4.17.21", "md5": "2.3.0", - "mksnapshot": "0.3.5", - "node-fetch": "2.2.0", + "node-fetch": "2.6.9", "regenerator-runtime": "0.12.1", - "rimraf": "2.6.2", + "rimraf": "2.6.3", "semver": "5.5.1", "shelljs": "0.8.5", "single-line-log": "1.1.2", - "terser": "3.8.2" + "terser": "4.8.1" }, "peerDependencies": { "app-builder-lib": "*", diff --git a/plugins/bundler/bundler.js b/plugins/bundler/bundler.js index cbcdd943..05d7a004 100644 --- a/plugins/bundler/bundler.js +++ b/plugins/bundler/bundler.js @@ -68,7 +68,7 @@ class MeteorDesktopBundler { 'cacache' ]; this.buildDeps = [ - 'asar', + '@electron/asar', 'shelljs', 'del', '@babel/core', @@ -509,7 +509,7 @@ class MeteorDesktopBundler { console.time('[meteor-desktop] preparing desktop.asar took'); - let asar; + let electronAsar; let shelljs; let babelCore; let babelPresetEnv; @@ -705,7 +705,7 @@ class MeteorDesktopBundler { try { const deps = this.lookForAndRequireDependencies(this.buildDeps); ({ - asar, + electronAsar, shelljs, del, babelCore, @@ -713,6 +713,7 @@ class MeteorDesktopBundler { terser, md5 } = deps); + console.log(deps); } catch (e) { // Look at the declaration of StringPrototypeToOriginal for explanation. String.prototype.to = StringPrototypeToOriginal; // eslint-disable-line @@ -881,20 +882,20 @@ class MeteorDesktopBundler { all.wait(); this.stampPerformance('babel/uglify'); - this.stampPerformance('asar'); + this.stampPerformance('@electron/asar'); const future = new Future(); const resolve = future.resolver(); const asarPath = path.join(desktopTmpAsarPath, 'desktop.asar'); - asar.createPackage( + electronAsar.createPackage( desktopTmpPath, - asarPath, - () => { + asarPath + ) + .then(() => { resolve(); - } - ); + }); future.wait(); - this.stampPerformance('asar'); + this.stampPerformance('@electron/asar'); const contents = fs.readFileSync(asarPath); diff --git a/tests/functional/electronApp.test.js b/tests/functional/electronApp.test.js index 5f781104..39415206 100644 --- a/tests/functional/electronApp.test.js +++ b/tests/functional/electronApp.test.js @@ -4,7 +4,7 @@ import sinonChai from 'sinon-chai'; import path from 'path'; import fs from 'fs'; import shell from 'shelljs'; -import asar from 'asar'; +import asar from '@electron/asar'; import { createTestInstance, StubLog, getModuleJson, saveModuleJson } from '../helpers/meteorDesktop'; import paths from '../helpers/paths'; diff --git a/tests/functional/modules/localServer.test.js b/tests/functional/modules/localServer.test.js index b4b9c0ba..1a149c6c 100644 --- a/tests/functional/modules/localServer.test.js +++ b/tests/functional/modules/localServer.test.js @@ -198,7 +198,7 @@ function localServerTests(useStreams = false) { it('should set application/woff for a .woff file', async () => { const response = await fetchFromLocalServer('/some-font.woff'); - expect(response.headers.get('Content-Type')).to.contain('application/font-woff'); + expect(response.headers.get('Content-Type')).to.contain('font/woff'); }); it('should set application/octet-stream for files without an extension', async () => { @@ -298,9 +298,9 @@ describe('localServer', () => { it('should server cordova.js file', async () => { const response = await fetchFromLocalServer('/cordova.js'); - const body = await response.text(); - expect(body).to.contain('window.cordova'); - expect(body).to.contain('module.exports = cordova;'); + const body = await response.text(); + expect(body).to.contain('window.cordova'); + expect(body).to.contain('module.exports = cordova;'); }); }); }); diff --git a/tests/unit/meteorApp.test.js b/tests/unit/meteorApp.test.js index 3d75203d..5fede597 100644 --- a/tests/unit/meteorApp.test.js +++ b/tests/unit/meteorApp.test.js @@ -6,7 +6,7 @@ import sinon from 'sinon'; import mockery from 'mockery'; // need for running test -import asar from 'asar'; // eslint-disable-line no-unused-vars +import asar from '@electron/asar'; // eslint-disable-line no-unused-vars chai.use(sinonChai); chai.use(dirty); From f521b19bc1bd71f07b92ea8a28b9714cc2dc8ddc Mon Sep 17 00:00:00 2001 From: "p.mikolajczak@tkhtechnology.com" Date: Wed, 5 Apr 2023 08:38:03 +0200 Subject: [PATCH 2/3] delete dist dir --- dist/bin/cli.js | 224 -------- dist/binaryModulesDetector.js | 80 --- dist/defaultDependencies.js | 8 - dist/dependenciesManager.js | 181 ------ dist/desktop.js | 271 --------- dist/electron.js | 61 -- dist/electronApp.js | 876 ----------------------------- dist/electronAppScaffold.js | 142 ----- dist/electronBuilder.js | 384 ------------- dist/env.js | 239 -------- dist/index.js | 247 --------- dist/log.js | 75 --- dist/meteorApp.js | 923 ------------------------------- dist/meteorManager.js | 147 ----- dist/packager.js | 142 ----- dist/scripts/addToScripts.js | 24 - dist/scripts/propagateVersion.js | 21 - dist/scripts/utils/addScript.js | 50 -- dist/skeletonDependencies.js | 24 - dist/utils.js | 328 ----------- 20 files changed, 4447 deletions(-) delete mode 100644 dist/bin/cli.js delete mode 100644 dist/binaryModulesDetector.js delete mode 100644 dist/defaultDependencies.js delete mode 100644 dist/dependenciesManager.js delete mode 100644 dist/desktop.js delete mode 100644 dist/electron.js delete mode 100644 dist/electronApp.js delete mode 100644 dist/electronAppScaffold.js delete mode 100644 dist/electronBuilder.js delete mode 100644 dist/env.js delete mode 100644 dist/index.js delete mode 100644 dist/log.js delete mode 100644 dist/meteorApp.js delete mode 100644 dist/meteorManager.js delete mode 100644 dist/packager.js delete mode 100644 dist/scripts/addToScripts.js delete mode 100644 dist/scripts/propagateVersion.js delete mode 100644 dist/scripts/utils/addScript.js delete mode 100644 dist/skeletonDependencies.js delete mode 100644 dist/utils.js diff --git a/dist/bin/cli.js b/dist/bin/cli.js deleted file mode 100644 index 683607e0..00000000 --- a/dist/bin/cli.js +++ /dev/null @@ -1,224 +0,0 @@ -#!/usr/bin/env node - -/* eslint-disable global-require */ -"use strict"; - -var _fs = _interopRequireDefault(require("fs")); - -var _path = _interopRequireDefault(require("path")); - -var _assignIn = _interopRequireDefault(require("lodash/assignIn")); - -var _commander = _interopRequireDefault(require("commander")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _ = _interopRequireDefault(require("../..")); - -var _addScript = _interopRequireDefault(require("../scripts/utils/addScript")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const { - join -} = _path.default; -const cmd = process.argv[2]; -/* eslint-disable no-console */ - -const { - log, - error, - info, - warn -} = console; -/* eslint-enable no-console */ - -/** - * Looks for .meteor directory. - * @param {string} appPath - Meteor app path - */ - -function isMeteorApp(appPath) { - const meteorPath = join(appPath, '.meteor'); - - try { - return _fs.default.statSync(meteorPath).isDirectory(); - } catch (e) { - return false; - } -} -/** - * Just ensures a ddp url is set. - * - * @param {string|null} ddpUrl - the url that Meteor app connects to - * @returns {string|null} - */ - - -function getDdpUrl(ddpUrl = null) { - if (!ddpUrl && _commander.default.buildMeteor) { - info('no ddp_url specified, setting default: http://127.0.0.1:3000'); - return 'http://127.0.0.1:3000'; - } - - return ddpUrl; -} // -------------------------- - - -function collect(val, memo) { - memo.push(val); - return memo; -} - -_commander.default.option('-b, --build-meteor', 'runs meteor to obtain the mobile build, kills it after').option('-t, --build-timeout ', 'timeout value when waiting for ' + 'meteor to build, default 600sec').option('-p, --port ', 'port on which meteor is running, when with -b this will be passed to meteor when obtaining the build').option('--production', 'builds meteor app with the production switch, uglifies contents ' + 'of .desktop, packs app to app.asar').option('-a, --android', 'force adding android as a mobile platform instead of ios').option('-s, --scaffold', 'will scaffold .desktop if not present').option('-i, --ignore-stderr [string]', 'only with -b, strings that when found will not terminate meteor build', collect, []).option('--meteor-settings ', 'only with -b, adds --settings options to meteor').option('--prod-debug', 'forces adding dev tools to a production build').option('--ia32', 'generate 32bit installer/package').option('--all-archs', 'generate 32bit and 64bit installers').option('--win', 'generate Windows installer').option('--linux', 'generate Linux installer').option('--mac', 'generate Mac installer').option('-d, --debug', 'run electron with debug switch'); - -_commander.default.usage('[command] [options]').version(require('./../../package.json').version, '-V, --version').on('--help', () => { - log(' [ddp_url] - pass a ddp url if you want to use different one than used in meteor\'s --mobile-server'); - log(' this will also work with -b'); - log(' '); - log(' Examples:'); - log(''); - log(' ', ['# cd into meteor dir first', 'cd /your/meteor/app', 'meteor --mobile-server=127.0.0.1:3000', '', '# open new terminal, assuming you have done npm install --save-dev @meteor-community/meteor-desktop', 'npm run desktop -- init', 'npm run desktop'].join('\n ')); - log('\n'); -}); - -function verifyArgsSyntax() { - if (process.env.npm_config_argv) { - let npmArgv; - - try { - const args = ['-b', '--build-meteor', '-t', '--build-timeout', '-p', '--port', '--production', '-a', '--android', '-s', '--scaffold', '--ia32', '--win', '--linux', '--all-archs', '--win', '--mac', '--meteor-settings']; - npmArgv = JSON.parse(process.env.npm_config_argv); - - if (npmArgv.remain.length === 0 && npmArgv.original.length > 2) { - if (npmArgv.original.some(arg => !!~args.indexOf(arg))) { - warn('WARNING: seems that you might used the wrong console syntax, no ` --' + ' ` delimiter was found, be sure you are invoking meteor-desktop with' + ' it when passing commands or options -> ' + '`npm run desktop -- command --option`\n'); - } - } - } catch (e) {// Not sure if `npm_config_argv` is always present... - } - } -} - -function meteorDesktopFactory(ddpUrl, production = false) { - info(`METEOR-DESKTOP v${require('./../../package.json').version}\n`); - verifyArgsSyntax(); - const input = process.cwd(); - - if (!isMeteorApp(input)) { - error(`not in a meteor app dir\n ${input}`); - process.exit(); - } - - if (!_commander.default.output) { - _commander.default.output = input; - } - - if (production && !_commander.default.production) { - info('package/build-installer implies setting --production, setting it for you'); - } - - if (!_commander.default.buildMeteor) { - _commander.default.port = _commander.default.port || 3000; - info(`REMINDER: your Meteor project should be running now on port ${_commander.default.port}\n`); - } - - if (_commander.default.prodDebug) { - info('!! WARNING: You are adding devTools to a production build !!\n'); - } - - const options = { - ddpUrl, - skipMobileBuild: _commander.default.buildMeteor ? !_commander.default.buildMeteor : true, - production: _commander.default.production || production - }; - (0, _assignIn.default)(options, _commander.default); - return (0, _.default)(input, _commander.default.output, options); -} - -function run(ddpUrl) { - meteorDesktopFactory(getDdpUrl(ddpUrl)).run(); -} - -function build(ddpUrl) { - meteorDesktopFactory(getDdpUrl(ddpUrl)).build(); -} - -function init() { - meteorDesktopFactory().init(); -} - -function justRun() { - meteorDesktopFactory().justRun(); -} - -function runPackager(ddpUrl) { - meteorDesktopFactory(getDdpUrl(ddpUrl), true).runPackager(); -} - -function buildInstaller(ddpUrl) { - meteorDesktopFactory(getDdpUrl(ddpUrl), true).buildInstaller(); -} - -function initTestsSupport() { - log('installing cross-env, ava, meteor-desktop-test-suite and spectron'); - log('running `meteor npm install --save-dev cross-env ava spectron meteor-desktop-test-suite`'); - - const { - code - } = _shelljs.default.exec('meteor npm install --save-dev cross-env ava spectron meteor-desktop-test-suite'); - - if (code !== 0) { - warn('could not add cross-env, ava and spectron to your `devDependencies`, please do it' + ' manually'); - } - - const test = 'cross-env NODE_ENV=test ava .desktop/**/*.test.js -s --verbose'; - const testWatch = 'cross-env NODE_ENV=test ava .desktop/**/*.test.js -s --verbose' + ' --watch --source .desktop'; - - function fail() { - error('\ncould not add entries to `scripts` in package.json'); - log('please try to add it manually\n'); - log(`test-desktop: ${test}`); - log(`test-desktop-watch: ${testWatch}`); - } - - const packageJsonPath = _path.default.resolve(_path.default.join(process.cwd(), 'package.json')); - - (0, _addScript.default)('test-desktop', test, packageJsonPath, fail); - (0, _addScript.default)('test-desktop-watch', testWatch, packageJsonPath, fail); - log('\nadded test-desktop and test-desktop-watch entries'); - log('run the test with `npm run test-desktop`'); -} - -_commander.default.command('init').description('scaffolds .desktop dir in the meteor app').action(init); - -_commander.default.command('run [ddp_url]').description('(default) builds and runs desktop app').action(run); - -_commander.default.command('build [ddp_url]').description('builds your desktop app').action(build); - -_commander.default.command('build-installer [ddp_url]').description('creates the installer').action(buildInstaller); - -_commander.default.command('just-run').description('alias for running `electron .` in `.meteor/desktop-build`').action(justRun); - -_commander.default.command('package [ddp_url]').description('runs electron packager').action(runPackager); - -_commander.default.command('init-tests-support').description('prepares project for running functional tests of desktop app').action(initTestsSupport); - -if (process.argv.length === 2 || !~'-h|--help|run|init|build|build-installer|just-run|init-tests-support|package'.indexOf(cmd)) { - let { - argv - } = process; - - if (process.argv.length === 2) { - argv.push('run'); - } else { - let command = argv.splice(0, 2); - command = command.concat('run', argv); - argv = command; - } - - _commander.default.parse(argv); -} else { - _commander.default.parse(process.argv); -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","cmd","process","argv","log","error","info","warn","console","isMeteorApp","appPath","meteorPath","fs","statSync","isDirectory","e","getDdpUrl","ddpUrl","program","buildMeteor","collect","val","memo","push","option","usage","version","require","on","verifyArgsSyntax","env","npm_config_argv","npmArgv","args","JSON","parse","remain","length","original","some","arg","indexOf","meteorDesktopFactory","production","input","cwd","exit","output","port","prodDebug","options","skipMobileBuild","assignIn","meteorDesktop","run","build","init","justRun","runPackager","buildInstaller","initTestsSupport","code","shell","exec","test","testWatch","fail","packageJsonPath","resolve","addScript","command","description","action","splice","concat"],"sources":["../../lib/bin/cli.js"],"sourcesContent":["#!/usr/bin/env node\n/* eslint-disable global-require */\nimport fs from 'fs';\nimport path from 'path';\nimport assignIn from 'lodash/assignIn';\nimport program from 'commander';\nimport shell from 'shelljs';\n\nimport meteorDesktop from '../..';\nimport addScript from '../scripts/utils/addScript';\n\nconst { join } = path;\nconst cmd = process.argv[2];\n\n/* eslint-disable no-console */\nconst {\n    log, error, info, warn\n} = console;\n\n/* eslint-enable no-console */\n\n/**\n * Looks for .meteor directory.\n * @param {string} appPath - Meteor app path\n */\nfunction isMeteorApp(appPath) {\n    const meteorPath = join(appPath, '.meteor');\n    try {\n        return fs.statSync(meteorPath).isDirectory();\n    } catch (e) {\n        return false;\n    }\n}\n\n/**\n * Just ensures a ddp url is set.\n *\n * @param {string|null} ddpUrl - the url that Meteor app connects to\n * @returns {string|null}\n */\nfunction getDdpUrl(ddpUrl = null) {\n    if (!ddpUrl && program.buildMeteor) {\n        info('no ddp_url specified, setting default: http://127.0.0.1:3000');\n        return 'http://127.0.0.1:3000';\n    }\n    return ddpUrl;\n}\n\n// --------------------------\n\nfunction collect(val, memo) {\n    memo.push(val);\n    return memo;\n}\n\nprogram\n    .option('-b, --build-meteor', 'runs meteor to obtain the mobile build, kills it after')\n    .option('-t, --build-timeout <timeout_in_sec>', 'timeout value when waiting for ' +\n        'meteor to build, default 600sec')\n    .option('-p, --port <port>', 'port on which meteor is running, when with -b this will be passed to meteor when obtaining the build')\n    .option('--production', 'builds meteor app with the production switch, uglifies contents ' +\n        'of .desktop, packs app to app.asar')\n    .option('-a, --android', 'force adding android as a mobile platform instead of ios')\n    .option('-s, --scaffold', 'will scaffold .desktop if not present')\n    .option('-i, --ignore-stderr [string]', 'only with -b, strings that when found will not terminate meteor build', collect, [])\n    .option('--meteor-settings <path>', 'only with -b, adds --settings options to meteor')\n    .option('--prod-debug', 'forces adding dev tools to a production build')\n    .option('--ia32', 'generate 32bit installer/package')\n    .option('--all-archs', 'generate 32bit and 64bit installers')\n    .option('--win', 'generate Windows installer')\n    .option('--linux', 'generate Linux installer')\n    .option('--mac', 'generate Mac installer')\n    .option('-d, --debug', 'run electron with debug switch');\n\n\nprogram\n    .usage('[command] [options]')\n    .version(require('./../../package.json').version, '-V, --version')\n    .on('--help', () => {\n        log('  [ddp_url] - pass a ddp url if you want to use different one than used in meteor\\'s --mobile-server');\n        log('              this will also work with -b');\n        log('    ');\n        log('  Examples:');\n        log('');\n        log(\n            '   ',\n            [\n                '# cd into meteor dir first',\n                'cd /your/meteor/app',\n                'meteor --mobile-server=127.0.0.1:3000',\n                '',\n                '# open new terminal, assuming you have done npm install --save-dev @meteor-community/meteor-desktop',\n                'npm run desktop -- init',\n                'npm run desktop'\n            ].join('\\n    ')\n        );\n        log('\\n');\n    });\n\n\nfunction verifyArgsSyntax() {\n    if (process.env.npm_config_argv) {\n        let npmArgv;\n        try {\n            const args = ['-b', '--build-meteor', '-t', '--build-timeout', '-p', '--port',\n                '--production', '-a', '--android', '-s', '--scaffold', '--ia32', '--win',\n                '--linux', '--all-archs', '--win', '--mac', '--meteor-settings'];\n            npmArgv = JSON.parse(process.env.npm_config_argv);\n            if (npmArgv.remain.length === 0 && npmArgv.original.length > 2) {\n                if (npmArgv.original.some(arg => !!~args.indexOf(arg))) {\n                    warn('WARNING: seems that you might used the wrong console syntax, no ` --' +\n                        ' ` delimiter was found, be sure you are invoking meteor-desktop with' +\n                        ' it when passing commands or options -> ' +\n                        '`npm run desktop -- command --option`\\n');\n                }\n            }\n        } catch (e) {\n            // Not sure if `npm_config_argv` is always present...\n        }\n    }\n}\n\nfunction meteorDesktopFactory(ddpUrl, production = false) {\n    info(`METEOR-DESKTOP v${require('./../../package.json').version}\\n`);\n\n    verifyArgsSyntax();\n\n    const input = process.cwd();\n\n    if (!isMeteorApp(input)) {\n        error(`not in a meteor app dir\\n ${input}`);\n        process.exit();\n    }\n\n    if (!program.output) {\n        program.output = input;\n    }\n\n    if (production && !program.production) {\n        info('package/build-installer implies setting --production, setting it for you');\n    }\n\n    if (!program.buildMeteor) {\n        program.port = program.port || 3000;\n        info(`REMINDER: your Meteor project should be running now on port ${program.port}\\n`);\n    }\n\n    if (program.prodDebug) {\n        info('!! WARNING: You are adding devTools to a production build !!\\n');\n    }\n\n    const options = {\n        ddpUrl,\n        skipMobileBuild: program.buildMeteor ? !program.buildMeteor : true,\n        production: program.production || production\n    };\n\n    assignIn(options, program);\n\n    return meteorDesktop(\n        input,\n        program.output,\n        options\n    );\n}\n\nfunction run(ddpUrl) {\n    meteorDesktopFactory(getDdpUrl(ddpUrl)).run();\n}\n\nfunction build(ddpUrl) {\n    meteorDesktopFactory(getDdpUrl(ddpUrl)).build();\n}\n\nfunction init() {\n    meteorDesktopFactory().init();\n}\n\nfunction justRun() {\n    meteorDesktopFactory().justRun();\n}\n\nfunction runPackager(ddpUrl) {\n    meteorDesktopFactory(getDdpUrl(ddpUrl), true).runPackager();\n}\n\nfunction buildInstaller(ddpUrl) {\n    meteorDesktopFactory(getDdpUrl(ddpUrl), true).buildInstaller();\n}\n\nfunction initTestsSupport() {\n    log('installing cross-env, ava, meteor-desktop-test-suite and spectron');\n    log('running `meteor npm install --save-dev cross-env ava spectron meteor-desktop-test-suite`');\n\n    const { code } = shell.exec('meteor npm install --save-dev cross-env ava spectron meteor-desktop-test-suite');\n\n    if (code !== 0) {\n        warn('could not add cross-env, ava and spectron to your `devDependencies`, please do it' +\n            ' manually');\n    }\n\n    const test = 'cross-env NODE_ENV=test ava .desktop/**/*.test.js -s --verbose';\n    const testWatch = 'cross-env NODE_ENV=test ava .desktop/**/*.test.js -s --verbose' +\n        ' --watch --source .desktop';\n\n    function fail() {\n        error('\\ncould not add entries to `scripts` in package.json');\n        log('please try to add it manually\\n');\n        log(`test-desktop: ${test}`);\n        log(`test-desktop-watch: ${testWatch}`);\n    }\n\n    const packageJsonPath = path.resolve(\n        path.join(process.cwd(), 'package.json')\n    );\n\n    addScript('test-desktop', test, packageJsonPath, fail);\n    addScript('test-desktop-watch', testWatch, packageJsonPath, fail);\n\n    log('\\nadded test-desktop and test-desktop-watch entries');\n    log('run the test with `npm run test-desktop`');\n}\n\nprogram\n    .command('init')\n    .description('scaffolds .desktop dir in the meteor app')\n    .action(init);\n\nprogram\n    .command('run [ddp_url]')\n    .description('(default) builds and runs desktop app')\n    .action(run);\n\nprogram\n    .command('build [ddp_url]')\n    .description('builds your desktop app')\n    .action(build);\n\nprogram\n    .command('build-installer [ddp_url]')\n    .description('creates the installer')\n    .action(buildInstaller);\n\nprogram\n    .command('just-run')\n    .description('alias for running `electron .` in `.meteor/desktop-build`')\n    .action(justRun);\n\nprogram\n    .command('package [ddp_url]')\n    .description('runs electron packager')\n    .action(runPackager);\n\nprogram\n    .command('init-tests-support')\n    .description('prepares project for running functional tests of desktop app')\n    .action(initTestsSupport);\n\nif (process.argv.length === 2 || !~('-h|--help|run|init|build|build-installer|just-run|init-tests-support|package'.indexOf(cmd))\n) {\n    let { argv } = process;\n    if (process.argv.length === 2) {\n        argv.push('run');\n    } else {\n        let command = argv.splice(0, 2);\n        command = command.concat('run', argv);\n        argv = command;\n    }\n    program.parse(argv);\n} else {\n    program.parse(process.argv);\n}\n"],"mappings":"AAAA;;AACA;;;AACA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;;;AAEA,MAAM;EAAEA;AAAF,IAAWC,aAAjB;AACA,MAAMC,GAAG,GAAGC,OAAO,CAACC,IAAR,CAAa,CAAb,CAAZ;AAEA;;AACA,MAAM;EACFC,GADE;EACGC,KADH;EACUC,IADV;EACgBC;AADhB,IAEFC,OAFJ;AAIA;;AAEA;AACA;AACA;AACA;;AACA,SAASC,WAAT,CAAqBC,OAArB,EAA8B;EAC1B,MAAMC,UAAU,GAAGZ,IAAI,CAACW,OAAD,EAAU,SAAV,CAAvB;;EACA,IAAI;IACA,OAAOE,WAAA,CAAGC,QAAH,CAAYF,UAAZ,EAAwBG,WAAxB,EAAP;EACH,CAFD,CAEE,OAAOC,CAAP,EAAU;IACR,OAAO,KAAP;EACH;AACJ;AAED;AACA;AACA;AACA;AACA;AACA;;;AACA,SAASC,SAAT,CAAmBC,MAAM,GAAG,IAA5B,EAAkC;EAC9B,IAAI,CAACA,MAAD,IAAWC,kBAAA,CAAQC,WAAvB,EAAoC;IAChCb,IAAI,CAAC,8DAAD,CAAJ;IACA,OAAO,uBAAP;EACH;;EACD,OAAOW,MAAP;AACH,C,CAED;;;AAEA,SAASG,OAAT,CAAiBC,GAAjB,EAAsBC,IAAtB,EAA4B;EACxBA,IAAI,CAACC,IAAL,CAAUF,GAAV;EACA,OAAOC,IAAP;AACH;;AAEDJ,kBAAA,CACKM,MADL,CACY,oBADZ,EACkC,wDADlC,EAEKA,MAFL,CAEY,sCAFZ,EAEoD,oCAC5C,iCAHR,EAIKA,MAJL,CAIY,mBAJZ,EAIiC,sGAJjC,EAKKA,MALL,CAKY,cALZ,EAK4B,qEACpB,oCANR,EAOKA,MAPL,CAOY,eAPZ,EAO6B,0DAP7B,EAQKA,MARL,CAQY,gBARZ,EAQ8B,uCAR9B,EASKA,MATL,CASY,8BATZ,EAS4C,uEAT5C,EASqHJ,OATrH,EAS8H,EAT9H,EAUKI,MAVL,CAUY,0BAVZ,EAUwC,iDAVxC,EAWKA,MAXL,CAWY,cAXZ,EAW4B,+CAX5B,EAYKA,MAZL,CAYY,QAZZ,EAYsB,kCAZtB,EAaKA,MAbL,CAaY,aAbZ,EAa2B,qCAb3B,EAcKA,MAdL,CAcY,OAdZ,EAcqB,4BAdrB,EAeKA,MAfL,CAeY,SAfZ,EAeuB,0BAfvB,EAgBKA,MAhBL,CAgBY,OAhBZ,EAgBqB,wBAhBrB,EAiBKA,MAjBL,CAiBY,aAjBZ,EAiB2B,gCAjB3B;;AAoBAN,kBAAA,CACKO,KADL,CACW,qBADX,EAEKC,OAFL,CAEaC,OAAO,CAAC,sBAAD,CAAP,CAAgCD,OAF7C,EAEsD,eAFtD,EAGKE,EAHL,CAGQ,QAHR,EAGkB,MAAM;EAChBxB,GAAG,CAAC,sGAAD,CAAH;EACAA,GAAG,CAAC,2CAAD,CAAH;EACAA,GAAG,CAAC,MAAD,CAAH;EACAA,GAAG,CAAC,aAAD,CAAH;EACAA,GAAG,CAAC,EAAD,CAAH;EACAA,GAAG,CACC,KADD,EAEC,CACI,4BADJ,EAEI,qBAFJ,EAGI,uCAHJ,EAII,EAJJ,EAKI,qGALJ,EAMI,yBANJ,EAOI,iBAPJ,EAQEL,IARF,CAQO,QARP,CAFD,CAAH;EAYAK,GAAG,CAAC,IAAD,CAAH;AACH,CAtBL;;AAyBA,SAASyB,gBAAT,GAA4B;EACxB,IAAI3B,OAAO,CAAC4B,GAAR,CAAYC,eAAhB,EAAiC;IAC7B,IAAIC,OAAJ;;IACA,IAAI;MACA,MAAMC,IAAI,GAAG,CAAC,IAAD,EAAO,gBAAP,EAAyB,IAAzB,EAA+B,iBAA/B,EAAkD,IAAlD,EAAwD,QAAxD,EACT,cADS,EACO,IADP,EACa,WADb,EAC0B,IAD1B,EACgC,YADhC,EAC8C,QAD9C,EACwD,OADxD,EAET,SAFS,EAEE,aAFF,EAEiB,OAFjB,EAE0B,OAF1B,EAEmC,mBAFnC,CAAb;MAGAD,OAAO,GAAGE,IAAI,CAACC,KAAL,CAAWjC,OAAO,CAAC4B,GAAR,CAAYC,eAAvB,CAAV;;MACA,IAAIC,OAAO,CAACI,MAAR,CAAeC,MAAf,KAA0B,CAA1B,IAA+BL,OAAO,CAACM,QAAR,CAAiBD,MAAjB,GAA0B,CAA7D,EAAgE;QAC5D,IAAIL,OAAO,CAACM,QAAR,CAAiBC,IAAjB,CAAsBC,GAAG,IAAI,CAAC,CAAC,CAACP,IAAI,CAACQ,OAAL,CAAaD,GAAb,CAAhC,CAAJ,EAAwD;UACpDjC,IAAI,CAAC,yEACD,sEADC,GAED,0CAFC,GAGD,yCAHA,CAAJ;QAIH;MACJ;IACJ,CAbD,CAaE,OAAOQ,CAAP,EAAU,CACR;IACH;EACJ;AACJ;;AAED,SAAS2B,oBAAT,CAA8BzB,MAA9B,EAAsC0B,UAAU,GAAG,KAAnD,EAA0D;EACtDrC,IAAI,CAAE,mBAAkBqB,OAAO,CAAC,sBAAD,CAAP,CAAgCD,OAAQ,IAA5D,CAAJ;EAEAG,gBAAgB;EAEhB,MAAMe,KAAK,GAAG1C,OAAO,CAAC2C,GAAR,EAAd;;EAEA,IAAI,CAACpC,WAAW,CAACmC,KAAD,CAAhB,EAAyB;IACrBvC,KAAK,CAAE,6BAA4BuC,KAAM,EAApC,CAAL;IACA1C,OAAO,CAAC4C,IAAR;EACH;;EAED,IAAI,CAAC5B,kBAAA,CAAQ6B,MAAb,EAAqB;IACjB7B,kBAAA,CAAQ6B,MAAR,GAAiBH,KAAjB;EACH;;EAED,IAAID,UAAU,IAAI,CAACzB,kBAAA,CAAQyB,UAA3B,EAAuC;IACnCrC,IAAI,CAAC,0EAAD,CAAJ;EACH;;EAED,IAAI,CAACY,kBAAA,CAAQC,WAAb,EAA0B;IACtBD,kBAAA,CAAQ8B,IAAR,GAAe9B,kBAAA,CAAQ8B,IAAR,IAAgB,IAA/B;IACA1C,IAAI,CAAE,+DAA8DY,kBAAA,CAAQ8B,IAAK,IAA7E,CAAJ;EACH;;EAED,IAAI9B,kBAAA,CAAQ+B,SAAZ,EAAuB;IACnB3C,IAAI,CAAC,gEAAD,CAAJ;EACH;;EAED,MAAM4C,OAAO,GAAG;IACZjC,MADY;IAEZkC,eAAe,EAAEjC,kBAAA,CAAQC,WAAR,GAAsB,CAACD,kBAAA,CAAQC,WAA/B,GAA6C,IAFlD;IAGZwB,UAAU,EAAEzB,kBAAA,CAAQyB,UAAR,IAAsBA;EAHtB,CAAhB;EAMA,IAAAS,iBAAA,EAASF,OAAT,EAAkBhC,kBAAlB;EAEA,OAAO,IAAAmC,SAAA,EACHT,KADG,EAEH1B,kBAAA,CAAQ6B,MAFL,EAGHG,OAHG,CAAP;AAKH;;AAED,SAASI,GAAT,CAAarC,MAAb,EAAqB;EACjByB,oBAAoB,CAAC1B,SAAS,CAACC,MAAD,CAAV,CAApB,CAAwCqC,GAAxC;AACH;;AAED,SAASC,KAAT,CAAetC,MAAf,EAAuB;EACnByB,oBAAoB,CAAC1B,SAAS,CAACC,MAAD,CAAV,CAApB,CAAwCsC,KAAxC;AACH;;AAED,SAASC,IAAT,GAAgB;EACZd,oBAAoB,GAAGc,IAAvB;AACH;;AAED,SAASC,OAAT,GAAmB;EACff,oBAAoB,GAAGe,OAAvB;AACH;;AAED,SAASC,WAAT,CAAqBzC,MAArB,EAA6B;EACzByB,oBAAoB,CAAC1B,SAAS,CAACC,MAAD,CAAV,EAAoB,IAApB,CAApB,CAA8CyC,WAA9C;AACH;;AAED,SAASC,cAAT,CAAwB1C,MAAxB,EAAgC;EAC5ByB,oBAAoB,CAAC1B,SAAS,CAACC,MAAD,CAAV,EAAoB,IAApB,CAApB,CAA8C0C,cAA9C;AACH;;AAED,SAASC,gBAAT,GAA4B;EACxBxD,GAAG,CAAC,mEAAD,CAAH;EACAA,GAAG,CAAC,0FAAD,CAAH;;EAEA,MAAM;IAAEyD;EAAF,IAAWC,gBAAA,CAAMC,IAAN,CAAW,gFAAX,CAAjB;;EAEA,IAAIF,IAAI,KAAK,CAAb,EAAgB;IACZtD,IAAI,CAAC,sFACD,WADA,CAAJ;EAEH;;EAED,MAAMyD,IAAI,GAAG,gEAAb;EACA,MAAMC,SAAS,GAAG,mEACd,4BADJ;;EAGA,SAASC,IAAT,GAAgB;IACZ7D,KAAK,CAAC,sDAAD,CAAL;IACAD,GAAG,CAAC,iCAAD,CAAH;IACAA,GAAG,CAAE,iBAAgB4D,IAAK,EAAvB,CAAH;IACA5D,GAAG,CAAE,uBAAsB6D,SAAU,EAAlC,CAAH;EACH;;EAED,MAAME,eAAe,GAAGnE,aAAA,CAAKoE,OAAL,CACpBpE,aAAA,CAAKD,IAAL,CAAUG,OAAO,CAAC2C,GAAR,EAAV,EAAyB,cAAzB,CADoB,CAAxB;;EAIA,IAAAwB,kBAAA,EAAU,cAAV,EAA0BL,IAA1B,EAAgCG,eAAhC,EAAiDD,IAAjD;EACA,IAAAG,kBAAA,EAAU,oBAAV,EAAgCJ,SAAhC,EAA2CE,eAA3C,EAA4DD,IAA5D;EAEA9D,GAAG,CAAC,qDAAD,CAAH;EACAA,GAAG,CAAC,0CAAD,CAAH;AACH;;AAEDc,kBAAA,CACKoD,OADL,CACa,MADb,EAEKC,WAFL,CAEiB,0CAFjB,EAGKC,MAHL,CAGYhB,IAHZ;;AAKAtC,kBAAA,CACKoD,OADL,CACa,eADb,EAEKC,WAFL,CAEiB,uCAFjB,EAGKC,MAHL,CAGYlB,GAHZ;;AAKApC,kBAAA,CACKoD,OADL,CACa,iBADb,EAEKC,WAFL,CAEiB,yBAFjB,EAGKC,MAHL,CAGYjB,KAHZ;;AAKArC,kBAAA,CACKoD,OADL,CACa,2BADb,EAEKC,WAFL,CAEiB,uBAFjB,EAGKC,MAHL,CAGYb,cAHZ;;AAKAzC,kBAAA,CACKoD,OADL,CACa,UADb,EAEKC,WAFL,CAEiB,2DAFjB,EAGKC,MAHL,CAGYf,OAHZ;;AAKAvC,kBAAA,CACKoD,OADL,CACa,mBADb,EAEKC,WAFL,CAEiB,wBAFjB,EAGKC,MAHL,CAGYd,WAHZ;;AAKAxC,kBAAA,CACKoD,OADL,CACa,oBADb,EAEKC,WAFL,CAEiB,8DAFjB,EAGKC,MAHL,CAGYZ,gBAHZ;;AAKA,IAAI1D,OAAO,CAACC,IAAR,CAAakC,MAAb,KAAwB,CAAxB,IAA6B,CAAC,CAAE,+EAA+EI,OAA/E,CAAuFxC,GAAvF,CAApC,EACE;EACE,IAAI;IAAEE;EAAF,IAAWD,OAAf;;EACA,IAAIA,OAAO,CAACC,IAAR,CAAakC,MAAb,KAAwB,CAA5B,EAA+B;IAC3BlC,IAAI,CAACoB,IAAL,CAAU,KAAV;EACH,CAFD,MAEO;IACH,IAAI+C,OAAO,GAAGnE,IAAI,CAACsE,MAAL,CAAY,CAAZ,EAAe,CAAf,CAAd;IACAH,OAAO,GAAGA,OAAO,CAACI,MAAR,CAAe,KAAf,EAAsBvE,IAAtB,CAAV;IACAA,IAAI,GAAGmE,OAAP;EACH;;EACDpD,kBAAA,CAAQiB,KAAR,CAAchC,IAAd;AACH,CAXD,MAWO;EACHe,kBAAA,CAAQiB,KAAR,CAAcjC,OAAO,CAACC,IAAtB;AACH"} \ No newline at end of file diff --git a/dist/binaryModulesDetector.js b/dist/binaryModulesDetector.js deleted file mode 100644 index a074f7bb..00000000 --- a/dist/binaryModulesDetector.js +++ /dev/null @@ -1,80 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _path = _interopRequireDefault(require("path")); - -var _isbinaryfile = _interopRequireDefault(require("isbinaryfile")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _log = _interopRequireDefault(require("./log")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -_shelljs.default.config.fatal = true; -/** - * Experimental module for detecting modules containing binary files. - * Based on the same functionality from electron-builder. - * - * @property {MeteorDesktop} $ - * @class - */ - -class BinaryModulesDetector { - /** - * @constructor - */ - constructor(nodeModulesPath) { - this.log = new _log.default('binaryModulesDetector'); - this.nodeModulesPath = nodeModulesPath; - } // TODO: make asynchronous - - - detect() { - this.log.verbose('detecting node modules with binary files'); - - const files = _shelljs.default.ls('-RAl', this.nodeModulesPath); - - const extract = []; - files.forEach(file => { - const pathSplit = file.name.split(_path.default.posix.sep); - const dir = pathSplit[0]; - const filename = pathSplit.pop(); - - if (extract.indexOf(dir) === -1 && !BinaryModulesDetector.shouldBeIgnored(dir, filename)) { - if (file.isFile()) { - let shouldUnpack = false; - - if (file.name.endsWith('.dll') || file.name.endsWith('.exe') || file.name.endsWith('.dylib')) { - shouldUnpack = true; - } else if (_path.default.extname(file.name) === '') { - shouldUnpack = _isbinaryfile.default.sync(_path.default.join(this.nodeModulesPath, file.name)); - } - - if (shouldUnpack) { - this.log.debug(`binary file: ${file.name}`); - extract.push(dir); - } - } - } - }); - - if (extract.length > 0) { - this.log.verbose(`detected modules to be extracted: ${extract.join(', ')}`); - } - - return extract; - } - - static shouldBeIgnored(dir, filename) { - return dir === '.bin' || filename === '.DS_Store' || filename === 'LICENSE' || filename === 'README'; - } - -} - -exports.default = BinaryModulesDetector; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/defaultDependencies.js b/dist/defaultDependencies.js deleted file mode 100644 index c5232dcc..00000000 --- a/dist/defaultDependencies.js +++ /dev/null @@ -1,8 +0,0 @@ -"use strict"; - -module.exports = { - electron: '11.5.0', - 'electron-builder': '23.3.1', - 'electron-packager': '15.4.0' -}; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJtb2R1bGUiLCJleHBvcnRzIiwiZWxlY3Ryb24iXSwic291cmNlcyI6WyIuLi9saWIvZGVmYXVsdERlcGVuZGVuY2llcy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJtb2R1bGUuZXhwb3J0cyA9IHtcbiAgICBlbGVjdHJvbjogJzExLjUuMCcsXG4gICAgJ2VsZWN0cm9uLWJ1aWxkZXInOiAnMjMuMy4xJyxcbiAgICAnZWxlY3Ryb24tcGFja2FnZXInOiAnMTUuNC4wJ1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7QUFBQUEsTUFBTSxDQUFDQyxPQUFQLEdBQWlCO0VBQ2JDLFFBQVEsRUFBRSxRQURHO0VBRWIsb0JBQW9CLFFBRlA7RUFHYixxQkFBcUI7QUFIUixDQUFqQiJ9 \ No newline at end of file diff --git a/dist/dependenciesManager.js b/dist/dependenciesManager.js deleted file mode 100644 index d5d4ac90..00000000 --- a/dist/dependenciesManager.js +++ /dev/null @@ -1,181 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _lodash = require("lodash"); - -var _log = _interopRequireDefault(require("./log")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars - -/** - * Utility class designed for merging dependencies list with simple validation and duplicate - * detection. - * - * @class - */ -class DependenciesManager { - /** - * @param {MeteorDesktop} $ - context - * @param {Object} defaultDependencies - core dependencies list - * @constructor - */ - constructor($, defaultDependencies) { - this.log = new _log.default('dependenciesManager'); - this.$ = $; - this.dependencies = defaultDependencies; // Regexes for matching certain types of dependencies version. - // https://docs.npmjs.com/files/package.json#dependencies - - this.regexes = { - local: /^(\.\.\/|~\/|\.\/|\/)/, - git: /^git(\+(ssh|http)s?)?/, - github: /^\w+-?\w+(?!-)\//, - http: /^https?.+tar\.gz/, - file: /^file:/ - }; // Check for commit hashes. - - const gitCheck = { - type: 'regex', - regex: /#[a-f0-9]{7,40}/, - test: 'match', - message: 'git or github link must have a commit hash' - }; // Check for displaying warnings when npm package from local path is used. - - const localCheck = { - onceName: 'localCheck', - type: 'warning', - message: 'using dependencies from local paths is permitted' + ' but dangerous - read more in README.md' - }; - this.checks = { - local: localCheck, - file: localCheck, - git: gitCheck, - github: gitCheck, - version: { - type: 'regex', - // Matches all the semver ranges operators, empty strings and `*`. - regex: /[\^|><= ~-]|\.x|^$|^\*$/, - test: 'do not match', - message: 'semver ranges are forbidden, please specify exact version' - } - }; - } - /** - * Just a public getter. - * @returns {Object} - */ - - - getDependencies() { - return this.dependencies; - } - /** - * Returns local dependencies. - * @returns {Object} - */ - - - getLocalDependencies() { - return Object.keys(this.dependencies).filter(dependency => this.regexes.local.test(this.dependencies[dependency]) || this.regexes.file.test(this.dependencies[dependency])).reduce((localDependencies, currentDependency) => Object.assign(localDependencies, { - [currentDependency]: this.dependencies[currentDependency] - }), {}); - } - /** - * Returns remote dependencies. - * @returns {Object} - */ - - - getRemoteDependencies() { - return Object.keys(this.dependencies).filter(dependency => !this.regexes.local.test(this.dependencies[dependency]) && !this.regexes.file.test(this.dependencies[dependency])).reduce((localDependencies, currentDependency) => Object.assign(localDependencies, { - [currentDependency]: this.dependencies[currentDependency] - }), {}); - } - /** - * Merges dependencies into one list. - * - * @param {string} from - describes where the dependencies were set - * @param {Object} dependencies - dependencies list - */ - - - mergeDependencies(from, dependencies) { - if (this.validateDependenciesVersions(from, dependencies)) { - this.detectDuplicatedDependencies(from, dependencies); - (0, _lodash.assignIn)(this.dependencies, dependencies); - } - } - /** - * Detects dependency version type. - * @param {string} version - version string of the dependency - * @return {string} - */ - - - detectDependencyVersionType(version) { - const type = Object.keys(this.regexes).find(dependencyType => this.regexes[dependencyType].test(version)); - return type || 'version'; - } - /** - * Validates semver and detect ranges. - * - * @param {string} from - describes where the dependencies were set - * @param {Object} dependencies - dependencies list - */ - - - validateDependenciesVersions(from, dependencies) { - const warningsShown = {}; - (0, _lodash.forEach)(dependencies, (version, name) => { - const type = this.detectDependencyVersionType(version); - - if (this.checks[type]) { - const check = this.checks[type]; - - if (check.type === 'regex') { - const checkResult = check.test === 'match' ? this.checks[type].regex.test(version) : !this.checks[type].regex.test(version); - - if (!checkResult) { - throw new Error(`dependency ${name}:${version} from ${from} failed version ` + `check with message: ${this.checks[type].message}`); - } - } - - if (check.type === 'warning' && !warningsShown[check.onceName]) { - warningsShown[check.onceName] = true; - this.log.warn(`dependency ${name}:${version} from ${from} caused a` + ` warning: ${check.message}`); - } - } - }); - return true; - } - /** - * Detects duplicates. - * - * @param {string} from - describes where the dependencies were set - * @param {Object} dependencies - dependencies list - */ - - - detectDuplicatedDependencies(from, dependencies) { - const duplicates = (0, _lodash.intersection)(Object.keys(dependencies), Object.keys(this.dependencies)); - - if (duplicates.length > 0) { - duplicates.forEach(name => { - if (dependencies[name] !== this.dependencies[name]) { - throw new Error(`While processing dependencies from ${from}, a dependency ` + `${name}: ${dependencies[name]} was found to be conflicting with a ` + `dependency (${this.dependencies[name]}) that was already declared in ` + 'other module or it is used in core of the electron app.'); - } - }); - } - } - -} - -exports.default = DependenciesManager; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DependenciesManager","constructor","$","defaultDependencies","log","Log","dependencies","regexes","local","git","github","http","file","gitCheck","type","regex","test","message","localCheck","onceName","checks","version","getDependencies","getLocalDependencies","Object","keys","filter","dependency","reduce","localDependencies","currentDependency","assign","getRemoteDependencies","mergeDependencies","from","validateDependenciesVersions","detectDuplicatedDependencies","assignIn","detectDependencyVersionType","find","dependencyType","warningsShown","forEach","name","check","checkResult","Error","warn","duplicates","intersection","length"],"sources":["../lib/dependenciesManager.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport { forEach, assignIn, intersection } from 'lodash';\n\nimport Log from './log';\n\n/**\n * Utility class designed for merging dependencies list with simple validation and duplicate\n * detection.\n *\n * @class\n */\nexport default class DependenciesManager {\n    /**\n     * @param {MeteorDesktop} $                   - context\n     * @param {Object}        defaultDependencies - core dependencies list\n     * @constructor\n     */\n    constructor($, defaultDependencies) {\n        this.log = new Log('dependenciesManager');\n        this.$ = $;\n        this.dependencies = defaultDependencies;\n\n        // Regexes for matching certain types of dependencies version.\n        // https://docs.npmjs.com/files/package.json#dependencies\n        this.regexes = {\n            local: /^(\\.\\.\\/|~\\/|\\.\\/|\\/)/,\n            git: /^git(\\+(ssh|http)s?)?/,\n            github: /^\\w+-?\\w+(?!-)\\//,\n            http: /^https?.+tar\\.gz/,\n            file: /^file:/\n        };\n\n        // Check for commit hashes.\n        const gitCheck = {\n            type: 'regex',\n            regex: /#[a-f0-9]{7,40}/,\n            test: 'match',\n            message: 'git or github link must have a commit hash'\n        };\n\n        // Check for displaying warnings when npm package from local path is used.\n        const localCheck = {\n            onceName: 'localCheck',\n            type: 'warning',\n            message: 'using dependencies from local paths is permitted' +\n            ' but dangerous - read more in README.md'\n        };\n\n        this.checks = {\n            local: localCheck,\n            file: localCheck,\n            git: gitCheck,\n            github: gitCheck,\n            version: {\n                type: 'regex',\n                // Matches all the semver ranges operators, empty strings and `*`.\n                regex: /[\\^|><= ~-]|\\.x|^$|^\\*$/,\n                test: 'do not match',\n                message: 'semver ranges are forbidden, please specify exact version'\n            }\n        };\n    }\n\n    /**\n     * Just a public getter.\n     * @returns {Object}\n     */\n    getDependencies() {\n        return this.dependencies;\n    }\n\n    /**\n     * Returns local dependencies.\n     * @returns {Object}\n     */\n    getLocalDependencies() {\n        return Object\n            .keys(this.dependencies)\n            .filter(\n                dependency =>\n                    this.regexes.local.test(this.dependencies[dependency]) ||\n                    this.regexes.file.test(this.dependencies[dependency])\n            )\n            .reduce(\n                (localDependencies, currentDependency) =>\n                    Object.assign(\n                        localDependencies,\n                        { [currentDependency]: this.dependencies[currentDependency] }\n                    ),\n                {}\n            );\n    }\n\n    /**\n     * Returns remote dependencies.\n     * @returns {Object}\n     */\n    getRemoteDependencies() {\n        return Object\n            .keys(this.dependencies)\n            .filter(\n                dependency =>\n                    !this.regexes.local.test(this.dependencies[dependency]) &&\n                    !this.regexes.file.test(this.dependencies[dependency])\n            )\n            .reduce(\n                (localDependencies, currentDependency) =>\n                    Object.assign(\n                        localDependencies,\n                        { [currentDependency]: this.dependencies[currentDependency] }\n                    ),\n                {}\n            );\n    }\n\n    /**\n     * Merges dependencies into one list.\n     *\n     * @param {string} from         - describes where the dependencies were set\n     * @param {Object} dependencies - dependencies list\n     */\n    mergeDependencies(from, dependencies) {\n        if (this.validateDependenciesVersions(from, dependencies)) {\n            this.detectDuplicatedDependencies(from, dependencies);\n            assignIn(this.dependencies, dependencies);\n        }\n    }\n\n    /**\n     * Detects dependency version type.\n     * @param {string} version - version string of the dependency\n     * @return {string}\n     */\n    detectDependencyVersionType(version) {\n        const type = Object.keys(this.regexes)\n            .find(dependencyType => this.regexes[dependencyType].test(version));\n        return type || 'version';\n    }\n\n    /**\n     * Validates semver and detect ranges.\n     *\n     * @param {string} from         - describes where the dependencies were set\n     * @param {Object} dependencies - dependencies list\n     */\n    validateDependenciesVersions(from, dependencies) {\n        const warningsShown = {};\n        forEach(dependencies, (version, name) => {\n            const type = this.detectDependencyVersionType(version);\n            if (this.checks[type]) {\n                const check = this.checks[type];\n                if (check.type === 'regex') {\n                    const checkResult = check.test === 'match' ?\n                        this.checks[type].regex.test(version) :\n                        !this.checks[type].regex.test(version);\n                    if (!checkResult) {\n                        throw new Error(`dependency ${name}:${version} from ${from} failed version ` +\n                            `check with message: ${this.checks[type].message}`);\n                    }\n                }\n                if (check.type === 'warning' && !warningsShown[check.onceName]) {\n                    warningsShown[check.onceName] = true;\n                    this.log.warn(`dependency ${name}:${version} from ${from} caused a` +\n                        ` warning: ${check.message}`);\n                }\n            }\n        });\n        return true;\n    }\n\n    /**\n     * Detects duplicates.\n     *\n     * @param {string} from         - describes where the dependencies were set\n     * @param {Object} dependencies - dependencies list\n     */\n    detectDuplicatedDependencies(from, dependencies) {\n        const duplicates = intersection(Object.keys(dependencies), Object.keys(this.dependencies));\n        if (duplicates.length > 0) {\n            duplicates.forEach((name) => {\n                if (dependencies[name] !== this.dependencies[name]) {\n                    throw new Error(`While processing dependencies from ${from}, a dependency ` +\n                        `${name}: ${dependencies[name]} was found to be conflicting with a ` +\n                        `dependency (${this.dependencies[name]}) that was already declared in ` +\n                        'other module or it is used in core of the electron app.');\n                }\n            });\n        }\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/desktop.js b/dist/desktop.js deleted file mode 100644 index 3a5f1cd9..00000000 --- a/dist/desktop.js +++ /dev/null @@ -1,271 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _fs = _interopRequireDefault(require("fs")); - -var _path = _interopRequireDefault(require("path")); - -var _log = _interopRequireDefault(require("./log")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars -_shelljs.default.config.fatal = true; -/** - * Checks if the path is empty. - * @param {string} searchPath - * @returns {boolean} - */ - -function isEmptySync(searchPath) { - let stat; - - try { - stat = _fs.default.statSync(searchPath); - } catch (e) { - return true; - } - - if (stat.isDirectory()) { - const items = _fs.default.readdirSync(searchPath); - - return !items || !items.length; - } - - return false; -} -/** - * Represents the .desktop directory. - * @class - * @property {desktopSettings} settings - */ - - -class Desktop { - /** - * @param {MeteorDesktop} $ - context - * - * @constructor - */ - constructor($) { - this.$ = $; - this.log = new _log.default('desktop'); - this.settings = null; - this.dependencies = null; - } - /** - * Tries to read and returns settings.json contents from .desktop dir. - * - * @returns {desktopSettings|null} - */ - - - getSettings() { - if (!this.settings) { - try { - this.settings = JSON.parse(_fs.default.readFileSync(this.$.env.paths.desktop.settings, 'UTF-8')); - } catch (e) { - this.log.error('error while trying to read \'.desktop/settings.json\': ', e); - process.exit(1); - } - } - - return this.settings; - } - /** - * Returns a version hash representing current .desktop contents. - * @returns {string} - */ - - - async getHashVersion() { - this.log.info('calculating hash version from .desktop contents'); - const version = await this.$.utils.readFilesAndComputeHash(this.$.env.paths.desktop.root); - this.log.verbose(`calculated .desktop hash version is ${version.hash}`); - return version.hash; - } - /** - * Tries to read a module.json file from a module at provided path. - * - * @param {string} modulePath - path to the module dir - * @returns {Object} - */ - - - getModuleConfig(modulePath) { - let moduleConfig = {}; - - try { - moduleConfig = JSON.parse(_fs.default.readFileSync(_path.default.join(modulePath, 'module.json'), 'UTF-8')); - } catch (e) { - this.log.error(`error while trying to read 'module.json' from '${modulePath}' module: `, e); - process.exit(1); - } - - if (!('name' in moduleConfig)) { - this.log.error(`no 'name' field defined in 'module.json' in '${modulePath}' module.`); - process.exit(1); - } - - return moduleConfig; - } - /** - * Scans all modules for module.json and gathers this configuration altogether. - * - * @returns {[]} - */ - - - gatherModuleConfigs() { - const configs = []; - - if (!isEmptySync(this.$.env.paths.desktop.modules)) { - _shelljs.default.ls('-d', _path.default.join(this.$.env.paths.desktop.modules, '*')).forEach(module => { - if (_fs.default.lstatSync(module).isDirectory()) { - const moduleConfig = this.getModuleConfig(module); - moduleConfig.dirName = _path.default.parse(module).name; - configs.push(moduleConfig); - } - }); - } - - return configs; - } - /** - * Summarizes all dependencies defined in .desktop. - * - * @params {Object} settings - settings.json - * @params {boolean} checkModules - whether to gather modules dependencies - * @params {boolean} refresh - recompute - * @returns {{fromSettings: {}, plugins: {}, modules: {}}} - */ - - - getDependencies(settings = null, checkModules = true, refresh = false) { - if (!refresh && this.dependencies) { - return this.dependencies; - } - - const dependencies = { - fromSettings: {}, - plugins: {}, - modules: {} - }; - /** @type {desktopSettings} * */ - - const settingsJson = settings || this.getSettings(); // Settings can have a 'dependencies' field. - - if ('dependencies' in settingsJson) { - dependencies.fromSettings = settingsJson.dependencies; - } // Plugins are also a npm packages. - - - if ('plugins' in settingsJson) { - dependencies.plugins = Object.keys(settingsJson.plugins).reduce((plugins, plugin) => { - /* eslint-disable no-param-reassign */ - if (typeof settingsJson.plugins[plugin] === 'object') { - plugins[plugin] = settingsJson.plugins[plugin].version; - } else { - plugins[plugin] = settingsJson.plugins[plugin]; - } - - return plugins; - }, {}); - } // Each module can have its own dependencies defined. - - - const moduleDependencies = {}; - - if (checkModules) { - const configs = this.gatherModuleConfigs(); - configs.forEach(moduleConfig => { - if (!('dependencies' in moduleConfig)) { - moduleConfig.dependencies = {}; - } - - if (moduleConfig.name in moduleDependencies) { - this.log.error(`duplicate name '${moduleConfig.name}' in 'module.json' in ` + `'${moduleConfig.dirName}' - another module already registered the same name.`); - process.exit(1); - } - - moduleDependencies[moduleConfig.name] = moduleConfig.dependencies; - }); - } - - dependencies.modules = moduleDependencies; - this.dependencies = dependencies; - return dependencies; - } - /** - * Copies the .desktop scaffold into the meteor app dir. - * Adds entry to .meteor/.gitignore. - */ - - - scaffold() { - this.log.info('creating .desktop scaffold in your project'); - - if (this.$.utils.exists(this.$.env.paths.desktop.root)) { - this.log.warn('.desktop already exists - delete it if you want a new one to be ' + 'created'); - return; - } - - _shelljs.default.cp('-r', this.$.env.paths.scaffold, this.$.env.paths.desktop.root); - - _shelljs.default.mkdir(this.$.env.paths.desktop.import); - - this.log.info('.desktop directory prepared'); - } - /** - * Verifies if all mandatory files are present in the .desktop. - * - * @returns {boolean} - */ - - - check() { - this.log.verbose('checking .desktop existence'); - return !!(this.$.utils.exists(this.$.env.paths.desktop.root) && this.$.utils.exists(this.$.env.paths.desktop.settings) && this.$.utils.exists(this.$.env.paths.desktop.desktop)); - } - -} -/** - * @typedef {Object} desktopSettings - * @property {string} name - * @property {string} projectName - * @property {boolean} devTools - * @property {boolean} devtron - * @property {boolean} desktopHCP - * @property {Object} squirrel - * @property {string} squirrel.autoUpdateFeedUrl - * @property {Object} squirrel.autoUpdateFeedHeaders - * @property {Object} squirrel.autoUpdateCheckOnStart - * @property {Object} desktopHCPSettings - * @property {boolean} desktopHCPSettings.ignoreCompatibilityVersion - * @property {boolean} desktopHCPSettings.blockAppUpdateOnDesktopIncompatibility - * @property {number} webAppStartupTimeout - * @property {Array} linkPackages - * @property {Array} exposedModules - * @property {Object} window - * @property {Object} windowDev - * @property {Object} packageJsonFields - * @property {Object} builderOptions - * @property {Object} builderCliOptions - * @property {Object} packagerOptions - * @property {Object} plugins - * @property {Object} dependencies - * @property {boolean} uglify - * @property {string} version - * */ - - -exports.default = Desktop; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["shell","config","fatal","isEmptySync","searchPath","stat","fs","statSync","e","isDirectory","items","readdirSync","length","Desktop","constructor","$","log","Log","settings","dependencies","getSettings","JSON","parse","readFileSync","env","paths","desktop","error","process","exit","getHashVersion","info","version","utils","readFilesAndComputeHash","root","verbose","hash","getModuleConfig","modulePath","moduleConfig","path","join","gatherModuleConfigs","configs","modules","ls","forEach","module","lstatSync","dirName","name","push","getDependencies","checkModules","refresh","fromSettings","plugins","settingsJson","Object","keys","reduce","plugin","moduleDependencies","scaffold","exists","warn","cp","mkdir","import","check"],"sources":["../lib/desktop.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport shell from 'shelljs';\nimport fs from 'fs';\nimport path from 'path';\n\nimport Log from './log';\n\nshell.config.fatal = true;\n\n/**\n * Checks if the path is empty.\n * @param {string} searchPath\n * @returns {boolean}\n */\nfunction isEmptySync(searchPath) {\n    let stat;\n    try {\n        stat = fs.statSync(searchPath);\n    } catch (e) {\n        return true;\n    }\n    if (stat.isDirectory()) {\n        const items = fs.readdirSync(searchPath);\n        return !items || !items.length;\n    }\n    return false;\n}\n\n/**\n * Represents the .desktop directory.\n * @class\n * @property {desktopSettings} settings\n */\nexport default class Desktop {\n    /**\n     * @param {MeteorDesktop} $ - context\n     *\n     * @constructor\n     */\n    constructor($) {\n        this.$ = $;\n        this.log = new Log('desktop');\n        this.settings = null;\n        this.dependencies = null;\n    }\n\n    /**\n     * Tries to read and returns settings.json contents from .desktop dir.\n     *\n     * @returns {desktopSettings|null}\n     */\n    getSettings() {\n        if (!this.settings) {\n            try {\n                this.settings = JSON.parse(\n                    fs.readFileSync(this.$.env.paths.desktop.settings, 'UTF-8')\n                );\n            } catch (e) {\n                this.log.error('error while trying to read \\'.desktop/settings.json\\': ', e);\n                process.exit(1);\n            }\n        }\n        return this.settings;\n    }\n\n    /**\n     * Returns a version hash representing current .desktop contents.\n     * @returns {string}\n     */\n    async getHashVersion() {\n        this.log.info('calculating hash version from .desktop contents');\n\n        const version = await this.$.utils.readFilesAndComputeHash(this.$.env.paths.desktop.root);\n\n        this.log.verbose(`calculated .desktop hash version is ${version.hash}`);\n        return version.hash;\n    }\n\n    /**\n     * Tries to read a module.json file from a module at provided path.\n     *\n     * @param {string} modulePath - path to the module dir\n     * @returns {Object}\n     */\n    getModuleConfig(modulePath) {\n        let moduleConfig = {};\n        try {\n            moduleConfig = JSON.parse(\n                fs.readFileSync(path.join(modulePath, 'module.json'), 'UTF-8')\n            );\n        } catch (e) {\n            this.log.error(\n                `error while trying to read 'module.json' from '${modulePath}' module: `,\n                e\n            );\n            process.exit(1);\n        }\n        if (!('name' in moduleConfig)) {\n            this.log.error(`no 'name' field defined in 'module.json' in '${modulePath}' module.`);\n            process.exit(1);\n        }\n        return moduleConfig;\n    }\n\n    /**\n     * Scans all modules for module.json and gathers this configuration altogether.\n     *\n     * @returns {[]}\n     */\n    gatherModuleConfigs() {\n        const configs = [];\n\n        if (!isEmptySync(this.$.env.paths.desktop.modules)) {\n            shell.ls('-d', path.join(this.$.env.paths.desktop.modules, '*')).forEach(\n                (module) => {\n                    if (fs.lstatSync(module).isDirectory()) {\n                        const moduleConfig = this.getModuleConfig(module);\n                        moduleConfig.dirName = path.parse(module).name;\n                        configs.push(moduleConfig);\n                    }\n                }\n            );\n        }\n        return configs;\n    }\n\n    /**\n     * Summarizes all dependencies defined in .desktop.\n     *\n     * @params {Object} settings      - settings.json\n     * @params {boolean} checkModules - whether to gather modules dependencies\n     * @params {boolean} refresh      - recompute\n     * @returns {{fromSettings: {}, plugins: {}, modules: {}}}\n     */\n    getDependencies(settings = null, checkModules = true, refresh = false) {\n        if (!refresh && this.dependencies) {\n            return this.dependencies;\n        }\n\n        const dependencies = {\n            fromSettings: {},\n            plugins: {},\n            modules: {}\n        };\n        /** @type {desktopSettings} * */\n        const settingsJson = settings || this.getSettings();\n\n        // Settings can have a 'dependencies' field.\n        if ('dependencies' in settingsJson) {\n            dependencies.fromSettings = settingsJson.dependencies;\n        }\n\n        // Plugins are also a npm packages.\n        if ('plugins' in settingsJson) {\n            dependencies.plugins = Object.keys(settingsJson.plugins).reduce((plugins, plugin) => {\n                /* eslint-disable no-param-reassign */\n                if (typeof settingsJson.plugins[plugin] === 'object') {\n                    plugins[plugin] = settingsJson.plugins[plugin].version;\n                } else {\n                    plugins[plugin] = settingsJson.plugins[plugin];\n                }\n                return plugins;\n            }, {});\n        }\n\n        // Each module can have its own dependencies defined.\n        const moduleDependencies = {};\n        if (checkModules) {\n            const configs = this.gatherModuleConfigs();\n\n            configs.forEach(\n                (moduleConfig) => {\n                    if (!('dependencies' in moduleConfig)) {\n                        moduleConfig.dependencies = {};\n                    }\n                    if (moduleConfig.name in moduleDependencies) {\n                        this.log.error(`duplicate name '${moduleConfig.name}' in 'module.json' in ` +\n                            `'${moduleConfig.dirName}' - another module already registered the same name.`);\n                        process.exit(1);\n                    }\n                    moduleDependencies[moduleConfig.name] = moduleConfig.dependencies;\n                }\n            );\n        }\n\n        dependencies.modules = moduleDependencies;\n        this.dependencies = dependencies;\n        return dependencies;\n    }\n\n    /**\n     * Copies the .desktop scaffold into the meteor app dir.\n     * Adds entry to .meteor/.gitignore.\n     */\n    scaffold() {\n        this.log.info('creating .desktop scaffold in your project');\n\n        if (this.$.utils.exists(this.$.env.paths.desktop.root)) {\n            this.log.warn('.desktop already exists - delete it if you want a new one to be ' +\n                'created');\n            return;\n        }\n\n        shell.cp('-r', this.$.env.paths.scaffold, this.$.env.paths.desktop.root);\n        shell.mkdir(this.$.env.paths.desktop.import);\n        this.log.info('.desktop directory prepared');\n    }\n\n    /**\n     * Verifies if all mandatory files are present in the .desktop.\n     *\n     * @returns {boolean}\n     */\n    check() {\n        this.log.verbose('checking .desktop existence');\n        return !!(this.$.utils.exists(this.$.env.paths.desktop.root) &&\n            this.$.utils.exists(this.$.env.paths.desktop.settings) &&\n            this.$.utils.exists(this.$.env.paths.desktop.desktop));\n    }\n}\n\n/**\n * @typedef {Object} desktopSettings\n * @property {string} name\n * @property {string} projectName\n * @property {boolean} devTools\n * @property {boolean} devtron\n * @property {boolean} desktopHCP\n * @property {Object} squirrel\n * @property {string} squirrel.autoUpdateFeedUrl\n * @property {Object} squirrel.autoUpdateFeedHeaders\n * @property {Object} squirrel.autoUpdateCheckOnStart\n * @property {Object} desktopHCPSettings\n * @property {boolean} desktopHCPSettings.ignoreCompatibilityVersion\n * @property {boolean} desktopHCPSettings.blockAppUpdateOnDesktopIncompatibility\n * @property {number} webAppStartupTimeout\n * @property {Array} linkPackages\n * @property {Array} exposedModules\n * @property {Object} window\n * @property {Object} windowDev\n * @property {Object} packageJsonFields\n * @property {Object} builderOptions\n * @property {Object} builderCliOptions\n * @property {Object} packagerOptions\n * @property {Object} plugins\n * @property {Object} dependencies\n * @property {boolean} uglify\n * @property {string} version\n * */\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/electron.js b/dist/electron.js deleted file mode 100644 index 4b4a584d..00000000 --- a/dist/electron.js +++ /dev/null @@ -1,61 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _crossSpawn = _interopRequireDefault(require("cross-spawn")); - -var _log = _interopRequireDefault(require("./log")); - -var _defaultDependencies = _interopRequireDefault(require("./defaultDependencies")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/** - * Simple Electron runner. Runs the project with the bin provided by the 'electron' package. - * @class - */ -class Electron { - constructor($) { - this.log = new _log.default('electron'); - this.$ = $; - } - - async init() { - this.electron = await this.$.getDependency('electron', _defaultDependencies.default.electron); - } - - run() { - // Until: https://github.com/electron-userland/electron-prebuilt/pull/118 - const { - env - } = process; - env.ELECTRON_ENV = 'development'; - const cmd = []; - - if (this.$.env.options.debug) { - cmd.push('--debug=5858'); - } - - cmd.push('.'); - const child = (0, _crossSpawn.default)(this.electron.dependency, cmd, { - cwd: this.$.env.paths.electronApp.root, - env - }); // TODO: check if we can configure piping in spawn options - - child.stdout.on('data', chunk => { - process.stdout.write(chunk); - }); - child.stderr.on('data', chunk => { - process.stderr.write(chunk); - }); - } - -} - -exports.default = Electron; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/electronApp.js b/dist/electronApp.js deleted file mode 100644 index 6e7966c3..00000000 --- a/dist/electronApp.js +++ /dev/null @@ -1,876 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _asar = _interopRequireDefault(require("@electron/asar")); - -var _assignIn = _interopRequireDefault(require("lodash/assignIn")); - -var _lodash = _interopRequireDefault(require("lodash")); - -var _installLocal = require("install-local"); - -var _core = require("@babel/core"); - -var _crypto = _interopRequireDefault(require("crypto")); - -var _del = _interopRequireDefault(require("del")); - -var _presetEnv = _interopRequireDefault(require("@babel/preset-env")); - -var _fs = _interopRequireDefault(require("fs")); - -var _path = _interopRequireDefault(require("path")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _semver = _interopRequireDefault(require("semver")); - -var _terser = _interopRequireDefault(require("terser")); - -var _log = _interopRequireDefault(require("./log")); - -var _electronAppScaffold = _interopRequireDefault(require("./electronAppScaffold")); - -var _dependenciesManager = _interopRequireDefault(require("./dependenciesManager")); - -var _binaryModulesDetector = _interopRequireDefault(require("./binaryModulesDetector")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars -_shelljs.default.config.fatal = true; -/** - * Represents the .desktop dir scaffold. - * @class - */ - -class ElectronApp { - /** - * @param {MeteorDesktop} $ - context - * @constructor - */ - constructor($) { - this.log = new _log.default('electronApp'); - this.scaffold = new _electronAppScaffold.default($); - this.depsManager = new _dependenciesManager.default($, this.scaffold.getDefaultPackageJson().dependencies); - this.$ = $; - this.meteorApp = this.$.meteorApp; - this.packageJson = null; - this.version = null; - this.compatibilityVersion = null; - this.deprectatedPlugins = ['meteor-desktop-localstorage']; - } - /** - * Makes an app.asar from the skeleton app. - * @property {Array} excludeFromDel - list of paths to exclude from deleting - * @returns {Promise} - */ - - - packSkeletonToAsar(excludeFromDel = []) { - this.log.info('packing skeleton app and node_modules to asar archive'); - return new Promise(resolve => { - const extract = this.getModulesToExtract(); // We want to pack skeleton app and node_modules together, so we need to temporarily - // move node_modules to app dir. - - this.log.debug('moving node_modules to app dir'); - - _fs.default.renameSync(this.$.env.paths.electronApp.nodeModules, _path.default.join(this.$.env.paths.electronApp.appRoot, 'node_modules')); - - let extracted = false; - extracted = this.extractModules(extract); - this.log.debug('packing'); - - _asar.default.createPackage(this.$.env.paths.electronApp.appRoot, this.$.env.paths.electronApp.appAsar).then(() => { - // Lets move the node_modules back. - this.log.debug('moving node_modules back from app dir'); - - _shelljs.default.mv(_path.default.join(this.$.env.paths.electronApp.appRoot, 'node_modules'), this.$.env.paths.electronApp.nodeModules); - - if (extracted) { - // We need to create a full node modules back. In other words we want - // the extracted modules back. - extract.forEach(module => _shelljs.default.cp('-rf', _path.default.join(this.$.env.paths.electronApp.extractedNodeModules, module), _path.default.join(this.$.env.paths.electronApp.nodeModules, module))); // Get the .bin back. - - if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModulesBin)) { - _shelljs.default.cp(_path.default.join(this.$.env.paths.electronApp.extractedNodeModulesBin, '*'), _path.default.join(this.$.env.paths.electronApp.nodeModules, '.bin')); - } - } - - this.log.debug('deleting source files'); - const exclude = [this.$.env.paths.electronApp.nodeModules].concat([this.$.env.paths.electronApp.appAsar, this.$.env.paths.electronApp.packageJson], excludeFromDel); - - _del.default.sync([`${this.$.env.paths.electronApp.root}${_path.default.sep}*`].concat(exclude.map(pathToExclude => `!${pathToExclude}`)), { - force: true - }); - - resolve(); - }); - }); - } - /** - * Moves specified node modules to a separate directory. - * @param {Array} extract - * @returns {boolean} - */ - - - extractModules(extract) { - const ext = ['.js', '.bat', '.sh', '.cmd', '']; - - if (extract.length > 0) { - if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) { - _shelljs.default.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules); - } - - _fs.default.mkdirSync(this.$.env.paths.electronApp.extractedNodeModules); - - _fs.default.mkdirSync(this.$.env.paths.electronApp.extractedNodeModulesBin); - - extract.forEach(module => { - _fs.default.renameSync(_path.default.join(this.$.env.paths.electronApp.appRoot, 'node_modules', module), _path.default.join(this.$.env.paths.electronApp.extractedNodeModules, module)); // Move bins. - - - this.extractBin(module, ext); - }); - return true; - } - - return false; - } - /** - * Extracts the bin files associated with a certain node modules. - * - * @param module - * @param ext - */ - - - extractBin(module, ext) { - let packageJson; - - try { - packageJson = JSON.parse(_fs.default.readFileSync(_path.default.join(this.$.env.paths.electronApp.extractedNodeModules, module, 'package.json'), 'utf8')); - } catch (e) { - packageJson = {}; - } - - const bins = 'bin' in packageJson && typeof packageJson.bin === 'object' ? Object.keys(packageJson.bin) : []; - - if (bins.length > 0) { - bins.forEach(bin => { - ext.forEach(extension => { - const binFilePath = _path.default.join(this.$.env.paths.electronApp.appRoot, 'node_modules', '.bin', `${bin}${extension}`); - - if (this.$.utils.exists(binFilePath) || this.$.utils.symlinkExists(binFilePath)) { - _fs.default.renameSync(binFilePath, _path.default.join(this.$.env.paths.electronApp.extractedNodeModulesBin, `${bin}${extension}`)); - } - }); - }); - } - } - /** - * Merges the `extract` field with automatically detected modules. - */ - - - getModulesToExtract() { - const binaryModulesDetector = new _binaryModulesDetector.default(this.$.env.paths.electronApp.nodeModules); - const toBeExtracted = binaryModulesDetector.detect(); - let { - extract - } = this.$.desktop.getSettings(); - - if (!Array.isArray(extract)) { - extract = []; - } - - const merge = {}; - toBeExtracted.concat(extract).forEach(module => { - merge[module] = true; - }); - extract = Object.keys(merge); - - if (extract.length > 0) { - this.log.verbose(`resultant modules to extract list is: ${extract.join(', ')}`); - } - - return extract; - } - /** - * Calculates a md5 from all dependencies. - */ - - - calculateCompatibilityVersion() { - this.log.verbose('calculating compatibility version'); - const settings = this.$.desktop.getSettings(); - - if ('desktopHCPCompatibilityVersion' in settings) { - this.compatibilityVersion = `${settings.desktopHCPCompatibilityVersion}`; - this.log.warn(`compatibility version overridden to ${this.compatibilityVersion}`); - return; - } - - const md5 = _crypto.default.createHash('md5'); - - let dependencies = this.depsManager.getDependencies(); - const dependenciesSorted = Object.keys(dependencies).sort(); - dependencies = dependenciesSorted.map(dependency => `${dependency}:${dependencies[dependency]}`); - const mainCompatibilityVersion = this.$.getVersion().split('.'); - this.log.debug('meteor-desktop compatibility version is ', `${mainCompatibilityVersion[0]}`); - dependencies.push(`meteor-desktop:${mainCompatibilityVersion[0]}`); - const desktopCompatibilityVersion = settings.version.split('.')[0]; - this.log.debug('.desktop compatibility version is ', desktopCompatibilityVersion); - dependencies.push(`desktop-app:${desktopCompatibilityVersion}`); - - if (process.env.METEOR_DESKTOP_DEBUG_DESKTOP_COMPATIBILITY_VERSION || process.env.METEOR_DESKTOP_DEBUG) { - this.log.debug(`compatibility version calculated from ${JSON.stringify(dependencies)}`); - } - - md5.update(JSON.stringify(dependencies)); - this.compatibilityVersion = md5.digest('hex'); - } - - async init() { - try { - await this.$.electron.init(); - await this.$.electronBuilder.init(); - } catch (e) { - this.log.warn('error occurred while initialising electron and electron-builder integration', e); - process.exit(1); - } - } - /** - * Runs all necessary tasks to build the desktopified app. - */ - - - async build(run = false) { - // TODO: refactor to a task runner - this.log.info('scaffolding'); - - if (!this.$.desktop.check()) { - if (!this.$.env.options.scaffold) { - this.log.error('seems that you do not have a .desktop dir in your project or it is' + ' corrupted. Run \'npm run desktop -- init\' to get a new one.'); // Do not fail, so that npm will not print his error stuff to console. - - process.exit(0); - } else { - this.$.desktop.scaffold(); - this.$.meteorApp.updateGitIgnore(); - } - } - - await this.init(); - - try { - this.$.meteorApp.updateGitIgnore(); - } catch (e) { - this.log.warn(`error occurred while adding ${this.$.env.paths.electronApp.rootName}` + 'to .gitignore: ', e); - } - - try { - await this.$.meteorApp.removeDeprecatedPackages(); - } catch (e) { - this.log.error('error while removing deprecated packages: ', e); - process.exit(1); - } - - try { - await this.$.meteorApp.ensureDesktopHCPPackages(); - } catch (e) { - this.log.error('error while checking for required packages: ', e); - process.exit(1); - } - - try { - await this.scaffold.make(); - } catch (e) { - this.log.error('error while scaffolding: ', e); - process.exit(1); - } - - try { - const fileName = '.npmrc'; - const dirName = '.meteor/desktop-build'; - - if (_fs.default.existsSync(dirName) && _fs.default.existsSync(fileName)) { - _fs.default.copyFileSync(fileName, `${dirName}/${fileName}`); - } - } catch (e) { - this.log.warn('error while copying .npmrc', e); - } - - try { - await this.exposeElectronModules(); - } catch (e) { - this.log.error('error while exposing electron modules: ', e); - process.exit(1); - } - - try { - this.updatePackageJsonFields(); - } catch (e) { - this.log.error('error while updating package.json: ', e); - } - - try { - this.updateDependenciesList(); - } catch (e) { - this.log.error('error while merging dependencies list: ', e); - } - - try { - this.calculateCompatibilityVersion(); - } catch (e) { - this.log.error('error while calculating compatibility version: ', e); - process.exit(1); - } - - try { - await this.handleTemporaryNodeModules(); - } catch (e) { - this.log.error('error occurred while handling temporary node_modules: ', e); - process.exit(1); - } - - let nodeModulesRemoved; - - try { - nodeModulesRemoved = await this.handleStateOfNodeModules(); - } catch (e) { - this.log.error('error occurred while clearing node_modules: ', e); - process.exit(1); - } - - try { - await this.rebuildDeps(true); - } catch (e) { - this.log.error('error occurred while installing node_modules: ', e); - process.exit(1); - } - - if (!nodeModulesRemoved) { - try { - await this.rebuildDeps(); - } catch (e) { - this.log.error('error occurred while rebuilding native node modules: ', e); - process.exit(1); - } - } - - try { - await this.linkNpmPackages(); - } catch (e) { - this.log.error(`linking packages failed: ${e}`); - process.exit(1); - } - - try { - await this.installLocalNodeModules(); - } catch (e) { - this.log.error('error occurred while installing local node modules: ', e); - process.exit(1); - } - - try { - await this.ensureMeteorDependencies(); - } catch (e) { - this.log.error('error occurred while ensuring meteor dependencies are installed: ', e); - process.exit(1); - } - - if (this.$.env.isProductionBuild()) { - try { - await this.packSkeletonToAsar(); - } catch (e) { - this.log.error('error while packing skeleton to asar: ', e); - process.exit(1); - } - } // TODO: find a way to avoid copying .desktop to a temp location - - - try { - this.copyDesktopToDesktopTemp(); - } catch (e) { - this.log.error('error while copying .desktop to a temporary location: ', e); - process.exit(1); - } - - try { - await this.updateSettingsJsonFields(); - } catch (e) { - this.log.error('error while updating settings.json: ', e); - process.exit(1); - } - - try { - await this.excludeFilesFromArchive(); - } catch (e) { - this.log.error('error while excluding files from packing to asar: ', e); - process.exit(1); - } - - try { - await this.transpileAndMinify(); - } catch (e) { - this.log.error('error while transpiling or minifying: ', e); - } - - try { - await this.packDesktopToAsar(); - } catch (e) { - this.log.error('error occurred while packing .desktop to asar: ', e); - process.exit(1); - } - - try { - await this.getMeteorClientBuild(); - } catch (e) { - this.log.error('error occurred during getting meteor mobile build: ', e); - } - - if (run) { - this.log.info('running'); - this.$.electron.run(); - } else { - this.log.info('built'); - } - } - /** - * Copies the `exposedModules` setting from `settings.json` into `preload.js` modifying its code - * so that the script will have it hardcoded. - */ - - - exposeElectronModules() { - const { - exposedModules - } = this.$.desktop.getSettings(); - - if (exposedModules && Array.isArray(exposedModules) && exposedModules.length > 0) { - let preload = _fs.default.readFileSync(this.$.env.paths.electronApp.preload, 'utf8'); - - const modules = this.$.desktop.getSettings().exposedModules.reduce( // eslint-disable-next-line no-return-assign,no-param-reassign - (prev, module) => (prev += `'${module}', `, prev), ''); - preload = preload.replace('const exposedModules = [', `const exposedModules = [${modules}`); - - _fs.default.writeFileSync(this.$.env.paths.electronApp.preload, preload); - } - } - /** - * Ensures all required dependencies are added to the Meteor project. - * @returns {Promise.} - */ - - - async ensureMeteorDependencies() { - let packages = []; - const packagesWithVersion = []; - let plugins = 'plugins ['; - Object.keys(this.$.desktop.getDependencies().plugins).forEach(plugin => { - // Read package.json of the plugin. - const packageJson = JSON.parse(_fs.default.readFileSync(_path.default.join(this.$.env.paths.electronApp.nodeModules, plugin, 'package.json'), 'utf8')); - - if ('meteorDependencies' in packageJson && typeof packageJson.meteorDependencies === 'object') { - plugins += `${plugin}, `; - packages.unshift(...Object.keys(packageJson.meteorDependencies)); - packagesWithVersion.unshift(...packages.map(packageName => { - if (packageJson.meteorDependencies[packageName] === '@version') { - return `${packageName}@${packageJson.version}`; - } - - return `${packageName}@${packageJson.meteorDependencies[packageName]}`; - })); - } - }); - const packagesCount = packages.length; - packages = packages.filter(value => !this.deprectatedPlugins.includes(value)); - - if (packagesCount !== packages.length) { - this.log.warn('you have some deprecated meteor desktop plugins in your settings, please remove ' + `them (deprecated plugins: ${this.deprectatedPlugins.join(', ')})`); - } - - if (packages.length > 0) { - plugins = `${plugins.substr(0, plugins.length - 2)}]`; - - try { - await this.$.meteorApp.meteorManager.ensurePackages(packages, packagesWithVersion, plugins); - } catch (e) { - throw new Error(e); - } - } - } - /** - * Builds meteor app. - */ - - - async getMeteorClientBuild() { - await this.$.meteorApp.build(); - } - /** - * Removes node_modules if needed. - * @returns {Promise} - */ - - - async handleStateOfNodeModules() { - if (this.$.env.isProductionBuild() || this.$.env.options.ia32) { - if (!this.$.env.isProductionBuild()) { - this.log.info('clearing node_modules because we need to have it clear for ia32 rebuild'); - } else { - this.log.info('clearing node_modules because this is a production build'); - } - - try { - await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.nodeModules); - } catch (e) { - throw new Error(e); - } - - return true; - } - - return false; - } - /** - * If there is a temporary node_modules folder and no node_modules folder, we will - * restore it, as it might be a leftover from an interrupted flow. - * @returns {Promise} - */ - - - async handleTemporaryNodeModules() { - if (this.$.utils.exists(this.$.env.paths.electronApp.tmpNodeModules)) { - if (!this.$.utils.exists(this.$.env.paths.electronApp.nodeModules)) { - this.log.debug('moving temp node_modules back'); - - _shelljs.default.mv(this.$.env.paths.electronApp.tmpNodeModules, this.$.env.paths.electronApp.nodeModules); - } else { - // If there is a node_modules folder, we should clear the temporary one. - this.log.debug('clearing temp node_modules because new one is already created'); - - try { - await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.tmpNodeModules); - } catch (e) { - throw new Error(e); - } - } - } - } - /** - * Runs npm link for every package specified in settings.json->linkPackages. - */ - - - async linkNpmPackages() { - if (this.$.env.isProductionBuild()) { - return; - } - - const settings = this.$.desktop.getSettings(); - const promises = []; - - if ('linkPackages' in this.$.desktop.getSettings()) { - if (Array.isArray(settings.linkPackages)) { - settings.linkPackages.forEach(packageName => promises.push(this.$.meteorApp.runNpm(['link', packageName], undefined, this.$.env.paths.electronApp.root))); - } - } - - await Promise.all(promises); - } - /** - * Runs npm in the electron app to get the dependencies installed. - * @returns {Promise} - */ - - - async ensureDeps() { - this.log.info('installing dependencies'); - - if (this.$.utils.exists(this.$.env.paths.electronApp.nodeModules)) { - this.log.debug('running npm prune to wipe unneeded dependencies'); - - try { - await this.runNpm(['prune']); - } catch (e) { - throw new Error(e); - } - } - - try { - await this.runNpm(['install'], this.$.env.stdio); - } catch (e) { - throw new Error(e); - } - } - /** - * Warns if plugins version are outdated in compare to the newest scaffold. - * @param {Object} pluginsVersions - current plugins versions from settings.json - */ - - - checkPluginsVersion(pluginsVersions) { - const settingsJson = JSON.parse(_fs.default.readFileSync(_path.default.join(this.$.env.paths.scaffold, 'settings.json'))); - const scaffoldPluginsVersion = this.$.desktop.getDependencies(settingsJson, false).plugins; - Object.keys(pluginsVersions).forEach(pluginName => { - if (pluginName in scaffoldPluginsVersion && scaffoldPluginsVersion[pluginName] !== pluginsVersions[pluginName] && _semver.default.lt(pluginsVersions[pluginName], scaffoldPluginsVersion[pluginName])) { - this.log.warn(`you are using outdated version ${pluginsVersions[pluginName]} of ` + `${pluginName}, the suggested version to use is ` + `${scaffoldPluginsVersion[pluginName]}`); - } - }); - } - /** - * Merges core dependency list with the dependencies from .desktop. - */ - - - updateDependenciesList() { - this.log.info('updating list of package.json\'s dependencies'); - const desktopDependencies = this.$.desktop.getDependencies(); - this.checkPluginsVersion(desktopDependencies.plugins); - this.log.debug('merging settings.json[dependencies]'); - this.depsManager.mergeDependencies('settings.json[dependencies]', desktopDependencies.fromSettings); - this.log.debug('merging settings.json[plugins]'); - this.depsManager.mergeDependencies('settings.json[plugins]', desktopDependencies.plugins); - this.log.debug('merging dependencies from modules'); - Object.keys(desktopDependencies.modules).forEach(module => this.depsManager.mergeDependencies(`module[${module}]`, desktopDependencies.modules[module])); - this.packageJson.dependencies = this.depsManager.getRemoteDependencies(); - this.packageJson.localDependencies = this.depsManager.getLocalDependencies(); - this.log.debug('writing updated package.json'); - - _fs.default.writeFileSync(this.$.env.paths.electronApp.packageJson, JSON.stringify(this.packageJson, null, 2)); - } - /** - * Install node modules from local paths using local-install. - * - * @param {string} arch - * @returns {Promise} - */ - - - installLocalNodeModules(arch = this.$.env.options.ia32 || process.arch === 'ia32' ? 'ia32' : 'x64') { - const localDependencies = _lodash.default.values(this.packageJson.localDependencies); - - if (localDependencies.length === 0) { - return Promise.resolve(); - } - - this.log.info('installing local node modules'); - const lastRebuild = this.$.electronBuilder.prepareLastRebuildObject(arch); - const env = this.$.electronBuilder.getGypEnv(lastRebuild.frameworkInfo, lastRebuild.platform, lastRebuild.arch); - const installer = new _installLocal.LocalInstaller({ - [this.$.env.paths.electronApp.root]: localDependencies - }, { - npmEnv: env - }); - (0, _installLocal.progress)(installer); - return installer.install(); - } - /** - * Rebuild binary dependencies against Electron's node headers. - * @returns {Promise} - */ - - - rebuildDeps(install = false) { - if (install) { - this.log.info('issuing node_modules install from electron-builder'); - } else { - this.log.info('issuing native modules rebuild from electron-builder'); - } - - const arch = this.$.env.options.ia32 || process.arch === 'ia32' ? 'ia32' : 'x64'; - - if (this.$.env.options.ia32) { - this.log.verbose('forcing rebuild for 32bit'); - } else { - this.log.verbose(`rebuilding for ${arch}`); - } - - return this.$.electronBuilder.installOrRebuild(arch, undefined, install); - } - /** - * Update package.json fields accordingly to what is set in settings.json. - * - * packageJson.name = settings.projectName - * packageJson.version = settings.version - * packageJson.* = settings.packageJsonFields - */ - - - updatePackageJsonFields() { - this.log.verbose('updating package.json fields'); - const settings = this.$.desktop.getSettings(); - /** @type {desktopSettings} */ - - const packageJson = this.scaffold.getDefaultPackageJson(); - packageJson.version = settings.version; - - if ('packageJsonFields' in settings) { - (0, _assignIn.default)(packageJson, settings.packageJsonFields); - } - - (0, _assignIn.default)(packageJson, { - name: settings.projectName - }); - this.log.debug('writing updated package.json'); - - _fs.default.writeFileSync(this.$.env.paths.electronApp.packageJson, JSON.stringify(packageJson, null, 4)); - - this.packageJson = packageJson; - } - /** - * Updates settings.json with env (prod/dev) information and versions. - */ - - - async updateSettingsJsonFields() { - this.log.debug('updating settings.json fields'); - const settings = this.$.desktop.getSettings(); // Save versions. - - settings.compatibilityVersion = this.compatibilityVersion; // Pass information about build type to the settings.json. - - settings.env = this.$.env.isProductionBuild() ? 'prod' : 'dev'; - const version = await this.$.desktop.getHashVersion(); - settings.desktopVersion = `${version}_${settings.env}`; - settings.meteorDesktopVersion = this.$.getVersion(); - - if (this.$.env.options.prodDebug) { - settings.prodDebug = true; - } - - _fs.default.writeFileSync(this.$.env.paths.desktopTmp.settings, JSON.stringify(settings, null, 4)); - } - /** - * Copies files from prepared .desktop to desktop.asar in electron app. - */ - - - packDesktopToAsar() { - this.log.info('packing .desktop to asar'); - return new Promise((resolve, reject) => { - _asar.default.createPackage(this.$.env.paths.desktopTmp.root, this.$.env.paths.electronApp.desktopAsar).then(() => { - this.log.verbose('clearing temporary .desktop'); - this.$.utils.rmWithRetries('-rf', this.$.env.paths.desktopTmp.root).then(() => { - resolve(); - }).catch(e => { - reject(e); - }); - resolve(); - }); - }); - } - /** - * Makes a temporary copy of .desktop. - */ - - - copyDesktopToDesktopTemp() { - this.log.verbose('copying .desktop to temporary location'); - - _shelljs.default.cp('-rf', this.$.env.paths.desktop.root, this.$.env.paths.desktopTmp.root); // Remove test files. - - - _del.default.sync([_path.default.join(this.$.env.paths.desktopTmp.root, '**', '*.test.js')], { - force: true - }); - } - /** - * Runs babel and uglify over .desktop if requested. - */ - - - async transpileAndMinify() { - this.log.info('transpiling and uglifying'); - const settings = this.$.desktop.getSettings(); - const options = 'uglifyOptions' in settings ? settings.uglifyOptions : {}; - const uglifyingEnabled = 'uglify' in settings && !!settings.uglify; - const preset = (0, _presetEnv.default)({ - assertVersion: () => {} - }, { - targets: { - node: '12' - } - }); - const { - data: files - } = await this.$.utils.readDir(this.$.env.paths.desktopTmp.root); - files.forEach(file => { - if (file.endsWith('.js')) { - let { - code - } = (0, _core.transformFileSync)(file, { - presets: [preset] - }); - let error; - - if (settings.env === 'prod' && uglifyingEnabled) { - ({ - code, - error - } = _terser.default.minify(code, options)); - } - - if (error) { - throw new Error(error); - } - - _fs.default.writeFileSync(file, code); - } - }); - } - /** - * Moves all the files that should not be packed into asar into a safe location which is the - * 'extracted' dir in the electron app. - */ - - - async excludeFilesFromArchive() { - this.log.info('excluding files from packing'); // Ensure empty `extracted` dir - - try { - await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.extracted); - } catch (e) { - throw new Error(e); - } - - _shelljs.default.mkdir(this.$.env.paths.electronApp.extracted); - - const configs = this.$.desktop.gatherModuleConfigs(); // Move files that should not be asar'ed. - - configs.forEach(config => { - const moduleConfig = config; - - if ('extract' in moduleConfig) { - if (!Array.isArray(moduleConfig.extract)) { - moduleConfig.extract = [moduleConfig.extract]; - } - - moduleConfig.extract.forEach(file => { - this.log.debug(`excluding ${file} from ${config.name}`); - - const filePath = _path.default.join(this.$.env.paths.desktopTmp.modules, moduleConfig.dirName, file); - - const destinationPath = _path.default.join(this.$.env.paths.electronApp.extracted, moduleConfig.dirName); - - if (!this.$.utils.exists(destinationPath)) { - _shelljs.default.mkdir(destinationPath); - } - - _shelljs.default.mv(filePath, destinationPath); - }); - } - }); - } - -} - -exports.default = ElectronApp; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["shell","config","fatal","ElectronApp","constructor","$","log","Log","scaffold","ElectronAppScaffold","depsManager","DependenciesManager","getDefaultPackageJson","dependencies","meteorApp","packageJson","version","compatibilityVersion","deprectatedPlugins","packSkeletonToAsar","excludeFromDel","info","Promise","resolve","extract","getModulesToExtract","debug","fs","renameSync","env","paths","electronApp","nodeModules","path","join","appRoot","extracted","extractModules","asar","createPackage","appAsar","then","mv","forEach","module","cp","extractedNodeModules","utils","exists","extractedNodeModulesBin","exclude","concat","del","sync","root","sep","map","pathToExclude","force","ext","length","rm","mkdirSync","extractBin","JSON","parse","readFileSync","e","bins","bin","Object","keys","extension","binFilePath","symlinkExists","binaryModulesDetector","BinaryModuleDetector","toBeExtracted","detect","desktop","getSettings","Array","isArray","merge","verbose","calculateCompatibilityVersion","settings","desktopHCPCompatibilityVersion","warn","md5","crypto","createHash","getDependencies","dependenciesSorted","sort","dependency","mainCompatibilityVersion","getVersion","split","push","desktopCompatibilityVersion","process","METEOR_DESKTOP_DEBUG_DESKTOP_COMPATIBILITY_VERSION","METEOR_DESKTOP_DEBUG","stringify","update","digest","init","electron","electronBuilder","exit","build","run","check","options","error","updateGitIgnore","rootName","removeDeprecatedPackages","ensureDesktopHCPPackages","make","fileName","dirName","existsSync","copyFileSync","exposeElectronModules","updatePackageJsonFields","updateDependenciesList","handleTemporaryNodeModules","nodeModulesRemoved","handleStateOfNodeModules","rebuildDeps","linkNpmPackages","installLocalNodeModules","ensureMeteorDependencies","isProductionBuild","copyDesktopToDesktopTemp","updateSettingsJsonFields","excludeFilesFromArchive","transpileAndMinify","packDesktopToAsar","getMeteorClientBuild","exposedModules","preload","modules","reduce","prev","replace","writeFileSync","packages","packagesWithVersion","plugins","plugin","meteorDependencies","unshift","packageName","packagesCount","filter","value","includes","substr","meteorManager","ensurePackages","Error","ia32","rmWithRetries","tmpNodeModules","promises","linkPackages","runNpm","undefined","all","ensureDeps","stdio","checkPluginsVersion","pluginsVersions","settingsJson","scaffoldPluginsVersion","pluginName","semver","lt","desktopDependencies","mergeDependencies","fromSettings","getRemoteDependencies","localDependencies","getLocalDependencies","arch","_","values","lastRebuild","prepareLastRebuildObject","getGypEnv","frameworkInfo","platform","installer","LocalInstaller","npmEnv","progress","install","installOrRebuild","assignIn","packageJsonFields","name","projectName","getHashVersion","desktopVersion","meteorDesktopVersion","prodDebug","desktopTmp","reject","desktopAsar","catch","uglifyOptions","uglifyingEnabled","uglify","preset","presetEnv","assertVersion","targets","node","data","files","readDir","file","endsWith","code","transformFileSync","presets","minify","mkdir","configs","gatherModuleConfigs","moduleConfig","filePath","destinationPath"],"sources":["../lib/electronApp.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport asar from '@electron/asar';\nimport assignIn from 'lodash/assignIn';\nimport _ from 'lodash';\nimport { LocalInstaller, progress } from 'install-local';\nimport { transformFileSync } from '@babel/core';\nimport crypto from 'crypto';\nimport del from 'del';\nimport presetEnv from '@babel/preset-env';\nimport fs from 'fs';\nimport path from 'path';\nimport shell from 'shelljs';\nimport semver from 'semver';\nimport uglify from 'terser';\n\nimport Log from './log';\nimport ElectronAppScaffold from './electronAppScaffold';\nimport DependenciesManager from './dependenciesManager';\nimport BinaryModuleDetector from './binaryModulesDetector';\n\nshell.config.fatal = true;\n\n/**\n * Represents the .desktop dir scaffold.\n * @class\n */\nexport default class ElectronApp {\n    /**\n     * @param {MeteorDesktop} $ - context\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('electronApp');\n        this.scaffold = new ElectronAppScaffold($);\n        this.depsManager = new DependenciesManager(\n            $,\n            this.scaffold.getDefaultPackageJson().dependencies\n        );\n        this.$ = $;\n        this.meteorApp = this.$.meteorApp;\n        this.packageJson = null;\n        this.version = null;\n        this.compatibilityVersion = null;\n        this.deprectatedPlugins = ['meteor-desktop-localstorage'];\n    }\n\n    /**\n     * Makes an app.asar from the skeleton app.\n     * @property {Array} excludeFromDel - list of paths to exclude from deleting\n     * @returns {Promise}\n     */\n    packSkeletonToAsar(excludeFromDel = []) {\n        this.log.info('packing skeleton app and node_modules to asar archive');\n        return new Promise((resolve) => {\n            const extract = this.getModulesToExtract();\n\n            // We want to pack skeleton app and node_modules together, so we need to temporarily\n            // move node_modules to app dir.\n            this.log.debug('moving node_modules to app dir');\n\n            fs.renameSync(\n                this.$.env.paths.electronApp.nodeModules,\n                path.join(this.$.env.paths.electronApp.appRoot, 'node_modules')\n            );\n\n            let extracted = false;\n            extracted = this.extractModules(extract);\n\n            this.log.debug('packing');\n            asar.createPackage(\n                this.$.env.paths.electronApp.appRoot,\n                this.$.env.paths.electronApp.appAsar\n            )\n                .then(() => {\n                    // Lets move the node_modules back.\n                    this.log.debug('moving node_modules back from app dir');\n\n                    shell.mv(\n                        path.join(this.$.env.paths.electronApp.appRoot, 'node_modules'),\n                        this.$.env.paths.electronApp.nodeModules\n                    );\n\n                    if (extracted) {\n                        // We need to create a full node modules back. In other words we want\n                        // the extracted modules back.\n                        extract.forEach(module => shell.cp(\n                            '-rf',\n                            path.join(this.$.env.paths.electronApp.extractedNodeModules, module),\n                            path.join(this.$.env.paths.electronApp.nodeModules, module)\n                        ));\n\n                        // Get the .bin back.\n                        if (this.$.utils.exists(\n                            this.$.env.paths.electronApp.extractedNodeModulesBin\n                        )) {\n                            shell.cp(\n                                path.join(this.$.env.paths.electronApp.extractedNodeModulesBin, '*'),\n                                path.join(this.$.env.paths.electronApp.nodeModules, '.bin')\n                            );\n                        }\n                    }\n\n                    this.log.debug('deleting source files');\n                    const exclude = [this.$.env.paths.electronApp.nodeModules].concat(\n                        [\n                            this.$.env.paths.electronApp.appAsar,\n                            this.$.env.paths.electronApp.packageJson\n                        ],\n                        excludeFromDel\n                    );\n\n                    del.sync(\n                        [`${this.$.env.paths.electronApp.root}${path.sep}*`].concat(\n                            exclude.map(pathToExclude => `!${pathToExclude}`)\n                        ),\n                        { force: true }\n                    );\n                    resolve();\n                });\n        });\n    }\n\n    /**\n     * Moves specified node modules to a separate directory.\n     * @param {Array} extract\n     * @returns {boolean}\n     */\n    extractModules(extract) {\n        const ext = ['.js', '.bat', '.sh', '.cmd', ''];\n\n        if (extract.length > 0) {\n            if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) {\n                shell.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules);\n            }\n            fs.mkdirSync(this.$.env.paths.electronApp.extractedNodeModules);\n            fs.mkdirSync(this.$.env.paths.electronApp.extractedNodeModulesBin);\n\n            extract.forEach((module) => {\n                fs.renameSync(\n                    path.join(this.$.env.paths.electronApp.appRoot, 'node_modules', module),\n                    path.join(this.$.env.paths.electronApp.extractedNodeModules, module),\n                );\n                // Move bins.\n                this.extractBin(module, ext);\n            });\n\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * Extracts the bin files associated with a certain node modules.\n     *\n     * @param module\n     * @param ext\n     */\n    extractBin(module, ext) {\n        let packageJson;\n        try {\n            packageJson = JSON.parse(\n                fs.readFileSync(\n                    path.join(\n                        this.$.env.paths.electronApp.extractedNodeModules, module, 'package.json'\n                    ),\n                    'utf8'\n                )\n            );\n        } catch (e) {\n            packageJson = {};\n        }\n\n\n        const bins = ('bin' in packageJson && typeof packageJson.bin === 'object') ? Object.keys(packageJson.bin) : [];\n\n        if (bins.length > 0) {\n            bins.forEach((bin) => {\n                ext.forEach((extension) => {\n                    const binFilePath = path.join(\n                        this.$.env.paths.electronApp.appRoot,\n                        'node_modules',\n                        '.bin',\n                        `${bin}${extension}`\n                    );\n                    if (this.$.utils.exists(binFilePath) ||\n                        this.$.utils.symlinkExists(binFilePath)\n                    ) {\n                        fs.renameSync(\n                            binFilePath,\n                            path.join(\n                                this.$.env.paths.electronApp.extractedNodeModulesBin,\n                                `${bin}${extension}`\n                            )\n                        );\n                    }\n                });\n            });\n        }\n    }\n\n    /**\n     * Merges the `extract` field with automatically detected modules.\n     */\n    getModulesToExtract() {\n        const binaryModulesDetector =\n            new BinaryModuleDetector(this.$.env.paths.electronApp.nodeModules);\n        const toBeExtracted = binaryModulesDetector.detect();\n\n        let { extract } = this.$.desktop.getSettings();\n\n        if (!Array.isArray(extract)) {\n            extract = [];\n        }\n\n        const merge = {};\n        toBeExtracted.concat(extract).forEach((module) => {\n            merge[module] = true;\n        });\n        extract = Object.keys(merge);\n        if (extract.length > 0) {\n            this.log.verbose(`resultant modules to extract list is: ${extract.join(', ')}`);\n        }\n        return extract;\n    }\n\n    /**\n     * Calculates a md5 from all dependencies.\n     */\n    calculateCompatibilityVersion() {\n        this.log.verbose('calculating compatibility version');\n        const settings = this.$.desktop.getSettings();\n\n        if (('desktopHCPCompatibilityVersion' in settings)) {\n            this.compatibilityVersion = `${settings.desktopHCPCompatibilityVersion}`;\n            this.log.warn(`compatibility version overridden to ${this.compatibilityVersion}`);\n            return;\n        }\n\n        const md5 = crypto.createHash('md5');\n        let dependencies = this.depsManager.getDependencies();\n        const dependenciesSorted = Object.keys(dependencies).sort();\n        dependencies = dependenciesSorted.map(dependency =>\n            `${dependency}:${dependencies[dependency]}`);\n        const mainCompatibilityVersion = this.$.getVersion().split('.');\n        this.log.debug('meteor-desktop compatibility version is ',\n            `${mainCompatibilityVersion[0]}`);\n        dependencies.push(\n            `meteor-desktop:${mainCompatibilityVersion[0]}`\n        );\n\n        const desktopCompatibilityVersion = settings.version.split('.')[0];\n        this.log.debug('.desktop compatibility version is ', desktopCompatibilityVersion);\n        dependencies.push(\n            `desktop-app:${desktopCompatibilityVersion}`\n        );\n\n        if (process.env.METEOR_DESKTOP_DEBUG_DESKTOP_COMPATIBILITY_VERSION ||\n            process.env.METEOR_DESKTOP_DEBUG\n        ) {\n            this.log.debug(`compatibility version calculated from ${JSON.stringify(dependencies)}`);\n        }\n\n        md5.update(JSON.stringify(dependencies));\n\n        this.compatibilityVersion = md5.digest('hex');\n    }\n\n    async init() {\n        try {\n            await this.$.electron.init();\n            await this.$.electronBuilder.init();\n        } catch (e) {\n            this.log.warn('error occurred while initialising electron and electron-builder integration', e);\n            process.exit(1);\n        }\n    }\n\n    /**\n     * Runs all necessary tasks to build the desktopified app.\n     */\n    async build(run = false) {\n        // TODO: refactor to a task runner\n        this.log.info('scaffolding');\n\n        if (!this.$.desktop.check()) {\n            if (!this.$.env.options.scaffold) {\n                this.log.error('seems that you do not have a .desktop dir in your project or it is' +\n                    ' corrupted. Run \\'npm run desktop -- init\\' to get a new one.');\n                // Do not fail, so that npm will not print his error stuff to console.\n                process.exit(0);\n            } else {\n                this.$.desktop.scaffold();\n                this.$.meteorApp.updateGitIgnore();\n            }\n        }\n\n        await this.init();\n\n\n        try {\n            this.$.meteorApp.updateGitIgnore();\n        } catch (e) {\n            this.log.warn(`error occurred while adding ${this.$.env.paths.electronApp.rootName}` +\n                'to .gitignore: ', e);\n        }\n\n        try {\n            await this.$.meteorApp.removeDeprecatedPackages();\n        } catch (e) {\n            this.log.error('error while removing deprecated packages: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.$.meteorApp.ensureDesktopHCPPackages();\n        } catch (e) {\n            this.log.error('error while checking for required packages: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.scaffold.make();\n        } catch (e) {\n            this.log.error('error while scaffolding: ', e);\n            process.exit(1);\n        }\n\n        try {\n            const fileName = '.npmrc';\n            const dirName = '.meteor/desktop-build';\n            if (fs.existsSync(dirName) && fs.existsSync(fileName)) {\n                fs.copyFileSync(fileName, `${dirName}/${fileName}`);\n            }\n        } catch (e) {\n            this.log.warn('error while copying .npmrc', e);\n        }\n\n        try {\n            await this.exposeElectronModules();\n        } catch (e) {\n            this.log.error('error while exposing electron modules: ', e);\n            process.exit(1);\n        }\n\n        try {\n            this.updatePackageJsonFields();\n        } catch (e) {\n            this.log.error('error while updating package.json: ', e);\n        }\n\n        try {\n            this.updateDependenciesList();\n        } catch (e) {\n            this.log.error('error while merging dependencies list: ', e);\n        }\n\n        try {\n            this.calculateCompatibilityVersion();\n        } catch (e) {\n            this.log.error('error while calculating compatibility version: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.handleTemporaryNodeModules();\n        } catch (e) {\n            this.log.error('error occurred while handling temporary node_modules: ', e);\n            process.exit(1);\n        }\n\n        let nodeModulesRemoved;\n        try {\n            nodeModulesRemoved = await this.handleStateOfNodeModules();\n        } catch (e) {\n            this.log.error('error occurred while clearing node_modules: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.rebuildDeps(true);\n        } catch (e) {\n            this.log.error('error occurred while installing node_modules: ', e);\n            process.exit(1);\n        }\n\n        if (!nodeModulesRemoved) {\n            try {\n                await this.rebuildDeps();\n            } catch (e) {\n                this.log.error('error occurred while rebuilding native node modules: ', e);\n                process.exit(1);\n            }\n        }\n\n        try {\n            await this.linkNpmPackages();\n        } catch (e) {\n            this.log.error(`linking packages failed: ${e}`);\n            process.exit(1);\n        }\n\n        try {\n            await this.installLocalNodeModules();\n        } catch (e) {\n            this.log.error('error occurred while installing local node modules: ', e);\n            process.exit(1);\n        }\n\n\n        try {\n            await this.ensureMeteorDependencies();\n        } catch (e) {\n            this.log.error('error occurred while ensuring meteor dependencies are installed: ', e);\n            process.exit(1);\n        }\n\n\n        if (this.$.env.isProductionBuild()) {\n            try {\n                await this.packSkeletonToAsar();\n            } catch (e) {\n                this.log.error('error while packing skeleton to asar: ', e);\n                process.exit(1);\n            }\n        }\n\n        // TODO: find a way to avoid copying .desktop to a temp location\n        try {\n            this.copyDesktopToDesktopTemp();\n        } catch (e) {\n            this.log.error('error while copying .desktop to a temporary location: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.updateSettingsJsonFields();\n        } catch (e) {\n            this.log.error('error while updating settings.json: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.excludeFilesFromArchive();\n        } catch (e) {\n            this.log.error('error while excluding files from packing to asar: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.transpileAndMinify();\n        } catch (e) {\n            this.log.error('error while transpiling or minifying: ', e);\n        }\n\n        try {\n            await this.packDesktopToAsar();\n        } catch (e) {\n            this.log.error('error occurred while packing .desktop to asar: ', e);\n            process.exit(1);\n        }\n\n        try {\n            await this.getMeteorClientBuild();\n        } catch (e) {\n            this.log.error('error occurred during getting meteor mobile build: ', e);\n        }\n\n        if (run) {\n            this.log.info('running');\n            this.$.electron.run();\n        } else {\n            this.log.info('built');\n        }\n    }\n\n    /**\n     * Copies the `exposedModules` setting from `settings.json` into `preload.js` modifying its code\n     * so that the script will have it hardcoded.\n     */\n    exposeElectronModules() {\n        const { exposedModules } = this.$.desktop.getSettings();\n        if (exposedModules && Array.isArray(exposedModules) && exposedModules.length > 0) {\n            let preload = fs.readFileSync(this.$.env.paths.electronApp.preload, 'utf8');\n            const modules = this.$.desktop.getSettings()\n                .exposedModules\n                .reduce(\n                    // eslint-disable-next-line no-return-assign,no-param-reassign\n                    (prev, module) => (prev += `'${module}', `, prev), ''\n                );\n\n            preload = preload.replace('const exposedModules = [', `const exposedModules = [${modules}`);\n            fs.writeFileSync(this.$.env.paths.electronApp.preload, preload);\n        }\n    }\n\n    /**\n     * Ensures all required dependencies are added to the Meteor project.\n     * @returns {Promise.<void>}\n     */\n    async ensureMeteorDependencies() {\n        let packages = [];\n        const packagesWithVersion = [];\n        let plugins = 'plugins [';\n\n        Object.keys(this.$.desktop.getDependencies().plugins).forEach((plugin) => {\n            // Read package.json of the plugin.\n            const packageJson =\n                JSON.parse(\n                    fs.readFileSync(\n                        path.join(\n                            this.$.env.paths.electronApp.nodeModules, plugin, 'package.json'\n                        ),\n                        'utf8'\n                    )\n                );\n\n            if ('meteorDependencies' in packageJson && typeof packageJson.meteorDependencies === 'object') {\n                plugins += `${plugin}, `;\n                packages.unshift(...Object.keys(packageJson.meteorDependencies));\n                packagesWithVersion.unshift(...packages.map((packageName) => {\n                    if (packageJson.meteorDependencies[packageName] === '@version') {\n                        return `${packageName}@${packageJson.version}`;\n                    }\n                    return `${packageName}@${packageJson.meteorDependencies[packageName]}`;\n                }));\n            }\n        });\n\n        const packagesCount = packages.length;\n        packages = packages.filter(value => !this.deprectatedPlugins.includes(value));\n        if (packagesCount !== packages.length) {\n            this.log.warn('you have some deprecated meteor desktop plugins in your settings, please remove ' +\n                `them (deprecated plugins: ${this.deprectatedPlugins.join(', ')})`);\n        }\n\n        if (packages.length > 0) {\n            plugins = `${plugins.substr(0, plugins.length - 2)}]`;\n            try {\n                await this.$.meteorApp.meteorManager.ensurePackages(\n                    packages, packagesWithVersion, plugins\n                );\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n    }\n\n    /**\n     * Builds meteor app.\n     */\n    async getMeteorClientBuild() {\n        await this.$.meteorApp.build();\n    }\n\n    /**\n     * Removes node_modules if needed.\n     * @returns {Promise<void>}\n     */\n    async handleStateOfNodeModules() {\n        if (this.$.env.isProductionBuild() || this.$.env.options.ia32) {\n            if (!this.$.env.isProductionBuild()) {\n                this.log.info('clearing node_modules because we need to have it clear for ia32 rebuild');\n            } else {\n                this.log.info('clearing node_modules because this is a production build');\n            }\n            try {\n                await this.$.utils.rmWithRetries(\n                    '-rf', this.$.env.paths.electronApp.nodeModules\n                );\n            } catch (e) {\n                throw new Error(e);\n            }\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * If there is a temporary node_modules folder and no node_modules folder, we will\n     * restore it, as it might be a leftover from an interrupted flow.\n     * @returns {Promise<void>}\n     */\n    async handleTemporaryNodeModules() {\n        if (this.$.utils.exists(this.$.env.paths.electronApp.tmpNodeModules)) {\n            if (!this.$.utils.exists(this.$.env.paths.electronApp.nodeModules)) {\n                this.log.debug('moving temp node_modules back');\n                shell.mv(\n                    this.$.env.paths.electronApp.tmpNodeModules,\n                    this.$.env.paths.electronApp.nodeModules\n                );\n            } else {\n                // If there is a node_modules folder, we should clear the temporary one.\n                this.log.debug('clearing temp node_modules because new one is already created');\n                try {\n                    await this.$.utils.rmWithRetries(\n                        '-rf', this.$.env.paths.electronApp.tmpNodeModules\n                    );\n                } catch (e) {\n                    throw new Error(e);\n                }\n            }\n        }\n    }\n\n    /**\n     * Runs npm link for every package specified in settings.json->linkPackages.\n     */\n    async linkNpmPackages() {\n        if (this.$.env.isProductionBuild()) {\n            return;\n        }\n        const settings = this.$.desktop.getSettings();\n        const promises = [];\n        if ('linkPackages' in this.$.desktop.getSettings()) {\n            if (Array.isArray(settings.linkPackages)) {\n                settings.linkPackages.forEach(packageName =>\n                    promises.push(\n                        this.$.meteorApp.runNpm(\n                            ['link', packageName],\n                            undefined,\n                            this.$.env.paths.electronApp.root\n                        )\n                    ));\n            }\n        }\n        await Promise.all(promises);\n    }\n\n    /**\n     * Runs npm in the electron app to get the dependencies installed.\n     * @returns {Promise}\n     */\n    async ensureDeps() {\n        this.log.info('installing dependencies');\n        if (this.$.utils.exists(this.$.env.paths.electronApp.nodeModules)) {\n            this.log.debug('running npm prune to wipe unneeded dependencies');\n            try {\n                await this.runNpm(['prune']);\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n        try {\n            await this.runNpm(['install'], this.$.env.stdio);\n        } catch (e) {\n            throw new Error(e);\n        }\n    }\n\n    /**\n     * Warns if plugins version are outdated in compare to the newest scaffold.\n     * @param {Object} pluginsVersions - current plugins versions from settings.json\n     */\n    checkPluginsVersion(pluginsVersions) {\n        const settingsJson = JSON.parse(\n            fs.readFileSync(path.join(this.$.env.paths.scaffold, 'settings.json'))\n        );\n        const scaffoldPluginsVersion = this.$.desktop.getDependencies(settingsJson, false).plugins;\n        Object.keys(pluginsVersions).forEach((pluginName) => {\n            if (pluginName in scaffoldPluginsVersion &&\n                scaffoldPluginsVersion[pluginName] !== pluginsVersions[pluginName] &&\n                semver.lt(pluginsVersions[pluginName], scaffoldPluginsVersion[pluginName])\n            ) {\n                this.log.warn(`you are using outdated version ${pluginsVersions[pluginName]} of ` +\n                    `${pluginName}, the suggested version to use is ` +\n                    `${scaffoldPluginsVersion[pluginName]}`);\n            }\n        });\n    }\n\n    /**\n     * Merges core dependency list with the dependencies from .desktop.\n     */\n    updateDependenciesList() {\n        this.log.info('updating list of package.json\\'s dependencies');\n        const desktopDependencies = this.$.desktop.getDependencies();\n\n        this.checkPluginsVersion(desktopDependencies.plugins);\n\n        this.log.debug('merging settings.json[dependencies]');\n        this.depsManager.mergeDependencies(\n            'settings.json[dependencies]',\n            desktopDependencies.fromSettings\n        );\n        this.log.debug('merging settings.json[plugins]');\n        this.depsManager.mergeDependencies(\n            'settings.json[plugins]',\n            desktopDependencies.plugins\n        );\n\n        this.log.debug('merging dependencies from modules');\n        Object.keys(desktopDependencies.modules).forEach(module =>\n            this.depsManager.mergeDependencies(\n                `module[${module}]`,\n                desktopDependencies.modules[module]\n            ));\n\n        this.packageJson.dependencies = this.depsManager.getRemoteDependencies();\n        this.packageJson.localDependencies = this.depsManager.getLocalDependencies();\n\n        this.log.debug('writing updated package.json');\n        fs.writeFileSync(\n            this.$.env.paths.electronApp.packageJson, JSON.stringify(this.packageJson, null, 2)\n        );\n    }\n\n    /**\n     * Install node modules from local paths using local-install.\n     *\n     * @param {string} arch\n     * @returns {Promise}\n     */\n    installLocalNodeModules(arch = this.$.env.options.ia32 || process.arch === 'ia32' ? 'ia32' : 'x64') {\n        const localDependencies = _.values(this.packageJson.localDependencies);\n        if (localDependencies.length === 0) {\n            return Promise.resolve();\n        }\n        this.log.info('installing local node modules');\n        const lastRebuild = this.$.electronBuilder.prepareLastRebuildObject(arch);\n        const env = this.$.electronBuilder.getGypEnv(lastRebuild.frameworkInfo, lastRebuild.platform, lastRebuild.arch);\n        const installer = new LocalInstaller(\n            { [this.$.env.paths.electronApp.root]: localDependencies },\n            { npmEnv: env }\n        );\n        progress(installer);\n        return installer.install();\n    }\n\n    /**\n     * Rebuild binary dependencies against Electron's node headers.\n     * @returns {Promise}\n     */\n    rebuildDeps(install = false) {\n        if (install) {\n            this.log.info('issuing node_modules install from electron-builder');\n        } else {\n            this.log.info('issuing native modules rebuild from electron-builder');\n        }\n\n        const arch = this.$.env.options.ia32 || process.arch === 'ia32' ? 'ia32' : 'x64';\n\n        if (this.$.env.options.ia32) {\n            this.log.verbose('forcing rebuild for 32bit');\n        } else {\n            this.log.verbose(`rebuilding for ${arch}`);\n        }\n\n        return this.$.electronBuilder.installOrRebuild(arch, undefined, install);\n    }\n\n    /**\n     * Update package.json fields accordingly to what is set in settings.json.\n     *\n     * packageJson.name = settings.projectName\n     * packageJson.version = settings.version\n     * packageJson.* = settings.packageJsonFields\n     */\n    updatePackageJsonFields() {\n        this.log.verbose('updating package.json fields');\n        const settings = this.$.desktop.getSettings();\n        /** @type {desktopSettings} */\n        const packageJson = this.scaffold.getDefaultPackageJson();\n\n        packageJson.version = settings.version;\n        if ('packageJsonFields' in settings) {\n            assignIn(packageJson, settings.packageJsonFields);\n        }\n        assignIn(packageJson, { name: settings.projectName });\n\n        this.log.debug('writing updated package.json');\n        fs.writeFileSync(\n            this.$.env.paths.electronApp.packageJson, JSON.stringify(packageJson, null, 4)\n        );\n        this.packageJson = packageJson;\n    }\n\n    /**\n     * Updates settings.json with env (prod/dev) information and versions.\n     */\n    async updateSettingsJsonFields() {\n        this.log.debug('updating settings.json fields');\n        const settings = this.$.desktop.getSettings();\n\n        // Save versions.\n        settings.compatibilityVersion = this.compatibilityVersion;\n\n        // Pass information about build type to the settings.json.\n        settings.env = (this.$.env.isProductionBuild()) ?\n            'prod' : 'dev';\n\n        const version = await this.$.desktop.getHashVersion();\n        settings.desktopVersion = `${version}_${settings.env}`;\n\n        settings.meteorDesktopVersion = this.$.getVersion();\n\n        if (this.$.env.options.prodDebug) {\n            settings.prodDebug = true;\n        }\n\n        fs.writeFileSync(\n            this.$.env.paths.desktopTmp.settings, JSON.stringify(settings, null, 4)\n        );\n    }\n\n    /**\n     * Copies files from prepared .desktop to desktop.asar in electron app.\n     */\n    packDesktopToAsar() {\n        this.log.info('packing .desktop to asar');\n        return new Promise((resolve, reject) => {\n            asar.createPackage(\n                this.$.env.paths.desktopTmp.root,\n                this.$.env.paths.electronApp.desktopAsar\n            )\n                .then(() => {\n                    this.log.verbose('clearing temporary .desktop');\n                    this.$.utils\n                        .rmWithRetries('-rf', this.$.env.paths.desktopTmp.root)\n                        .then(() => {\n                            resolve();\n                        })\n                        .catch((e) => {\n                            reject(e);\n                        });\n                    resolve();\n                });\n        });\n    }\n\n    /**\n     * Makes a temporary copy of .desktop.\n     */\n    copyDesktopToDesktopTemp() {\n        this.log.verbose('copying .desktop to temporary location');\n        shell.cp('-rf', this.$.env.paths.desktop.root, this.$.env.paths.desktopTmp.root);\n        // Remove test files.\n        del.sync([\n            path.join(this.$.env.paths.desktopTmp.root, '**', '*.test.js')\n        ], { force: true });\n    }\n\n\n    /**\n     * Runs babel and uglify over .desktop if requested.\n     */\n    async transpileAndMinify() {\n        this.log.info('transpiling and uglifying');\n\n        const settings = this.$.desktop.getSettings();\n        const options = 'uglifyOptions' in settings ? settings.uglifyOptions : {};\n\n        const uglifyingEnabled = 'uglify' in settings && !!settings.uglify;\n\n        const preset = presetEnv({ assertVersion: () => { } }, { targets: { node: '12' } });\n\n        const { data: files } = await this.$.utils.readDir(this.$.env.paths.desktopTmp.root);\n\n        files.forEach((file) => {\n            if (file.endsWith('.js')) {\n                let { code } = transformFileSync(file, {\n                    presets: [preset]\n                });\n                let error;\n                if (settings.env === 'prod' && uglifyingEnabled) {\n                    ({ code, error } = uglify.minify(code, options));\n                }\n                if (error) {\n                    throw new Error(error);\n                }\n                fs.writeFileSync(file, code);\n            }\n        });\n    }\n\n    /**\n     * Moves all the files that should not be packed into asar into a safe location which is the\n     * 'extracted' dir in the electron app.\n     */\n    async excludeFilesFromArchive() {\n        this.log.info('excluding files from packing');\n\n        // Ensure empty `extracted` dir\n\n        try {\n            await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.extracted);\n        } catch (e) {\n            throw new Error(e);\n        }\n\n        shell.mkdir(this.$.env.paths.electronApp.extracted);\n\n        const configs = this.$.desktop.gatherModuleConfigs();\n\n        // Move files that should not be asar'ed.\n        configs.forEach((config) => {\n            const moduleConfig = config;\n            if ('extract' in moduleConfig) {\n                if (!Array.isArray(moduleConfig.extract)) {\n                    moduleConfig.extract = [moduleConfig.extract];\n                }\n                moduleConfig.extract.forEach((file) => {\n                    this.log.debug(`excluding ${file} from ${config.name}`);\n                    const filePath = path.join(\n                        this.$.env.paths.desktopTmp.modules, moduleConfig.dirName, file\n                    );\n                    const destinationPath = path.join(\n                        this.$.env.paths.electronApp.extracted, moduleConfig.dirName\n                    );\n\n                    if (!this.$.utils.exists(destinationPath)) {\n                        shell.mkdir(destinationPath);\n                    }\n                    shell.mv(filePath, destinationPath);\n                });\n            }\n        });\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/electronAppScaffold.js b/dist/electronAppScaffold.js deleted file mode 100644 index d108be14..00000000 --- a/dist/electronAppScaffold.js +++ /dev/null @@ -1,142 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _fs = _interopRequireDefault(require("fs")); - -var _del = _interopRequireDefault(require("del")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _path = _interopRequireDefault(require("path")); - -var _log = _interopRequireDefault(require("./log")); - -var _skeletonDependencies = _interopRequireDefault(require("./skeletonDependencies")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars -const { - join -} = _path.default; -_shelljs.default.config.fatal = true; -/** - * Represents the .desktop dir scaffold. - */ - -class ElectronAppScaffold { - /** - * @param {MeteorDesktop} $ - context - * @constructor - */ - constructor($) { - this.log = new _log.default('electronAppScaffold'); - this.$ = $; - this.packageJson = { - name: 'MyMeteorApp', - main: this.$.env.isProductionBuild() ? 'app.asar/index.js' : 'app/index.js', - dependencies: Object.assign({}, _skeletonDependencies.default) - }; - - if (!this.$.env.isProductionBuild() || this.$.env.options.prodDebug) { - this.packageJson.dependencies.devtron = '1.4.0'; - this.packageJson.dependencies['electron-debug'] = '1.5.0'; - } - } - /** - * Just a public getter from the default package.json object. - * @returns {Object} - */ - - - getDefaultPackageJson() { - return Object.assign({}, this.packageJson); - } - /** - * Clear the electron app. Removes everything except the node_modules which would be a waste - * to delete. Later `npm prune` will keep it clear. - */ - - - clear() { - if (!this.$.utils.exists(this.$.env.paths.electronApp.root)) { - this.log.verbose(`creating ${this.$.env.paths.electronApp.rootName}`); - - _shelljs.default.mkdir(this.$.env.paths.electronApp.root); - } - - return (0, _del.default)([`${this.$.env.paths.electronApp.root}${_path.default.sep}*`, `!${this.$.env.paths.electronApp.nodeModules}`], { - force: true - }); - } - /** - * Just copies the Skeleton App into the electron app. - */ - - - copySkeletonApp() { - this.log.verbose('copying skeleton app'); - - try { - _shelljs.default.cp('-rf', join(this.$.env.paths.meteorDesktop.skeleton, '*'), this.$.env.paths.electronApp.appRoot + _path.default.sep); - } catch (e) { - this.log.error('error while copying skeleton app:', e); - process.exit(1); - } - } - /** - * After clearing the electron app path, copies a fresh skeleton. - */ - - - async make() { - try { - this.log.verbose(`clearing ${this.$.env.paths.electronApp.rootName}`); - await this.clear(); - } catch (e) { - this.log.error(`error while removing ${this.$.env.paths.electronApp.root}: `, e); - process.exit(1); - } - - this.createAppRoot(); - this.copySkeletonApp(); // TODO: hey, wait, .gitignore is not needed - right? - - /* - this.log.debug('creating .gitignore'); - fs.writeFileSync(this.$.env.paths.electronApp.gitIgnore, [ - 'node_modules' - ].join('\n')); - */ - - this.log.verbose('writing package.json'); - - _fs.default.writeFileSync(this.$.env.paths.electronApp.packageJson, JSON.stringify(this.packageJson, null, 2)); - } - /** - * Creates the app directory in the electron app. - */ - - - createAppRoot() { - try { - this.log.verbose(`creating ${this.$.env.paths.electronApp.appRoot}`); - - _fs.default.mkdirSync(this.$.env.paths.electronApp.appRoot); - } catch (e) { - if (e.code !== 'EEXIST') { - this.log.error(`error while creating dir: ${this.$.env.paths.electronApp.appRoot}: `, e); - process.exit(1); - } - } - } - -} - -exports.default = ElectronAppScaffold; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","shell","config","fatal","ElectronAppScaffold","constructor","$","log","Log","packageJson","name","main","env","isProductionBuild","dependencies","Object","assign","options","prodDebug","devtron","getDefaultPackageJson","clear","utils","exists","paths","electronApp","root","verbose","rootName","mkdir","del","sep","nodeModules","force","copySkeletonApp","cp","meteorDesktop","skeleton","appRoot","e","error","process","exit","make","createAppRoot","fs","writeFileSync","JSON","stringify","mkdirSync","code"],"sources":["../lib/electronAppScaffold.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport fs from 'fs';\nimport del from 'del';\nimport shell from 'shelljs';\nimport path from 'path';\n\nimport Log from './log';\nimport dependencies from './skeletonDependencies';\n\nconst { join } = path;\nshell.config.fatal = true;\n\n/**\n * Represents the .desktop dir scaffold.\n */\nexport default class ElectronAppScaffold {\n    /**\n     * @param {MeteorDesktop} $ - context\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('electronAppScaffold');\n        this.$ = $;\n\n        this.packageJson = {\n            name: 'MyMeteorApp',\n            main: (this.$.env.isProductionBuild()) ?\n                'app.asar/index.js' : 'app/index.js',\n            dependencies: Object.assign({}, dependencies)\n        };\n\n        if (!this.$.env.isProductionBuild() || this.$.env.options.prodDebug) {\n            this.packageJson.dependencies.devtron = '1.4.0';\n            this.packageJson.dependencies['electron-debug'] = '1.5.0';\n        }\n    }\n\n    /**\n     * Just a public getter from the default package.json object.\n     * @returns {Object}\n     */\n    getDefaultPackageJson() {\n        return Object.assign({}, this.packageJson);\n    }\n\n    /**\n     * Clear the electron app. Removes everything except the node_modules which would be a waste\n     * to delete. Later `npm prune` will keep it clear.\n     */\n    clear() {\n        if (!this.$.utils.exists(this.$.env.paths.electronApp.root)) {\n            this.log.verbose(`creating ${this.$.env.paths.electronApp.rootName}`);\n            shell.mkdir(this.$.env.paths.electronApp.root);\n        }\n\n        return del([\n            `${this.$.env.paths.electronApp.root}${path.sep}*`,\n            `!${this.$.env.paths.electronApp.nodeModules}`\n        ], { force: true });\n    }\n\n    /**\n     * Just copies the Skeleton App into the electron app.\n     */\n    copySkeletonApp() {\n        this.log.verbose('copying skeleton app');\n        try {\n            shell.cp(\n                '-rf',\n                join(this.$.env.paths.meteorDesktop.skeleton, '*'),\n                this.$.env.paths.electronApp.appRoot + path.sep\n            );\n        } catch (e) {\n            this.log.error('error while copying skeleton app:', e);\n            process.exit(1);\n        }\n    }\n\n    /**\n     * After clearing the electron app path, copies a fresh skeleton.\n     */\n    async make() {\n        try {\n            this.log.verbose(`clearing ${this.$.env.paths.electronApp.rootName}`);\n            await this.clear();\n        } catch (e) {\n            this.log.error(\n                `error while removing ${this.$.env.paths.electronApp.root}: `, e\n            );\n            process.exit(1);\n        }\n\n        this.createAppRoot();\n\n        this.copySkeletonApp();\n\n        // TODO: hey, wait, .gitignore is not needed - right?\n        /*\n        this.log.debug('creating .gitignore');\n        fs.writeFileSync(this.$.env.paths.electronApp.gitIgnore, [\n            'node_modules'\n        ].join('\\n'));\n        */\n        this.log.verbose('writing package.json');\n        fs.writeFileSync(\n            this.$.env.paths.electronApp.packageJson, JSON.stringify(this.packageJson, null, 2)\n        );\n    }\n\n    /**\n     * Creates the app directory in the electron app.\n     */\n    createAppRoot() {\n        try {\n            this.log.verbose(`creating ${this.$.env.paths.electronApp.appRoot}`);\n            fs.mkdirSync(this.$.env.paths.electronApp.appRoot);\n        } catch (e) {\n            if (e.code !== 'EEXIST') {\n                this.log.error(\n                    `error while creating dir: ${this.$.env.paths.electronApp.appRoot}: `, e\n                );\n                process.exit(1);\n            }\n        }\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/electronBuilder.js b/dist/electronBuilder.js deleted file mode 100644 index d4438f23..00000000 --- a/dist/electronBuilder.js +++ /dev/null @@ -1,384 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _path = _interopRequireDefault(require("path")); - -var _fs = _interopRequireDefault(require("fs")); - -var _rimraf = _interopRequireDefault(require("rimraf")); - -var _crossSpawn = _interopRequireDefault(require("cross-spawn")); - -var _log = _interopRequireDefault(require("./log")); - -var _defaultDependencies = _interopRequireDefault(require("./defaultDependencies")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars - -/** - * Promisfied rimraf. - * - * @param {string} dirPath - path to the dir to be deleted - * @param {number} delay - delay the task by ms - * @returns {Promise} - */ -function removeDir(dirPath, delay = 0) { - return new Promise((resolve, reject) => { - setTimeout(() => { - (0, _rimraf.default)(dirPath, { - maxBusyTries: 100 - }, err => { - if (err) { - reject(err); - } else { - resolve(); - } - }); - }, delay); - }); -} -/** - * Wrapper for electron-builder. - */ - - -class InstallerBuilder { - /** - * @param {MeteorDesktop} $ - context - * - * @constructor - */ - constructor($) { - this.log = new _log.default('electronBuilder'); - this.$ = $; - this.firstPass = true; - this.lastRebuild = {}; - this.currentContext = null; - this.installerDir = _path.default.join(this.$.env.options.output, this.$.env.paths.installerDir); - this.platforms = []; - } - - async init() { - this.builder = await this.$.getDependency('electron-builder', _defaultDependencies.default['electron-builder']); - const appBuilder = await this.$.getDependency('app-builder-lib', _defaultDependencies.default['electron-builder'], false); - this.yarn = require(_path.default.join(appBuilder.path, 'out', 'util', 'yarn')); - this.getGypEnv = this.yarn.getGypEnv; - this.packageDependencies = require(_path.default.join(appBuilder.path, 'out', 'util', 'packageDependencies')); - } - /** - * Prepares the last rebuild object for electron-builder. - * - * @param {string} arch - * @param {string} platform - * @returns {Object} - */ - - - prepareLastRebuildObject(arch, platform = process.platform) { - const productionDeps = this.packageDependencies.createLazyProductionDeps(this.$.env.paths.electronApp.root); - this.lastRebuild = { - frameworkInfo: { - version: this.$.getElectronVersion(), - useCustomDist: true - }, - platform, - arch, - productionDeps - }; - return this.lastRebuild; - } - /** - * Calls npm rebuild from electron-builder. - * @param {string} arch - * @param {string} platform - * @param {boolean} install - * @returns {Promise} - */ - - - async installOrRebuild(arch, platform = process.platform, install = false) { - this.log.debug(`calling installOrRebuild from electron-builder for arch ${arch}`); - this.prepareLastRebuildObject(arch, platform); - await this.yarn.installOrRebuild(this.$.desktop.getSettings().builderOptions || {}, this.$.env.paths.electronApp.root, this.lastRebuild, install); - } - /** - * Callback invoked before build is made. Ensures that app.asar have the right rebuilt - * node_modules. - * - * @param {Object} context - * @returns {Promise} - */ - - - beforeBuild(context) { - this.currentContext = Object.assign({}, context); - return new Promise((resolve, reject) => { - const platformMatches = process.platform === context.platform.nodeName; - const rebuild = platformMatches && context.arch !== this.lastRebuild.arch; - - if (!platformMatches) { - this.log.warn('skipping dependencies rebuild because platform is different, if you have native ' + 'node modules as your app dependencies you should od the build on the target platform only'); - } - - if (!rebuild) { - this.moveNodeModulesOut().catch(e => reject(e)).then(() => setTimeout(() => resolve(false), 2000)); // Timeout helps on Windows to clear the file locks. - } else { - // Lets rebuild the node_modules for different arch. - this.installOrRebuild(context.arch, context.platform.nodeName).catch(e => reject(e)).then(() => this.$.electronApp.installLocalNodeModules(context.arch)).catch(e => reject(e)).then(() => { - this.$.electronApp.scaffold.createAppRoot(); - this.$.electronApp.scaffold.copySkeletonApp(); - return this.$.electronApp.packSkeletonToAsar([this.$.env.paths.electronApp.meteorAsar, this.$.env.paths.electronApp.desktopAsar, this.$.env.paths.electronApp.extracted]); - }).catch(e => reject(e)).then(() => this.moveNodeModulesOut()).catch(e => reject(e)).then(() => resolve(false)); - } - }); - } - /** - * Callback to be invoked after packing. Restores node_modules to the .desktop-build. - * @returns {Promise} - */ - - - afterPack(context) { - this.platforms = this.platforms.filter(platform => platform !== context.electronPlatformName); - - if (this.platforms.length !== 0) { - return Promise.resolve(); - } - - return new Promise((resolve, reject) => { - _shelljs.default.config.fatal = true; - - if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) { - this.log.debug('injecting extracted modules'); - - _shelljs.default.cp('-Rf', this.$.env.paths.electronApp.extractedNodeModules, _path.default.join(this.getPackagedAppPath(context), 'node_modules')); - } - - this.log.debug('moving node_modules back'); // Move node_modules back. - - try { - _shelljs.default.mv(this.$.env.paths.electronApp.tmpNodeModules, this.$.env.paths.electronApp.nodeModules); - } catch (e) { - reject(e); - return; - } finally { - _shelljs.default.config.reset(); - } - - if (this.firstPass) { - this.firstPass = false; - } - - this.log.debug('node_modules moved back'); - this.wait().catch(e => reject(e)).then(() => resolve()); - }); - } - /** - * This command kills orphaned MSBuild.exe processes. - * Sometime after native node_modules compilation they are still writing some logs, - * prevent node_modules from being deleted. - */ - - - killMSBuild() { - if (this.currentContext.platform.nodeName !== 'win32') { - return; - } - - try { - const out = _crossSpawn.default.sync('wmic', ['process', 'where', 'caption="MSBuild.exe"', 'get', 'processid']).stdout.toString('utf-8').split('\n'); - - const regex = new RegExp(/(\d+)/, 'gm'); // No we will check for those with the matching params. - - out.forEach(line => { - const match = regex.exec(line) || false; - - if (match) { - this.log.debug(`killing MSBuild.exe at pid: ${match[1]}`); - - _crossSpawn.default.sync('taskkill', ['/pid', match[1], '/f', '/t']); - } - - regex.lastIndex = 0; - }); - } catch (e) { - this.log.debug('kill MSBuild failed'); - } - } - /** - * Returns the path to packaged app. - * @returns {string} - */ - - - getPackagedAppPath(context = {}) { - if (this.currentContext.platform.nodeName === 'darwin') { - return _path.default.join(this.installerDir, 'mac', `${context.packager.appInfo.productFilename}.app`, 'Contents', 'Resources', 'app'); - } - - const platformDir = `${this.currentContext.platform.nodeName === 'win32' ? 'win' : 'linux'}-${this.currentContext.arch === 'ia32' ? 'ia32-' : ''}unpacked`; - return _path.default.join(this.installerDir, platformDir, 'resources', 'app'); - } - /** - * On Windows it waits for the app.asar in the packed app to be free (no file locks). - * @returns {*} - */ - - - wait() { - if (this.currentContext.platform.nodeName !== 'win32') { - return Promise.resolve(); - } - - const appAsarPath = _path.default.join(this.getPackagedAppPath(), 'app.asar'); - - let retries = 0; - const self = this; - return new Promise((resolve, reject) => { - function check() { - _fs.default.open(appAsarPath, 'r+', (err, fd) => { - retries += 1; - - if (err) { - if (err.code !== 'ENOENT') { - self.log.debug(`waiting for app.asar to be readable, ${'code' in err ? `currently reading it returns ${err.code}` : ''}`); - - if (retries < 6) { - setTimeout(() => check(), 4000); - } else { - reject(`file is locked: ${appAsarPath}`); - } - } else { - resolve(); - } - } else { - _fs.default.closeSync(fd); - - resolve(); - } - }); - } - - check(); - }); - } - /** - * Prepares the target object passed to the electron-builder. - * - * @returns {Map>>} - */ - - - prepareTargets() { - let arch = this.$.env.options.ia32 ? 'ia32' : 'x64'; - arch = this.$.env.options.allArchs ? 'all' : arch; - const targets = []; - - if (this.$.env.options.win) { - targets.push(this.builder.dependency.Platform.WINDOWS); - } - - if (this.$.env.options.linux) { - targets.push(this.builder.dependency.Platform.LINUX); - } - - if (this.$.env.options.mac) { - targets.push(this.builder.dependency.Platform.MAC); - } - - if (targets.length === 0) { - if (this.$.env.os.isWindows) { - targets.push(this.builder.dependency.Platform.WINDOWS); - } else if (this.$.env.os.isLinux) { - targets.push(this.builder.dependency.Platform.LINUX); - } else { - targets.push(this.builder.dependency.Platform.MAC); - } - } - - return this.builder.dependency.createTargets(targets, null, arch); - } - - async build() { - const settings = this.$.desktop.getSettings(); - - if (!('builderOptions' in settings)) { - this.log.error('no builderOptions in settings.json, aborting'); - process.exit(1); - } - - const builderOptions = Object.assign({}, settings.builderOptions); - builderOptions.asar = false; - builderOptions.npmRebuild = true; - builderOptions.beforeBuild = this.beforeBuild.bind(this); - builderOptions.afterPack = this.afterPack.bind(this); - builderOptions.electronVersion = this.$.getElectronVersion(); - builderOptions.directories = { - app: this.$.env.paths.electronApp.root, - output: _path.default.join(this.$.env.options.output, this.$.env.paths.installerDir) - }; - - if ('mac' in builderOptions && 'target' in builderOptions.mac) { - if (builderOptions.mac.target.includes('mas')) { - this.platforms = ['darwin', 'mas']; - } - } - - try { - this.log.debug('calling build from electron-builder'); - await this.builder.dependency.build(Object.assign({ - targets: this.prepareTargets(), - config: builderOptions - }, settings.builderCliOptions)); - - if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) { - _shelljs.default.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules); - } - } catch (e) { - this.log.error('error while building installer: ', e); - } - } - /** - * Moves node_modules out of the app because while the app will be packaged - * we do not want it to be there. - * @returns {Promise} - */ - - - moveNodeModulesOut() { - return new Promise((resolve, reject) => { - this.log.debug('moving node_modules out, because we have them already in' + ' app.asar'); - this.killMSBuild(); - removeDir(this.$.env.paths.electronApp.tmpNodeModules).catch(e => reject(e)).then(() => { - _shelljs.default.config.fatal = true; - _shelljs.default.config.verbose = true; - - try { - _shelljs.default.mv(this.$.env.paths.electronApp.nodeModules, this.$.env.paths.electronApp.tmpNodeModules); - - _shelljs.default.config.reset(); - - return this.wait(); - } catch (e) { - _shelljs.default.config.reset(); - - return Promise.reject(e); - } - }).catch(e => reject(e)).then(() => removeDir(this.$.env.paths.electronApp.nodeModules, 1000)).catch(e => reject(e)).then(() => this.wait()).catch(reject).then(resolve); - }); - } - -} - -exports.default = InstallerBuilder; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["removeDir","dirPath","delay","Promise","resolve","reject","setTimeout","rimraf","maxBusyTries","err","InstallerBuilder","constructor","$","log","Log","firstPass","lastRebuild","currentContext","installerDir","path","join","env","options","output","paths","platforms","init","builder","getDependency","defaultDependencies","appBuilder","yarn","require","getGypEnv","packageDependencies","prepareLastRebuildObject","arch","platform","process","productionDeps","createLazyProductionDeps","electronApp","root","frameworkInfo","version","getElectronVersion","useCustomDist","installOrRebuild","install","debug","desktop","getSettings","builderOptions","beforeBuild","context","Object","assign","platformMatches","nodeName","rebuild","warn","moveNodeModulesOut","catch","e","then","installLocalNodeModules","scaffold","createAppRoot","copySkeletonApp","packSkeletonToAsar","meteorAsar","desktopAsar","extracted","afterPack","filter","electronPlatformName","length","shell","config","fatal","utils","exists","extractedNodeModules","cp","getPackagedAppPath","mv","tmpNodeModules","nodeModules","reset","wait","killMSBuild","out","spawn","sync","stdout","toString","split","regex","RegExp","forEach","line","match","exec","lastIndex","packager","appInfo","productFilename","platformDir","appAsarPath","retries","self","check","fs","open","fd","code","closeSync","prepareTargets","ia32","allArchs","targets","win","push","dependency","Platform","WINDOWS","linux","LINUX","mac","MAC","os","isWindows","isLinux","createTargets","build","settings","error","exit","asar","npmRebuild","bind","electronVersion","directories","app","target","includes","builderCliOptions","rm","verbose"],"sources":["../lib/electronBuilder.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport shell from 'shelljs';\nimport path from 'path';\nimport fs from 'fs';\nimport rimraf from 'rimraf';\nimport spawn from 'cross-spawn';\nimport Log from './log';\nimport defaultDependencies from './defaultDependencies';\n\n/**\n * Promisfied rimraf.\n *\n * @param {string} dirPath - path to the dir to be deleted\n * @param {number} delay - delay the task by ms\n * @returns {Promise<any>}\n */\nfunction removeDir(dirPath, delay = 0) {\n    return new Promise((resolve, reject) => {\n        setTimeout(() => {\n            rimraf(dirPath, {\n                maxBusyTries: 100\n            }, (err) => {\n                if (err) {\n                    reject(err);\n                } else {\n                    resolve();\n                }\n            });\n        }, delay);\n    });\n}\n\n/**\n * Wrapper for electron-builder.\n */\nexport default class InstallerBuilder {\n    /**\n     * @param {MeteorDesktop} $ - context\n     *\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('electronBuilder');\n        this.$ = $;\n        this.firstPass = true;\n        this.lastRebuild = {};\n        this.currentContext = null;\n        this.installerDir = path.join(this.$.env.options.output, this.$.env.paths.installerDir);\n        this.platforms = [];\n    }\n\n    async init() {\n        this.builder = await this.$.getDependency('electron-builder', defaultDependencies['electron-builder']);\n        const appBuilder = await this.$.getDependency('app-builder-lib', defaultDependencies['electron-builder'], false);\n\n        this.yarn = require(path.join(appBuilder.path, 'out', 'util', 'yarn'));\n        this.getGypEnv = this.yarn.getGypEnv;\n        this.packageDependencies = require(path.join(appBuilder.path, 'out', 'util', 'packageDependencies'));\n    }\n\n    /**\n     * Prepares the last rebuild object for electron-builder.\n     *\n     * @param {string} arch\n     * @param {string} platform\n     * @returns {Object}\n     */\n    prepareLastRebuildObject(arch, platform = process.platform) {\n        const productionDeps = this.packageDependencies\n            .createLazyProductionDeps(this.$.env.paths.electronApp.root);\n        this.lastRebuild = {\n            frameworkInfo: { version: this.$.getElectronVersion(), useCustomDist: true },\n            platform,\n            arch,\n            productionDeps\n        };\n        return this.lastRebuild;\n    }\n\n    /**\n     * Calls npm rebuild from electron-builder.\n     * @param {string} arch\n     * @param {string} platform\n     * @param {boolean} install\n     * @returns {Promise}\n     */\n    async installOrRebuild(arch, platform = process.platform, install = false) {\n        this.log.debug(`calling installOrRebuild from electron-builder for arch ${arch}`);\n        this.prepareLastRebuildObject(arch, platform);\n        await this.yarn.installOrRebuild(this.$.desktop.getSettings().builderOptions || {},\n            this.$.env.paths.electronApp.root, this.lastRebuild, install);\n    }\n\n    /**\n     * Callback invoked before build is made. Ensures that app.asar have the right rebuilt\n     * node_modules.\n     *\n     * @param {Object} context\n     * @returns {Promise}\n     */\n    beforeBuild(context) {\n        this.currentContext = Object.assign({}, context);\n        return new Promise((resolve, reject) => {\n            const platformMatches = process.platform === context.platform.nodeName;\n            const rebuild = platformMatches && context.arch !== this.lastRebuild.arch;\n            if (!platformMatches) {\n                this.log.warn('skipping dependencies rebuild because platform is different, if you have native ' +\n                    'node modules as your app dependencies you should od the build on the target platform only');\n            }\n\n            if (!rebuild) {\n                this.moveNodeModulesOut()\n                    .catch(e => reject(e))\n                    .then(() => setTimeout(() => resolve(false), 2000));\n                // Timeout helps on Windows to clear the file locks.\n            } else {\n                // Lets rebuild the node_modules for different arch.\n                this.installOrRebuild(context.arch, context.platform.nodeName)\n                    .catch(e => reject(e))\n                    .then(() => this.$.electronApp.installLocalNodeModules(context.arch))\n                    .catch(e => reject(e))\n                    .then(() => {\n                        this.$.electronApp.scaffold.createAppRoot();\n                        this.$.electronApp.scaffold.copySkeletonApp();\n                        return this.$.electronApp.packSkeletonToAsar(\n                            [\n                                this.$.env.paths.electronApp.meteorAsar,\n                                this.$.env.paths.electronApp.desktopAsar,\n                                this.$.env.paths.electronApp.extracted\n                            ]\n                        );\n                    })\n                    .catch(e => reject(e))\n                    .then(() => this.moveNodeModulesOut())\n                    .catch(e => reject(e))\n                    .then(() => resolve(false));\n            }\n        });\n    }\n\n    /**\n     * Callback to be invoked after packing. Restores node_modules to the .desktop-build.\n     * @returns {Promise}\n     */\n    afterPack(context) {\n        this.platforms = this.platforms\n            .filter(platform => platform !== context.electronPlatformName);\n        if (this.platforms.length !== 0) {\n            return Promise.resolve();\n        }\n        return new Promise((resolve, reject) => {\n            shell.config.fatal = true;\n\n            if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) {\n                this.log.debug('injecting extracted modules');\n                shell.cp(\n                    '-Rf',\n                    this.$.env.paths.electronApp.extractedNodeModules,\n                    path.join(this.getPackagedAppPath(context), 'node_modules')\n                );\n            }\n\n            this.log.debug('moving node_modules back');\n            // Move node_modules back.\n\n            try {\n                shell.mv(\n                    this.$.env.paths.electronApp.tmpNodeModules,\n                    this.$.env.paths.electronApp.nodeModules\n                );\n            } catch (e) {\n                reject(e);\n                return;\n            } finally {\n                shell.config.reset();\n            }\n\n            if (this.firstPass) {\n                this.firstPass = false;\n            }\n            this.log.debug('node_modules moved back');\n\n            this.wait()\n                .catch(e => reject(e))\n                .then(() => resolve());\n        });\n    }\n\n    /**\n     * This command kills orphaned MSBuild.exe processes.\n     * Sometime after native node_modules compilation they are still writing some logs,\n     * prevent node_modules from being deleted.\n     */\n    killMSBuild() {\n        if (this.currentContext.platform.nodeName !== 'win32') {\n            return;\n        }\n        try {\n            const out = spawn\n                .sync(\n                    'wmic',\n                    ['process', 'where', 'caption=\"MSBuild.exe\"', 'get', 'processid']\n                )\n                .stdout.toString('utf-8')\n                .split('\\n');\n\n            const regex = new RegExp(/(\\d+)/, 'gm');\n            // No we will check for those with the matching params.\n            out.forEach((line) => {\n                const match = regex.exec(line) || false;\n                if (match) {\n                    this.log.debug(`killing MSBuild.exe at pid: ${match[1]}`);\n                    spawn.sync('taskkill', ['/pid', match[1], '/f', '/t']);\n                }\n                regex.lastIndex = 0;\n            });\n        } catch (e) {\n            this.log.debug('kill MSBuild failed');\n        }\n    }\n\n    /**\n     * Returns the path to packaged app.\n     * @returns {string}\n     */\n    getPackagedAppPath(context = {}) {\n        if (this.currentContext.platform.nodeName === 'darwin') {\n            return path.join(\n                this.installerDir,\n                'mac',\n                `${context.packager.appInfo.productFilename}.app`,\n                'Contents', 'Resources', 'app'\n            );\n        }\n        const platformDir =\n            `${this.currentContext.platform.nodeName === 'win32' ? 'win' : 'linux'}-${this.currentContext.arch === 'ia32' ? 'ia32-' : ''}unpacked`;\n        return path.join(\n            this.installerDir,\n            platformDir,\n            'resources', 'app'\n        );\n    }\n\n    /**\n     * On Windows it waits for the app.asar in the packed app to be free (no file locks).\n     * @returns {*}\n     */\n    wait() {\n        if (this.currentContext.platform.nodeName !== 'win32') {\n            return Promise.resolve();\n        }\n        const appAsarPath = path.join(\n            this.getPackagedAppPath(),\n            'app.asar'\n        );\n        let retries = 0;\n        const self = this;\n        return new Promise((resolve, reject) => {\n            function check() {\n                fs.open(appAsarPath, 'r+', (err, fd) => {\n                    retries += 1;\n                    if (err) {\n                        if (err.code !== 'ENOENT') {\n                            self.log.debug(`waiting for app.asar to be readable, ${'code' in err ? `currently reading it returns ${err.code}` : ''}`);\n                            if (retries < 6) {\n                                setTimeout(() => check(), 4000);\n                            } else {\n                                reject(`file is locked: ${appAsarPath}`);\n                            }\n                        } else {\n                            resolve();\n                        }\n                    } else {\n                        fs.closeSync(fd);\n                        resolve();\n                    }\n                });\n            }\n            check();\n        });\n    }\n\n    /**\n     * Prepares the target object passed to the electron-builder.\n     *\n     * @returns {Map<Platform, Map<Arch, Array<string>>>}\n     */\n    prepareTargets() {\n        let arch = this.$.env.options.ia32 ? 'ia32' : 'x64';\n        arch = this.$.env.options.allArchs ? 'all' : arch;\n\n        const targets = [];\n\n        if (this.$.env.options.win) {\n            targets.push(this.builder.dependency.Platform.WINDOWS);\n        }\n        if (this.$.env.options.linux) {\n            targets.push(this.builder.dependency.Platform.LINUX);\n        }\n        if (this.$.env.options.mac) {\n            targets.push(this.builder.dependency.Platform.MAC);\n        }\n\n        if (targets.length === 0) {\n            if (this.$.env.os.isWindows) {\n                targets.push(this.builder.dependency.Platform.WINDOWS);\n            } else if (this.$.env.os.isLinux) {\n                targets.push(this.builder.dependency.Platform.LINUX);\n            } else {\n                targets.push(this.builder.dependency.Platform.MAC);\n            }\n        }\n        return this.builder.dependency.createTargets(targets, null, arch);\n    }\n\n    async build() {\n        const settings = this.$.desktop.getSettings();\n        if (!('builderOptions' in settings)) {\n            this.log.error(\n                'no builderOptions in settings.json, aborting'\n            );\n            process.exit(1);\n        }\n\n        const builderOptions = Object.assign({}, settings.builderOptions);\n\n        builderOptions.asar = false;\n        builderOptions.npmRebuild = true;\n\n        builderOptions.beforeBuild = this.beforeBuild.bind(this);\n        builderOptions.afterPack = this.afterPack.bind(this);\n        builderOptions.electronVersion = this.$.getElectronVersion();\n\n        builderOptions.directories = {\n            app: this.$.env.paths.electronApp.root,\n            output: path.join(this.$.env.options.output, this.$.env.paths.installerDir)\n        };\n\n        if ('mac' in builderOptions && 'target' in builderOptions.mac) {\n            if (builderOptions.mac.target.includes('mas')) {\n                this.platforms = ['darwin', 'mas'];\n            }\n        }\n\n        try {\n            this.log.debug('calling build from electron-builder');\n            await this.builder.dependency.build(Object.assign({\n                targets: this.prepareTargets(),\n                config: builderOptions\n            }, settings.builderCliOptions));\n\n            if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) {\n                shell.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules);\n            }\n        } catch (e) {\n            this.log.error('error while building installer: ', e);\n        }\n    }\n\n    /**\n     * Moves node_modules out of the app because while the app will be packaged\n     * we do not want it to be there.\n     * @returns {Promise<any>}\n     */\n    moveNodeModulesOut() {\n        return new Promise((resolve, reject) => {\n            this.log.debug('moving node_modules out, because we have them already in' +\n                ' app.asar');\n            this.killMSBuild();\n            removeDir(this.$.env.paths.electronApp.tmpNodeModules)\n                .catch(e => reject(e))\n                .then(() => {\n                    shell.config.fatal = true;\n                    shell.config.verbose = true;\n                    try {\n                        shell.mv(\n                            this.$.env.paths.electronApp.nodeModules,\n                            this.$.env.paths.electronApp.tmpNodeModules\n                        );\n                        shell.config.reset();\n                        return this.wait();\n                    } catch (e) {\n                        shell.config.reset();\n                        return Promise.reject(e);\n                    }\n                })\n                .catch(e => reject(e))\n                .then(() => removeDir(this.$.env.paths.electronApp.nodeModules, 1000))\n                .catch(e => reject(e))\n                .then(() => this.wait())\n                .catch(reject)\n                .then(resolve);\n        });\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/env.js b/dist/env.js deleted file mode 100644 index 8f8fd133..00000000 --- a/dist/env.js +++ /dev/null @@ -1,239 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _path = _interopRequireDefault(require("path")); - -var _os = _interopRequireDefault(require("os")); - -var _assignIn = _interopRequireDefault(require("lodash/assignIn")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const { - join -} = _path.default; -/** - * @class - * @property {packagePaths} paths - */ - -class Env { - constructor(input, output, options) { - this.options = options; - - if (this.isProductionBuild()) { - process.env.NODE_ENV = 'production'; - } - - this.sys = { - platform: process.platform, - arch: process.arch - }; // Operational System. - - this.os = { - isWindows: process.platform === 'win32', - isLinux: process.platform === 'linux', - isOsx: process.platform === 'darwin' - }; - this.stdio = 'inherit'; - this.os.name = this.sys.platform === 'darwin' ? 'osx' : this.sys.platform; - this.os.home = process.env[this.os.isWindows ? 'USERPROFILE' : 'HOME']; - this.os.tmp = _os.default.tmpdir(); - /** @type {packagePaths} */ - - this.paths = {}; - /** @type {meteorDesktopPaths} */ - - this.paths.meteorDesktop = { - root: _path.default.resolve(__dirname, '..') - }; - this.paths.meteorDesktop.skeleton = join(this.paths.meteorDesktop.root, 'skeleton'); - /** @type {meteorAppPaths} */ - - this.paths.meteorApp = { - root: input - }; - /** @type {desktopPaths} */ - - this.paths.desktop = { - rootName: '.desktop', - root: join(this.paths.meteorApp.root, '.desktop') - }; - (0, _assignIn.default)(this.paths.desktop, { - modules: join(this.paths.desktop.root, 'modules'), - import: join(this.paths.desktop.root, 'import'), - assets: join(this.paths.desktop.root, 'assets'), - settings: join(this.paths.desktop.root, 'settings.json'), - desktop: join(this.paths.desktop.root, 'desktop.js') - }); - this.paths.desktop.splashScreen = join(this.paths.desktop.assets, 'splashScreen.png'); - this.paths.desktop.loadingGif = join(this.paths.desktop.assets, 'loading.gif'); - this.paths.desktop.meteorIco = join(this.paths.desktop.assets, 'meteor.ico'); - /** @type {electronAppPaths} */ - - this.paths.electronApp = { - rootName: 'desktop-build' - }; - this.paths.electronApp.root = join(this.paths.meteorApp.root, '.meteor', this.paths.electronApp.rootName); - this.paths.electronApp.tmpNodeModules = join(this.paths.meteorApp.root, '.meteor', '.desktop_node_modules'); - this.paths.cache = join(this.paths.meteorApp.root, '.meteor', 'local', 'desktop-cache'); - this.paths.electronApp.extractedNodeModules = join(this.paths.meteorApp.root, '.meteor', '.desktop_extracted_node_modules'); - this.paths.electronApp.extractedNodeModulesBin = join(this.paths.electronApp.extractedNodeModules, '.bin'); - this.paths.electronApp.appRoot = join(this.paths.electronApp.root, 'app'); - (0, _assignIn.default)(this.paths.electronApp, { - app: join(this.paths.electronApp.appRoot, 'app.js'), - cordova: join(this.paths.electronApp.appRoot, 'cordova.js'), - index: join(this.paths.electronApp.appRoot, 'index.js'), - preload: join(this.paths.electronApp.appRoot, 'preload.js'), - modules: join(this.paths.electronApp.appRoot, 'modules'), - desktopAsar: join(this.paths.electronApp.root, 'desktop.asar'), - extracted: join(this.paths.electronApp.root, 'extracted'), - appAsar: join(this.paths.electronApp.root, 'app.asar'), - import: join(this.paths.electronApp.root, 'import'), - assets: join(this.paths.electronApp.root, 'assets'), - packageJson: join(this.paths.electronApp.root, 'package.json'), - settings: join(this.paths.electronApp.root, 'settings.json'), - desktop: join(this.paths.electronApp.root, 'desktop.js'), - desktopTmp: join(this.paths.electronApp.root, '__desktop'), - nodeModules: join(this.paths.electronApp.root, 'node_modules'), - meteorAsar: join(this.paths.electronApp.root, 'meteor.asar'), - meteorApp: join(this.paths.electronApp.root, 'meteor'), - meteorAppIndex: join(this.paths.electronApp.root, 'meteor', 'index.html'), - meteorAppProgramJson: join(this.paths.electronApp.root, 'meteor', 'program.json'), - skeleton: join(this.paths.electronApp.root, 'skeleton') - }); - (0, _assignIn.default)(this.paths.meteorApp, { - platforms: join(this.paths.meteorApp.root, '.meteor', 'platforms'), - packages: join(this.paths.meteorApp.root, '.meteor', 'packages'), - versions: join(this.paths.meteorApp.root, '.meteor', 'versions'), - release: join(this.paths.meteorApp.root, '.meteor', 'release'), - packageJson: join(this.paths.meteorApp.root, 'package.json'), - gitIgnore: join(this.paths.meteorApp.root, '.meteor', '.gitignore'), - cordovaBuild: join(this.paths.meteorApp.root, '.meteor', 'local', 'cordova-build', 'www', 'application'), - webCordova: join(this.paths.meteorApp.root, '.meteor', 'local', 'build', 'programs', 'web.cordova') - }); - (0, _assignIn.default)(this.paths.meteorApp, { - cordovaBuildIndex: join(this.paths.meteorApp.cordovaBuild, 'index.html'), - cordovaBuildProgramJson: join(this.paths.meteorApp.cordovaBuild, 'program.json') - }); - (0, _assignIn.default)(this.paths.meteorApp, { - webCordovaProgramJson: join(this.paths.meteorApp.webCordova, 'program.json') - }); - /** @type {desktopTmpPaths} */ - - this.paths.desktopTmp = { - root: join(this.paths.electronApp.root, '__desktop') - }; - (0, _assignIn.default)(this.paths.desktopTmp, { - modules: join(this.paths.desktopTmp.root, 'modules'), - settings: join(this.paths.desktopTmp.root, 'settings.json') - }); - this.paths.packageDir = '.desktop-package'; - this.paths.installerDir = '.desktop-installer'; // Scaffold - - this.paths.scaffold = join(__dirname, '..', 'scaffold'); - } - /** - * @returns {boolean|*} - * @public - */ - - - isProductionBuild() { - return !!('production' in this.options && this.options.production); - } - -} - -exports.default = Env; -module.exports = Env; -/** - * @typedef {Object} desktopPaths - * @property {string} rootName - * @property {string} root - * @property {string} modules - * @property {string} import - * @property {string} assets - * @property {string} settings - * @property {string} desktop - * @property {string} splashScreen - * @property {string} loadingGif - * @property {string} meteorIco - */ - -/** - * @typedef {Object} meteorAppPaths - * @property {string} root - * @property {string} platforms - * @property {string} release - * @property {string} packages - * @property {string} versions - * @property {string} gitIgnore - * @property {string} packageJson - * @property {string} cordovaBuild - * @property {string} cordovaBuildIndex - * @property {string} cordovaBuildProgramJson - * @property {string} webCordova - * @property {string} webCordovaIndex - * @property {string} webCordovaProgramJson - */ - -/** - * @typedef {Object} electronAppPaths - * @property {string} rootName - * @property {string} root - * @property {Object} appRoot - * @property {string} appRoot.cordova - * @property {string} appRoot.index - * @property {string} appRoot.app - * @property {string} appRoot.modules - * @property {string} desktopAsar - * @property {string} extracted - * @property {string} appAsar - * @property {string} preload - * @property {string} import - * @property {string} assets - * @property {string} gitIgnore - * @property {string} packageJson - * @property {string} settings - * @property {string} desktop - * @property {string} desktopTmp - * @property {string} nodeModules - * @property {string} meteorAsar - * @property {string} meteorApp - * @property {string} meteorAppIndex - * @property {string} meteorAppProgramJson - * @property {string} skeleton - * @property {string} tmpNodeModules - * @property {string} extractedNodeModules - * @property {string} extractedNodeModulesBin - */ - -/** - * @typedef {Object} desktopTmpPaths - * @property {string} root - * @property {string} modules - * @property {string} settings - */ - -/** - * @typedef {Object} meteorDesktopPaths - * @property {string} root - * @property {string} skeleton - */ - -/** - * @typedef {Object} packagePaths - * @property {meteorAppPaths} meteorApp - * @property {desktopPaths} desktop - * @property {electronAppPaths} electronApp - * @property {desktopTmpPaths} desktopTmp - * @property {meteorDesktopPaths} meteorDesktop - * @property {string} packageDir - * @property {string} scaffold - */ -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","Env","constructor","input","output","options","isProductionBuild","process","env","NODE_ENV","sys","platform","arch","os","isWindows","isLinux","isOsx","stdio","name","home","tmp","tmpdir","paths","meteorDesktop","root","resolve","__dirname","skeleton","meteorApp","desktop","rootName","assignIn","modules","import","assets","settings","splashScreen","loadingGif","meteorIco","electronApp","tmpNodeModules","cache","extractedNodeModules","extractedNodeModulesBin","appRoot","app","cordova","index","preload","desktopAsar","extracted","appAsar","packageJson","desktopTmp","nodeModules","meteorAsar","meteorAppIndex","meteorAppProgramJson","platforms","packages","versions","release","gitIgnore","cordovaBuild","webCordova","cordovaBuildIndex","cordovaBuildProgramJson","webCordovaProgramJson","packageDir","installerDir","scaffold","production","module","exports"],"sources":["../lib/env.js"],"sourcesContent":["import path from 'path';\nimport os from 'os';\nimport assignIn from 'lodash/assignIn';\n\nconst { join } = path;\n\n/**\n * @class\n * @property {packagePaths} paths\n */\nexport default class Env {\n    constructor(input, output, options) {\n        this.options = options;\n\n        if (this.isProductionBuild()) {\n            process.env.NODE_ENV = 'production';\n        }\n\n        this.sys = {\n            platform: process.platform,\n            arch: process.arch\n        };\n\n        // Operational System.\n        this.os = {\n            isWindows: (process.platform === 'win32'),\n            isLinux: (process.platform === 'linux'),\n            isOsx: (process.platform === 'darwin')\n\n        };\n        this.stdio = 'inherit';\n\n        this.os.name = (this.sys.platform === 'darwin' ? 'osx' : this.sys.platform);\n        this.os.home = process.env[(this.os.isWindows ? 'USERPROFILE' : 'HOME')];\n        this.os.tmp = os.tmpdir();\n\n        /** @type {packagePaths} */\n        this.paths = {};\n\n        /** @type {meteorDesktopPaths} */\n        this.paths.meteorDesktop = {\n            root: path.resolve(__dirname, '..')\n        };\n\n        this.paths.meteorDesktop.skeleton = join(this.paths.meteorDesktop.root, 'skeleton');\n\n        /** @type {meteorAppPaths} */\n        this.paths.meteorApp = {\n            root: input\n        };\n\n        /** @type {desktopPaths} */\n        this.paths.desktop = {\n            rootName: '.desktop',\n            root: join(this.paths.meteorApp.root, '.desktop')\n        };\n\n        assignIn(this.paths.desktop, {\n            modules: join(this.paths.desktop.root, 'modules'),\n            import: join(this.paths.desktop.root, 'import'),\n            assets: join(this.paths.desktop.root, 'assets'),\n            settings: join(this.paths.desktop.root, 'settings.json'),\n            desktop: join(this.paths.desktop.root, 'desktop.js')\n        });\n\n        this.paths.desktop.splashScreen = join(this.paths.desktop.assets, 'splashScreen.png');\n        this.paths.desktop.loadingGif = join(this.paths.desktop.assets, 'loading.gif');\n        this.paths.desktop.meteorIco = join(this.paths.desktop.assets, 'meteor.ico');\n\n        /** @type {electronAppPaths} */\n        this.paths.electronApp = {\n            rootName: 'desktop-build',\n        };\n        this.paths.electronApp.root =\n            join(this.paths.meteorApp.root, '.meteor', this.paths.electronApp.rootName);\n\n        this.paths.electronApp.tmpNodeModules =\n            join(this.paths.meteorApp.root, '.meteor', '.desktop_node_modules');\n\n        this.paths.cache =\n            join(this.paths.meteorApp.root, '.meteor', 'local', 'desktop-cache');\n\n        this.paths.electronApp.extractedNodeModules =\n            join(this.paths.meteorApp.root, '.meteor', '.desktop_extracted_node_modules');\n\n        this.paths.electronApp.extractedNodeModulesBin =\n            join(this.paths.electronApp.extractedNodeModules, '.bin');\n\n\n        this.paths.electronApp.appRoot =\n            join(this.paths.electronApp.root, 'app');\n\n        assignIn(this.paths.electronApp, {\n            app: join(this.paths.electronApp.appRoot, 'app.js'),\n            cordova: join(this.paths.electronApp.appRoot, 'cordova.js'),\n            index: join(this.paths.electronApp.appRoot, 'index.js'),\n            preload: join(this.paths.electronApp.appRoot, 'preload.js'),\n            modules: join(this.paths.electronApp.appRoot, 'modules'),\n            desktopAsar: join(this.paths.electronApp.root, 'desktop.asar'),\n            extracted: join(this.paths.electronApp.root, 'extracted'),\n            appAsar: join(this.paths.electronApp.root, 'app.asar'),\n            import: join(this.paths.electronApp.root, 'import'),\n            assets: join(this.paths.electronApp.root, 'assets'),\n            packageJson: join(this.paths.electronApp.root, 'package.json'),\n            settings: join(this.paths.electronApp.root, 'settings.json'),\n            desktop: join(this.paths.electronApp.root, 'desktop.js'),\n            desktopTmp: join(this.paths.electronApp.root, '__desktop'),\n            nodeModules: join(this.paths.electronApp.root, 'node_modules'),\n            meteorAsar: join(this.paths.electronApp.root, 'meteor.asar'),\n            meteorApp: join(this.paths.electronApp.root, 'meteor'),\n            meteorAppIndex: join(this.paths.electronApp.root, 'meteor', 'index.html'),\n            meteorAppProgramJson: join(this.paths.electronApp.root, 'meteor', 'program.json'),\n            skeleton: join(this.paths.electronApp.root, 'skeleton')\n        });\n\n        assignIn(this.paths.meteorApp, {\n            platforms: join(this.paths.meteorApp.root, '.meteor', 'platforms'),\n            packages: join(this.paths.meteorApp.root, '.meteor', 'packages'),\n            versions: join(this.paths.meteorApp.root, '.meteor', 'versions'),\n            release: join(this.paths.meteorApp.root, '.meteor', 'release'),\n            packageJson: join(this.paths.meteorApp.root, 'package.json'),\n            gitIgnore: join(this.paths.meteorApp.root, '.meteor', '.gitignore'),\n            cordovaBuild: join(\n                this.paths.meteorApp.root,\n                '.meteor',\n                'local',\n                'cordova-build',\n                'www',\n                'application'\n            ),\n            webCordova: join(\n                this.paths.meteorApp.root,\n                '.meteor',\n                'local',\n                'build',\n                'programs',\n                'web.cordova'\n            )\n        });\n\n        assignIn(this.paths.meteorApp, {\n            cordovaBuildIndex: join(\n                this.paths.meteorApp.cordovaBuild, 'index.html'\n            ),\n            cordovaBuildProgramJson: join(\n                this.paths.meteorApp.cordovaBuild, 'program.json'\n            )\n        });\n\n        assignIn(this.paths.meteorApp, {\n            webCordovaProgramJson: join(\n                this.paths.meteorApp.webCordova, 'program.json'\n            )\n        });\n\n\n        /** @type {desktopTmpPaths} */\n        this.paths.desktopTmp = {\n            root: join(this.paths.electronApp.root, '__desktop'),\n        };\n\n        assignIn(this.paths.desktopTmp, {\n            modules: join(this.paths.desktopTmp.root, 'modules'),\n            settings: join(this.paths.desktopTmp.root, 'settings.json')\n        });\n\n        this.paths.packageDir = '.desktop-package';\n        this.paths.installerDir = '.desktop-installer';\n\n        // Scaffold\n        this.paths.scaffold = join(__dirname, '..', 'scaffold');\n    }\n\n    /**\n     * @returns {boolean|*}\n     * @public\n     */\n    isProductionBuild() {\n        return !!('production' in this.options && this.options.production);\n    }\n}\n\nmodule.exports = Env;\n\n/**\n * @typedef {Object} desktopPaths\n * @property {string} rootName\n * @property {string} root\n * @property {string} modules\n * @property {string} import\n * @property {string} assets\n * @property {string} settings\n * @property {string} desktop\n * @property {string} splashScreen\n * @property {string} loadingGif\n * @property {string} meteorIco\n */\n\n/**\n * @typedef {Object} meteorAppPaths\n * @property {string} root\n * @property {string} platforms\n * @property {string} release\n * @property {string} packages\n * @property {string} versions\n * @property {string} gitIgnore\n * @property {string} packageJson\n * @property {string} cordovaBuild\n * @property {string} cordovaBuildIndex\n * @property {string} cordovaBuildProgramJson\n * @property {string} webCordova\n * @property {string} webCordovaIndex\n * @property {string} webCordovaProgramJson\n */\n\n/**\n * @typedef {Object} electronAppPaths\n * @property {string} rootName\n * @property {string} root\n * @property {Object} appRoot\n * @property {string} appRoot.cordova\n * @property {string} appRoot.index\n * @property {string} appRoot.app\n * @property {string} appRoot.modules\n * @property {string} desktopAsar\n * @property {string} extracted\n * @property {string} appAsar\n * @property {string} preload\n * @property {string} import\n * @property {string} assets\n * @property {string} gitIgnore\n * @property {string} packageJson\n * @property {string} settings\n * @property {string} desktop\n * @property {string} desktopTmp\n * @property {string} nodeModules\n * @property {string} meteorAsar\n * @property {string} meteorApp\n * @property {string} meteorAppIndex\n * @property {string} meteorAppProgramJson\n * @property {string} skeleton\n * @property {string} tmpNodeModules\n * @property {string} extractedNodeModules\n * @property {string} extractedNodeModulesBin\n */\n\n/**\n * @typedef {Object} desktopTmpPaths\n * @property {string} root\n * @property {string} modules\n * @property {string} settings\n */\n\n/**\n * @typedef {Object} meteorDesktopPaths\n * @property {string} root\n * @property {string} skeleton\n */\n\n/**\n * @typedef {Object} packagePaths\n * @property {meteorAppPaths} meteorApp\n * @property {desktopPaths} desktop\n * @property {electronAppPaths} electronApp\n * @property {desktopTmpPaths} desktopTmp\n * @property {meteorDesktopPaths} meteorDesktop\n * @property {string} packageDir\n * @property {string} scaffold\n */\n"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;;;AAEA,MAAM;EAAEA;AAAF,IAAWC,aAAjB;AAEA;AACA;AACA;AACA;;AACe,MAAMC,GAAN,CAAU;EACrBC,WAAW,CAACC,KAAD,EAAQC,MAAR,EAAgBC,OAAhB,EAAyB;IAChC,KAAKA,OAAL,GAAeA,OAAf;;IAEA,IAAI,KAAKC,iBAAL,EAAJ,EAA8B;MAC1BC,OAAO,CAACC,GAAR,CAAYC,QAAZ,GAAuB,YAAvB;IACH;;IAED,KAAKC,GAAL,GAAW;MACPC,QAAQ,EAAEJ,OAAO,CAACI,QADX;MAEPC,IAAI,EAAEL,OAAO,CAACK;IAFP,CAAX,CAPgC,CAYhC;;IACA,KAAKC,EAAL,GAAU;MACNC,SAAS,EAAGP,OAAO,CAACI,QAAR,KAAqB,OAD3B;MAENI,OAAO,EAAGR,OAAO,CAACI,QAAR,KAAqB,OAFzB;MAGNK,KAAK,EAAGT,OAAO,CAACI,QAAR,KAAqB;IAHvB,CAAV;IAMA,KAAKM,KAAL,GAAa,SAAb;IAEA,KAAKJ,EAAL,CAAQK,IAAR,GAAgB,KAAKR,GAAL,CAASC,QAAT,KAAsB,QAAtB,GAAiC,KAAjC,GAAyC,KAAKD,GAAL,CAASC,QAAlE;IACA,KAAKE,EAAL,CAAQM,IAAR,GAAeZ,OAAO,CAACC,GAAR,CAAa,KAAKK,EAAL,CAAQC,SAAR,GAAoB,aAApB,GAAoC,MAAjD,CAAf;IACA,KAAKD,EAAL,CAAQO,GAAR,GAAcP,WAAA,CAAGQ,MAAH,EAAd;IAEA;;IACA,KAAKC,KAAL,GAAa,EAAb;IAEA;;IACA,KAAKA,KAAL,CAAWC,aAAX,GAA2B;MACvBC,IAAI,EAAExB,aAAA,CAAKyB,OAAL,CAAaC,SAAb,EAAwB,IAAxB;IADiB,CAA3B;IAIA,KAAKJ,KAAL,CAAWC,aAAX,CAAyBI,QAAzB,GAAoC5B,IAAI,CAAC,KAAKuB,KAAL,CAAWC,aAAX,CAAyBC,IAA1B,EAAgC,UAAhC,CAAxC;IAEA;;IACA,KAAKF,KAAL,CAAWM,SAAX,GAAuB;MACnBJ,IAAI,EAAErB;IADa,CAAvB;IAIA;;IACA,KAAKmB,KAAL,CAAWO,OAAX,GAAqB;MACjBC,QAAQ,EAAE,UADO;MAEjBN,IAAI,EAAEzB,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,UAA5B;IAFO,CAArB;IAKA,IAAAO,iBAAA,EAAS,KAAKT,KAAL,CAAWO,OAApB,EAA6B;MACzBG,OAAO,EAAEjC,IAAI,CAAC,KAAKuB,KAAL,CAAWO,OAAX,CAAmBL,IAApB,EAA0B,SAA1B,CADY;MAEzBS,MAAM,EAAElC,IAAI,CAAC,KAAKuB,KAAL,CAAWO,OAAX,CAAmBL,IAApB,EAA0B,QAA1B,CAFa;MAGzBU,MAAM,EAAEnC,IAAI,CAAC,KAAKuB,KAAL,CAAWO,OAAX,CAAmBL,IAApB,EAA0B,QAA1B,CAHa;MAIzBW,QAAQ,EAAEpC,IAAI,CAAC,KAAKuB,KAAL,CAAWO,OAAX,CAAmBL,IAApB,EAA0B,eAA1B,CAJW;MAKzBK,OAAO,EAAE9B,IAAI,CAAC,KAAKuB,KAAL,CAAWO,OAAX,CAAmBL,IAApB,EAA0B,YAA1B;IALY,CAA7B;IAQA,KAAKF,KAAL,CAAWO,OAAX,CAAmBO,YAAnB,GAAkCrC,IAAI,CAAC,KAAKuB,KAAL,CAAWO,OAAX,CAAmBK,MAApB,EAA4B,kBAA5B,CAAtC;IACA,KAAKZ,KAAL,CAAWO,OAAX,CAAmBQ,UAAnB,GAAgCtC,IAAI,CAAC,KAAKuB,KAAL,CAAWO,OAAX,CAAmBK,MAApB,EAA4B,aAA5B,CAApC;IACA,KAAKZ,KAAL,CAAWO,OAAX,CAAmBS,SAAnB,GAA+BvC,IAAI,CAAC,KAAKuB,KAAL,CAAWO,OAAX,CAAmBK,MAApB,EAA4B,YAA5B,CAAnC;IAEA;;IACA,KAAKZ,KAAL,CAAWiB,WAAX,GAAyB;MACrBT,QAAQ,EAAE;IADW,CAAzB;IAGA,KAAKR,KAAL,CAAWiB,WAAX,CAAuBf,IAAvB,GACIzB,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,KAAKF,KAAL,CAAWiB,WAAX,CAAuBT,QAA9D,CADR;IAGA,KAAKR,KAAL,CAAWiB,WAAX,CAAuBC,cAAvB,GACIzC,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,uBAAvC,CADR;IAGA,KAAKF,KAAL,CAAWmB,KAAX,GACI1C,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,OAAvC,EAAgD,eAAhD,CADR;IAGA,KAAKF,KAAL,CAAWiB,WAAX,CAAuBG,oBAAvB,GACI3C,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,iCAAvC,CADR;IAGA,KAAKF,KAAL,CAAWiB,WAAX,CAAuBI,uBAAvB,GACI5C,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBG,oBAAxB,EAA8C,MAA9C,CADR;IAIA,KAAKpB,KAAL,CAAWiB,WAAX,CAAuBK,OAAvB,GACI7C,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,KAA9B,CADR;IAGA,IAAAO,iBAAA,EAAS,KAAKT,KAAL,CAAWiB,WAApB,EAAiC;MAC7BM,GAAG,EAAE9C,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBK,OAAxB,EAAiC,QAAjC,CADoB;MAE7BE,OAAO,EAAE/C,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBK,OAAxB,EAAiC,YAAjC,CAFgB;MAG7BG,KAAK,EAAEhD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBK,OAAxB,EAAiC,UAAjC,CAHkB;MAI7BI,OAAO,EAAEjD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBK,OAAxB,EAAiC,YAAjC,CAJgB;MAK7BZ,OAAO,EAAEjC,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBK,OAAxB,EAAiC,SAAjC,CALgB;MAM7BK,WAAW,EAAElD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,cAA9B,CANY;MAO7B0B,SAAS,EAAEnD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,WAA9B,CAPc;MAQ7B2B,OAAO,EAAEpD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,UAA9B,CARgB;MAS7BS,MAAM,EAAElC,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,QAA9B,CATiB;MAU7BU,MAAM,EAAEnC,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,QAA9B,CAViB;MAW7B4B,WAAW,EAAErD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,cAA9B,CAXY;MAY7BW,QAAQ,EAAEpC,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,eAA9B,CAZe;MAa7BK,OAAO,EAAE9B,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,YAA9B,CAbgB;MAc7B6B,UAAU,EAAEtD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,WAA9B,CAda;MAe7B8B,WAAW,EAAEvD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,cAA9B,CAfY;MAgB7B+B,UAAU,EAAExD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,aAA9B,CAhBa;MAiB7BI,SAAS,EAAE7B,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,QAA9B,CAjBc;MAkB7BgC,cAAc,EAAEzD,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,QAA9B,EAAwC,YAAxC,CAlBS;MAmB7BiC,oBAAoB,EAAE1D,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,QAA9B,EAAwC,cAAxC,CAnBG;MAoB7BG,QAAQ,EAAE5B,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,UAA9B;IApBe,CAAjC;IAuBA,IAAAO,iBAAA,EAAS,KAAKT,KAAL,CAAWM,SAApB,EAA+B;MAC3B8B,SAAS,EAAE3D,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,WAAvC,CADY;MAE3BmC,QAAQ,EAAE5D,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,UAAvC,CAFa;MAG3BoC,QAAQ,EAAE7D,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,UAAvC,CAHa;MAI3BqC,OAAO,EAAE9D,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,SAAvC,CAJc;MAK3B4B,WAAW,EAAErD,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,cAA5B,CALU;MAM3BsC,SAAS,EAAE/D,IAAI,CAAC,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IAAtB,EAA4B,SAA5B,EAAuC,YAAvC,CANY;MAO3BuC,YAAY,EAAEhE,IAAI,CACd,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IADP,EAEd,SAFc,EAGd,OAHc,EAId,eAJc,EAKd,KALc,EAMd,aANc,CAPS;MAe3BwC,UAAU,EAAEjE,IAAI,CACZ,KAAKuB,KAAL,CAAWM,SAAX,CAAqBJ,IADT,EAEZ,SAFY,EAGZ,OAHY,EAIZ,OAJY,EAKZ,UALY,EAMZ,aANY;IAfW,CAA/B;IAyBA,IAAAO,iBAAA,EAAS,KAAKT,KAAL,CAAWM,SAApB,EAA+B;MAC3BqC,iBAAiB,EAAElE,IAAI,CACnB,KAAKuB,KAAL,CAAWM,SAAX,CAAqBmC,YADF,EACgB,YADhB,CADI;MAI3BG,uBAAuB,EAAEnE,IAAI,CACzB,KAAKuB,KAAL,CAAWM,SAAX,CAAqBmC,YADI,EACU,cADV;IAJF,CAA/B;IASA,IAAAhC,iBAAA,EAAS,KAAKT,KAAL,CAAWM,SAApB,EAA+B;MAC3BuC,qBAAqB,EAAEpE,IAAI,CACvB,KAAKuB,KAAL,CAAWM,SAAX,CAAqBoC,UADE,EACU,cADV;IADA,CAA/B;IAOA;;IACA,KAAK1C,KAAL,CAAW+B,UAAX,GAAwB;MACpB7B,IAAI,EAAEzB,IAAI,CAAC,KAAKuB,KAAL,CAAWiB,WAAX,CAAuBf,IAAxB,EAA8B,WAA9B;IADU,CAAxB;IAIA,IAAAO,iBAAA,EAAS,KAAKT,KAAL,CAAW+B,UAApB,EAAgC;MAC5BrB,OAAO,EAAEjC,IAAI,CAAC,KAAKuB,KAAL,CAAW+B,UAAX,CAAsB7B,IAAvB,EAA6B,SAA7B,CADe;MAE5BW,QAAQ,EAAEpC,IAAI,CAAC,KAAKuB,KAAL,CAAW+B,UAAX,CAAsB7B,IAAvB,EAA6B,eAA7B;IAFc,CAAhC;IAKA,KAAKF,KAAL,CAAW8C,UAAX,GAAwB,kBAAxB;IACA,KAAK9C,KAAL,CAAW+C,YAAX,GAA0B,oBAA1B,CA5JgC,CA8JhC;;IACA,KAAK/C,KAAL,CAAWgD,QAAX,GAAsBvE,IAAI,CAAC2B,SAAD,EAAY,IAAZ,EAAkB,UAAlB,CAA1B;EACH;EAED;AACJ;AACA;AACA;;;EACIpB,iBAAiB,GAAG;IAChB,OAAO,CAAC,EAAE,gBAAgB,KAAKD,OAArB,IAAgC,KAAKA,OAAL,CAAakE,UAA/C,CAAR;EACH;;AAzKoB;;;AA4KzBC,MAAM,CAACC,OAAP,GAAiBxE,GAAjB;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA"} \ No newline at end of file diff --git a/dist/index.js b/dist/index.js deleted file mode 100644 index 44c7cecc..00000000 --- a/dist/index.js +++ /dev/null @@ -1,247 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = _exports; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _fs = _interopRequireDefault(require("fs")); - -var _path = _interopRequireDefault(require("path")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _env = _interopRequireDefault(require("./env")); - -var _electron = _interopRequireDefault(require("./electron")); - -var _log = _interopRequireDefault(require("./log")); - -var _desktop = _interopRequireDefault(require("./desktop")); - -var _electronApp = _interopRequireDefault(require("./electronApp")); - -var _meteorApp = _interopRequireDefault(require("./meteorApp")); - -var _electronBuilder = _interopRequireDefault(require("./electronBuilder")); - -var _packager = _interopRequireDefault(require("./packager")); - -var _utils = _interopRequireDefault(require("./utils")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars -_shelljs.default.config.fatal = true; -/** - * Main entity. - * @class - * @property {Env} env - * @property {Electron} electron - * @property {InstallerBuilder} installerBuilder - * @property {ElectronApp} electronApp - * @property {Desktop} desktop - * @property {MeteorApp} meteorApp - */ - -class MeteorDesktop { - /** - * @param {string} input - Meteor app dir - * @param {string} output - output dir for bundle/package/installer - * @param {Object} options - options from cli.js - * @param {Object} dependencies - dependencies object - * @constructor - */ - constructor(input, output, options, dependencies) { - const Log = dependencies.log; - this.log = new Log('index'); - this.version = this.getVersion(); - this.log.info('initializing'); - this.env = new _env.default(input, output, options); - this.electron = new _electron.default(this); - this.electronBuilder = new _electronBuilder.default(this); - this.electronApp = new _electronApp.default(this); - this.desktop = new _desktop.default(this); - this.meteorApp = new _meteorApp.default(this); - this.utils = _utils.default; - } - /** - * Tries to read the version from our own package.json. - * - * @returns {string} - */ - - - getVersion() { - if (this.version) { - return this.version; - } - - let version = null; - - try { - ({ - version - } = JSON.parse(_fs.default.readFileSync(_path.default.join(__dirname, '..', 'package.json'), 'UTF-8'))); - } catch (e) { - this.log.error(`error while trying to read ${_path.default.join(__dirname, 'package.json')}`, e); - process.exit(1); - } - - if (process.env.PLUGIN_VERSION && (version.includes('rc') || version.includes('beta') || version.includes('alpha'))) { - version = process.env.PLUGIN_VERSION; - } - - return version; - } - /** - * Tries to read the version from our own package.json. - * - * @returns {string} - */ - - - getElectronVersion() { - let version = null; - - try { - const { - dependencies = {}, - devDependencies = {} - } = JSON.parse(_fs.default.readFileSync(_path.default.join(this.env.paths.meteorApp.root, 'package.json'), 'UTF-8')); - - if (!('electron' in dependencies) && !('electron' in devDependencies)) { - this.log.error('electron not found in meteor project dependencies'); - process.exit(1); - } - - version = dependencies.electron || devDependencies.electron; - - if (this.electronApp.depsManager.checks.version.regex.test(version)) { - ({ - version - } = JSON.parse(_fs.default.readFileSync(_path.default.join(this.env.paths.meteorApp.root, 'node_modules', 'electron', 'package.json'), 'UTF-8'))); - } - } catch (e) { - this.log.error(`error while trying to read ${_path.default.join(this.env.paths.meteorApp.root, 'package.json')}`, e); - process.exit(1); - } - - return version; - } - - async init() { - this.desktop.scaffold(); - this.meteorApp.updateGitIgnore(); - await this.electronApp.init(); - } - - async buildInstaller(throwError = false) { - this.env.options.installerBuild = true; - await this.electronApp.build(); - - try { - await this.electronBuilder.build(); - } catch (e) { - this.log.error('error occurred while building installer', e); - - if (throwError) { - throw new Error(e); - } - } - } - - async run() { - await this.electronApp.build(true); - } - - async build() { - await this.electronApp.build(); - } - - justRun() { - this.electron.run(); - } - - async runPackager() { - this.packager = new _packager.default(this); - await this.packager.init(); - await this.electronApp.build(); - this.packager.packageApp().catch(e => { - this.log.error(`while trying to build a package an error occurred: ${e}`); - }); - } - - async getDependency(name, version, declarationCheck = true) { - if (declarationCheck) { - try { - const { - dependencies = {}, - devDependencies = {} - } = JSON.parse(_fs.default.readFileSync(_path.default.join(this.env.paths.meteorApp.root, 'package.json'), 'UTF-8')); - - if (!(name in dependencies) && !(name in devDependencies)) { - await this.meteorApp.runNpm(['i', '-D', '-E', '--only=dev', `${name}@${version}`], 'inherit'); - } - } catch (e) { - this.log.error(`could no read ${_path.default.join(this.env.paths.meteorApp.root, 'package.json')}`, e); - process.exit(1); - } - } - - const dependencyPath = _path.default.join(this.env.paths.meteorApp.root, 'node_modules', name); - - let dependency = null; - - try { - dependency = require(dependencyPath); - } catch (e) { - if (declarationCheck) { - this.log.warn(`could not find ${name}, installing the default version for you: ${name}@${version}`); - - try { - await this.meteorApp.runNpm(['i', '-D', '-E', '--only=dev', `${name}@${version}`], 'inherit'); - } catch (err) { - this.log.error(err); - process.exit(1); - } - } else { - this.log.warn(`could not find ${name}, exiting`); - process.exit(1); - } - } finally { - if (!dependency) { - dependency = require(dependencyPath); - } - } - - const dependencyVersion = require(_path.default.join(dependencyPath, 'package.json')).version; - - if (dependencyVersion !== version) { - if (dependencyVersion.split('.')[0] !== version.split('.')[0]) { - this.log.warn(`you are using a ${name}@${dependencyVersion} while the recommended version is ` + `${version}, the compatibility version is different, use at your own risk, be sure to report ` + 'that when submitting issues'); - } else { - this.log.warn(`you are using a ${name}@${dependencyVersion} while the recommended version is ` + `${version}, be sure to report that when submitting issues`); - } - } - - return { - dependency, - path: dependencyPath - }; - } - -} - -function _exports(input, output, options, { - log = _log.default -} = { - log: _log.default -}) { - return new MeteorDesktop(input, output, options, { - log - }); -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["shell","config","fatal","MeteorDesktop","constructor","input","output","options","dependencies","Log","log","version","getVersion","info","env","Env","electron","Electron","electronBuilder","ElectronBuilder","electronApp","ElectronApp","desktop","Desktop","meteorApp","MeteorApp","utils","JSON","parse","fs","readFileSync","path","join","__dirname","e","error","process","exit","PLUGIN_VERSION","includes","getElectronVersion","devDependencies","paths","root","depsManager","checks","regex","test","init","scaffold","updateGitIgnore","buildInstaller","throwError","installerBuild","build","Error","run","justRun","runPackager","packager","Packager","packageApp","catch","getDependency","name","declarationCheck","runNpm","dependencyPath","dependency","require","warn","err","dependencyVersion","split","exports","Logger"],"sources":["../lib/index.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport fs from 'fs';\nimport path from 'path';\nimport shell from 'shelljs';\nimport Env from './env';\nimport Electron from './electron';\nimport Logger from './log';\nimport Desktop from './desktop';\nimport ElectronApp from './electronApp';\nimport MeteorApp from './meteorApp';\nimport ElectronBuilder from './electronBuilder';\nimport Packager from './packager';\nimport utils from './utils';\n\nshell.config.fatal = true;\n\n/**\n * Main entity.\n * @class\n * @property {Env} env\n * @property {Electron} electron\n * @property {InstallerBuilder} installerBuilder\n * @property {ElectronApp} electronApp\n * @property {Desktop} desktop\n * @property {MeteorApp} meteorApp\n */\nclass MeteorDesktop {\n    /**\n     * @param {string} input        - Meteor app dir\n     * @param {string} output       - output dir for bundle/package/installer\n     * @param {Object} options      - options from cli.js\n     * @param {Object} dependencies - dependencies object\n     * @constructor\n     */\n    constructor(input, output, options, dependencies) {\n        const Log = dependencies.log;\n        this.log = new Log('index');\n        this.version = this.getVersion();\n\n        this.log.info('initializing');\n\n        this.env = new Env(input, output, options);\n        this.electron = new Electron(this);\n        this.electronBuilder = new ElectronBuilder(this);\n        this.electronApp = new ElectronApp(this);\n        this.desktop = new Desktop(this);\n        this.meteorApp = new MeteorApp(this);\n        this.utils = utils;\n    }\n\n    /**\n     * Tries to read the version from our own package.json.\n     *\n     * @returns {string}\n     */\n    getVersion() {\n        if (this.version) {\n            return this.version;\n        }\n\n        let version = null;\n        try {\n            ({ version } = JSON.parse(\n                fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'UTF-8')\n            ));\n        } catch (e) {\n            this.log.error(`error while trying to read ${path.join(__dirname, 'package.json')}`, e);\n            process.exit(1);\n        }\n        if (process.env.PLUGIN_VERSION &&\n            (version.includes('rc') || version.includes('beta') || version.includes('alpha'))\n        ) {\n            version = process.env.PLUGIN_VERSION;\n        }\n        return version;\n    }\n\n    /**\n     * Tries to read the version from our own package.json.\n     *\n     * @returns {string}\n     */\n    getElectronVersion() {\n        let version = null;\n        try {\n            const { dependencies = {}, devDependencies = {} } = JSON.parse(\n                fs.readFileSync(path.join(this.env.paths.meteorApp.root, 'package.json'), 'UTF-8')\n            );\n            if (!('electron' in dependencies) && !('electron' in devDependencies)) {\n                this.log.error('electron not found in meteor project dependencies');\n                process.exit(1);\n            }\n            version = dependencies.electron || devDependencies.electron;\n            if (this.electronApp.depsManager.checks.version.regex.test(version)) {\n                ({ version } = JSON.parse(\n                    fs.readFileSync(path.join(this.env.paths.meteorApp.root, 'node_modules', 'electron', 'package.json'), 'UTF-8')\n                ));\n            }\n        } catch (e) {\n            this.log.error(`error while trying to read ${path.join(this.env.paths.meteorApp.root, 'package.json')}`, e);\n            process.exit(1);\n        }\n        return version;\n    }\n\n    async init() {\n        this.desktop.scaffold();\n        this.meteorApp.updateGitIgnore();\n        await this.electronApp.init();\n    }\n\n    async buildInstaller(throwError = false) {\n        this.env.options.installerBuild = true;\n        await this.electronApp.build();\n        try {\n            await this.electronBuilder.build();\n        } catch (e) {\n            this.log.error('error occurred while building installer', e);\n            if (throwError) {\n                throw new Error(e);\n            }\n        }\n    }\n\n    async run() {\n        await this.electronApp.build(true);\n    }\n\n    async build() {\n        await this.electronApp.build();\n    }\n\n    justRun() {\n        this.electron.run();\n    }\n\n    async runPackager() {\n        this.packager = new Packager(this);\n        await this.packager.init();\n        await this.electronApp.build();\n\n        this.packager.packageApp().catch((e) => {\n            this.log.error(`while trying to build a package an error occurred: ${e}`);\n        });\n    }\n\n    async getDependency(name, version, declarationCheck = true) {\n        if (declarationCheck) {\n            try {\n                const { dependencies = {}, devDependencies = {} } = JSON.parse(\n                    fs.readFileSync(path.join(this.env.paths.meteorApp.root, 'package.json'), 'UTF-8')\n                );\n                if (!(name in dependencies) && !(name in devDependencies)) {\n                    await this.meteorApp.runNpm(['i', '-D', '-E', '--only=dev', `${name}@${version}`], 'inherit');\n                }\n            } catch (e) {\n                this.log.error(`could no read ${path.join(this.env.paths.meteorApp.root, 'package.json')}`, e);\n                process.exit(1);\n            }\n        }\n\n        const dependencyPath = path.join(this.env.paths.meteorApp.root, 'node_modules', name);\n        let dependency = null;\n        try {\n            dependency = require(dependencyPath);\n        } catch (e) {\n            if (declarationCheck) {\n                this.log.warn(`could not find ${name}, installing the default version for you: ${name}@${version}`);\n                try {\n                    await this.meteorApp.runNpm(['i', '-D', '-E', '--only=dev', `${name}@${version}`], 'inherit');\n                } catch (err) {\n                    this.log.error(err);\n                    process.exit(1);\n                }\n            } else {\n                this.log.warn(`could not find ${name}, exiting`);\n                process.exit(1);\n            }\n        } finally {\n            if (!dependency) {\n                dependency = require(dependencyPath);\n            }\n        }\n        const dependencyVersion = require(path.join(dependencyPath, 'package.json')).version;\n\n        if (dependencyVersion !== version) {\n            if (dependencyVersion.split('.')[0] !== version.split('.')[0]) {\n                this.log.warn(`you are using a ${name}@${dependencyVersion} while the recommended version is ` +\n                    `${version}, the compatibility version is different, use at your own risk, be sure to report ` +\n                    'that when submitting issues');\n            } else {\n                this.log.warn(`you are using a ${name}@${dependencyVersion} while the recommended version is ` +\n                    `${version}, be sure to report that when submitting issues`);\n            }\n        }\n        return { dependency, path: dependencyPath };\n    }\n}\n\nexport default function exports(input, output, options, { log = Logger } = { log: Logger }) {\n    return new MeteorDesktop(input, output, options, { log });\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/log.js b/dist/log.js deleted file mode 100644 index 5677ea1e..00000000 --- a/dist/log.js +++ /dev/null @@ -1,75 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -/* eslint-disable no-console */ - -/* - 0.OFF - 1.INFO - 2.WARN - 3.ERROR - 4.TRACE - 5.DEBUG - 6.ALL - */ -class Log { - constructor(prefix) { - this.prefix = prefix; - } - - static level() { - return process.env.MD_LOG_LEVEL || 'ALL'; - } - - static slice(args) { - return Array.prototype.slice.call(args, 0); - } - - log(type, args) { - console.log.apply(null, [`${type} ${this.prefix}: `].concat(Log.slice(args))); - } - - info(...args) { - if (/INFO|ALL/i.test(Log.level())) { - this.log('INFO', args); - } - } - - warn(...args) { - if (/WARN|ALL/i.test(Log.level())) { - this.log('WARN', args); - } - } - - error(...args) { - if (/ERROR|ALL/i.test(Log.level())) { - this.log('ERROR', args); - } - } - - debug(...args) { - if (/DEBUG|ALL/i.test(Log.level())) { - this.log('DEBUG', args); - } - } - - verbose(...args) { - if (/VERBOSE|ALL/i.test(Log.level())) { - this.log('VERBOSE', args); - } - } - - trace(...args) { - if (/TRACE|ALL/i.test(Log.level())) { - this.log('TRACE', args); - } - } - -} - -exports.default = Log; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/meteorApp.js b/dist/meteorApp.js deleted file mode 100644 index e4508bfe..00000000 --- a/dist/meteorApp.js +++ /dev/null @@ -1,923 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _fs = _interopRequireDefault(require("fs")); - -var _crossSpawn = _interopRequireDefault(require("cross-spawn")); - -var _semver = _interopRequireDefault(require("semver")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _path = _interopRequireDefault(require("path")); - -var _singleLineLog = _interopRequireDefault(require("single-line-log")); - -var _asar = _interopRequireDefault(require("@electron/asar")); - -var _nodeFetch = _interopRequireDefault(require("node-fetch")); - -var _isDesktopInjector = _interopRequireDefault(require("../skeleton/modules/autoupdate/isDesktopInjector")); - -var _log = _interopRequireDefault(require("./log")); - -var _meteorManager = _interopRequireDefault(require("./meteorManager")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars -const { - join -} = _path.default; -const sll = _singleLineLog.default.stdout; // TODO: refactor all strategy ifs to one place - -/** - * Represents the Meteor app. - * @property {MeteorDesktop} $ - * @class - */ - -class MeteorApp { - /** - * @param {MeteorDesktop} $ - context - * @constructor - */ - constructor($) { - this.log = new _log.default('meteorApp'); - this.$ = $; - this.meteorManager = new _meteorManager.default($); - this.mobilePlatform = null; - this.oldManifest = null; - this.injector = new _isDesktopInjector.default(); - this.matcher = new RegExp('__meteor_runtime_config__ = JSON.parse\\(decodeURIComponent\\("([^"]*)"\\)\\)'); - this.replacer = new RegExp('(__meteor_runtime_config__ = JSON.parse\\(decodeURIComponent\\()"([^"]*)"(\\)\\))'); - this.meteorVersion = null; - this.indexHTMLstrategy = null; - this.indexHTMLStrategies = { - INDEX_FROM_CORDOVA_BUILD: 1, - INDEX_FROM_RUNNING_SERVER: 2 - }; - this.deprectatedPackages = ['omega:meteor-desktop-localstorage']; - } - /** - * Remove any deprecated packages from meteor project. - * @returns {Promise} - */ - - - async removeDeprecatedPackages() { - try { - if (this.meteorManager.checkPackages(this.deprectatedPackages)) { - this.log.info('deprecated meteor plugins found, removing them'); - await this.meteorManager.deletePackages(this.deprectatedPackages); - } - } catch (e) { - throw new Error(e); - } - } - /** - * Ensures that required packages are added to the Meteor app. - */ - - - async ensureDesktopHCPPackages() { - const desktopHCPPackages = ['communitypackages:meteor-desktop-watcher', 'communitypackages:meteor-desktop-bundler']; - - if (this.$.desktop.getSettings().desktopHCP) { - this.log.verbose('desktopHCP is enabled, checking for required packages'); - const packagesWithVersion = desktopHCPPackages.map(packageName => `${packageName}@${this.$.getVersion()}`); - - try { - await this.meteorManager.ensurePackages(desktopHCPPackages, packagesWithVersion, 'desktopHCP'); - } catch (e) { - throw new Error(e); - } - } else { - this.log.verbose('desktopHCP is not enabled, removing required packages'); - - try { - if (this.meteorManager.checkPackages(desktopHCPPackages)) { - await this.meteorManager.deletePackages(desktopHCPPackages); - } - } catch (e) { - throw new Error(e); - } - } - } - /** - * Adds entry to .meteor/.gitignore if necessary. - */ - - - updateGitIgnore() { - this.log.verbose('updating .meteor/.gitignore'); // Lets read the .meteor/.gitignore and filter out blank lines. - - const gitIgnore = _fs.default.readFileSync(this.$.env.paths.meteorApp.gitIgnore, 'UTF-8').split('\n').filter(ignoredPath => ignoredPath.trim() !== ''); - - if (!~gitIgnore.indexOf(this.$.env.paths.electronApp.rootName)) { - this.log.verbose(`adding ${this.$.env.paths.electronApp.rootName} to .meteor/.gitignore`); - gitIgnore.push(this.$.env.paths.electronApp.rootName); - - _fs.default.writeFileSync(this.$.env.paths.meteorApp.gitIgnore, gitIgnore.join('\n'), 'UTF-8'); - } - } - /** - * Reads the Meteor release version used in the app. - * @returns {string} - */ - - - getMeteorRelease() { - let release = _fs.default.readFileSync(this.$.env.paths.meteorApp.release, 'UTF-8').replace(/\r/gm, '').split('\n')[0]; - - [, release] = release.split('@'); // We do not care if it is beta. - - if (~release.indexOf('-')) { - [release] = release.split('-'); - } - - return release; - } - /** - * Cast Meteor release to semver version. - * @returns {string} - */ - - - castMeteorReleaseToSemver() { - return `${this.getMeteorRelease()}.0.0`.match(/(^\d+\.\d+\.\d+)/gmi)[0]; - } - /** - * Validate meteor version against a versionRange. - * @param {string} versionRange - semver version range - */ - - - checkMeteorVersion(versionRange) { - const release = this.castMeteorReleaseToSemver(); - - if (!_semver.default.satisfies(release, versionRange)) { - if (this.$.env.options.skipMobileBuild) { - this.log.error(`wrong meteor version (${release}) in project - only ` + `${versionRange} is supported`); - } else { - this.log.error(`wrong meteor version (${release}) in project - only ` + `${versionRange} is supported for automatic meteor builds (you can always ` + 'try with `--skip-mobile-build` if you are using meteor >= 1.2.1'); - } - - process.exit(1); - } - } - /** - * Decides which strategy to use while trying to get client build out of Meteor project. - * @returns {number} - */ - - - chooseStrategy() { - if (this.$.env.options.forceCordovaBuild) { - return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD; - } - - const release = this.castMeteorReleaseToSemver(); - - if (_semver.default.satisfies(release, '> 1.3.4')) { - return this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER; - } - - if (_semver.default.satisfies(release, '1.3.4')) { - const explodedVersion = this.getMeteorRelease().split('.'); - - if (explodedVersion.length >= 4) { - if (explodedVersion[3] > 1) { - return this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER; - } - - return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD; - } - } - - return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD; - } - /** - * Checks required preconditions. - * - Meteor version - * - is mobile platform added - */ - - - async checkPreconditions() { - if (this.$.env.options.skipMobileBuild) { - this.checkMeteorVersion('>= 1.2.1'); - } else { - this.checkMeteorVersion('>= 1.3.3'); - this.indexHTMLstrategy = this.chooseStrategy(); - - if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) { - this.log.debug('meteor version is < 1.3.4.2 so the index.html from cordova-build will' + ' be used'); - } else { - this.log.debug('meteor version is >= 1.3.4.2 so the index.html will be downloaded ' + 'from __cordova/index.html'); - } - } - - if (!this.$.env.options.skipMobileBuild) { - const platforms = _fs.default.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8'); - - if (!~platforms.indexOf('android') && !~platforms.indexOf('ios')) { - if (!this.$.env.options.android) { - this.mobilePlatform = 'ios'; - } else { - this.mobilePlatform = 'android'; - } - - this.log.warn(`no mobile target detected - will add '${this.mobilePlatform}' ` + 'just to get a mobile build'); - - try { - await this.addMobilePlatform(this.mobilePlatform); - } catch (e) { - this.log.error('failed to add a mobile platform - please try to do it manually'); - process.exit(1); - } - } - } - } - /** - * Tries to add a mobile platform to meteor project. - * @param {string} platform - platform to add - * @returns {Promise} - */ - - - addMobilePlatform(platform) { - return new Promise((resolve, reject) => { - this.log.verbose(`adding mobile platform: ${platform}`); - (0, _crossSpawn.default)('meteor', ['add-platform', platform], { - cwd: this.$.env.paths.meteorApp.root, - stdio: this.$.env.stdio - }).on('exit', () => { - const platforms = _fs.default.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8'); - - if (!~platforms.indexOf('android') && !~platforms.indexOf('ios')) { - reject(); - } else { - resolve(); - } - }); - }); - } - /** - * Tries to remove a mobile platform from meteor project. - * @param {string} platform - platform to remove - * @returns {Promise} - */ - - - removeMobilePlatform(platform) { - if (this.$.env.options.skipRemoveMobilePlatform) { - return Promise.resolve(); - } - - return new Promise((resolve, reject) => { - this.log.verbose(`removing mobile platform: ${platform}`); - (0, _crossSpawn.default)('meteor', ['remove-platform', platform], { - cwd: this.$.env.paths.meteorApp.root, - stdio: this.$.env.stdio, - env: Object.assign({ - METEOR_PRETTY_OUTPUT: 0 - }, process.env) - }).on('exit', () => { - const platforms = _fs.default.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8'); - - if (~platforms.indexOf(platform)) { - reject(); - } else { - resolve(); - } - }); - }); - } - /** - * Just checks for index.html and program.json existence. - * @returns {boolean} - */ - - - isCordovaBuildReady() { - if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) { - return this.$.utils.exists(this.$.env.paths.meteorApp.cordovaBuildIndex) && this.$.utils.exists(this.$.env.paths.meteorApp.cordovaBuildProgramJson) && (!this.oldManifest || this.oldManifest && this.oldManifest !== _fs.default.readFileSync(this.$.env.paths.meteorApp.cordovaBuildProgramJson, 'UTF-8')); - } - - return this.$.utils.exists(this.$.env.paths.meteorApp.webCordovaProgramJson) && (!this.oldManifest || this.oldManifest && this.oldManifest !== _fs.default.readFileSync(this.$.env.paths.meteorApp.webCordovaProgramJson, 'UTF-8')); - } - /** - * Fetches index.html from running project. - * @returns {Promise.<*>} - */ - - - async acquireIndex() { - const port = this.$.env.options.port ? this.$.env.options.port : 3080; - this.log.info('acquiring index.html'); - const res = await (0, _nodeFetch.default)(`http://127.0.0.1:${port}/__cordova/index.html`); - const text = await res.text(); // Simple test if we really download index.html for web.cordova. - - if (~text.indexOf('src="/cordova.js"')) { - return text; - } - - return false; - } - /** - * Fetches mainfest.json from running project. - * @returns {Promise.} - */ - - - async acquireManifest() { - const port = this.$.env.options.port ? this.$.env.options.port : 3080; - this.log.info('acquiring manifest.json'); - const res = await (0, _nodeFetch.default)(`http://127.0.0.1:${port}/__cordova/manifest.json?meteor_dont_serve_index=true`); - const text = await res.text(); - return JSON.parse(text); - } - /** - * Tries to get a mobile build from meteor app. - * In case of failure leaves a meteor.log. - * A lot of stuff is happening here - but the main aim is to get a mobile build from - * .meteor/local/cordova-build/www/application and exit as soon as possible. - * - * @returns {Promise} - */ - - - buildMobileTarget() { - const programJson = this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD ? this.$.env.paths.meteorApp.cordovaBuildProgramJson : this.$.env.paths.meteorApp.webCordovaProgramJson; - - if (this.$.utils.exists(programJson)) { - this.oldManifest = _fs.default.readFileSync(programJson, 'UTF-8'); - } - - return new Promise((resolve, reject) => { - const self = this; - let log = ''; - let desiredExit = false; - let buildTimeout = null; - let errorTimeout = null; - let messageTimeout = null; - let killTimeout = null; - let cordovaCheckInterval = null; - let portProblem = false; - - function windowsKill(pid) { - self.log.debug(`killing pid: ${pid}`); - - _crossSpawn.default.sync('taskkill', ['/pid', pid, '/f', '/t']); // We will look for other process which might have been created outside the - // process tree. - // Lets list all node.exe processes. - - - const out = _crossSpawn.default.sync('wmic', ['process', 'where', 'caption="node.exe"', 'get', 'commandline,processid']).stdout.toString('utf-8').split('\n'); - - const args = self.prepareArguments(); // Lets mount regex. - - const regexV1 = new RegExp(`${args.join('\\s+')}\\s+(\\d+)`, 'gm'); - const regexV2 = new RegExp(`"${args.join('"\\s+"')}"\\s+(\\d+)`, 'gm'); // No we will check for those with the matching params. - - out.forEach(line => { - const match = regexV1.exec(line) || regexV2.exec(line) || false; - - if (match) { - self.log.debug(`killing pid: ${match[1]}`); - - _crossSpawn.default.sync('taskkill', ['/pid', match[1], '/f', '/t']); - } - - regexV1.lastIndex = 0; - regexV2.lastIndex = 0; - }); - } - - function writeLog() { - _fs.default.writeFileSync('meteor.log', log, 'UTF-8'); - } - - function clearTimeoutsAndIntervals() { - clearInterval(cordovaCheckInterval); - clearTimeout(buildTimeout); - clearTimeout(errorTimeout); - clearTimeout(messageTimeout); - clearTimeout(killTimeout); - } - - const args = this.prepareArguments(); - this.log.info(`running "meteor ${args.join(' ')}"... this might take a while`); - const env = { - METEOR_PRETTY_OUTPUT: 0, - METEOR_NO_RELEASE_CHECK: 1 - }; - - if (this.$.env.options.prodDebug) { - env.METEOR_DESKOP_PROD_DEBUG = true; - } // Lets spawn meteor. - - - const child = (0, _crossSpawn.default)('meteor', args, { - env: Object.assign(env, process.env), - cwd: this.$.env.paths.meteorApp.root - }, { - shell: true - }); // Kills the currently running meteor command. - - function kill() { - sll(''); - child.kill('SIGKILL'); - - if (self.$.env.os.isWindows) { - windowsKill(child.pid); - } - } - - function exit() { - killTimeout = setTimeout(() => { - clearTimeoutsAndIntervals(); - desiredExit = true; - kill(); - resolve(); - }, 500); - } - - function copyBuild() { - self.copyBuild().then(() => { - exit(); - }).catch(() => { - clearTimeoutsAndIntervals(); - kill(); - writeLog(); - reject('copy'); - }); - } - - cordovaCheckInterval = setInterval(() => { - // Check if we already have cordova-build ready. - if (this.isCordovaBuildReady()) { - // If so, then exit immediately. - if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) { - copyBuild(); - } - } - }, 1000); - child.stderr.on('data', chunk => { - const line = chunk.toString('UTF-8'); - log += `${line}\n`; - - if (errorTimeout) { - clearTimeout(errorTimeout); - } // Do not exit if this is the warning for using --production. - // Output exceeds -> https://github.com/meteor/meteor/issues/8592 - - - if (!~line.indexOf('--production') && !~line.indexOf('Output exceeds ') && !~line.indexOf('Node#moveTo') && !~line.indexOf('Browserslist') && Array.isArray(self.$.env.options.ignoreStderr) && self.$.env.options.ignoreStderr.every(str => !~line.indexOf(str))) { - self.log.warn('STDERR:', line); // We will exit 1s after last error in stderr. - - errorTimeout = setTimeout(() => { - clearTimeoutsAndIntervals(); - kill(); - writeLog(); - reject('error'); - }, 1000); - } - }); - child.stdout.on('data', chunk => { - const line = chunk.toString('UTF-8'); - - if (!desiredExit && line.trim().replace(/[\n\r\t\v\f]+/gm, '') !== '') { - const linesToDisplay = line.trim().split('\n\r'); // Only display last line from the chunk. - - const sanitizedLine = linesToDisplay.pop().replace(/[\n\r\t\v\f]+/gm, ''); - sll(sanitizedLine); - } - - log += `${line}\n`; - - if (~line.indexOf('after_platform_add')) { - sll(''); - this.log.info('done... 10%'); - } - - if (~line.indexOf('Local package version')) { - if (messageTimeout) { - clearTimeout(messageTimeout); - } - - messageTimeout = setTimeout(() => { - sll(''); - this.log.info('building in progress...'); - }, 1500); - } - - if (~line.indexOf('Preparing Cordova project')) { - sll(''); - this.log.info('done... 60%'); - } - - if (~line.indexOf('Can\'t listen on port')) { - portProblem = true; - } - - if (~line.indexOf('Your application has errors')) { - if (errorTimeout) { - clearTimeout(errorTimeout); - } - - errorTimeout = setTimeout(() => { - clearTimeoutsAndIntervals(); - kill(); - writeLog(); - reject('errorInApp'); - }, 1000); - } - - if (~line.indexOf('App running at')) { - copyBuild(); - } - }); // When Meteor exits - - child.on('exit', () => { - sll(''); - clearTimeoutsAndIntervals(); - - if (!desiredExit) { - writeLog(); - - if (portProblem) { - reject('port'); - } else { - reject('exit'); - } - } - }); - buildTimeout = setTimeout(() => { - kill(); - writeLog(); - reject('timeout'); - }, this.$.env.options.buildTimeout ? this.$.env.options.buildTimeout * 1000 : 600000); - }); - } - /** - * Replaces the DDP url that was used originally when Meteor was building the client. - * @param {string} indexHtml - path to index.html from the client - */ - - - updateDdpUrl(indexHtml) { - let content; - let runtimeConfig; - - try { - content = _fs.default.readFileSync(indexHtml, 'UTF-8'); - } catch (e) { - this.log.error(`error loading index.html file: ${e.message}`); - process.exit(1); - } - - if (!this.matcher.test(content)) { - this.log.error('could not find runtime config in index file'); - process.exit(1); - } - - try { - const matches = content.match(this.matcher); - runtimeConfig = JSON.parse(decodeURIComponent(matches[1])); - } catch (e) { - this.log.error('could not find runtime config in index file'); - process.exit(1); - } - - if (this.$.env.options.ddpUrl.substr(-1, 1) !== '/') { - this.$.env.options.ddpUrl += '/'; - } - - runtimeConfig.ROOT_URL = this.$.env.options.ddpUrl; - runtimeConfig.DDP_DEFAULT_CONNECTION_URL = this.$.env.options.ddpUrl; - content = content.replace(this.replacer, `$1"${encodeURIComponent(JSON.stringify(runtimeConfig))}"$3`); - - try { - _fs.default.writeFileSync(indexHtml, content); - } catch (e) { - this.log.error(`error writing index.html file: ${e.message}`); - process.exit(1); - } - - this.log.info('successfully updated ddp string in the runtime config of a mobile build' + ` to ${this.$.env.options.ddpUrl}`); - } - /** - * Prepares the arguments passed to `meteor` command. - * @returns {string[]} - */ - - - prepareArguments() { - const args = ['run', '--verbose', `--mobile-server=${this.$.env.options.ddpUrl}`]; - - if (this.$.env.isProductionBuild()) { - args.push('--production'); - } - - args.push('-p'); - - if (this.$.env.options.port) { - args.push(this.$.env.options.port); - } else { - args.push('3080'); - } - - if (this.$.env.options.meteorSettings) { - args.push('--settings', this.$.env.options.meteorSettings); - } - - return args; - } - /** - * Validates the mobile build and copies it into electron app. - */ - - - async copyBuild() { - this.log.debug('clearing build dir'); - - try { - await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.meteorApp); - } catch (e) { - throw new Error(e); - } - - let prefix = 'cordovaBuild'; - let copyPathPostfix = ''; - - if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) { - prefix = 'webCordova'; - copyPathPostfix = `${_path.default.sep}*`; - let indexHtml; - - try { - _fs.default.mkdirSync(this.$.env.paths.electronApp.meteorApp); - - indexHtml = await this.acquireIndex(); - - _fs.default.writeFileSync(this.$.env.paths.electronApp.meteorAppIndex, indexHtml); - - this.log.info('successfully downloaded index.html from running meteor app'); - } catch (e) { - this.log.error('error while trying to download index.html for web.cordova, ' + 'be sure that you are running a mobile target or with' + ' --mobile-server: ', e); - throw e; - } - } - - const cordovaBuild = this.$.env.paths.meteorApp[prefix]; - const { - cordovaBuildIndex - } = this.$.env.paths.meteorApp; - const cordovaBuildProgramJson = this.$.env.paths.meteorApp[`${prefix}ProgramJson`]; - - if (!this.$.utils.exists(cordovaBuild)) { - this.log.error(`no mobile build found at ${cordovaBuild}`); - this.log.error('are you sure you did run meteor with --mobile-server?'); - throw new Error('required file not present'); - } - - if (!this.$.utils.exists(cordovaBuildProgramJson)) { - this.log.error('no program.json found in mobile build found at ' + `${cordovaBuild}`); - this.log.error('are you sure you did run meteor with --mobile-server?'); - throw new Error('required file not present'); - } - - if (this.indexHTMLstrategy !== this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) { - if (!this.$.utils.exists(cordovaBuildIndex)) { - this.log.error('no index.html found in cordova build found at ' + `${cordovaBuild}`); - this.log.error('are you sure you did run meteor with --mobile-server?'); - throw new Error('required file not present'); - } - } - - this.log.verbose('copying mobile build'); - - _shelljs.default.cp('-R', `${cordovaBuild}${copyPathPostfix}`, this.$.env.paths.electronApp.meteorApp); // Because of various permission problems here we try to clear te path by clearing - // all possible restrictions. - - - _shelljs.default.chmod('-R', '777', this.$.env.paths.electronApp.meteorApp); - - if (this.$.env.os.isWindows) { - _shelljs.default.exec(`attrib -r ${this.$.env.paths.electronApp.meteorApp}${_path.default.sep}*.* /s`); - } - - if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) { - let programJson; - - try { - programJson = await this.acquireManifest(); - - _fs.default.writeFileSync(this.$.env.paths.electronApp.meteorAppProgramJson, JSON.stringify(programJson, null, 4)); - - this.log.info('successfully downloaded manifest.json from running meteor app'); - } catch (e) { - this.log.error('error while trying to download manifest.json for web.cordova,' + ' be sure that you are running a mobile target or with' + ' --mobile-server: ', e); - throw e; - } - } - - this.log.info('mobile build copied to electron app'); - this.log.debug('copy cordova.js to meteor build'); - - _shelljs.default.cp(join(__dirname, '..', 'skeleton', 'cordova.js'), this.$.env.paths.electronApp.meteorApp); - } - /** - * Injects Meteor.isDesktop - */ - - - injectIsDesktop() { - this.log.info('injecting isDesktop'); - let manifestJsonPath = this.$.env.paths.meteorApp.cordovaBuildProgramJson; - - if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) { - manifestJsonPath = this.$.env.paths.meteorApp.webCordovaProgramJson; - } - - try { - const { - manifest - } = JSON.parse(_fs.default.readFileSync(manifestJsonPath, 'UTF-8')); - let injected = false; - let injectedStartupDidComplete = false; - let result = null; // We will search in every .js file in the manifest. - // We could probably detect whether this is a dev or production build and only search in - // the correct files, but for now this should be fine. - - manifest.forEach(file => { - let fileContents; // Hacky way of setting isDesktop. - - if (file.type === 'js') { - fileContents = _fs.default.readFileSync(join(this.$.env.paths.electronApp.meteorApp, file.path), 'UTF-8'); - result = this.injector.processFileContents(fileContents); - ({ - fileContents - } = result); - injectedStartupDidComplete = result.injectedStartupDidComplete ? true : injectedStartupDidComplete; - injected = result.injected ? true : injected; - - _fs.default.writeFileSync(join(this.$.env.paths.electronApp.meteorApp, file.path), fileContents); - } - }); - - if (!injected) { - this.log.error('error injecting isDesktop global var.'); - process.exit(1); - } - - if (!injectedStartupDidComplete) { - this.log.error('error injecting isDesktop for startupDidComplete'); - process.exit(1); - } - } catch (e) { - this.log.error('error occurred while injecting isDesktop: ', e); - process.exit(1); - } - - this.log.info('injected successfully'); - } - /** - * Builds, modifies and copies the meteor app to electron app. - */ - - - async build() { - this.log.info('checking for any mobile platform'); - - try { - await this.checkPreconditions(); - } catch (e) { - this.log.error('error occurred during checking preconditions: ', e); - process.exit(1); - } - - this.log.info('building meteor app'); - - if (!this.$.env.options.skipMobileBuild) { - try { - await this.buildMobileTarget(); - } catch (reason) { - switch (reason) { - case 'timeout': - this.log.error('timeout while building, log has been written to meteor.log'); - break; - - case 'error': - this.log.error('build was terminated by meteor-desktop as some errors were reported to stderr, you ' + 'should see it above, also check meteor.log for more info, to ignore it use the ' + '--ignore-stderr ""'); - break; - - case 'errorInApp': - this.log.error('your meteor app has errors - look into meteor.log for more' + ' info'); - break; - - case 'port': - this.log.error('your port 3080 is currently used (you probably have this or other ' + 'meteor project running?), use `-t` or `--meteor-port` to use ' + 'different port while building'); - break; - - case 'exit': - this.log.error('meteor cmd exited unexpectedly, log has been written to meteor.log'); - break; - - case 'copy': - this.log.error('error encountered when copying the build'); - break; - - default: - this.log.error('error occurred during building mobile target', reason); - } - - if (this.mobilePlatform) { - await this.removeMobilePlatform(this.mobilePlatform); - } - - process.exit(1); - } - } else { - this.indexHTMLstrategy = this.chooseStrategy(); - - try { - await this.copyBuild(); - } catch (e) { - process.exit(1); - } - } - - this.injectIsDesktop(); - this.changeDdpUrl(); - - try { - await this.packToAsar(); - } catch (e) { - this.log.error('error while packing meteor app to asar'); - process.exit(1); - } - - this.log.info('meteor build finished'); - - if (this.mobilePlatform) { - await this.removeMobilePlatform(this.mobilePlatform); - } - } - - changeDdpUrl() { - if (this.$.env.options.ddpUrl !== null) { - try { - this.updateDdpUrl(this.$.env.paths.electronApp.meteorAppIndex); - } catch (e) { - this.log.error(`error while trying to change the ddp url: ${e.message}`); - } - } - } - - packToAsar() { - this.log.info('packing meteor app to asar archive'); - return new Promise((resolve, reject) => _asar.default.createPackage(this.$.env.paths.electronApp.meteorApp, _path.default.join(this.$.env.paths.electronApp.root, 'meteor.asar')).then(() => { - // On Windows some files might still be blocked. Giving a tick for them to be - // ready for deletion. - setImmediate(() => { - this.log.verbose('clearing meteor app after packing'); - this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.meteorApp).then(() => { - resolve(); - }).catch(e => { - reject(e); - }); - }); - })); - } - /** - * Wrapper for spawning npm. - * @param {Array} commands - commands for spawn - * @param {string} stdio - * @param {string} cwd - * @return {Promise} - */ - - - runNpm(commands, stdio = 'ignore', cwd = this.$.env.paths.meteorApp.root) { - return new Promise((resolve, reject) => { - this.log.verbose(`executing meteor npm ${commands.join(' ')}`); - (0, _crossSpawn.default)('meteor', ['npm', ...commands], { - cwd, - stdio - }).on('exit', code => code === 0 ? resolve() : reject(new Error(`npm exit code was ${code}`))); - }); - } - -} - -exports.default = MeteorApp; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","sll","singleLineLog","stdout","MeteorApp","constructor","$","log","Log","meteorManager","MeteorManager","mobilePlatform","oldManifest","injector","IsDesktopInjector","matcher","RegExp","replacer","meteorVersion","indexHTMLstrategy","indexHTMLStrategies","INDEX_FROM_CORDOVA_BUILD","INDEX_FROM_RUNNING_SERVER","deprectatedPackages","removeDeprecatedPackages","checkPackages","info","deletePackages","e","Error","ensureDesktopHCPPackages","desktopHCPPackages","desktop","getSettings","desktopHCP","verbose","packagesWithVersion","map","packageName","getVersion","ensurePackages","updateGitIgnore","gitIgnore","fs","readFileSync","env","paths","meteorApp","split","filter","ignoredPath","trim","indexOf","electronApp","rootName","push","writeFileSync","getMeteorRelease","release","replace","castMeteorReleaseToSemver","match","checkMeteorVersion","versionRange","semver","satisfies","options","skipMobileBuild","error","process","exit","chooseStrategy","forceCordovaBuild","explodedVersion","length","checkPreconditions","debug","platforms","android","warn","addMobilePlatform","platform","Promise","resolve","reject","spawn","cwd","root","stdio","on","removeMobilePlatform","skipRemoveMobilePlatform","Object","assign","METEOR_PRETTY_OUTPUT","isCordovaBuildReady","utils","exists","cordovaBuildIndex","cordovaBuildProgramJson","webCordovaProgramJson","acquireIndex","port","res","fetch","text","acquireManifest","JSON","parse","buildMobileTarget","programJson","self","desiredExit","buildTimeout","errorTimeout","messageTimeout","killTimeout","cordovaCheckInterval","portProblem","windowsKill","pid","sync","out","toString","args","prepareArguments","regexV1","regexV2","forEach","line","exec","lastIndex","writeLog","clearTimeoutsAndIntervals","clearInterval","clearTimeout","METEOR_NO_RELEASE_CHECK","prodDebug","METEOR_DESKOP_PROD_DEBUG","child","shell","kill","os","isWindows","setTimeout","copyBuild","then","catch","setInterval","stderr","chunk","Array","isArray","ignoreStderr","every","str","linesToDisplay","sanitizedLine","pop","updateDdpUrl","indexHtml","content","runtimeConfig","message","test","matches","decodeURIComponent","ddpUrl","substr","ROOT_URL","DDP_DEFAULT_CONNECTION_URL","encodeURIComponent","stringify","isProductionBuild","meteorSettings","rmWithRetries","prefix","copyPathPostfix","sep","mkdirSync","meteorAppIndex","cordovaBuild","cp","chmod","meteorAppProgramJson","__dirname","injectIsDesktop","manifestJsonPath","manifest","injected","injectedStartupDidComplete","result","file","fileContents","type","processFileContents","build","reason","changeDdpUrl","packToAsar","asar","createPackage","setImmediate","runNpm","commands","code"],"sources":["../lib/meteorApp.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport fs from 'fs';\nimport spawn from 'cross-spawn';\nimport semver from 'semver';\nimport shell from 'shelljs';\nimport path from 'path';\nimport singleLineLog from 'single-line-log';\nimport asar from '@electron/asar';\nimport fetch from 'node-fetch';\n\nimport IsDesktopInjector from '../skeleton/modules/autoupdate/isDesktopInjector';\nimport Log from './log';\nimport MeteorManager from './meteorManager';\n\nconst { join } = path;\nconst sll = singleLineLog.stdout;\n\n// TODO: refactor all strategy ifs to one place\n\n/**\n * Represents the Meteor app.\n * @property {MeteorDesktop} $\n * @class\n */\nexport default class MeteorApp {\n    /**\n     * @param {MeteorDesktop} $ - context\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('meteorApp');\n        this.$ = $;\n        this.meteorManager = new MeteorManager($);\n        this.mobilePlatform = null;\n        this.oldManifest = null;\n        this.injector = new IsDesktopInjector();\n        this.matcher = new RegExp(\n            '__meteor_runtime_config__ = JSON.parse\\\\(decodeURIComponent\\\\(\"([^\"]*)\"\\\\)\\\\)'\n        );\n        this.replacer = new RegExp(\n            '(__meteor_runtime_config__ = JSON.parse\\\\(decodeURIComponent\\\\()\"([^\"]*)\"(\\\\)\\\\))'\n        );\n        this.meteorVersion = null;\n        this.indexHTMLstrategy = null;\n\n        this.indexHTMLStrategies = {\n            INDEX_FROM_CORDOVA_BUILD: 1,\n            INDEX_FROM_RUNNING_SERVER: 2\n        };\n\n        this.deprectatedPackages = ['omega:meteor-desktop-localstorage'];\n    }\n\n    /**\n     * Remove any deprecated packages from meteor project.\n     * @returns {Promise<void>}\n     */\n    async removeDeprecatedPackages() {\n        try {\n            if (this.meteorManager.checkPackages(this.deprectatedPackages)) {\n                this.log.info('deprecated meteor plugins found, removing them');\n                await this.meteorManager.deletePackages(this.deprectatedPackages);\n            }\n        } catch (e) {\n            throw new Error(e);\n        }\n    }\n\n    /**\n     * Ensures that required packages are added to the Meteor app.\n     */\n    async ensureDesktopHCPPackages() {\n        const desktopHCPPackages = ['communitypackages:meteor-desktop-watcher', 'communitypackages:meteor-desktop-bundler'];\n        if (this.$.desktop.getSettings().desktopHCP) {\n            this.log.verbose('desktopHCP is enabled, checking for required packages');\n\n            const packagesWithVersion = desktopHCPPackages.map(packageName => `${packageName}@${this.$.getVersion()}`);\n\n            try {\n                await this.meteorManager.ensurePackages(desktopHCPPackages, packagesWithVersion, 'desktopHCP');\n            } catch (e) {\n                throw new Error(e);\n            }\n        } else {\n            this.log.verbose('desktopHCP is not enabled, removing required packages');\n\n            try {\n                if (this.meteorManager.checkPackages(desktopHCPPackages)) {\n                    await this.meteorManager.deletePackages(desktopHCPPackages);\n                }\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n    }\n\n    /**\n     * Adds entry to .meteor/.gitignore if necessary.\n     */\n    updateGitIgnore() {\n        this.log.verbose('updating .meteor/.gitignore');\n        // Lets read the .meteor/.gitignore and filter out blank lines.\n        const gitIgnore = fs.readFileSync(this.$.env.paths.meteorApp.gitIgnore, 'UTF-8')\n            .split('\\n').filter(ignoredPath => ignoredPath.trim() !== '');\n\n        if (!~gitIgnore.indexOf(this.$.env.paths.electronApp.rootName)) {\n            this.log.verbose(`adding ${this.$.env.paths.electronApp.rootName} to .meteor/.gitignore`);\n            gitIgnore.push(this.$.env.paths.electronApp.rootName);\n\n            fs.writeFileSync(this.$.env.paths.meteorApp.gitIgnore, gitIgnore.join('\\n'), 'UTF-8');\n        }\n    }\n\n    /**\n     * Reads the Meteor release version used in the app.\n     * @returns {string}\n     */\n    getMeteorRelease() {\n        let release = fs.readFileSync(this.$.env.paths.meteorApp.release, 'UTF-8')\n            .replace(/\\r/gm, '')\n            .split('\\n')[0];\n        ([, release] = release.split('@'));\n        // We do not care if it is beta.\n        if (~release.indexOf('-')) {\n            ([release] = release.split('-'));\n        }\n        return release;\n    }\n\n    /**\n     * Cast Meteor release to semver version.\n     * @returns {string}\n     */\n    castMeteorReleaseToSemver() {\n        return `${this.getMeteorRelease()}.0.0`.match(/(^\\d+\\.\\d+\\.\\d+)/gmi)[0];\n    }\n\n    /**\n     * Validate meteor version against a versionRange.\n     * @param {string} versionRange - semver version range\n     */\n    checkMeteorVersion(versionRange) {\n        const release = this.castMeteorReleaseToSemver();\n        if (!semver.satisfies(release, versionRange)) {\n            if (this.$.env.options.skipMobileBuild) {\n                this.log.error(`wrong meteor version (${release}) in project - only ` +\n                    `${versionRange} is supported`);\n            } else {\n                this.log.error(`wrong meteor version (${release}) in project - only ` +\n                    `${versionRange} is supported for automatic meteor builds (you can always ` +\n                    'try with `--skip-mobile-build` if you are using meteor >= 1.2.1');\n            }\n            process.exit(1);\n        }\n    }\n\n    /**\n     * Decides which strategy to use while trying to get client build out of Meteor project.\n     * @returns {number}\n     */\n    chooseStrategy() {\n        if (this.$.env.options.forceCordovaBuild) {\n            return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD;\n        }\n\n        const release = this.castMeteorReleaseToSemver();\n        if (semver.satisfies(release, '> 1.3.4')) {\n            return this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER;\n        }\n        if (semver.satisfies(release, '1.3.4')) {\n            const explodedVersion = this.getMeteorRelease().split('.');\n            if (explodedVersion.length >= 4) {\n                if (explodedVersion[3] > 1) {\n                    return this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER;\n                }\n                return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD;\n            }\n        }\n        return this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD;\n    }\n\n    /**\n     * Checks required preconditions.\n     * - Meteor version\n     * - is mobile platform added\n     */\n    async checkPreconditions() {\n        if (this.$.env.options.skipMobileBuild) {\n            this.checkMeteorVersion('>= 1.2.1');\n        } else {\n            this.checkMeteorVersion('>= 1.3.3');\n            this.indexHTMLstrategy = this.chooseStrategy();\n            if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) {\n                this.log.debug(\n                    'meteor version is < 1.3.4.2 so the index.html from cordova-build will' +\n                    ' be used'\n                );\n            } else {\n                this.log.debug(\n                    'meteor version is >= 1.3.4.2 so the index.html will be downloaded ' +\n                    'from __cordova/index.html'\n                );\n            }\n        }\n\n        if (!this.$.env.options.skipMobileBuild) {\n            const platforms = fs.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8');\n            if (!~platforms.indexOf('android') && !~platforms.indexOf('ios')) {\n                if (!this.$.env.options.android) {\n                    this.mobilePlatform = 'ios';\n                } else {\n                    this.mobilePlatform = 'android';\n                }\n                this.log.warn(`no mobile target detected - will add '${this.mobilePlatform}' ` +\n                    'just to get a mobile build');\n                try {\n                    await this.addMobilePlatform(this.mobilePlatform);\n                } catch (e) {\n                    this.log.error('failed to add a mobile platform - please try to do it manually');\n                    process.exit(1);\n                }\n            }\n        }\n    }\n\n    /**\n     * Tries to add a mobile platform to meteor project.\n     * @param {string} platform - platform to add\n     * @returns {Promise}\n     */\n    addMobilePlatform(platform) {\n        return new Promise((resolve, reject) => {\n            this.log.verbose(`adding mobile platform: ${platform}`);\n            spawn('meteor', ['add-platform', platform], {\n                cwd: this.$.env.paths.meteorApp.root,\n                stdio: this.$.env.stdio\n            }).on('exit', () => {\n                const platforms = fs.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8');\n                if (!~platforms.indexOf('android') && !~platforms.indexOf('ios')) {\n                    reject();\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n\n    /**\n     * Tries to remove a mobile platform from meteor project.\n     * @param {string} platform - platform to remove\n     * @returns {Promise}\n     */\n    removeMobilePlatform(platform) {\n        if (this.$.env.options.skipRemoveMobilePlatform) {\n            return Promise.resolve();\n        }\n        return new Promise((resolve, reject) => {\n            this.log.verbose(`removing mobile platform: ${platform}`);\n            spawn('meteor', ['remove-platform', platform], {\n                cwd: this.$.env.paths.meteorApp.root,\n                stdio: this.$.env.stdio,\n                env: Object.assign({ METEOR_PRETTY_OUTPUT: 0 }, process.env)\n            }).on('exit', () => {\n                const platforms = fs.readFileSync(this.$.env.paths.meteorApp.platforms, 'UTF-8');\n                if (~platforms.indexOf(platform)) {\n                    reject();\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n\n    /**\n     * Just checks for index.html and program.json existence.\n     * @returns {boolean}\n     */\n    isCordovaBuildReady() {\n        if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) {\n            return this.$.utils.exists(this.$.env.paths.meteorApp.cordovaBuildIndex) &&\n                this.$.utils.exists(this.$.env.paths.meteorApp.cordovaBuildProgramJson) &&\n                (\n                    !this.oldManifest ||\n                    (this.oldManifest &&\n                        this.oldManifest !== fs.readFileSync(\n                            this.$.env.paths.meteorApp.cordovaBuildProgramJson, 'UTF-8'\n                        )\n                    )\n                );\n        }\n        return this.$.utils.exists(this.$.env.paths.meteorApp.webCordovaProgramJson) &&\n            (\n                !this.oldManifest ||\n                (this.oldManifest &&\n                    this.oldManifest !== fs.readFileSync(\n                        this.$.env.paths.meteorApp.webCordovaProgramJson, 'UTF-8'\n                    )\n                )\n            );\n    }\n\n    /**\n     * Fetches index.html from running project.\n     * @returns {Promise.<*>}\n     */\n    async acquireIndex() {\n        const port = (this.$.env.options.port) ? this.$.env.options.port : 3080;\n        this.log.info('acquiring index.html');\n        const res = await fetch(`http://127.0.0.1:${port}/__cordova/index.html`);\n        const text = await res.text();\n        // Simple test if we really download index.html for web.cordova.\n        if (~text.indexOf('src=\"/cordova.js\"')) {\n            return text;\n        }\n        return false;\n    }\n\n    /**\n     * Fetches mainfest.json from running project.\n     * @returns {Promise.<void>}\n     */\n    async acquireManifest() {\n        const port = (this.$.env.options.port) ? this.$.env.options.port : 3080;\n        this.log.info('acquiring manifest.json');\n        const res = await fetch(\n            `http://127.0.0.1:${port}/__cordova/manifest.json?meteor_dont_serve_index=true`\n        );\n        const text = await res.text();\n        return JSON.parse(text);\n    }\n\n    /**\n     * Tries to get a mobile build from meteor app.\n     * In case of failure leaves a meteor.log.\n     * A lot of stuff is happening here - but the main aim is to get a mobile build from\n     * .meteor/local/cordova-build/www/application and exit as soon as possible.\n     *\n     * @returns {Promise}\n     */\n    buildMobileTarget() {\n        const programJson =\n            (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) ?\n                this.$.env.paths.meteorApp.cordovaBuildProgramJson :\n                this.$.env.paths.meteorApp.webCordovaProgramJson;\n\n        if (this.$.utils.exists(programJson)) {\n            this.oldManifest = fs.readFileSync(programJson, 'UTF-8');\n        }\n\n        return new Promise((resolve, reject) => {\n            const self = this;\n            let log = '';\n            let desiredExit = false;\n            let buildTimeout = null;\n            let errorTimeout = null;\n            let messageTimeout = null;\n            let killTimeout = null;\n            let cordovaCheckInterval = null;\n            let portProblem = false;\n\n            function windowsKill(pid) {\n                self.log.debug(`killing pid: ${pid}`);\n                spawn.sync('taskkill', ['/pid', pid, '/f', '/t']);\n\n                // We will look for other process which might have been created outside the\n                // process tree.\n                // Lets list all node.exe processes.\n\n                const out = spawn\n                    .sync(\n                        'wmic',\n                        ['process', 'where', 'caption=\"node.exe\"', 'get', 'commandline,processid']\n                    )\n                    .stdout.toString('utf-8')\n                    .split('\\n');\n                const args = self.prepareArguments();\n                // Lets mount regex.\n                const regexV1 = new RegExp(`${args.join('\\\\s+')}\\\\s+(\\\\d+)`, 'gm');\n                const regexV2 = new RegExp(`\"${args.join('\"\\\\s+\"')}\"\\\\s+(\\\\d+)`, 'gm');\n                // No we will check for those with the matching params.\n                out.forEach((line) => {\n                    const match = regexV1.exec(line) || regexV2.exec(line) || false;\n                    if (match) {\n                        self.log.debug(`killing pid: ${match[1]}`);\n                        spawn.sync('taskkill', ['/pid', match[1], '/f', '/t']);\n                    }\n                    regexV1.lastIndex = 0;\n                    regexV2.lastIndex = 0;\n                });\n            }\n\n            function writeLog() {\n                fs.writeFileSync('meteor.log', log, 'UTF-8');\n            }\n\n            function clearTimeoutsAndIntervals() {\n                clearInterval(cordovaCheckInterval);\n                clearTimeout(buildTimeout);\n                clearTimeout(errorTimeout);\n                clearTimeout(messageTimeout);\n                clearTimeout(killTimeout);\n            }\n\n            const args = this.prepareArguments();\n\n            this.log.info(`running \"meteor ${args.join(' ')}\"... this might take a while`);\n\n            const env = { METEOR_PRETTY_OUTPUT: 0, METEOR_NO_RELEASE_CHECK: 1 };\n            if (this.$.env.options.prodDebug) {\n                env.METEOR_DESKOP_PROD_DEBUG = true;\n            }\n\n            // Lets spawn meteor.\n            const child = spawn(\n                'meteor',\n                args,\n                {\n                    env: Object.assign(env, process.env),\n                    cwd: this.$.env.paths.meteorApp.root\n                },\n                { shell: true }\n            );\n\n            // Kills the currently running meteor command.\n            function kill() {\n                sll('');\n                child.kill('SIGKILL');\n                if (self.$.env.os.isWindows) {\n                    windowsKill(child.pid);\n                }\n            }\n\n            function exit() {\n                killTimeout = setTimeout(() => {\n                    clearTimeoutsAndIntervals();\n                    desiredExit = true;\n                    kill();\n                    resolve();\n                }, 500);\n            }\n\n            function copyBuild() {\n                self.copyBuild().then(() => {\n                    exit();\n                }).catch(() => {\n                    clearTimeoutsAndIntervals();\n                    kill();\n                    writeLog();\n                    reject('copy');\n                });\n            }\n\n            cordovaCheckInterval = setInterval(() => {\n                // Check if we already have cordova-build ready.\n                if (this.isCordovaBuildReady()) {\n                    // If so, then exit immediately.\n                    if (this.indexHTMLstrategy ===\n                        this.indexHTMLStrategies.INDEX_FROM_CORDOVA_BUILD) {\n                        copyBuild();\n                    }\n                }\n            }, 1000);\n\n            child.stderr.on('data', (chunk) => {\n                const line = chunk.toString('UTF-8');\n                log += `${line}\\n`;\n                if (errorTimeout) {\n                    clearTimeout(errorTimeout);\n                }\n                // Do not exit if this is the warning for using --production.\n                // Output exceeds -> https://github.com/meteor/meteor/issues/8592\n                if (\n                    !~line.indexOf('--production') &&\n                    !~line.indexOf('Output exceeds ') &&\n                    !~line.indexOf('Node#moveTo') &&\n                    !~line.indexOf('Browserslist') &&\n                    (\n                        Array.isArray(self.$.env.options.ignoreStderr) &&\n                        self.$.env.options.ignoreStderr.every(str => !~line.indexOf(str))\n                    )\n                ) {\n                    self.log.warn('STDERR:', line);\n                    // We will exit 1s after last error in stderr.\n                    errorTimeout = setTimeout(() => {\n                        clearTimeoutsAndIntervals();\n                        kill();\n                        writeLog();\n                        reject('error');\n                    }, 1000);\n                }\n            });\n\n            child.stdout.on('data', (chunk) => {\n                const line = chunk.toString('UTF-8');\n                if (!desiredExit && line.trim().replace(/[\\n\\r\\t\\v\\f]+/gm, '') !== '') {\n                    const linesToDisplay = line.trim()\n                        .split('\\n\\r');\n                    // Only display last line from the chunk.\n                    const sanitizedLine = linesToDisplay.pop().replace(/[\\n\\r\\t\\v\\f]+/gm, '');\n                    sll(sanitizedLine);\n                }\n                log += `${line}\\n`;\n                if (~line.indexOf('after_platform_add')) {\n                    sll('');\n                    this.log.info('done... 10%');\n                }\n\n                if (~line.indexOf('Local package version')) {\n                    if (messageTimeout) {\n                        clearTimeout(messageTimeout);\n                    }\n                    messageTimeout = setTimeout(() => {\n                        sll('');\n                        this.log.info('building in progress...');\n                    }, 1500);\n                }\n\n                if (~line.indexOf('Preparing Cordova project')) {\n                    sll('');\n                    this.log.info('done... 60%');\n                }\n\n                if (~line.indexOf('Can\\'t listen on port')) {\n                    portProblem = true;\n                }\n\n                if (~line.indexOf('Your application has errors')) {\n                    if (errorTimeout) {\n                        clearTimeout(errorTimeout);\n                    }\n                    errorTimeout = setTimeout(() => {\n                        clearTimeoutsAndIntervals();\n                        kill();\n                        writeLog();\n                        reject('errorInApp');\n                    }, 1000);\n                }\n\n                if (~line.indexOf('App running at')) {\n                    copyBuild();\n                }\n            });\n\n            // When Meteor exits\n            child.on('exit', () => {\n                sll('');\n                clearTimeoutsAndIntervals();\n                if (!desiredExit) {\n                    writeLog();\n                    if (portProblem) {\n                        reject('port');\n                    } else {\n                        reject('exit');\n                    }\n                }\n            });\n\n            buildTimeout = setTimeout(() => {\n                kill();\n                writeLog();\n                reject('timeout');\n            }, this.$.env.options.buildTimeout ? this.$.env.options.buildTimeout * 1000 : 600000);\n        });\n    }\n\n    /**\n     * Replaces the DDP url that was used originally when Meteor was building the client.\n     * @param {string} indexHtml - path to index.html from the client\n     */\n    updateDdpUrl(indexHtml) {\n        let content;\n        let runtimeConfig;\n\n        try {\n            content = fs.readFileSync(indexHtml, 'UTF-8');\n        } catch (e) {\n            this.log.error(`error loading index.html file: ${e.message}`);\n            process.exit(1);\n        }\n        if (!this.matcher.test(content)) {\n            this.log.error('could not find runtime config in index file');\n            process.exit(1);\n        }\n\n        try {\n            const matches = content.match(this.matcher);\n            runtimeConfig = JSON.parse(decodeURIComponent(matches[1]));\n        } catch (e) {\n            this.log.error('could not find runtime config in index file');\n            process.exit(1);\n        }\n\n        if (this.$.env.options.ddpUrl.substr(-1, 1) !== '/') {\n            this.$.env.options.ddpUrl += '/';\n        }\n\n        runtimeConfig.ROOT_URL = this.$.env.options.ddpUrl;\n        runtimeConfig.DDP_DEFAULT_CONNECTION_URL = this.$.env.options.ddpUrl;\n\n        content = content.replace(\n            this.replacer, `$1\"${encodeURIComponent(JSON.stringify(runtimeConfig))}\"$3`\n        );\n\n        try {\n            fs.writeFileSync(indexHtml, content);\n        } catch (e) {\n            this.log.error(`error writing index.html file: ${e.message}`);\n            process.exit(1);\n        }\n        this.log.info('successfully updated ddp string in the runtime config of a mobile build' +\n            ` to ${this.$.env.options.ddpUrl}`);\n    }\n\n    /**\n     * Prepares the arguments passed to `meteor` command.\n     * @returns {string[]}\n     */\n    prepareArguments() {\n        const args = ['run', '--verbose', `--mobile-server=${this.$.env.options.ddpUrl}`];\n        if (this.$.env.isProductionBuild()) {\n            args.push('--production');\n        }\n        args.push('-p');\n        if (this.$.env.options.port) {\n            args.push(this.$.env.options.port);\n        } else {\n            args.push('3080');\n        }\n        if (this.$.env.options.meteorSettings) {\n            args.push('--settings', this.$.env.options.meteorSettings);\n        }\n        return args;\n    }\n\n    /**\n     * Validates the mobile build and copies it into electron app.\n     */\n    async copyBuild() {\n        this.log.debug('clearing build dir');\n        try {\n            await this.$.utils.rmWithRetries('-rf', this.$.env.paths.electronApp.meteorApp);\n        } catch (e) {\n            throw new Error(e);\n        }\n\n        let prefix = 'cordovaBuild';\n        let copyPathPostfix = '';\n\n        if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) {\n            prefix = 'webCordova';\n            copyPathPostfix = `${path.sep}*`;\n            let indexHtml;\n            try {\n                fs.mkdirSync(this.$.env.paths.electronApp.meteorApp);\n                indexHtml = await this.acquireIndex();\n                fs.writeFileSync(this.$.env.paths.electronApp.meteorAppIndex, indexHtml);\n                this.log.info('successfully downloaded index.html from running meteor app');\n            } catch (e) {\n                this.log.error('error while trying to download index.html for web.cordova, ' +\n                    'be sure that you are running a mobile target or with' +\n                    ' --mobile-server: ', e);\n                throw e;\n            }\n        }\n\n        const cordovaBuild = this.$.env.paths.meteorApp[prefix];\n        const { cordovaBuildIndex } = this.$.env.paths.meteorApp;\n        const cordovaBuildProgramJson = this.$.env.paths.meteorApp[`${prefix}ProgramJson`];\n\n        if (!this.$.utils.exists(cordovaBuild)) {\n            this.log.error(`no mobile build found at ${cordovaBuild}`);\n            this.log.error('are you sure you did run meteor with --mobile-server?');\n            throw new Error('required file not present');\n        }\n\n        if (!this.$.utils.exists(cordovaBuildProgramJson)) {\n            this.log.error('no program.json found in mobile build found at ' +\n                `${cordovaBuild}`);\n            this.log.error('are you sure you did run meteor with --mobile-server?');\n            throw new Error('required file not present');\n        }\n\n        if (this.indexHTMLstrategy !== this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) {\n            if (!this.$.utils.exists(cordovaBuildIndex)) {\n                this.log.error('no index.html found in cordova build found at ' +\n                    `${cordovaBuild}`);\n                this.log.error('are you sure you did run meteor with --mobile-server?');\n                throw new Error('required file not present');\n            }\n        }\n\n        this.log.verbose('copying mobile build');\n        shell.cp(\n            '-R', `${cordovaBuild}${copyPathPostfix}`, this.$.env.paths.electronApp.meteorApp\n        );\n\n        // Because of various permission problems here we try to clear te path by clearing\n        // all possible restrictions.\n        shell.chmod(\n            '-R', '777', this.$.env.paths.electronApp.meteorApp\n        );\n        if (this.$.env.os.isWindows) {\n            shell.exec(`attrib -r ${this.$.env.paths.electronApp.meteorApp}${path.sep}*.* /s`);\n        }\n\n        if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) {\n            let programJson;\n            try {\n                programJson = await this.acquireManifest();\n                fs.writeFileSync(\n                    this.$.env.paths.electronApp.meteorAppProgramJson,\n                    JSON.stringify(programJson, null, 4)\n                );\n                this.log.info('successfully downloaded manifest.json from running meteor app');\n            } catch (e) {\n                this.log.error('error while trying to download manifest.json for web.cordova,' +\n                    ' be sure that you are running a mobile target or with' +\n                    ' --mobile-server: ', e);\n                throw e;\n            }\n        }\n\n        this.log.info('mobile build copied to electron app');\n\n        this.log.debug('copy cordova.js to meteor build');\n        shell.cp(\n            join(__dirname, '..', 'skeleton', 'cordova.js'),\n            this.$.env.paths.electronApp.meteorApp\n        );\n    }\n\n    /**\n     * Injects Meteor.isDesktop\n     */\n    injectIsDesktop() {\n        this.log.info('injecting isDesktop');\n\n        let manifestJsonPath = this.$.env.paths.meteorApp.cordovaBuildProgramJson;\n        if (this.indexHTMLstrategy === this.indexHTMLStrategies.INDEX_FROM_RUNNING_SERVER) {\n            manifestJsonPath = this.$.env.paths.meteorApp.webCordovaProgramJson;\n        }\n\n        try {\n            const { manifest } = JSON.parse(\n                fs.readFileSync(manifestJsonPath, 'UTF-8')\n            );\n            let injected = false;\n            let injectedStartupDidComplete = false;\n            let result = null;\n\n            // We will search in every .js file in the manifest.\n            // We could probably detect whether this is a dev or production build and only search in\n            // the correct files, but for now this should be fine.\n            manifest.forEach((file) => {\n                let fileContents;\n                // Hacky way of setting isDesktop.\n                if (file.type === 'js') {\n                    fileContents = fs.readFileSync(\n                        join(this.$.env.paths.electronApp.meteorApp, file.path),\n                        'UTF-8'\n                    );\n                    result = this.injector.processFileContents(fileContents);\n\n                    ({ fileContents } = result);\n                    injectedStartupDidComplete =\n                        result.injectedStartupDidComplete ? true : injectedStartupDidComplete;\n                    injected = result.injected ? true : injected;\n\n                    fs.writeFileSync(\n                        join(this.$.env.paths.electronApp.meteorApp, file.path), fileContents\n                    );\n                }\n            });\n\n            if (!injected) {\n                this.log.error('error injecting isDesktop global var.');\n                process.exit(1);\n            }\n            if (!injectedStartupDidComplete) {\n                this.log.error('error injecting isDesktop for startupDidComplete');\n                process.exit(1);\n            }\n        } catch (e) {\n            this.log.error('error occurred while injecting isDesktop: ', e);\n            process.exit(1);\n        }\n        this.log.info('injected successfully');\n    }\n\n    /**\n     * Builds, modifies and copies the meteor app to electron app.\n     */\n    async build() {\n        this.log.info('checking for any mobile platform');\n        try {\n            await this.checkPreconditions();\n        } catch (e) {\n            this.log.error('error occurred during checking preconditions: ', e);\n            process.exit(1);\n        }\n\n        this.log.info('building meteor app');\n\n        if (!this.$.env.options.skipMobileBuild) {\n            try {\n                await this.buildMobileTarget();\n            } catch (reason) {\n                switch (reason) {\n                    case 'timeout':\n                        this.log.error(\n                            'timeout while building, log has been written to meteor.log'\n                        );\n                        break;\n                    case 'error':\n                        this.log.error(\n                            'build was terminated by meteor-desktop as some errors were reported to stderr, you ' +\n                            'should see it above, also check meteor.log for more info, to ignore it use the ' +\n                            '--ignore-stderr \"<string>\"'\n                        );\n                        break;\n                    case 'errorInApp':\n                        this.log.error(\n                            'your meteor app has errors - look into meteor.log for more' +\n                            ' info'\n                        );\n                        break;\n                    case 'port':\n                        this.log.error(\n                            'your port 3080 is currently used (you probably have this or other ' +\n                            'meteor project running?), use `-t` or `--meteor-port` to use ' +\n                            'different port while building'\n                        );\n                        break;\n                    case 'exit':\n                        this.log.error(\n                            'meteor cmd exited unexpectedly, log has been written to meteor.log'\n                        );\n                        break;\n                    case 'copy':\n                        this.log.error(\n                            'error encountered when copying the build'\n                        );\n                        break;\n                    default:\n                        this.log.error('error occurred during building mobile target', reason);\n                }\n                if (this.mobilePlatform) {\n                    await this.removeMobilePlatform(this.mobilePlatform);\n                }\n                process.exit(1);\n            }\n        } else {\n            this.indexHTMLstrategy = this.chooseStrategy();\n            try {\n                await this.copyBuild();\n            } catch (e) {\n                process.exit(1);\n            }\n        }\n\n        this.injectIsDesktop();\n\n        this.changeDdpUrl();\n\n        try {\n            await this.packToAsar();\n        } catch (e) {\n            this.log.error('error while packing meteor app to asar');\n            process.exit(1);\n        }\n\n        this.log.info('meteor build finished');\n\n        if (this.mobilePlatform) {\n            await this.removeMobilePlatform(this.mobilePlatform);\n        }\n    }\n\n    changeDdpUrl() {\n        if (this.$.env.options.ddpUrl !== null) {\n            try {\n                this.updateDdpUrl(this.$.env.paths.electronApp.meteorAppIndex);\n            } catch (e) {\n                this.log.error(`error while trying to change the ddp url: ${e.message}`);\n            }\n        }\n    }\n\n    packToAsar() {\n        this.log.info('packing meteor app to asar archive');\n        return new Promise((resolve, reject) =>\n            asar.createPackage(\n                this.$.env.paths.electronApp.meteorApp,\n                path.join(this.$.env.paths.electronApp.root, 'meteor.asar')\n            )\n                .then(() => {\n                    // On Windows some files might still be blocked. Giving a tick for them to be\n                    // ready for deletion.\n                    setImmediate(() => {\n                        this.log.verbose('clearing meteor app after packing');\n                        this.$.utils\n                            .rmWithRetries('-rf', this.$.env.paths.electronApp.meteorApp)\n                            .then(() => {\n                                resolve();\n                            })\n                            .catch((e) => {\n                                reject(e);\n                            });\n                    });\n                }));\n    }\n\n    /**\n     * Wrapper for spawning npm.\n     * @param {Array}  commands - commands for spawn\n     * @param {string} stdio\n     * @param {string} cwd\n     * @return {Promise}\n     */\n    runNpm(commands, stdio = 'ignore', cwd = this.$.env.paths.meteorApp.root) {\n        return new Promise((resolve, reject) => {\n            this.log.verbose(`executing meteor npm ${commands.join(' ')}`);\n\n            spawn('meteor', ['npm', ...commands], {\n                cwd,\n                stdio\n            }).on('exit', code => (\n                (code === 0) ? resolve() : reject(new Error(`npm exit code was ${code}`))\n            ));\n        });\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/meteorManager.js b/dist/meteorManager.js deleted file mode 100644 index 098723b3..00000000 --- a/dist/meteorManager.js +++ /dev/null @@ -1,147 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _fs = _interopRequireDefault(require("fs")); - -var _crossSpawn = _interopRequireDefault(require("cross-spawn")); - -var _log = _interopRequireDefault(require("./log")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars - -/** - * Utility class designed for managing Meteor packages. - * - * @property {MeteorDesktop} $ - * @class - */ -class MeteorManager { - /** - * @param {MeteorDesktop} $ - context - * @constructor - */ - constructor($) { - this.log = new _log.default('meteorManager'); - this.$ = $; - } - /** - * Looks for specified packages in .meteor/packages. In other words checks if the project has - * specified packages added. - * @param {Array} packages - * @returns {boolean} - */ - - - checkPackages(packages) { - const usedPackages = _fs.default.readFileSync(this.$.env.paths.meteorApp.packages, 'UTF-8').replace(/\r/gm, '').split('\n').filter(line => !line.trim().startsWith('#')); - - return !packages.some(packageToFind => !usedPackages.some(meteorPackage => ~meteorPackage.indexOf(packageToFind))); - } - /** - * Looks for specified packages in .meteor/packages. In other words checks if the project has - * specified packages added. - * @param {Array} packages - * @returns {boolean} - */ - - - checkPackagesVersion(packages) { - const usedPackages = _fs.default.readFileSync(this.$.env.paths.meteorApp.versions, 'UTF-8').replace(/\r/gm, '').split('\n'); - - return !packages.some(packageToFind => !usedPackages.some(meteorPackage => meteorPackage === packageToFind)); - } - /** - * Ensures certain packages are added to meteor project and in correct version. - * @param {Array} packages - * @param {Array} packagesWithVersion - * @param {string} who - name of the entity that requests presence of thos packages (can be the - * integration itself or a plugin) - * @returns {Promise.} - */ - - - async ensurePackages(packages, packagesWithVersion, who) { - if (!this.checkPackages(packages)) { - this.log.warn(`${who} requires some packages that are not added to project, will try to add them now`); - - try { - await this.addPackages(packages, packagesWithVersion); - } catch (e) { - throw new Error(e); - } - } - - if (!this.checkPackagesVersion(packagesWithVersion)) { - this.log.warn(`${who} required packages version is different, fixing it`); - - try { - await this.addPackages(packages, packagesWithVersion); - } catch (e) { - throw new Error(e); - } - } - } - /** - * Removes packages from the meteor app. - * @param {Array} packages - array with names of the packages to remove - */ - - - deletePackages(packages) { - this.log.warn('removing packages from meteor project', ...packages); - return new Promise((resolve, reject) => { - (0, _crossSpawn.default)('meteor', ['remove'].concat(packages), { - cwd: this.$.env.paths.meteorApp.root, - stdio: ['pipe', 'pipe', process.stderr], - env: Object.assign({ - METEOR_PRETTY_OUTPUT: 0, - METEOR_NO_RELEASE_CHECK: 1 - }, process.env) - }).on('exit', code => { - if (code !== 0 || this.checkPackages(packages)) { - reject('removing packages failed'); - } else { - resolve(); - } - }); - }); - } - /** - * Adds packages to the meteor app. - * @param {Array} packages - array with names of the packages to add - * @param {Array} packagesWithVersion - array with names and versions of the packages to add - */ - - - addPackages(packages, packagesWithVersion) { - this.log.info('adding packages to meteor project', ...packagesWithVersion); - return new Promise((resolve, reject) => { - (0, _crossSpawn.default)('meteor', ['add'].concat(packagesWithVersion.map(packageName => packageName.replace('@', '@='))), { - cwd: this.$.env.paths.meteorApp.root, - stdio: ['pipe', 'pipe', process.stderr], - env: Object.assign({ - METEOR_PRETTY_OUTPUT: 0, - METEOR_NO_RELEASE_CHECK: 1 - }, process.env) - }).on('exit', code => { - if (code !== 0 || !this.checkPackages(packages)) { - reject('adding packages failed'); - } else { - resolve(); - } - }); - }); - } - -} - -exports.default = MeteorManager; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["MeteorManager","constructor","$","log","Log","checkPackages","packages","usedPackages","fs","readFileSync","env","paths","meteorApp","replace","split","filter","line","trim","startsWith","some","packageToFind","meteorPackage","indexOf","checkPackagesVersion","versions","ensurePackages","packagesWithVersion","who","warn","addPackages","e","Error","deletePackages","Promise","resolve","reject","spawn","concat","cwd","root","stdio","process","stderr","Object","assign","METEOR_PRETTY_OUTPUT","METEOR_NO_RELEASE_CHECK","on","code","info","map","packageName"],"sources":["../lib/meteorManager.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport fs from 'fs';\nimport spawn from 'cross-spawn';\n\nimport Log from './log';\n\n/**\n * Utility class designed for managing Meteor packages.\n *\n * @property {MeteorDesktop} $\n * @class\n */\nexport default class MeteorManager {\n    /**\n     * @param {MeteorDesktop} $ - context\n     * @constructor\n     */\n    constructor($) {\n        this.log = new Log('meteorManager');\n        this.$ = $;\n    }\n\n    /**\n     * Looks for specified packages in .meteor/packages. In other words checks if the project has\n     * specified packages added.\n     * @param {Array} packages\n     * @returns {boolean}\n     */\n    checkPackages(packages) {\n        const usedPackages = fs\n            .readFileSync(this.$.env.paths.meteorApp.packages, 'UTF-8')\n            .replace(/\\r/gm, '')\n            .split('\\n')\n            .filter(line => !line.trim().startsWith('#'));\n        return !packages.some(\n            packageToFind =>\n                !usedPackages.some(meteorPackage => ~meteorPackage.indexOf(packageToFind))\n        );\n    }\n\n    /**\n     * Looks for specified packages in .meteor/packages. In other words checks if the project has\n     * specified packages added.\n     * @param {Array} packages\n     * @returns {boolean}\n     */\n    checkPackagesVersion(packages) {\n        const usedPackages = fs.readFileSync(this.$.env.paths.meteorApp.versions, 'UTF-8')\n            .replace(/\\r/gm, '')\n            .split('\\n');\n        return !packages.some(\n            packageToFind => !usedPackages.some(meteorPackage => meteorPackage === packageToFind)\n        );\n    }\n\n    /**\n     * Ensures certain packages are added to meteor project and in correct version.\n     * @param {Array} packages\n     * @param {Array} packagesWithVersion\n     * @param {string} who - name of the entity that requests presence of thos packages (can be the\n     *                       integration itself or a plugin)\n     * @returns {Promise.<void>}\n     */\n    async ensurePackages(packages, packagesWithVersion, who) {\n        if (!this.checkPackages(packages)) {\n            this.log.warn(`${who} requires some packages that are not added to project, will try to add them now`);\n            try {\n                await this.addPackages(packages, packagesWithVersion);\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n        if (!this.checkPackagesVersion(packagesWithVersion)) {\n            this.log.warn(`${who} required packages version is different, fixing it`);\n            try {\n                await this.addPackages(packages, packagesWithVersion);\n            } catch (e) {\n                throw new Error(e);\n            }\n        }\n    }\n\n    /**\n     * Removes packages from the meteor app.\n     * @param {Array} packages            - array with names of the packages to remove\n     */\n    deletePackages(packages) {\n        this.log.warn('removing packages from meteor project', ...packages);\n        return new Promise((resolve, reject) => {\n            spawn(\n                'meteor',\n                ['remove'].concat(packages), {\n                    cwd: this.$.env.paths.meteorApp.root,\n                    stdio: ['pipe', 'pipe', process.stderr],\n                    env: Object.assign(\n                        { METEOR_PRETTY_OUTPUT: 0, METEOR_NO_RELEASE_CHECK: 1 }, process.env\n                    )\n                }\n            ).on('exit', (code) => {\n                if (code !== 0 || this.checkPackages(packages)) {\n                    reject('removing packages failed');\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n\n    /**\n     * Adds packages to the meteor app.\n     * @param {Array} packages            - array with names of the packages to add\n     * @param {Array} packagesWithVersion - array with names and versions of the packages to add\n     */\n    addPackages(packages, packagesWithVersion) {\n        this.log.info('adding packages to meteor project', ...packagesWithVersion);\n        return new Promise((resolve, reject) => {\n            spawn(\n                'meteor',\n                ['add'].concat(\n                    packagesWithVersion.map(packageName => packageName.replace('@', '@='))\n                ),\n                {\n                    cwd: this.$.env.paths.meteorApp.root,\n                    stdio: ['pipe', 'pipe', process.stderr],\n                    env: Object.assign(\n                        { METEOR_PRETTY_OUTPUT: 0, METEOR_NO_RELEASE_CHECK: 1 }, process.env\n                    )\n                }\n            ).on('exit', (code) => {\n                if (code !== 0 || !this.checkPackages(packages)) {\n                    reject('adding packages failed');\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/packager.js b/dist/packager.js deleted file mode 100644 index 5dc2f01f..00000000 --- a/dist/packager.js +++ /dev/null @@ -1,142 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; - -var _runtime = _interopRequireDefault(require("regenerator-runtime/runtime")); - -var _assignIn = _interopRequireDefault(require("lodash/assignIn")); - -var _path = _interopRequireDefault(require("path")); - -var _fs = _interopRequireDefault(require("fs")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -var _log = _interopRequireDefault(require("./log")); - -var _defaultDependencies = _interopRequireDefault(require("./defaultDependencies")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// eslint-disable-next-line no-unused-vars -const { - join -} = _path.default; -/** - * Wrapper around electron-packager. - * @class - */ - -class ElectronPackager { - constructor($) { - this.log = new _log.default('electron-packager'); - this.$ = $; - } - - async init() { - this.packager = (await this.$.getDependency('electron-packager', _defaultDependencies.default['electron-packager'])).dependency; - } - /** - * Runs the packager with provided arguments. - * - * @param {Object} args - * @returns {Promise} - */ - - - runPackager(args) { - return new Promise((resolve, reject) => { - this.packager(args, err => { - if (err) { - reject(err); - } else { - this.log.info(`wrote packaged app to ${this.$.env.paths.packageDir}`); - resolve(); - } - }); - }); - } - - async packageApp() { - const { - version - } = JSON.parse(_fs.default.readFileSync(join(this.$.env.paths.meteorApp.root, 'node_modules', 'electron', 'package.json'), 'UTF-8')); - const settings = this.$.desktop.getSettings(); - const { - name - } = settings; - - if (!name) { - this.log.error('`name` field in settings.json not set'); - process.exit(1); - } - - const arch = this.$.env.options.ia32 ? 'ia32' : 'x64'; - this.log.info(`packaging '${name}' for platform '${this.$.env.sys.platform}-${arch}'` + ` using electron v${version}`); - - try { - await this.$.utils.rmWithRetries('-rf', _path.default.join(this.$.env.options.output, this.$.env.paths.packageDir)); - } catch (e) { - throw new Error(e); - } - - const args = { - name, - arch, - prune: false, - electronVersion: version, - platform: this.$.env.sys.platform, - dir: this.$.env.paths.electronApp.root, - out: _path.default.join(this.$.env.options.output, this.$.env.paths.packageDir) - }; - - if ('packagerOptions' in settings) { - const { - packagerOptions - } = settings; - ['windows', 'linux', 'osx'].forEach(system => { - if (this.$.env.os[`is${system[0].toUpperCase()}${system.substring(1)}`] && `_${system}` in packagerOptions) { - (0, _assignIn.default)(packagerOptions, packagerOptions[`_${system}`]); - } - }); - Object.keys(packagerOptions).forEach(field => { - if (packagerOptions[field] === '@version') { - packagerOptions[field] = settings.version; - } - }); - (0, _assignIn.default)(args, packagerOptions); - } // Move node_modules away. We do not want to delete it, just temporarily remove it from - // our way. - - - _fs.default.renameSync(this.$.env.paths.electronApp.nodeModules, this.$.env.paths.electronApp.tmpNodeModules); - - let extracted = false; - - if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) { - _fs.default.renameSync(this.$.env.paths.electronApp.extractedNodeModules, this.$.env.paths.electronApp.nodeModules); - - extracted = true; - } - - try { - await this.runPackager(args); - } finally { - if (extracted) { - _shelljs.default.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules); - - _shelljs.default.rm('-rf', this.$.env.paths.electronApp.nodeModules); - } // Move node_modules back. - - - _fs.default.renameSync(this.$.env.paths.electronApp.tmpNodeModules, this.$.env.paths.electronApp.nodeModules); - } - } - -} - -exports.default = ElectronPackager; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["join","path","ElectronPackager","constructor","$","log","Log","init","packager","getDependency","defaultDependencies","dependency","runPackager","args","Promise","resolve","reject","err","info","env","paths","packageDir","packageApp","version","JSON","parse","fs","readFileSync","meteorApp","root","settings","desktop","getSettings","name","error","process","exit","arch","options","ia32","sys","platform","utils","rmWithRetries","output","e","Error","prune","electronVersion","dir","electronApp","out","packagerOptions","forEach","system","os","toUpperCase","substring","assignIn","Object","keys","field","renameSync","nodeModules","tmpNodeModules","extracted","exists","extractedNodeModules","shell","rm"],"sources":["../lib/packager.js"],"sourcesContent":["// eslint-disable-next-line no-unused-vars\nimport regeneratorRuntime from 'regenerator-runtime/runtime';\nimport assignIn from 'lodash/assignIn';\nimport path from 'path';\nimport fs from 'fs';\nimport shell from 'shelljs';\n\nimport Log from './log';\nimport defaultDependencies from './defaultDependencies';\n\nconst { join } = path;\n\n/**\n * Wrapper around electron-packager.\n * @class\n */\nexport default class ElectronPackager {\n    constructor($) {\n        this.log = new Log('electron-packager');\n        this.$ = $;\n    }\n\n    async init() {\n        this.packager = (await this.$.getDependency('electron-packager', defaultDependencies['electron-packager'])).dependency;\n    }\n\n    /**\n     * Runs the packager with provided arguments.\n     *\n     * @param {Object} args\n     * @returns {Promise}\n     */\n    runPackager(args) {\n        return new Promise((resolve, reject) => {\n            this.packager(args, (err) => {\n                if (err) {\n                    reject(err);\n                } else {\n                    this.log.info(`wrote packaged app to ${this.$.env.paths.packageDir}`);\n                    resolve();\n                }\n            });\n        });\n    }\n\n    async packageApp() {\n        const { version } = JSON.parse(fs.readFileSync(\n            join(\n                this.$.env.paths.meteorApp.root,\n                'node_modules',\n                'electron',\n                'package.json'\n            ), 'UTF-8'\n        ));\n\n        const settings = this.$.desktop.getSettings();\n        const { name } = settings;\n        if (!name) {\n            this.log.error('`name` field in settings.json not set');\n            process.exit(1);\n        }\n\n        const arch = this.$.env.options.ia32 ? 'ia32' : 'x64';\n\n        this.log.info(\n            `packaging '${name}' for platform '${this.$.env.sys.platform}-${arch}'` +\n            ` using electron v${version}`\n        );\n\n        try {\n            await this.$.utils.rmWithRetries(\n                '-rf', path.join(this.$.env.options.output, this.$.env.paths.packageDir)\n            );\n        } catch (e) {\n            throw new Error(e);\n        }\n\n        const args = {\n            name,\n            arch,\n            prune: false,\n            electronVersion: version,\n            platform: this.$.env.sys.platform,\n            dir: this.$.env.paths.electronApp.root,\n            out: path.join(this.$.env.options.output, this.$.env.paths.packageDir)\n        };\n\n        if ('packagerOptions' in settings) {\n            const { packagerOptions } = settings;\n\n            ['windows', 'linux', 'osx'].forEach((system) => {\n                if (\n                    this.$.env.os[`is${system[0].toUpperCase()}${system.substring(1)}`] &&\n                    (`_${system}`) in packagerOptions\n                ) {\n                    assignIn(packagerOptions, packagerOptions[`_${system}`]);\n                }\n            });\n\n            Object.keys(packagerOptions).forEach((field) => {\n                if (packagerOptions[field] === '@version') {\n                    packagerOptions[field] = settings.version;\n                }\n            });\n\n            assignIn(args, packagerOptions);\n        }\n\n        // Move node_modules away. We do not want to delete it, just temporarily remove it from\n        // our way.\n        fs.renameSync(\n            this.$.env.paths.electronApp.nodeModules,\n            this.$.env.paths.electronApp.tmpNodeModules\n        );\n\n        let extracted = false;\n\n        if (this.$.utils.exists(this.$.env.paths.electronApp.extractedNodeModules)) {\n            fs.renameSync(\n                this.$.env.paths.electronApp.extractedNodeModules,\n                this.$.env.paths.electronApp.nodeModules\n            );\n            extracted = true;\n        }\n\n        try {\n            await this.runPackager(args);\n        } finally {\n            if (extracted) {\n                shell.rm('-rf', this.$.env.paths.electronApp.extractedNodeModules);\n                shell.rm('-rf', this.$.env.paths.electronApp.nodeModules);\n            }\n            // Move node_modules back.\n            fs.renameSync(\n                this.$.env.paths.electronApp.tmpNodeModules,\n                this.$.env.paths.electronApp.nodeModules\n            );\n        }\n    }\n}\n"],"mappings":"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"} \ No newline at end of file diff --git a/dist/scripts/addToScripts.js b/dist/scripts/addToScripts.js deleted file mode 100644 index aa8d2507..00000000 --- a/dist/scripts/addToScripts.js +++ /dev/null @@ -1,24 +0,0 @@ -"use strict"; - -var _path = _interopRequireDefault(require("path")); - -var _addScript = _interopRequireDefault(require("./utils/addScript")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/* eslint-disable no-console */ - -/** - * This script adds a 'desktop' entry to 'scripts' in package.json. If the entry already exists - * it leaves it untouched. - */ -function fail() { - console.error('[meteor-desktop] failed to add meteor-desktop to your package.json scripts, ' + 'please add it manually as \'desktop\': \'meteor-desktop\''); - process.exit(0); -} - -const packageJsonPath = _path.default.resolve(_path.default.join(__dirname, '..', '..', '..', '..', 'package.json')); - -(0, _addScript.default)('desktop', 'meteor-desktop', packageJsonPath, fail); -console.log('[meteor-desktop] successfully added a \'desktop\' entry to your package.json' + ' scripts section.'); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmYWlsIiwiY29uc29sZSIsImVycm9yIiwicHJvY2VzcyIsImV4aXQiLCJwYWNrYWdlSnNvblBhdGgiLCJwYXRoIiwicmVzb2x2ZSIsImpvaW4iLCJfX2Rpcm5hbWUiLCJhZGRTY3JpcHQiLCJsb2ciXSwic291cmNlcyI6WyIuLi8uLi9saWIvc2NyaXB0cy9hZGRUb1NjcmlwdHMuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgbm8tY29uc29sZSAqL1xuaW1wb3J0IHBhdGggZnJvbSAncGF0aCc7XG5cbmltcG9ydCBhZGRTY3JpcHQgZnJvbSAnLi91dGlscy9hZGRTY3JpcHQnO1xuLyoqXG4gKiBUaGlzIHNjcmlwdCBhZGRzIGEgJ2Rlc2t0b3AnIGVudHJ5IHRvICdzY3JpcHRzJyBpbiBwYWNrYWdlLmpzb24uIElmIHRoZSBlbnRyeSBhbHJlYWR5IGV4aXN0c1xuICogaXQgbGVhdmVzIGl0IHVudG91Y2hlZC5cbiAqL1xuZnVuY3Rpb24gZmFpbCgpIHtcbiAgICBjb25zb2xlLmVycm9yKCdbbWV0ZW9yLWRlc2t0b3BdIGZhaWxlZCB0byBhZGQgbWV0ZW9yLWRlc2t0b3AgdG8geW91ciBwYWNrYWdlLmpzb24gc2NyaXB0cywgJyArXG4gICAgICAgICdwbGVhc2UgYWRkIGl0IG1hbnVhbGx5IGFzIFxcJ2Rlc2t0b3BcXCc6IFxcJ21ldGVvci1kZXNrdG9wXFwnJyk7XG4gICAgcHJvY2Vzcy5leGl0KDApO1xufVxuXG5jb25zdCBwYWNrYWdlSnNvblBhdGggPSBwYXRoLnJlc29sdmUoXG4gICAgcGF0aC5qb2luKF9fZGlybmFtZSwgJy4uJywgJy4uJywgJy4uJywgJy4uJywgJ3BhY2thZ2UuanNvbicpXG4pO1xuXG5hZGRTY3JpcHQoJ2Rlc2t0b3AnLCAnbWV0ZW9yLWRlc2t0b3AnLCBwYWNrYWdlSnNvblBhdGgsIGZhaWwpO1xuXG5jb25zb2xlLmxvZygnW21ldGVvci1kZXNrdG9wXSBzdWNjZXNzZnVsbHkgYWRkZWQgYSBcXCdkZXNrdG9wXFwnIGVudHJ5IHRvIHlvdXIgcGFja2FnZS5qc29uJyArXG4gICAgJyBzY3JpcHRzIHNlY3Rpb24uJyk7XG4iXSwibWFwcGluZ3MiOiI7O0FBQ0E7O0FBRUE7Ozs7QUFIQTs7QUFJQTtBQUNBO0FBQ0E7QUFDQTtBQUNBLFNBQVNBLElBQVQsR0FBZ0I7RUFDWkMsT0FBTyxDQUFDQyxLQUFSLENBQWMsaUZBQ1YsMkRBREo7RUFFQUMsT0FBTyxDQUFDQyxJQUFSLENBQWEsQ0FBYjtBQUNIOztBQUVELE1BQU1DLGVBQWUsR0FBR0MsYUFBQSxDQUFLQyxPQUFMLENBQ3BCRCxhQUFBLENBQUtFLElBQUwsQ0FBVUMsU0FBVixFQUFxQixJQUFyQixFQUEyQixJQUEzQixFQUFpQyxJQUFqQyxFQUF1QyxJQUF2QyxFQUE2QyxjQUE3QyxDQURvQixDQUF4Qjs7QUFJQSxJQUFBQyxrQkFBQSxFQUFVLFNBQVYsRUFBcUIsZ0JBQXJCLEVBQXVDTCxlQUF2QyxFQUF3REwsSUFBeEQ7QUFFQUMsT0FBTyxDQUFDVSxHQUFSLENBQVksaUZBQ1IsbUJBREoifQ== \ No newline at end of file diff --git a/dist/scripts/propagateVersion.js b/dist/scripts/propagateVersion.js deleted file mode 100644 index eb548ed1..00000000 --- a/dist/scripts/propagateVersion.js +++ /dev/null @@ -1,21 +0,0 @@ -"use strict"; - -// This propagates the version from package.json to Meteor plugins. -const { - version -} = require('../../package.json'); - -const fs = require('fs'); - -const paths = ['./plugins/bundler/package.js', './plugins/watcher/package.js']; -paths.forEach(path => { - let packageJs = fs.readFileSync(path, 'UTF-8'); - packageJs = packageJs.replace(/(version: ')([^']+)'/, `$1${version}'`); - - if (~path.indexOf('watcher')) { - packageJs = packageJs.replace(/(communitypackages:meteor-desktop-bundler@)([^']+)'/, `$1${version}'`); - } - - fs.writeFileSync(path, packageJs); -}); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJ2ZXJzaW9uIiwicmVxdWlyZSIsImZzIiwicGF0aHMiLCJmb3JFYWNoIiwicGF0aCIsInBhY2thZ2VKcyIsInJlYWRGaWxlU3luYyIsInJlcGxhY2UiLCJpbmRleE9mIiwid3JpdGVGaWxlU3luYyJdLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9zY3JpcHRzL3Byb3BhZ2F0ZVZlcnNpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gVGhpcyBwcm9wYWdhdGVzIHRoZSB2ZXJzaW9uIGZyb20gcGFja2FnZS5qc29uIHRvIE1ldGVvciBwbHVnaW5zLlxuXG5jb25zdCB7IHZlcnNpb24gfSA9IHJlcXVpcmUoJy4uLy4uL3BhY2thZ2UuanNvbicpO1xuY29uc3QgZnMgPSByZXF1aXJlKCdmcycpO1xuXG5jb25zdCBwYXRocyA9IFsnLi9wbHVnaW5zL2J1bmRsZXIvcGFja2FnZS5qcycsICcuL3BsdWdpbnMvd2F0Y2hlci9wYWNrYWdlLmpzJ107XG5wYXRocy5mb3JFYWNoKChwYXRoKSA9PiB7XG4gICAgbGV0IHBhY2thZ2VKcyA9IGZzLnJlYWRGaWxlU3luYyhwYXRoLCAnVVRGLTgnKTtcbiAgICBwYWNrYWdlSnMgPSBwYWNrYWdlSnMucmVwbGFjZSgvKHZlcnNpb246ICcpKFteJ10rKScvLCBgJDEke3ZlcnNpb259J2ApO1xuICAgIGlmICh+cGF0aC5pbmRleE9mKCd3YXRjaGVyJykpIHtcbiAgICAgICAgcGFja2FnZUpzID0gcGFja2FnZUpzLnJlcGxhY2UoLyhjb21tdW5pdHlwYWNrYWdlczptZXRlb3ItZGVza3RvcC1idW5kbGVyQCkoW14nXSspJy8sIGAkMSR7dmVyc2lvbn0nYCk7XG4gICAgfVxuICAgIGZzLndyaXRlRmlsZVN5bmMocGF0aCwgcGFja2FnZUpzKTtcbn0pO1xuIl0sIm1hcHBpbmdzIjoiOztBQUFBO0FBRUEsTUFBTTtFQUFFQTtBQUFGLElBQWNDLE9BQU8sQ0FBQyxvQkFBRCxDQUEzQjs7QUFDQSxNQUFNQyxFQUFFLEdBQUdELE9BQU8sQ0FBQyxJQUFELENBQWxCOztBQUVBLE1BQU1FLEtBQUssR0FBRyxDQUFDLDhCQUFELEVBQWlDLDhCQUFqQyxDQUFkO0FBQ0FBLEtBQUssQ0FBQ0MsT0FBTixDQUFlQyxJQUFELElBQVU7RUFDcEIsSUFBSUMsU0FBUyxHQUFHSixFQUFFLENBQUNLLFlBQUgsQ0FBZ0JGLElBQWhCLEVBQXNCLE9BQXRCLENBQWhCO0VBQ0FDLFNBQVMsR0FBR0EsU0FBUyxDQUFDRSxPQUFWLENBQWtCLHNCQUFsQixFQUEyQyxLQUFJUixPQUFRLEdBQXZELENBQVo7O0VBQ0EsSUFBSSxDQUFDSyxJQUFJLENBQUNJLE9BQUwsQ0FBYSxTQUFiLENBQUwsRUFBOEI7SUFDMUJILFNBQVMsR0FBR0EsU0FBUyxDQUFDRSxPQUFWLENBQWtCLHFEQUFsQixFQUEwRSxLQUFJUixPQUFRLEdBQXRGLENBQVo7RUFDSDs7RUFDREUsRUFBRSxDQUFDUSxhQUFILENBQWlCTCxJQUFqQixFQUF1QkMsU0FBdkI7QUFDSCxDQVBEIn0= \ No newline at end of file diff --git a/dist/scripts/utils/addScript.js b/dist/scripts/utils/addScript.js deleted file mode 100644 index 3e6b47e5..00000000 --- a/dist/scripts/utils/addScript.js +++ /dev/null @@ -1,50 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = addScript; - -var _fs = _interopRequireDefault(require("fs")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function readJsonFile(jsonFilePath) { - try { - return JSON.parse(_fs.default.readFileSync(jsonFilePath, 'UTF-8')); - } catch (e) { - return false; - } -} - -function writeJsonFile(jsonFilePath, jsonContents) { - try { - _fs.default.writeFileSync(jsonFilePath, JSON.stringify(jsonContents, null, 2)); - } catch (e) { - return false; - } - - return true; -} - -function addScript(name, script, packageJsonPath, fail) { - const packageJson = readJsonFile(packageJsonPath); - - if (!(packageJson && packageJson.name)) { - fail(); - return; - } - - if (!('scripts' in packageJson)) { - packageJson.scripts = {}; - } - - if (!(name in packageJson.scripts)) { - packageJson.scripts[name] = script; - } - - if (!writeJsonFile(packageJsonPath, packageJson)) { - fail(); - } -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/dist/skeletonDependencies.js b/dist/skeletonDependencies.js deleted file mode 100644 index 31e6e13d..00000000 --- a/dist/skeletonDependencies.js +++ /dev/null @@ -1,24 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.default = void 0; -var _default = { - connect: '3.6.6', - 'server-destroy': '1.0.1', - winston: '2.3.0', - 'find-port': '2.0.1', - rimraf: '2.6.2', - shelljs: '0.7.5', - lodash: '4.17.15', - request: '2.88.0', - queue: '4.0.1', - reify: '0.17.3', - send: '0.16.2', - mime: '2.0.3', - 'fs-extra': '3.0.1', - 'fs-plus': '2.9.3' -}; -exports.default = _default; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjb25uZWN0Iiwid2luc3RvbiIsInJpbXJhZiIsInNoZWxsanMiLCJsb2Rhc2giLCJyZXF1ZXN0IiwicXVldWUiLCJyZWlmeSIsInNlbmQiLCJtaW1lIl0sInNvdXJjZXMiOlsiLi4vbGliL3NrZWxldG9uRGVwZW5kZW5jaWVzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IHtcbiAgICBjb25uZWN0OiAnMy42LjYnLFxuICAgICdzZXJ2ZXItZGVzdHJveSc6ICcxLjAuMScsXG4gICAgd2luc3RvbjogJzIuMy4wJyxcbiAgICAnZmluZC1wb3J0JzogJzIuMC4xJyxcbiAgICByaW1yYWY6ICcyLjYuMicsXG4gICAgc2hlbGxqczogJzAuNy41JyxcbiAgICBsb2Rhc2g6ICc0LjE3LjE1JyxcbiAgICByZXF1ZXN0OiAnMi44OC4wJyxcbiAgICBxdWV1ZTogJzQuMC4xJyxcbiAgICByZWlmeTogJzAuMTcuMycsXG4gICAgc2VuZDogJzAuMTYuMicsXG4gICAgbWltZTogJzIuMC4zJyxcbiAgICAnZnMtZXh0cmEnOiAnMy4wLjEnLFxuICAgICdmcy1wbHVzJzogJzIuOS4zJ1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O2VBQWU7RUFDWEEsT0FBTyxFQUFFLE9BREU7RUFFWCxrQkFBa0IsT0FGUDtFQUdYQyxPQUFPLEVBQUUsT0FIRTtFQUlYLGFBQWEsT0FKRjtFQUtYQyxNQUFNLEVBQUUsT0FMRztFQU1YQyxPQUFPLEVBQUUsT0FORTtFQU9YQyxNQUFNLEVBQUUsU0FQRztFQVFYQyxPQUFPLEVBQUUsUUFSRTtFQVNYQyxLQUFLLEVBQUUsT0FUSTtFQVVYQyxLQUFLLEVBQUUsUUFWSTtFQVdYQyxJQUFJLEVBQUUsUUFYSztFQVlYQyxJQUFJLEVBQUUsT0FaSztFQWFYLFlBQVksT0FiRDtFQWNYLFdBQVc7QUFkQSxDIn0= \ No newline at end of file diff --git a/dist/utils.js b/dist/utils.js deleted file mode 100644 index f931f672..00000000 --- a/dist/utils.js +++ /dev/null @@ -1,328 +0,0 @@ -"use strict"; - -Object.defineProperty(exports, "__esModule", { - value: true -}); -exports.computeHashForHashesSet = computeHashForHashesSet; -exports.default = void 0; -exports.exists = exists; -exports.getFileList = getFileList; -exports.readAndGetFileHash = readAndGetFileHash; -exports.readAndHashFiles = readAndHashFiles; -exports.readDir = readDir; -exports.readFilesAndComputeHash = readFilesAndComputeHash; -exports.rmWithRetries = rmWithRetries; -exports.symlinkExists = symlinkExists; - -var _path = _interopRequireDefault(require("path")); - -var _fs = _interopRequireDefault(require("fs")); - -var _crypto = _interopRequireDefault(require("crypto")); - -var _shelljs = _interopRequireDefault(require("shelljs")); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/* eslint-disable consistent-return */ - -/** - * Exists - * @param {string} pathToCheck - * @returns {boolean} - */ -function exists(pathToCheck) { - try { - _fs.default.accessSync(pathToCheck); - - return true; - } catch (e) { - return false; - } -} -/** - * Simple wrapper for shelljs.rm with additional retries in case of failure. - * It is useful when something is concurrently reading the dir you want to remove. - */ - - -function rmWithRetries(...args) { - let retries = 0; - return new Promise((resolve, reject) => { - function rm(...rmArgs) { - try { - _shelljs.default.config.fatal = true; - - _shelljs.default.rm(...rmArgs); - - _shelljs.default.config.reset(); - - resolve(); - } catch (e) { - retries += 1; - - if (retries < 5) { - setTimeout(() => { - rm(...rmArgs); - }, 100); - } else { - _shelljs.default.config.reset(); - - reject(e); - } - } - } - - rm(...args); - }); -} - -function readDir(dir, callback) { - if (!callback) { - return new Promise((resolve, reject) => { - readDir(dir, (err, data, stats) => { - if (err) { - reject(err); - } else { - resolve({ - data, - stats - }); - } - }); - }); - } - - let list = []; - let allStats = {}; - - _fs.default.readdir(dir, (err, files) => { - if (err) { - return callback(err); - } - - let pending = files.length; - - if (!pending) { - return callback(null, list, allStats); - } - - files.forEach(file => { - const filePath = _path.default.join(dir, file); - - _fs.default.stat(filePath, (_err, stats) => { - if (_err) { - return callback(_err); - } - - if (stats.isDirectory()) { - readDir(filePath, (__err, res, _allStats) => { - if (__err) { - return callback(__err); - } - - list = list.concat(res); - allStats = Object.assign(allStats, _allStats); - pending -= 1; - - if (!pending) { - return callback(null, list, allStats); - } - }); - } else { - list.push(filePath); - allStats[filePath] = { - size: stats.size, - dates: [stats.birthtime.getTime(), stats.ctime.getTime(), stats.mtime.getTime()] - }; - pending -= 1; - - if (!pending) { - return callback(null, list, allStats); - } - } - }); - }); - }); -} -/** - * Returns a file list from a directory. - * @param {string} dir - dir path - * @param {boolean} sort - whether to apply sort - * @returns {Promise} - */ - - -function getFileList(dir, sort = false) { - return new Promise((resolve, reject) => { - readDir(dir, (error, files) => { - if (error) { - reject(error); - return; - } // eslint-disable-next-line no-param-reassign - - - let resultantFilesList; - - if (sort) { - const stripLength = dir.substr(0, 2) === './' ? dir.length - 1 : dir.length + 1; - let pathsUnified = files.map(pth => pth.substr(stripLength).replace(/[\\/]/gm, '-')); - const temporaryIndex = {}; - files.forEach((file, i) => { - temporaryIndex[pathsUnified[i]] = file; - }); - pathsUnified = pathsUnified.sort(); - const filesSorted = []; - pathsUnified.forEach(key => { - filesSorted.push(temporaryIndex[key]); - }); - resultantFilesList = filesSorted; - } else { - resultantFilesList = files; - } - - resolve(resultantFilesList); - }); - }); -} -/** - * Returns file's hash. - * @param {string} file - file path - * @param {boolean} returnFileContents - include file contents in the resultant object - * @returns {Promise} - */ - - -function readAndGetFileHash(file, returnFileContents = false) { - return new Promise((resolve, reject) => { - _fs.default.readFile(file, (err, data) => { - if (err) { - reject(err); - return; - } - - const hash = _crypto.default.createHash('sha1'); - - hash.update(data); - const returnObject = { - hash: hash.digest('hex') - }; - - if (returnFileContents) { - returnObject.contents = data.toString('utf8'); - } - - resolve(returnObject); - }); - }); -} -/** - * Calculates a hash from objects values in specified order. - * @param {Array} orderOfKeys - * @param {Object} hashSet - * @param {Function} keyFilter - * @returns {string} - */ - - -function computeHashForHashesSet(orderOfKeys, hashSet, keyFilter = key => key) { - const hash = _crypto.default.createHash('sha1'); - - const hashesJoined = orderOfKeys.reduce( // eslint-disable-next-line no-param-reassign,no-return-assign - (tmpHash, key) => (tmpHash += hashSet[keyFilter(key)], tmpHash), ''); - hash.update(hashesJoined); - return hash.digest('hex'); -} -/** - * Reads files from disk and computes hashes for them. - * @param {Array} files - array with file paths - * @returns {Promise} - */ - - -function readAndHashFiles(files, fileFilter) { - const fileHashes = {}; - const fileContents = {}; - const promises = []; - - function readSingleFile(file) { - return new Promise((resolve, reject) => { - readAndGetFileHash(file, file.endsWith('.js') && !file.endsWith('.test.js')).then(result => { - let fileName = file; - - if (fileFilter) { - fileName = fileFilter(fileName); - } - - fileHashes[fileName] = result.hash; - - if (result.contents) { - fileContents[fileName] = result.contents; - } - - resolve(); - }).catch(reject); - }); - } - - files.forEach(file => { - promises.push(readSingleFile(file)); - }); - return new Promise((resolve, reject) => { - Promise.all(promises).then(() => { - resolve({ - files, - fileContents, - fileHashes - }); - }).catch(reject); - }); -} -/** - * Reads files from .desktop and computes a version hash. - * - * @param {string} dir - path - * @param {Function} fileFilter - * @returns {Promise} - */ - - -function readFilesAndComputeHash(dir, fileFilter) { - return new Promise((resolve, reject) => { - getFileList(dir, true).catch(reject).then(files => readAndHashFiles(files, fileFilter)).catch(reject).then(result => { - // eslint-disable-next-line no-param-reassign - result.hash = computeHashForHashesSet(result.files, result.fileHashes, fileFilter); - resolve(result); - }); - }); -} -/** - * Symlink exists - * @param {string} pathToCheck - * @returns {boolean} - */ - - -function symlinkExists(pathToCheck) { - try { - _fs.default.readlinkSync(pathToCheck); - - return true; - } catch (e) { - return false; - } -} - -var _default = { - getFileList, - rmWithRetries, - exists, - readDir, - readAndGetFileHash, - computeHashForHashesSet, - readAndHashFiles, - readFilesAndComputeHash, - symlinkExists -}; -exports.default = _default; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["exists","pathToCheck","fs","accessSync","e","rmWithRetries","args","retries","Promise","resolve","reject","rm","rmArgs","shell","config","fatal","reset","setTimeout","readDir","dir","callback","err","data","stats","list","allStats","readdir","files","pending","length","forEach","file","filePath","path","join","stat","_err","isDirectory","__err","res","_allStats","concat","Object","assign","push","size","dates","birthtime","getTime","ctime","mtime","getFileList","sort","error","resultantFilesList","stripLength","substr","pathsUnified","map","pth","replace","temporaryIndex","i","filesSorted","key","readAndGetFileHash","returnFileContents","readFile","hash","crypto","createHash","update","returnObject","digest","contents","toString","computeHashForHashesSet","orderOfKeys","hashSet","keyFilter","hashesJoined","reduce","tmpHash","readAndHashFiles","fileFilter","fileHashes","fileContents","promises","readSingleFile","endsWith","then","result","fileName","catch","all","readFilesAndComputeHash","symlinkExists","readlinkSync"],"sources":["../lib/utils.js"],"sourcesContent":["/* eslint-disable consistent-return */\nimport path from 'path';\nimport fs from 'fs';\nimport crypto from 'crypto';\nimport shell from 'shelljs';\n\n/**\n * Exists\n * @param {string} pathToCheck\n * @returns {boolean}\n */\nexport function exists(pathToCheck) {\n    try {\n        fs.accessSync(pathToCheck);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\n/**\n * Simple wrapper for shelljs.rm with additional retries in case of failure.\n * It is useful when something is concurrently reading the dir you want to remove.\n */\nexport function rmWithRetries(...args) {\n    let retries = 0;\n    return new Promise((resolve, reject) => {\n        function rm(...rmArgs) {\n            try {\n                shell.config.fatal = true;\n                shell.rm(...rmArgs);\n                shell.config.reset();\n                resolve();\n            } catch (e) {\n                retries += 1;\n                if (retries < 5) {\n                    setTimeout(() => {\n                        rm(...rmArgs);\n                    }, 100);\n                } else {\n                    shell.config.reset();\n                    reject(e);\n                }\n            }\n        }\n        rm(...args);\n    });\n}\n\nexport function readDir(dir, callback) {\n    if (!callback) {\n        return new Promise((resolve, reject) => {\n            readDir(dir, (err, data, stats) => {\n                if (err) {\n                    reject(err);\n                } else {\n                    resolve({ data, stats });\n                }\n            });\n        });\n    }\n    let list = [];\n    let allStats = {};\n\n    fs.readdir(dir, (err, files) => {\n        if (err) {\n            return callback(err);\n        }\n        let pending = files.length;\n        if (!pending) {\n            return callback(null, list, allStats);\n        }\n        files.forEach((file) => {\n            const filePath = path.join(dir, file);\n            fs.stat(filePath, (_err, stats) => {\n                if (_err) {\n                    return callback(_err);\n                }\n                if (stats.isDirectory()) {\n                    readDir(filePath, (__err, res, _allStats) => {\n                        if (__err) {\n                            return callback(__err);\n                        }\n                        list = list.concat(res);\n                        allStats = Object.assign(allStats, _allStats);\n                        pending -= 1;\n                        if (!pending) {\n                            return callback(null, list, allStats);\n                        }\n                    });\n                } else {\n                    list.push(filePath);\n                    allStats[filePath] = {\n                        size: stats.size,\n                        dates: [\n                            stats.birthtime.getTime(),\n                            stats.ctime.getTime(),\n                            stats.mtime.getTime()\n                        ]\n                    };\n                    pending -= 1;\n                    if (!pending) {\n                        return callback(null, list, allStats);\n                    }\n                }\n            });\n        });\n    });\n}\n\n/**\n * Returns a file list from a directory.\n * @param {string} dir - dir path\n * @param {boolean} sort - whether to apply sort\n * @returns {Promise<Array>}\n */\nexport function getFileList(dir, sort = false) {\n    return new Promise((resolve, reject) => {\n        readDir(dir, (error, files) => {\n            if (error) {\n                reject(error);\n                return;\n            }\n            // eslint-disable-next-line no-param-reassign\n            let resultantFilesList;\n\n            if (sort) {\n                const stripLength = (dir.substr(0, 2) === './') ? dir.length - 1 : dir.length + 1;\n                let pathsUnified = files.map((pth => pth.substr(stripLength).replace(/[\\\\/]/gm, '-')));\n                const temporaryIndex = {};\n                files.forEach((file, i) => {\n                    temporaryIndex[pathsUnified[i]] = file;\n                });\n                pathsUnified = pathsUnified.sort();\n                const filesSorted = [];\n                pathsUnified.forEach((key) => {\n                    filesSorted.push(temporaryIndex[key]);\n                });\n                resultantFilesList = filesSorted;\n            } else {\n                resultantFilesList = files;\n            }\n            resolve(resultantFilesList);\n        });\n    });\n}\n\n/**\n * Returns file's hash.\n * @param {string} file - file path\n * @param {boolean} returnFileContents - include file contents in the resultant object\n * @returns {Promise<Object>}\n */\nexport function readAndGetFileHash(file, returnFileContents = false) {\n    return new Promise((resolve, reject) => {\n        fs.readFile(file, (err, data) => {\n            if (err) {\n                reject(err);\n                return;\n            }\n            const hash = crypto.createHash('sha1');\n            hash.update(data);\n            const returnObject = { hash: hash.digest('hex') };\n            if (returnFileContents) {\n                returnObject.contents = data.toString('utf8');\n            }\n            resolve(returnObject);\n        });\n    });\n}\n\n/**\n * Calculates a hash from objects values in specified order.\n * @param {Array} orderOfKeys\n * @param {Object} hashSet\n * @param {Function} keyFilter\n * @returns {string}\n */\nexport function computeHashForHashesSet(orderOfKeys, hashSet, keyFilter = key => key) {\n    const hash = crypto.createHash('sha1');\n    const hashesJoined = orderOfKeys.reduce(\n        // eslint-disable-next-line no-param-reassign,no-return-assign\n        (tmpHash, key) => (tmpHash += hashSet[keyFilter(key)], tmpHash), ''\n    );\n    hash.update(hashesJoined);\n    return hash.digest('hex');\n}\n\n\n/**\n * Reads files from disk and computes hashes for them.\n * @param {Array} files - array with file paths\n * @returns {Promise<Object>}\n */\nexport function readAndHashFiles(files, fileFilter) {\n    const fileHashes = {};\n    const fileContents = {};\n    const promises = [];\n\n    function readSingleFile(file) {\n        return new Promise((resolve, reject) => {\n            readAndGetFileHash(file, file.endsWith('.js') && !file.endsWith('.test.js'))\n                .then((result) => {\n                    let fileName = file;\n                    if (fileFilter) {\n                        fileName = fileFilter(fileName);\n                    }\n                    fileHashes[fileName] = result.hash;\n                    if (result.contents) {\n                        fileContents[fileName] = result.contents;\n                    }\n                    resolve();\n                })\n                .catch(reject);\n        });\n    }\n\n    files.forEach((file) => {\n        promises.push(readSingleFile(file));\n    });\n\n    return new Promise((resolve, reject) => {\n        Promise.all(promises)\n            .then(() => {\n                resolve({ files, fileContents, fileHashes });\n            })\n            .catch(reject);\n    });\n}\n\n/**\n * Reads files from .desktop and computes a version hash.\n *\n * @param {string} dir - path\n * @param {Function} fileFilter\n * @returns {Promise<Object>}\n */\nexport function readFilesAndComputeHash(dir, fileFilter) {\n    return new Promise((resolve, reject) => {\n        getFileList(dir, true)\n            .catch(reject)\n            .then(files => readAndHashFiles(files, fileFilter))\n            .catch(reject)\n            .then((result) => {\n                // eslint-disable-next-line no-param-reassign\n                result.hash = computeHashForHashesSet(result.files, result.fileHashes, fileFilter);\n                resolve(result);\n            });\n    });\n}\n\n/**\n * Symlink exists\n * @param {string} pathToCheck\n * @returns {boolean}\n */\nexport function symlinkExists(pathToCheck) {\n    try {\n        fs.readlinkSync(pathToCheck);\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\n\n\nexport default {\n    getFileList,\n    rmWithRetries,\n    exists,\n    readDir,\n    readAndGetFileHash,\n    computeHashForHashesSet,\n    readAndHashFiles,\n    readFilesAndComputeHash,\n    symlinkExists\n};\n"],"mappings":"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"} \ No newline at end of file From 7c64e3e6b86711dcde3c2a1228ebe59b0655e6a9 Mon Sep 17 00:00:00 2001 From: "p.mikolajczak@tkhtechnology.com" Date: Wed, 5 Apr 2023 08:38:50 +0200 Subject: [PATCH 3/3] Update gitignore, config.yml --- .circleci/config.yml | 2 +- .gitignore | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 70d09d72..e5d2eac1 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -29,7 +29,7 @@ jobs: - checkout - run: name: Update npm - command: 'sudo npm install -g npm@latest' + command: 'sudo npm install -g npm@6' - restore_cache: key: dependency-cache-{{ checksum "package.json" }}-{{ checksum ".circleci/config.yml" }} - run: diff --git a/.gitignore b/.gitignore index 28f46c1a..fd027d5c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ node_modules .idea +dist tests/_tmp_ tests/.__tmp_int .npm