node_modules ignore

server/node_modules/node-plop/lib/actions/_common-action-add-file.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = addFile;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _del = _interopRequireDefault(require("del"));
+
+var _commonActionUtils = require("./_common-action-utils");
+
+var _isbinaryfile = require("isbinaryfile");
+
+var fspp = _interopRequireWildcard(require("../fs-promise-proxy"));
+
+async function addFile(data, cfg, plop) {
+  const fileDestPath = (0, _commonActionUtils.makeDestPath)(data, cfg, plop);
+  const {
+    force,
+    skipIfExists = false
+  } = cfg;
+
+  try {
+    // check path
+    let destExists = await fspp.fileExists(fileDestPath); // if we are forcing and the file already exists, delete the file
+
+    if (force === true && destExists) {
+      await (0, _del.default)([fileDestPath], {
+        force
+      });
+      destExists = false;
+    } // we can't create files where one already exists
+
+
+    if (destExists) {
+      if (skipIfExists) {
+        return `[SKIPPED] ${fileDestPath} (exists)`;
+      }
+
+      throw `File already exists\n -> ${fileDestPath}`;
+    } else {
+      await fspp.makeDir(_path.default.dirname(fileDestPath));
+      const absTemplatePath = cfg.templateFile && _path.default.resolve(plop.getPlopfilePath(), cfg.templateFile) || null;
+
+      if (absTemplatePath != null && (0, _isbinaryfile.isBinaryFileSync)(absTemplatePath)) {
+        const rawTemplate = await fspp.readFileRaw(cfg.templateFile);
+        await fspp.writeFileRaw(fileDestPath, rawTemplate);
+      } else {
+        const renderedTemplate = await (0, _commonActionUtils.getRenderedTemplate)(data, cfg, plop);
+        const transformedTemplate = await (0, _commonActionUtils.getTransformedTemplate)(renderedTemplate, data, cfg);
+        await fspp.writeFile(fileDestPath, transformedTemplate);
+      } // keep the executable flags
+
+
+      if (absTemplatePath != null) {
+        const sourceStats = await fspp.stat(absTemplatePath);
+        const destStats = await fspp.stat(fileDestPath);
+        const executableFlags = sourceStats.mode & (fspp.constants.S_IXUSR | fspp.constants.S_IXGRP | fspp.constants.S_IXOTH);
+        await fspp.chmod(fileDestPath, destStats.mode | executableFlags);
+      }
+    } // return the added file path (relative to the destination path)
+
+
+    return (0, _commonActionUtils.getRelativeToBasePath)(fileDestPath, plop);
+  } catch (err) {
+    (0, _commonActionUtils.throwStringifiedError)(err);
+  }
+}

server/node_modules/node-plop/lib/actions/_common-action-interface-check.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = _default;
+
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/json/stringify"));
+
+function _default(action, {
+  checkPath = true,
+  checkAbortOnFail = true
+} = {}) {
+  // it's not even an object, you fail!
+  if (typeof action !== 'object') {
+    return `Invalid action object: ${(0, _stringify.default)(action)}`;
+  }
+
+  const {
+    path,
+    abortOnFail
+  } = action;
+
+  if (checkPath && (typeof path !== 'string' || path.length === 0)) {
+    return `Invalid path "${path}"`;
+  } // abortOnFail is optional, but if it's provided it needs to be a Boolean
+
+
+  if (checkAbortOnFail && abortOnFail !== undefined && typeof abortOnFail !== 'boolean') {
+    return `Invalid value for abortOnFail (${abortOnFail} is not a Boolean)`;
+  }
+
+  if ('transform' in action && typeof action.transform !== 'function') {
+    return `Invalid value for transform (${typeof action.transform} is not a function)`;
+  }
+
+  if (action.type === 'modify' && !('pattern' in action) && !('transform' in action)) {
+    return 'Invalid modify action (modify must have a pattern or transform function)';
+  }
+
+  if ('skip' in action && typeof action.skip !== 'function') {
+    return `Invalid value for skip (${typeof action.skip} is not a function)`;
+  }
+
+  return true;
+}

