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);
+  }
+}