@zimbra/zimlet-cli 12.12.0 → 14.0.0

package/dist/index.js

@@ -1,13 +1,11 @@
 #!/usr/bin/env node
 "use strict";
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = run;
 exports.configure = configure;
+exports.default = run;
 
 var _fs = _interopRequireDefault(require("fs"));
 
@@ -37,90 +35,69 @@ var _shims = require("./shims");
 
 var _copyWebpackPlugin = _interopRequireDefault(require("copy-webpack-plugin"));
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function run(args, callback) {
-  var config = configure(args);
-  var compiler = (0, _webpack["default"])(config);
-  var preferredPort = config.devServer && +config.devServer.port;
-  compiler.hooks.failed.tap('zimlet-cli', function (err) {
+  let config = configure(args);
+  let compiler = (0, _webpack.default)(config);
+  const preferredPort = config.devServer && +config.devServer.port;
+  compiler.hooks.failed.tap('zimlet-cli', err => {
     console.error(err.stack || err);
     if (err.details) console.error(err.details);
   });
-  compiler.hooks.done.tap('zimlet-cli', function (stats) {
-    var info = stats.toJson();
+  compiler.hooks.done.tap('zimlet-cli', stats => {
+    let info = stats.toJson();
 
     if (stats.hasErrors()) {
-      process.stdout.write(_chalk["default"].red('Build failed!\n\n'));
-      info.errors.forEach(function (err) {
-        return console.error(err);
-      });
+      process.stdout.write(_chalk.default.red('Build failed!\n\n'));
+      info.errors.forEach(err => console.error(err));
     } else {
       if (stats.hasWarnings()) {
-        info.warnings.forEach(function (err) {
-          return console.warn(err);
-        });
+        info.warnings.forEach(err => console.warn(err));
       }
 
-      process.stdout.write(_chalk["default"].green('Compiled successfully!\n\n'));
+      process.stdout.write(_chalk.default.green('Compiled successfully!\n\n'));
 
       if (config.devServer) {
-        var _config$devServer = config.devServer,
-            https = _config$devServer.https,
-            host = _config$devServer.host,
-            port = _config$devServer.port;
-        var protocol = https ? 'https' : 'http';
+        let {
+          https,
+          host,
+          port
+        } = config.devServer;
+        let protocol = https ? 'https' : 'http';
         if (host === '0.0.0.0') host = 'localhost';
-        var serverAddr = "".concat(protocol, "://").concat(host, ":").concat(_chalk["default"].bold(port), "/index.js");
-        var localIpAddr = "".concat(protocol, "://").concat(_ip["default"].address(), ":").concat(_chalk["default"].bold(port), "/index.js");
+        let serverAddr = `${protocol}://${host}:${_chalk.default.bold(port)}/index.js`;
+        let localIpAddr = `${protocol}://${_ip.default.address()}:${_chalk.default.bold(port)}/index.js`;
 
         if (preferredPort !== config.devServer.port) {
-          process.stdout.write("NOTE: Port ".concat(preferredPort, " is not available, using ").concat(port, " instead.\n\n"));
+          process.stdout.write(`NOTE: Port ${preferredPort} is not available, using ${port} instead.\n\n`);
         }
 
         process.stdout.write('You can view the application in browser.\n\n');
-        process.stdout.write("".concat(_chalk["default"].bold('Local:'), "            ").concat(serverAddr, "\n"));
-        process.stdout.write("".concat(_chalk["default"].bold('On Your Network:'), "  ").concat(localIpAddr, "\n"));
+        process.stdout.write(`${_chalk.default.bold('Local:')}            ${serverAddr}\n`);
+        process.stdout.write(`${_chalk.default.bold('On Your Network:')}  ${localIpAddr}\n`);
       }
     }
   });
 
   if (config.devServer) {
-    (0, _getPort["default"])({
+    (0, _getPort.default)({
       port: (0, _getPort.makeRange)(preferredPort, preferredPort + 100)
-    }).then(function (port) {
+    }).then(port => {
       if (config.devServer.port !== port) {
         config.devServer.port = port;
       }
 
-      new _webpackDevServer["default"](compiler, config.devServer).listen(config.devServer.port);
+      new _webpackDevServer.default(compiler, config.devServer).listen(config.devServer.port);
     });
   } else {
-    compiler.run(function (err, stats) {
+    compiler.run((err, stats) => {
       if (!err && stats.hasErrors()) {
-        err = "".concat(stats.toJson().errors.length, " errors");
+        err = `${stats.toJson().errors.length} errors`;
       }
 
       callback(err, null);
@@ -130,17 +107,17 @@ function run(args, callback) {
 
 function configure(env) {
   env = env || {};
-  var watch = env.watch || env.w || process.env.NODE_ENV === 'dev' || process.env.NODE_ENV === 'development';
-  var PROD = !watch;
-  var https = !(process.env.HTTPS === 'false' || env.https === false),
+  const watch = env.watch || env.w || process.env.NODE_ENV === 'dev' || process.env.NODE_ENV === 'development';
+  const PROD = !watch;
+  let https = !(process.env.HTTPS === 'false' || env.https === false),
       host = process.env.HOST || env.host || 'localhost',
       port = process.env.PORT || env.port || 8081;
-  var cwd = env.cwd = process.cwd(),
+  let cwd = env.cwd = process.cwd(),
       context = cwd,
       pkg;
 
   try {
-    pkg = require(_path["default"].resolve(cwd, 'package.json'));
+    pkg = require(_path.default.resolve(cwd, 'package.json'));
   } catch (e) {}
 
   if (!pkg) {
@@ -150,26 +127,25 @@ function configure(env) {
   } // entry point (initial file to load)
 
 
-  var entry = _path["default"].resolve(cwd, pkg.module || pkg['jsnext:main'] || pkg.main);
+  let entry = _path.default.resolve(cwd, pkg.module || pkg['jsnext:main'] || pkg.main);
 
-  if (isDir(entry)) entry = _path["default"].resolve(entry, 'index.js'); // attempt to use ./src dir if present:
+  if (isDir(entry)) entry = _path.default.resolve(entry, 'index.js'); // attempt to use ./src dir if present:
 
-  if (isDir(_path["default"].resolve(cwd, 'src'))) context = _path["default"].resolve(context, 'src'); // normalize desination dir
+  if (isDir(_path.default.resolve(cwd, 'src'))) context = _path.default.resolve(context, 'src'); // normalize desination dir
 
-  var dest = _path["default"].resolve(cwd, env.dest || 'build'); // use absolute paths
+  let dest = _path.default.resolve(cwd, env.dest || 'build'); // use absolute paths
 
 
-  context = _path["default"].resolve(context);
-  var componentDirs = [_path["default"].resolve(context, 'components'), _path["default"].resolve(context, 'screens'), _path["default"].resolve(context, 'pages')];
-  var cssLoaderOptions = {
+  context = _path.default.resolve(context);
+  let componentDirs = [_path.default.resolve(context, 'components'), _path.default.resolve(context, 'screens'), _path.default.resolve(context, 'pages')];
+  let cssLoaderOptions = {
     sourceMap: watch && !PROD
   };
-  var postCssLoaderOptions = {
+  let postCssLoaderOptions = {
     sourceMap: true,
     postcssOptions: {
       config: false,
-      plugins: [(0, _postcssPresetEnv["default"])({
-        browsers: ['last 2 versions', 'not ie > 0', 'iOS >= 8'],
+      plugins: [(0, _postcssPresetEnv.default)({
         stage: 3,
         autoprefixer: true,
         features: {
@@ -177,50 +153,46 @@ function configure(env) {
           // disable customProperties plugin so css variables and :root blocks are preserved
           'custom-properties': false
         }
-      }), (0, _postcssDiscardComments["default"])({
+      }), (0, _postcssDiscardComments.default)({
         removeAll: true
       })]
     }
   };
-  var cssModulesRegexp = (0, _util.crossPlatformPathRegex)(/(?:([^/@]+?)(?:-(?:pages?|components?|screens?))?\/)?src\/(?:pages|components|screens)\/(.+?)(\/[a-z0-9._-]+[.](less|css))?$/);
-  var webpackConfig = {
+  let cssModulesRegexp = (0, _util.crossPlatformPathRegex)(/(?:([^/@]+?)(?:-(?:pages?|components?|screens?))?\/)?src\/(?:pages|components|screens)\/(.+?)(\/[a-z0-9._-]+[.](less|css))?$/);
+  let webpackConfig = {
     mode: PROD ? 'production' : 'development',
-    context: context,
-    entry: _path["default"].resolve(__dirname, 'entry.js'),
+    context,
+    entry: _path.default.resolve(__dirname, 'entry.js'),
     output: {
       path: dest,
-      filename: "index.js",
+      filename: `index.js`,
       chunkFilename: '[name].[chunkhash:8].chunk.js',
       // NOTE: Explicit public path is required in order to make HMR work within an sourceless iframe.
       // This is due to a bug in webpack-dev-server that uses the document protocol for all https pages:
       // https://github.com/webpack/webpack-dev-server/blob/c490b245ad65f315762e03e51710f7f7177b1e7b/client/index.js#L188-L190
-      publicPath: watch ? "http".concat(https ? 's' : '', "://").concat(host, ":").concat(port, "/") : env.publicpath || '/'
+      publicPath: watch ? `http${https ? 's' : ''}://${host}:${port}/` : env.publicpath || '/'
     },
     resolve: {
       extensions: ['.mjs', '.jsx', '.js', '.json', '.css', '.less'],
       mainFields: ['browser', 'module', 'jsnext:main', 'main'],
-      modules: [_path["default"].resolve(cwd, 'node_modules'), 'node_modules'],
-      alias: _objectSpread(_objectSpread({}, _shims.SHIMMED_MODULES.reduce(function (shimAliases, name) {
-        if (Array.isArray(name)) {
-          // If module name is an Array, the first element is the root name of the module
-          var _name = name;
-
-          var _name2 = _slicedToArray(_name, 1);
-
-          name = _name2[0];
-        }
-
-        shimAliases[name] = (0, _shims.getShimPath)(name);
-        return shimAliases;
-      }, {})), {}, {
+      modules: [_path.default.resolve(cwd, 'node_modules'), 'node_modules'],
+      alias: { ..._shims.SHIMMED_MODULES.reduce((shimAliases, name) => {
+          if (Array.isArray(name)) {
+            // If module name is an Array, the first element is the root name of the module
+            [name] = name;
+          }
+
+          shimAliases[name] = (0, _shims.getShimPath)(name);
+          return shimAliases;
+        }, {}),
         react: (0, _shims.getShimPath)('preact/compat'),
         'react-dom': (0, _shims.getShimPath)('preact/compat'),
-        style: _path["default"].resolve(context, 'style'),
-        'zimlet-cli-entrypoint': _path["default"].resolve(context, entry)
-      })
+        style: _path.default.resolve(context, 'style'),
+        'zimlet-cli-entrypoint': _path.default.resolve(context, entry)
+      }
     },
     resolveLoader: {
-      modules: [_path["default"].resolve(__dirname, 'loaders'), _path["default"].resolve(__dirname, '..', 'node_modules'), _path["default"].resolve(cwd, 'node_modules')]
+      modules: [_path.default.resolve(__dirname, 'loaders'), _path.default.resolve(__dirname, '..', 'node_modules'), _path.default.resolve(cwd, 'node_modules')]
     },
     module: {
       rules: [{
@@ -231,7 +203,8 @@ function configure(env) {
           comments: true,
           presets: [[require.resolve('@babel/preset-env'), {
             loose: true,
-            modules: false
+            modules: false,
+            bugfixes: true
           }]],
           plugins: [require.resolve('@babel/plugin-syntax-dynamic-import'), [require.resolve('@babel/plugin-proposal-decorators'), {
             legacy: true
@@ -246,16 +219,16 @@ function configure(env) {
         // include: /(^|\/)src\/(?:components|screens)\//,
         include: componentDirs,
         use: [{
-          loader: _path["default"].resolve(__dirname, 'zimlet-style-loader.js')
+          loader: _path.default.resolve(__dirname, 'zimlet-style-loader.js')
         }, {
           loader: 'css-loader',
-          options: _objectSpread(_objectSpread({}, cssLoaderOptions), {}, {
+          options: { ...cssLoaderOptions,
             modules: {
               localIdentRegExp: cssModulesRegexp,
               localIdentName: '[1]_[2]_[local]'
             },
             importLoaders: 1
-          })
+          }
         }, {
           loader: 'postcss-loader',
           options: postCssLoaderOptions
@@ -267,7 +240,7 @@ function configure(env) {
         // exclude: /(^|\/)src\/(?:components|screens)\//,
         exclude: componentDirs,
         use: [{
-          loader: _path["default"].resolve(__dirname, 'zimlet-style-loader.js')
+          loader: _path.default.resolve(__dirname, 'zimlet-style-loader.js')
         }, {
           loader: 'css-loader',
           options: cssLoaderOptions
@@ -292,23 +265,23 @@ function configure(env) {
       __dirname: false,
       setImmediate: false
     } : {},
-    plugins: [].concat(PROD ? [new _webpack["default"].HashedModuleIdsPlugin()] : [new _webpack["default"].HotModuleReplacementPlugin()], new _webpack["default"].LoaderOptionsPlugin({
+    plugins: [].concat(PROD ? [new _webpack.default.HashedModuleIdsPlugin()] : [new _webpack.default.HotModuleReplacementPlugin()], new _webpack.default.LoaderOptionsPlugin({
       minimize: PROD,
       debug: !PROD
-    }), new _progressBarWebpackPlugin["default"]({
-      format: "\x1B[90m\x1B[44mBuild\x1B[49m\x1B[39m [:bar] \x1B[32m\x1B[1m:percent\x1B[22m\x1B[39m (:elapseds) \x1B[2m:msg\x1B[22m",
+    }), new _progressBarWebpackPlugin.default({
+      format: '\u001b[90m\u001b[44mBuild\u001b[49m\u001b[39m [:bar] \u001b[32m\u001b[1m:percent\u001b[22m\u001b[39m (:elapseds) \u001b[2m:msg\u001b[22m',
       renderThrottle: 100,
       summary: false
-    }), new _webpack["default"].DefinePlugin({
+    }), new _webpack.default.DefinePlugin({
       'process.env.NODE_ENV': JSON.stringify(PROD ? 'production' : 'development')
-    }), isFile(_path["default"].resolve(cwd, 'config_template.xml')) && new _copyWebpackPlugin["default"]({
+    }), isFile(_path.default.resolve(cwd, 'config_template.xml')) && new _copyWebpackPlugin.default({
       patterns: [{
-        from: _path["default"].join(cwd, 'config_template.xml'),
-        to: _path["default"].join(dest, 'config_template.xml')
+        from: _path.default.join(cwd, 'config_template.xml'),
+        to: _path.default.join(dest, 'config_template.xml')
       }]
     })).filter(Boolean),
     watchOptions: {
-      ignored: ['build', dest, _path["default"].resolve(cwd, 'node_modules')]
+      ignored: ['build', dest, _path.default.resolve(cwd, 'node_modules')]
     },
     stats: 'errors-only',
     devtool: watch ? 'cheap-module-eval-source-map' : 'source-map'
@@ -316,21 +289,23 @@ function configure(env) {
 
   if (watch) {
     webpackConfig.devServer = {
-      host: host,
-      port: port,
+      host,
+      port,
       hot: !process.env.DISABLE_HOT,
-      https: https,
+      https,
       compress: true,
       publicPath: '/',
       contentBase: context,
       disableHostCheck: true,
-      before: function before(app) {
+
+      before(app) {
         app.use(require('cors')({
           maxAge: 3600
         }));
       },
+
       watchOptions: {
-        ignored: ['build', dest, _path["default"].resolve(cwd, 'node_modules')]
+        ignored: ['build', dest, _path.default.resolve(cwd, 'node_modules')]
       },
       overlay: false,
       noInfo: true,
@@ -339,18 +314,18 @@ function configure(env) {
     };
   }
 
-  (0, _transformConfig["default"])(env, webpackConfig);
+  (0, _transformConfig.default)(env, webpackConfig);
   return webpackConfig;
 }
 
 function isDir(filepath) {
   try {
-    return !!_fs["default"].statSync(filepath).isDirectory();
+    return !!_fs.default.statSync(filepath).isDirectory();
   } catch (err) {}
 }
 
 function isFile(filepath) {
   try {
-    return !!_fs["default"].statSync(filepath).isFile();
+    return !!_fs.default.statSync(filepath).isFile();
   } catch (err) {}
 }

package/dist/lib/async-command.js

@@ -3,13 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = asyncCommand;
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+exports.default = asyncCommand;
 
 function done(err, result) {
   if (err) {
@@ -22,14 +16,14 @@ function done(err, result) {
 }
 
 function asyncCommand(options) {
-  return _objectSpread(_objectSpread({}, options), {}, {
-    handler: function handler(argv) {
-      var r = options.handler(argv, done);
-      if (r && r.then) r.then(function (result) {
-        return done(null, result);
-      }, done);
+  return { ...options,
+
+    handler(argv) {
+      let r = options.handler(argv, done);
+      if (r && r.then) r.then(result => done(null, result), done);
     }
-  });
+
+  };
 }
 
 module.exports = exports.default;

package/dist/lib/setup.js

@@ -3,155 +3,77 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.install = install;
 exports.addScripts = addScripts;
 exports.initGit = initGit;
+exports.install = install;
 
 var _crossSpawnPromise = _interopRequireDefault(require("cross-spawn-promise"));
 
 var _util = require("../util");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function install(cwd, isYarn) {
-  var cmd = isYarn ? 'yarn' : 'npm';
-  return (0, _crossSpawnPromise["default"])(cmd, ['install'], {
-    cwd: cwd,
+  let cmd = isYarn ? 'yarn' : 'npm';
+  return (0, _crossSpawnPromise.default)(cmd, ['install'], {
+    cwd,
     stdio: 'ignore'
   });
 }
 
-function addScripts(_x, _x2, _x3) {
-  return _addScripts.apply(this, arguments);
+async function addScripts(obj, cwd, isYarn) {
+  return {
+    build: 'zimlet build',
+    watch: 'zimlet watch',
+    package: 'zimlet package'
+  };
 } // Initializes the folder using `git init` and a proper `.gitignore` file
 // if `git` is present in the $PATH.
 
 
-function _addScripts() {
-  _addScripts = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(obj, cwd, isYarn) {
-    return regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            return _context.abrupt("return", {
-              build: 'zimlet build',
-              watch: 'zimlet watch',
-              "package": 'zimlet package'
-            });
-
-          case 1:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _addScripts.apply(this, arguments);
-}
-
-function initGit(_x4) {
-  return _initGit.apply(this, arguments);
-}
-
-function _initGit() {
-  _initGit = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(target) {
-    var git, cwd, gitUser, gitEmail, defaultGitUser, defaultGitEmail;
-    return regeneratorRuntime.wrap(function _callee2$(_context2) {
-      while (1) {
-        switch (_context2.prev = _context2.next) {
-          case 0:
-            git = (0, _util.hasCommand)('git');
-
-            if (!git) {
-              _context2.next = 39;
-              break;
-            }
-
-            cwd = target;
-            _context2.next = 5;
-            return (0, _crossSpawnPromise["default"])('git', ['init'], {
-              cwd: cwd
-            });
-
-          case 5:
-            _context2.next = 7;
-            return (0, _crossSpawnPromise["default"])('git', ['add', '-A'], {
-              cwd: cwd
-            });
-
-          case 7:
-            defaultGitUser = 'Zimlet CLI';
-            defaultGitEmail = 'zimlet-cli@users.noreply.github.com';
-            _context2.prev = 9;
-            _context2.next = 12;
-            return (0, _crossSpawnPromise["default"])('git', ['config', 'user.name']);
-
-          case 12:
-            gitUser = _context2.sent.toString();
-            _context2.next = 19;
-            break;
-
-          case 15:
-            _context2.prev = 15;
-            _context2.t0 = _context2["catch"](9);
-            (0, _util.warn)("Git config value of user.name not defined.  Defaulting to ".concat(defaultGitUser, " for initial commit message."));
-            gitUser = defaultGitUser;
-
-          case 19:
-            _context2.prev = 19;
-            _context2.next = 22;
-            return (0, _crossSpawnPromise["default"])('git', ['config', 'user.email']);
-
-          case 22:
-            gitEmail = _context2.sent.toString();
-            _context2.next = 29;
-            break;
-
-          case 25:
-            _context2.prev = 25;
-            _context2.t1 = _context2["catch"](19);
-            (0, _util.warn)("Git config value of user.email not defined.  Defaulting to ".concat(defaultGitEmail, " for initial commit message."));
-            gitEmail = defaultGitEmail;
-
-          case 29:
-            _context2.prev = 29;
-            _context2.next = 32;
-            return (0, _crossSpawnPromise["default"])('git', ['commit', '-m', 'initial commit from zimlet-cli'], {
-              cwd: cwd,
-              env: {
-                GIT_COMMITTER_NAME: gitUser,
-                GIT_COMMITTER_EMAIL: gitEmail,
-                GIT_AUTHOR_NAME: gitUser,
-                GIT_AUTHOR_EMAIL: gitEmail
-              }
-            });
-
-          case 32:
-            _context2.next = 37;
-            break;
-
-          case 34:
-            _context2.prev = 34;
-            _context2.t2 = _context2["catch"](29);
-            (0, _util.warn)("could not make initial git commit: ".concat(_context2.t2));
-
-          case 37:
-            _context2.next = 40;
-            break;
-
-          case 39:
-            (0, _util.warn)('Could not locate `git` binary in `$PATH`. Skipping!');
-
-          case 40:
-          case "end":
-            return _context2.stop();
+async function initGit(target) {
+  let git = (0, _util.hasCommand)('git');
+
+  if (git) {
+    const cwd = target;
+    await (0, _crossSpawnPromise.default)('git', ['init'], {
+      cwd
+    });
+    await (0, _crossSpawnPromise.default)('git', ['add', '-A'], {
+      cwd
+    });
+    let gitUser, gitEmail;
+    const defaultGitUser = 'Zimlet CLI';
+    const defaultGitEmail = 'zimlet-cli@users.noreply.github.com';
+
+    try {
+      gitUser = (await (0, _crossSpawnPromise.default)('git', ['config', 'user.name'])).toString();
+    } catch (e) {
+      (0, _util.warn)(`Git config value of user.name not defined.  Defaulting to ${defaultGitUser} for initial commit message.`);
+      gitUser = defaultGitUser;
+    }
+
+    try {
+      gitEmail = (await (0, _crossSpawnPromise.default)('git', ['config', 'user.email'])).toString();
+    } catch (e) {
+      (0, _util.warn)(`Git config value of user.email not defined.  Defaulting to ${defaultGitEmail} for initial commit message.`);
+      gitEmail = defaultGitEmail;
+    }
+
+    try {
+      await (0, _crossSpawnPromise.default)('git', ['commit', '-m', 'initial commit from zimlet-cli'], {
+        cwd,
+        env: {
+          GIT_COMMITTER_NAME: gitUser,
+          GIT_COMMITTER_EMAIL: gitEmail,
+          GIT_AUTHOR_NAME: gitUser,
+          GIT_AUTHOR_EMAIL: gitEmail
         }
-      }
-    }, _callee2, null, [[9, 15], [19, 25], [29, 34]]);
-  }));
-  return _initGit.apply(this, arguments);
+      });
+    } catch (e) {
+      (0, _util.warn)(`could not make initial git commit: ${e}`);
+    }
+  } else {
+    (0, _util.warn)('Could not locate `git` binary in `$PATH`. Skipping!');
+  }
 }