server/node_modules/node-plop/lib/actions/_common-action-utils.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.getRenderedTemplatePath = getRenderedTemplatePath;
+exports.getTemplate = getTemplate;
+exports.getRenderedTemplate = getRenderedTemplate;
+exports.getTransformedTemplate = getTransformedTemplate;
+exports.throwStringifiedError = exports.getRelativeToBasePath = exports.makeDestPath = exports.normalizePath = void 0;
+
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/json/stringify"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var fspp = _interopRequireWildcard(require("../fs-promise-proxy"));
+
+const getFullData = (data, cfg) => (0, _assign.default)({}, cfg.data, data);
+
+const normalizePath = path => {
+  return !path.sep || path.sep === '\\' ? path.replace(/\\/g, '/') : path;
+};
+
+exports.normalizePath = normalizePath;
+
+const makeDestPath = (data, cfg, plop) => {
+  return _path.default.resolve(plop.getDestBasePath(), plop.renderString(normalizePath(cfg.path) || '', getFullData(data, cfg)));
+};
+
+exports.makeDestPath = makeDestPath;
+
+function getRenderedTemplatePath(data, cfg, plop) {
+  if (cfg.templateFile) {
+    const absTemplatePath = _path.default.resolve(plop.getPlopfilePath(), cfg.templateFile);
+
+    return plop.renderString(normalizePath(absTemplatePath), getFullData(data, cfg));
+  }
+
+  return null;
+}
+
+async function getTemplate(data, cfg, plop) {
+  const makeTmplPath = p => _path.default.resolve(plop.getPlopfilePath(), p);
+
+  let {
+    template
+  } = cfg;
+
+  if (cfg.templateFile) {
+    template = await fspp.readFile(makeTmplPath(cfg.templateFile));
+  }
+
+  if (template == null) {
+    template = '';
+  }
+
+  return template;
+}
+
+async function getRenderedTemplate(data, cfg, plop) {
+  const template = await getTemplate(data, cfg, plop);
+  return plop.renderString(template, getFullData(data, cfg));
+}
+
+const getRelativeToBasePath = (filePath, plop) => filePath.replace(_path.default.resolve(plop.getDestBasePath()), '');
+
+exports.getRelativeToBasePath = getRelativeToBasePath;
+
+const throwStringifiedError = err => {
+  if (typeof err === 'string') {
+    throw err;
+  } else {
+    throw err.message || (0, _stringify.default)(err);
+  }
+};
+
+exports.throwStringifiedError = throwStringifiedError;
+
+async function getTransformedTemplate(template, data, cfg) {
+  // transform() was already typechecked at runtime in interface check
+  if ('transform' in cfg) {
+    const result = await cfg.transform(template, data);
+    if (typeof result !== 'string') throw new TypeError(`Invalid return value for transform (${(0, _stringify.default)(result)} is not a string)`);
+    return result;
+  } else {
+    return template;
+  }
+}

server/node_modules/node-plop/lib/actions/add.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = _default;
+
+var _commonActionInterfaceCheck = _interopRequireDefault(require("./_common-action-interface-check"));
+
+var _commonActionAddFile = _interopRequireDefault(require("./_common-action-add-file"));
+
+var _commonActionUtils = require("./_common-action-utils");
+
+async function _default(data, cfg, plop) {
+  const interfaceTestResult = (0, _commonActionInterfaceCheck.default)(cfg);
+
+  if (interfaceTestResult !== true) {
+    throw interfaceTestResult;
+  }
+
+  cfg.templateFile = (0, _commonActionUtils.getRenderedTemplatePath)(data, cfg, plop);
+  return await (0, _commonActionAddFile.default)(data, cfg, plop);
+}

server/node_modules/node-plop/lib/actions/addMany.js

@@ -0,0 +1,137 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = _default;
+
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));
+
+var _startsWith = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/starts-with"));
+
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _globby = _interopRequireDefault(require("globby"));
+
+var _commonActionInterfaceCheck = _interopRequireDefault(require("./_common-action-interface-check"));
+
+var _commonActionAddFile = _interopRequireDefault(require("./_common-action-add-file"));
+
+var _commonActionUtils = require("./_common-action-utils");
+
+const defaultConfig = {
+  verbose: true,
+  stripExtensions: ['hbs']
+};
+
+async function _default(data, userConfig, plop) {
+  var _context, _context2;
+
+  // shallow-merge default config and input config
+  const cfg = (0, _assign.default)({}, defaultConfig, userConfig); // check the common action interface attributes. skip path check because it's NA
+
+  const interfaceTestResult = (0, _commonActionInterfaceCheck.default)(cfg, {
+    checkPath: false
+  });
+
+  if (interfaceTestResult !== true) {
+    throw interfaceTestResult;
+  } // check that destination (instead of path) is a string value
+
+
+  const dest = cfg.destination;
+
+  if (typeof dest !== 'string' || dest.length === 0) {
+    throw `Invalid destination "${dest}"`;
+  }
+
+  if (cfg.base) {
+    cfg.base = plop.renderString(cfg.base, data);
+  }
+
+  if (typeof cfg.templateFiles === 'function') {
+    cfg.templateFiles = cfg.templateFiles();
+  }
+
+  cfg.templateFiles = (0, _map.default)(_context = (0, _concat.default)(_context2 = []).call(_context2, cfg.templateFiles) // Ensure `cfg.templateFiles` is an array, even if a string is passed.
+  ).call(_context, file => plop.renderString(file, data)); // render the paths as hbs templates
+
+  const templateFiles = resolveTemplateFiles(cfg.templateFiles, cfg.base, cfg.globOptions, plop);
+  const filesAdded = [];
+
+  for (let templateFile of templateFiles) {
+    const absTemplatePath = _path.default.resolve(plop.getPlopfilePath(), templateFile);
+
+    const fileCfg = (0, _assign.default)({}, cfg, {
+      path: stripExtensions(cfg.stripExtensions, resolvePath(cfg.destination, templateFile, cfg.base)),
+      templateFile: absTemplatePath
+    });
+    const addedPath = await (0, _commonActionAddFile.default)(data, fileCfg, plop);
+    filesAdded.push(addedPath);
+  }
+
+  const summary = `${filesAdded.length} files added`;
+  if (!cfg.verbose) return summary;else return `${summary}\n -> ${filesAdded.join('\n -> ')}`;
+}
+
+function resolveTemplateFiles(templateFilesGlob, basePath, globOptions, plop) {
+  var _context3, _context4;
+
+  globOptions = (0, _assign.default)({
+    cwd: plop.getPlopfilePath()
+  }, globOptions);
+  return (0, _filter.default)(_context3 = (0, _filter.default)(_context4 = _globby.default.sync(templateFilesGlob, (0, _assign.default)({
+    braceExpansion: false
+  }, globOptions))).call(_context4, isUnder(basePath))).call(_context3, isAbsoluteOrRelativeFileTo(plop.getPlopfilePath()));
+}
+
+function isAbsoluteOrRelativeFileTo(relativePath) {
+  const isFile = file => _fs.default.existsSync(file) && _fs.default.lstatSync(file).isFile();
+
+  return file => isFile(file) || isFile(_path.default.join(relativePath, file));
+}
+
+function isUnder(basePath = '') {
+  return path => (0, _startsWith.default)(path).call(path, basePath);
+}
+
+function resolvePath(destination, file, rootPath) {
+  return (0, _commonActionUtils.normalizePath)(_path.default.join(destination, dropFileRootPath(file, rootPath)));
+}
+
+function dropFileRootPath(file, rootPath) {
+  return rootPath ? file.replace(rootPath, '') : dropFileRootFolder(file);
+}
+
+function dropFileRootFolder(file) {
+  const fileParts = _path.default.normalize(file).split(_path.default.sep);
+
+  fileParts.shift();
+  return fileParts.join(_path.default.sep);
+}
+
+function stripExtensions(shouldStrip, fileName) {
+  var _context5;
+
+  const maybeFile = _path.default.parse(fileName);
+
+  if ((0, _isArray.default)(shouldStrip) && !(0, _includes.default)(_context5 = (0, _map.default)(shouldStrip).call(shouldStrip, item => `.${item}`)).call(_context5, maybeFile.ext)) return fileName;
+  return _path.default.parse(maybeFile.name).ext !== '' ? _path.default.join(maybeFile.dir, maybeFile.name) : fileName;
+}

server/node_modules/node-plop/lib/actions/append.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = _default;
+
+var fspp = _interopRequireWildcard(require("../fs-promise-proxy"));
+
+var _commonActionUtils = require("./_common-action-utils");
+
+var _commonActionInterfaceCheck = _interopRequireDefault(require("./_common-action-interface-check"));
+
+const doAppend = async function (data, cfg, plop, fileData) {
+  const stringToAppend = await (0, _commonActionUtils.getRenderedTemplate)(data, cfg, plop); // if the appended string should be unique (default),
+  // remove any occurence of it (but only if pattern would match)
+
+  const {
+    separator = '\n'
+  } = cfg;
+
+  if (cfg.unique !== false) {
+    // only remove after "pattern", so that we remove not too much accidentally
+    const parts = fileData.split(cfg.pattern);
+    const lastPart = parts[parts.length - 1];
+    const lastPartWithoutDuplicates = lastPart.replace(new RegExp(separator + stringToAppend, 'g'), '');
+    fileData = fileData.replace(lastPart, lastPartWithoutDuplicates);
+  } // add the appended string to the end of the "fileData" if "pattern"
+  // was not provided, i.e. null or false
+
+
+  if (!cfg.pattern) {
+    // make sure to add a "separator" if "fileData" is not empty
+    if (fileData.length > 0) {
+      fileData += separator;
+    }
+
+    return fileData + stringToAppend;
+  }
+
+  return fileData.replace(cfg.pattern, '$&' + separator + stringToAppend);
+};
+
+async function _default(data, cfg, plop) {
+  const interfaceTestResult = (0, _commonActionInterfaceCheck.default)(cfg);
+
+  if (interfaceTestResult !== true) {
+    throw interfaceTestResult;
+  }
+
+  const fileDestPath = (0, _commonActionUtils.makeDestPath)(data, cfg, plop);
+
+  try {
+    // check path
+    const pathExists = await fspp.fileExists(fileDestPath);
+
+    if (!pathExists) {
+      throw 'File does not exist';
+    } else {
+      let fileData = await fspp.readFile(fileDestPath);
+      fileData = await doAppend(data, cfg, plop, fileData);
+      await fspp.writeFile(fileDestPath, fileData);
+    }
+
+    return (0, _commonActionUtils.getRelativeToBasePath)(fileDestPath, plop);
+  } catch (err) {
+    (0, _commonActionUtils.throwStringifiedError)(err);
+  }
+}

server/node_modules/node-plop/lib/actions/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+_Object$defineProperty(exports, "add", {
+  enumerable: true,
+  get: function () {
+    return _add.default;
+  }
+});
+
+_Object$defineProperty(exports, "addMany", {
+  enumerable: true,
+  get: function () {
+    return _addMany.default;
+  }
+});
+
+_Object$defineProperty(exports, "modify", {
+  enumerable: true,
+  get: function () {
+    return _modify.default;
+  }
+});
+
+_Object$defineProperty(exports, "append", {
+  enumerable: true,
+  get: function () {
+    return _append.default;
+  }
+});
+
+var _add = _interopRequireDefault(require("./add"));
+
+var _addMany = _interopRequireDefault(require("./addMany"));
+
+var _modify = _interopRequireDefault(require("./modify"));
+
+var _append = _interopRequireDefault(require("./append"));

server/node_modules/node-plop/lib/actions/modify.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = _default;
+
+var fspp = _interopRequireWildcard(require("../fs-promise-proxy"));
+
+var _commonActionUtils = require("./_common-action-utils");
+
+var _commonActionInterfaceCheck = _interopRequireDefault(require("./_common-action-interface-check"));
+
+async function _default(data, cfg, plop) {
+  const interfaceTestResult = (0, _commonActionInterfaceCheck.default)(cfg);
+
+  if (interfaceTestResult !== true) {
+    throw interfaceTestResult;
+  }
+
+  const fileDestPath = (0, _commonActionUtils.makeDestPath)(data, cfg, plop);
+
+  try {
+    // check path
+    const pathExists = await fspp.fileExists(fileDestPath);
+
+    if (!pathExists) {
+      throw 'File does not exist';
+    } else {
+      let fileData = await fspp.readFile(fileDestPath);
+      cfg.templateFile = (0, _commonActionUtils.getRenderedTemplatePath)(data, cfg, plop);
+      const replacement = await (0, _commonActionUtils.getRenderedTemplate)(data, cfg, plop);
+
+      if (typeof cfg.pattern === 'string' || cfg.pattern instanceof RegExp) {
+        fileData = fileData.replace(cfg.pattern, replacement);
+      }
+
+      const transformed = await (0, _commonActionUtils.getTransformedTemplate)(fileData, data, cfg);
+      await fspp.writeFile(fileDestPath, transformed);
+    }
+
+    return (0, _commonActionUtils.getRelativeToBasePath)(fileDestPath, plop);
+  } catch (err) {
+    (0, _commonActionUtils.throwStringifiedError)(err);
+  }
+}

server/node_modules/node-plop/lib/baked-in-helpers.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _changeCase = _interopRequireDefault(require("change-case"));
+
+var _default = {
+  camelCase: _changeCase.default.camel,
+  snakeCase: _changeCase.default.snake,
+  dotCase: _changeCase.default.dot,
+  pathCase: _changeCase.default.path,
+  lowerCase: _changeCase.default.lower,
+  upperCase: _changeCase.default.upper,
+  sentenceCase: _changeCase.default.sentence,
+  constantCase: _changeCase.default.constant,
+  titleCase: _changeCase.default.title,
+  dashCase: _changeCase.default.param,
+  kabobCase: _changeCase.default.param,
+  kebabCase: _changeCase.default.param,
+  properCase: _changeCase.default.pascal,
+  pascalCase: _changeCase.default.pascal
+};
+exports.default = _default;

server/node_modules/node-plop/lib/fs-promise-proxy.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.constants = exports.fileExists = exports.writeFileRaw = exports.readFileRaw = exports.writeFile = exports.readFile = exports.chmod = exports.stat = exports.readdir = exports.makeDir = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _mkdirp = _interopRequireDefault(require("mkdirp"));
+
+var _util = require("util");
+
+const _readFile = (0, _util.promisify)(_fs.default.readFile);
+
+const _writeFile = (0, _util.promisify)(_fs.default.writeFile);
+
+const _access = (0, _util.promisify)(_fs.default.access);
+
+const makeDir = (0, _util.promisify)(_mkdirp.default);
+exports.makeDir = makeDir;
+const readdir = (0, _util.promisify)(_fs.default.readdir);
+exports.readdir = readdir;
+const stat = (0, _util.promisify)(_fs.default.stat);
+exports.stat = stat;
+const chmod = (0, _util.promisify)(_fs.default.chmod);
+exports.chmod = chmod;
+
+const readFile = path => _readFile(path, 'utf8');
+
+exports.readFile = readFile;
+
+const writeFile = (path, data) => _writeFile(path, data, 'utf8');
+
+exports.writeFile = writeFile;
+
+const readFileRaw = path => _readFile(path, null);
+
+exports.readFileRaw = readFileRaw;
+
+const writeFileRaw = (path, data) => _writeFile(path, data, null);
+
+exports.writeFileRaw = writeFileRaw;
+
+const fileExists = path => _access(path).then(() => true, () => false);
+
+exports.fileExists = fileExists;
+const constants = _fs.default.constants;
+exports.constants = constants;

server/node_modules/node-plop/lib/generator-runner.js

@@ -0,0 +1,238 @@
+'use strict';
+
+var _interopRequireWildcard = require("@babel/runtime-corejs3/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty2 = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty2(exports, "__esModule", {
+  value: true
+});
+
+exports.default = _default;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/define-property"));
+
+var _defineProperties = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/define-properties"));
+
+var _getOwnPropertyDescriptors = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors"));
+
+var _getOwnPropertyDescriptor = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _reduce = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reduce"));
+
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/json/stringify"));
+
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/promise"));
+
+var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
+
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+
+var _defineProperty3 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
+
+var _entries = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/entries"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _promptBypass = _interopRequireDefault(require("./prompt-bypass"));
+
+var buildInActions = _interopRequireWildcard(require("./actions"));
+
+function ownKeys(object, enumerableOnly) { var keys = (0, _keys.default)(object); if (_getOwnPropertySymbols.default) { var symbols = (0, _getOwnPropertySymbols.default)(object); if (enumerableOnly) symbols = (0, _filter.default)(symbols).call(symbols, function (sym) { return (0, _getOwnPropertyDescriptor.default)(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) { var _context3; (0, _forEach.default)(_context3 = ownKeys(source, true)).call(_context3, function (key) { (0, _defineProperty3.default)(target, key, source[key]); }); } else if (_getOwnPropertyDescriptors.default) { (0, _defineProperties.default)(target, (0, _getOwnPropertyDescriptors.default)(source)); } else { var _context4; (0, _forEach.default)(_context4 = ownKeys(source)).call(_context4, function (key) { (0, _defineProperty2.default)(target, key, (0, _getOwnPropertyDescriptor.default)(source, key)); }); } } return target; }
+
+function _default(plopfileApi, flags) {
+  let abort; // triggers inquirer with the correct prompts for this generator
+  // returns a promise that resolves with the user's answers
+
+  const runGeneratorPrompts = async function (genObject, bypassArr = []) {
+    const {
+      prompts
+    } = genObject;
+
+    if (prompts == null) {
+      throw Error(`${genObject.name} has no prompts`);
+    }
+
+    if (typeof prompts === 'function') {
+      return await prompts(plopfileApi.inquirer);
+    } // handle bypass data when provided
+
+
+    const [promptsAfterBypass, bypassAnswers] = (0, _promptBypass.default)(prompts, bypassArr, plopfileApi);
+    return await plopfileApi.inquirer.prompt(promptsAfterBypass).then(answers => (0, _assign.default)(answers, bypassAnswers));
+  }; // Run the actions for this generator
+
+
+  const runGeneratorActions = async function (genObject, data = {}, hooks = {}) {
+    const noop = () => {};
+
+    const {
+      onSuccess = noop,
+      // runs after each successful action
+      onFailure = noop,
+      // runs after each failed action
+      onComment = noop // runs for each comment line in the actions array
+
+    } = hooks;
+    const changes = []; // array of changed made by the actions
+
+    const failures = []; // array of actions that failed
+
+    let {
+      actions
+    } = genObject; // the list of actions to execute
+
+    const customActionTypes = getCustomActionTypes();
+    const actionTypes = (0, _assign.default)({}, customActionTypes, buildInActions);
+    abort = false; // if action is a function, run it to get our array of actions
+
+    if (typeof actions === 'function') {
+      actions = actions(data);
+    } // if actions are not defined... we cannot proceed.
+
+
+    if (actions == null) {
+      throw Error(`${genObject.name} has no actions`);
+    } // if actions are not an array, invalid!
+
+
+    if (!(actions instanceof Array)) {
+      throw Error(`${genObject.name} has invalid actions`);
+    }
+
+    for (let [actionIdx, action] of (0, _entries.default)(actions).call(actions)) {
+      // including strings in the actions array is used for commenting
+      if (typeof action === 'string' && abort) {
+        continue;
+      }
+
+      if (typeof action === 'string') {
+        onComment(action);
+        continue;
+      }
+
+      const actionIsFunction = typeof action === 'function';
+      const actionCfg = actionIsFunction ? {
+        type: 'function'
+      } : action;
+      const actionLogic = actionIsFunction ? action : actionTypes[actionCfg.type]; // bail out if a previous action aborted
+
+      if (abort) {
+        const failure = {
+          type: actionCfg.type || '',
+          path: actionCfg.path || '',
+          error: 'Aborted due to previous action failure'
+        };
+        onFailure(failure);
+        failures.push(failure);
+        continue;
+      }
+
+      actionCfg.force = flags.force === true || actionCfg.force === true;
+
+      if (typeof actionLogic !== 'function') {
+        if (actionCfg.abortOnFail !== false) {
+          abort = true;
+        }
+
+        const failure = {
+          type: actionCfg.type || '',
+          path: actionCfg.path || '',
+          error: `Invalid action (#${actionIdx + 1})`
+        };
+        onFailure(failure);
+        failures.push(failure);
+        continue;
+      }
+
+      try {
+        const actionResult = await executeActionLogic(actionLogic, actionCfg, data);
+        onSuccess(actionResult);
+        changes.push(actionResult);
+      } catch (failure) {
+        if (actionCfg.abortOnFail !== false) {
+          abort = true;
+        }
+
+        onFailure(failure);
+        failures.push(failure);
+      }
+    }
+
+    return {
+      changes,
+      failures
+    };
+  }; // handle action logic
+
+
+  const executeActionLogic = async function (action, cfg, data) {
+    var _context;
+
+    const type = cfg.type || '';
+    let cfgData = cfg.data || {}; // data can also be a function that returns a data object
+
+    if (typeof cfgData === 'function') {
+      cfgData = await cfgData();
+    } // check if action should run
+
+
+    if (typeof cfg.skip === 'function') {
+      // Merge main data and config data in new object
+      const reasonToSkip = await cfg.skip(_objectSpread({}, data, {}, cfgData));
+
+      if (typeof reasonToSkip === 'string') {
+        // Return actionResult instead of string
+        return {
+          type: 'skip',
+          path: reasonToSkip
+        };
+      }
+    } // track keys that can be applied to the main data scope
+
+
+    const cfgDataKeys = (0, _filter.default)(_context = (0, _keys.default)(cfgData)).call(_context, k => typeof data[k] === 'undefined'); // copy config data into main data scope so it's available for templates
+
+    (0, _forEach.default)(cfgDataKeys).call(cfgDataKeys, k => {
+      data[k] = cfgData[k];
+    });
+    return await _promise.default.resolve(action(data, cfg, plopfileApi)).then( // show the resolved value in the console
+    result => ({
+      type,
+      path: typeof result === 'string' ? result : (0, _stringify.default)(result)
+    }), // a rejected promise is treated as a failure
+    err => {
+      throw {
+        type,
+        path: '',
+        error: err.message || err.toString()
+      };
+    }) // cleanup main data scope so config data doesn't leak
+    .finally(() => (0, _forEach.default)(cfgDataKeys).call(cfgDataKeys, k => {
+      delete data[k];
+    }));
+  }; // request the list of custom actions from the plopfile
+
+
+  function getCustomActionTypes() {
+    var _context2;
+
+    return (0, _reduce.default)(_context2 = plopfileApi.getActionTypeList()).call(_context2, function (types, name) {
+      types[name] = plopfileApi.getActionType(name);
+      return types;
+    }, {});
+  }
+
+  return {
+    runGeneratorActions,
+    runGeneratorPrompts
+  };
+}

server/node_modules/node-plop/lib/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _nodePlop = _interopRequireDefault(require("./node-plop"));
+
+/**
+ * Main node-plop module
+ *
+ * @param {string} plopfilePath - The absolute path to the plopfile we are interested in working with
+ * @param {object} plopCfg - A config object to be passed into the plopfile when it's executed
+ * @returns {object} the node-plop API for the plopfile requested
+ */
+module.exports = _nodePlop.default;

server/node_modules/node-plop/lib/node-plop.js

@@ -0,0 +1,310 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _reduce = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reduce"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+
+var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
+
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _inquirer = _interopRequireDefault(require("inquirer"));
+
+var _handlebars = _interopRequireDefault(require("handlebars"));
+
+var _lodash = _interopRequireDefault(require("lodash.get"));
+
+var _resolve = _interopRequireDefault(require("resolve"));
+
+var _bakedInHelpers = _interopRequireDefault(require("./baked-in-helpers"));
+
+var _generatorRunner = _interopRequireDefault(require("./generator-runner"));
+
+function nodePlop(plopfilePath = '', plopCfg = {}) {
+  let pkgJson = {};
+  let defaultInclude = {
+    generators: true
+  };
+  let welcomeMessage;
+  const {
+    destBasePath,
+    force
+  } = plopCfg;
+  const generators = {};
+  const partials = {};
+  const actionTypes = {};
+  const helpers = (0, _assign.default)({
+    pkg: propertyPath => (0, _lodash.default)(pkgJson, propertyPath, '')
+  }, _bakedInHelpers.default);
+  const baseHelpers = (0, _keys.default)(helpers);
+  const setPrompt = _inquirer.default.registerPrompt;
+
+  const setWelcomeMessage = message => {
+    welcomeMessage = message;
+  };
+
+  const setHelper = (name, fn) => {
+    helpers[name] = fn;
+  };
+
+  const setPartial = (name, str) => {
+    partials[name] = str;
+  };
+
+  const setActionType = (name, fn) => {
+    actionTypes[name] = fn;
+  };
+
+  function renderString(template, data) {
+    var _context, _context2;
+
+    (0, _forEach.default)(_context = (0, _keys.default)(helpers)).call(_context, h => _handlebars.default.registerHelper(h, helpers[h]));
+    (0, _forEach.default)(_context2 = (0, _keys.default)(partials)).call(_context2, p => _handlebars.default.registerPartial(p, partials[p]));
+    return _handlebars.default.compile(template)(data);
+  }
+
+  const getWelcomeMessage = () => welcomeMessage;
+
+  const getHelper = name => helpers[name];
+
+  const getPartial = name => partials[name];
+
+  const getActionType = name => actionTypes[name];
+
+  const getGenerator = name => generators[name];
+
+  function setGenerator(name = '', config = {}) {
+    // if no name is provided, use a default
+    name = name || `generator-${(0, _keys.default)(generators).length + 1}`; // add the generator to this context
+
+    generators[name] = (0, _assign.default)(config, {
+      name: name,
+      basePath: plopfilePath
+    });
+    return generators[name];
+  }
+
+  const getHelperList = () => {
+    var _context3;
+
+    return (0, _filter.default)(_context3 = (0, _keys.default)(helpers)).call(_context3, h => !(0, _includes.default)(baseHelpers).call(baseHelpers, h));
+  };
+
+  const getPartialList = () => (0, _keys.default)(partials);
+
+  const getActionTypeList = () => (0, _keys.default)(actionTypes);
+
+  function getGeneratorList() {
+    var _context4;
+
+    return (0, _map.default)(_context4 = (0, _keys.default)(generators)).call(_context4, function (name) {
+      const {
+        description
+      } = generators[name];
+      return {
+        name,
+        description
+      };
+    });
+  }
+
+  const setDefaultInclude = inc => defaultInclude = inc;
+
+  const getDefaultInclude = () => defaultInclude;
+
+  const getDestBasePath = () => destBasePath || plopfilePath;
+
+  const getPlopfilePath = () => plopfilePath;
+
+  const setPlopfilePath = filePath => {
+    const pathStats = _fs.default.statSync(filePath);
+
+    if (pathStats.isFile()) {
+      plopfilePath = _path.default.dirname(filePath);
+    } else {
+      plopfilePath = filePath;
+    }
+  };
+
+  function load(targets, loadCfg = {}, includeOverride) {
+    if (typeof targets === 'string') {
+      targets = [targets];
+    }
+
+    const config = (0, _assign.default)({
+      destBasePath: getDestBasePath()
+    }, loadCfg);
+    (0, _forEach.default)(targets).call(targets, function (target) {
+      var _context5;
+
+      const targetPath = _resolve.default.sync(target, {
+        basedir: getPlopfilePath()
+      });
+
+      const proxy = nodePlop(targetPath, config);
+      const proxyDefaultInclude = proxy.getDefaultInclude() || {};
+      const includeCfg = includeOverride || proxyDefaultInclude;
+      const include = (0, _assign.default)({
+        generators: false,
+        helpers: false,
+        partials: false,
+        actionTypes: false
+      }, includeCfg);
+      const genNameList = (0, _map.default)(_context5 = proxy.getGeneratorList()).call(_context5, g => g.name);
+      loadAsset(genNameList, include.generators, setGenerator, proxyName => ({
+        proxyName,
+        proxy
+      }));
+      loadAsset(proxy.getPartialList(), include.partials, setPartial, proxy.getPartial);
+      loadAsset(proxy.getHelperList(), include.helpers, setHelper, proxy.getHelper);
+      loadAsset(proxy.getActionTypeList(), include.actionTypes, setActionType, proxy.getActionType);
+    });
+  }
+
+  function loadAsset(nameList, include, addFunc, getFunc) {
+    var incArr;
+
+    if (include === true) {
+      incArr = nameList;
+    }
+
+    if (include instanceof Array) {
+      incArr = (0, _filter.default)(include).call(include, n => typeof n === 'string');
+    }
+
+    if (incArr != null) {
+      include = (0, _reduce.default)(incArr).call(incArr, function (inc, name) {
+        inc[name] = name;
+        return inc;
+      }, {});
+    }
+
+    if (include instanceof Object) {
+      var _context6;
+
+      (0, _forEach.default)(_context6 = (0, _keys.default)(include)).call(_context6, i => addFunc(include[i], getFunc(i)));
+    }
+  }
+
+  function loadPackageJson() {
+    // look for a package.json file to use for the "pkg" helper
+    try {
+      pkgJson = require(_path.default.join(getDestBasePath(), 'package.json'));
+    } catch (error) {
+      pkgJson = {};
+    }
+  } /////////
+  // the API that is exposed to the plopfile when it is executed
+  // it differs from the nodePlopApi in that it does not include the
+  // generator runner methods
+  //
+
+
+  const plopfileApi = {
+    // main methods for setting and getting plop context things
+    setPrompt,
+    setWelcomeMessage,
+    getWelcomeMessage,
+    setGenerator,
+    getGenerator,
+    getGeneratorList,
+    setPartial,
+    getPartial,
+    getPartialList,
+    setHelper,
+    getHelper,
+    getHelperList,
+    setActionType,
+    getActionType,
+    getActionTypeList,
+    // path context methods
+    setPlopfilePath,
+    getPlopfilePath,
+    getDestBasePath,
+    // plop.load functionality
+    load,
+    setDefaultInclude,
+    getDefaultInclude,
+    // render a handlebars template
+    renderString,
+    // passthrough properties
+    inquirer: _inquirer.default,
+    handlebars: _handlebars.default,
+    // passthroughs for backward compatibility
+    addPrompt: setPrompt,
+    addPartial: setPartial,
+    addHelper: setHelper
+  }; // the runner for this instance of the nodePlop api
+
+  const runner = (0, _generatorRunner.default)(plopfileApi, {
+    force
+  });
+  const nodePlopApi = (0, _assign.default)({}, plopfileApi, {
+    getGenerator(name) {
+      var generator = plopfileApi.getGenerator(name);
+
+      if (generator == null) {
+        throw Error(`Generator "${name}" does not exist.`);
+      } // if this generator was loaded from an external plopfile, proxy the
+      // generator request through to the external plop instance
+
+
+      if (generator.proxy) {
+        return generator.proxy.getGenerator(generator.proxyName);
+      }
+
+      return (0, _assign.default)({}, generator, {
+        runActions: (data, hooks) => runner.runGeneratorActions(generator, data, hooks),
+        runPrompts: (bypassArr = []) => runner.runGeneratorPrompts(generator, bypassArr)
+      });
+    },
+
+    setGenerator(name, config) {
+      const g = plopfileApi.setGenerator(name, config);
+      return this.getGenerator(g.name);
+    }
+
+  });
+
+  if (plopfilePath) {
+    plopfilePath = _path.default.resolve(plopfilePath);
+
+    const plopFileName = _path.default.basename(plopfilePath);
+
+    setPlopfilePath(plopfilePath);
+    loadPackageJson();
+
+    const plopFileExport = require(_path.default.join(plopfilePath, plopFileName));
+
+    const plop = typeof plopFileExport === 'function' ? plopFileExport : plopFileExport.default;
+    plop(plopfileApi, plopCfg);
+  } else {
+    setPlopfilePath(process.cwd());
+    loadPackageJson();
+  }
+
+  return nodePlopApi;
+}
+
+var _default = nodePlop;
+exports.default = _default;

server/node_modules/node-plop/lib/prompt-bypass.js

@@ -0,0 +1,218 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = _default;
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _some = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/some"));
+
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+
+var _find = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/find"));
+
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+
+/* ========================================================================
+ * PROMPT BYPASSING
+ * -----------------
+ * this allows a user to bypass a prompt by supplying input before
+ * the prompts are run. we handle input differently depending on the
+ * type of prompt that's in play (ie "y" means "true" for a confirm prompt)
+ * ======================================================================== */
+/////
+// HELPER FUNCTIONS
+//
+// pull the "value" out of a choice option
+const getChoiceValue = choice => {
+  const isObject = typeof choice === 'object';
+
+  if (isObject && choice.value != null) {
+    return choice.value;
+  }
+
+  if (isObject && choice.name != null) {
+    return choice.name;
+  }
+
+  if (isObject && choice.key != null) {
+    return choice.key;
+  }
+
+  return choice;
+}; // check if the choice value matches the bypass value
+
+
+function checkChoiceValue(choiceValue, value) {
+  return typeof choiceValue === 'string' && choiceValue.toLowerCase() === value.toLowerCase();
+} // check if a bypass value matches some aspect of
+// a particular choice option (index, value, key, etc)
+
+
+function choiceMatchesValue(choice, choiceIdx, value) {
+  return checkChoiceValue(choice, value) || checkChoiceValue(choice.value, value) || checkChoiceValue(choice.key, value) || checkChoiceValue(choice.name, value) || checkChoiceValue(choiceIdx.toString(), value);
+} // check if a value matches a particular set of flagged input options
+
+
+const isFlag = (list, v) => (0, _includes.default)(list).call(list, v.toLowerCase()); // input values that represent different types of responses
+
+
+const flag = {
+  isTrue: v => isFlag(['yes', 'y', 'true', 't'], v),
+  isFalse: v => isFlag(['no', 'n', 'false', 'f'], v),
+  isPrompt: v => /^_+$/.test(v)
+}; // generic list bypass function. used for all types of lists.
+// accepts value, index, or key as matching criteria
+
+const listTypeBypass = (v, prompt) => {
+  var _context;
+
+  const choice = (0, _find.default)(_context = prompt.choices).call(_context, (c, idx) => choiceMatchesValue(c, idx, v));
+
+  if (choice != null) {
+    return getChoiceValue(choice);
+  }
+
+  throw Error('invalid choice');
+}; /////
+// BYPASS FUNCTIONS
+//
+// list of prompt bypass functions by prompt type
+
+
+const typeBypass = {
+  confirm(v) {
+    if (flag.isTrue(v)) {
+      return true;
+    }
+
+    if (flag.isFalse(v)) {
+      return false;
+    }
+
+    throw Error('invalid input');
+  },
+
+  checkbox(v, prompt) {
+    const valList = v.split(',');
+    const valuesNoMatch = (0, _filter.default)(valList).call(valList, val => {
+      var _context2;
+
+      return !(0, _some.default)(_context2 = prompt.choices).call(_context2, (c, idx) => choiceMatchesValue(c, idx, val));
+    });
+
+    if (valuesNoMatch.length) {
+      throw Error(`no match for "${valuesNoMatch.join('", "')}"`);
+    }
+
+    return (0, _map.default)(valList).call(valList, val => {
+      var _context3;
+
+      return getChoiceValue((0, _find.default)(_context3 = prompt.choices).call(_context3, (c, idx) => choiceMatchesValue(c, idx, val)));
+    });
+  },
+
+  list: listTypeBypass,
+  rawlist: listTypeBypass,
+  expand: listTypeBypass
+}; /////
+// MAIN LOGIC
+//
+// returns new prompts, initial answers object, and any failures
+
+function _default(prompts, bypassArr, plop) {
+  const noop = [prompts, {}, []]; // bail out if we don't have prompts or bypass data
+
+  if (!(0, _isArray.default)(prompts)) {
+    return noop;
+  }
+
+  if (bypassArr.length === 0) {
+    return noop;
+  } // pull registered prompts out of inquirer
+
+
+  const {
+    prompts: inqPrompts
+  } = plop.inquirer.prompt;
+  const answers = {};
+  const bypassFailures = []; // generate a list of pompts that the user is bypassing
+
+  const bypassedPrompts = (0, _filter.default)(prompts).call(prompts, function (p, idx) {
+    // if the user didn't provide value for this prompt, skip it
+    if (idx >= bypassArr.length) {
+      return false;
+    }
+
+    const val = bypassArr[idx].toString(); // if the user asked to be given this prompt, skip it
+
+    if (flag.isPrompt(val)) {
+      return false;
+    } // if this prompt is dynamic, throw error because we can't know if
+    // the pompt bypass values given line up with the path this user
+    // has taken through the prompt tree.
+
+
+    if (typeof p.when === 'function') {
+      bypassFailures.push(`You can not bypass conditional prompts: ${p.name}`);
+      return false;
+    }
+
+    try {
+      const inqPrompt = inqPrompts[p.type] || {}; // try to find a bypass function to run
+
+      const bypass = p.bypass || inqPrompt.bypass || typeBypass[p.type] || null; // get the real answer data out of the bypass function and attach it
+      // to the answer data object
+
+      const bypassIsFunc = typeof bypass === 'function';
+      const value = bypassIsFunc ? bypass.call(null, val, p) : val; // if inquirer prompt has a filter function - call it
+
+      const answer = (0, _filter.default)(p) ? (0, _filter.default)(p).call(p, value, answers) : value; // if inquirer prompt has a validate function - call it
+
+      if (p.validate) {
+        const validation = p.validate(value, answers);
+
+        if (validation !== true) {
+          // if validation failed return validation error
+          bypassFailures.push(validation);
+          return false;
+        }
+      }
+
+      answers[p.name] = answer;
+    } catch (err) {
+      // if we encounter an error above... assume the bypass value was invalid
+      bypassFailures.push(`The "${p.name}" prompt did not recognize "${val}" as a valid ${p.type} value (ERROR: ${err.message})`);
+      return false;
+    } // if we got this far, we successfully bypassed this prompt
+
+
+    return true;
+  }); // rip out any prompts that have been bypassed
+
+  const promptsAfterBypass = [// first prompt will copy the bypass answer data so it's available
+  // for prompts and actions to use
+  {
+    when: data => ((0, _assign.default)(data, answers), false)
+  }, // inlcude any prompts that were NOT bypassed
+  ...(0, _filter.default)(prompts).call(prompts, p => !(0, _includes.default)(bypassedPrompts).call(bypassedPrompts, p))]; // if we have failures, throw the first one
+
+  if (bypassFailures.length) {
+    throw Error(bypassFailures[0]);
+  } else {
+    // return the prompts that still need to be run
+    return [promptsAfterBypass, answers];
+  } // BOOM!
+
+}