node_modules ignore

server/node_modules/plop/src/bypass.js

@@ -0,0 +1,70 @@
+import chalk from "chalk";
+import * as out from "./console-out.js";
+
+export { combineBypassData };
+
+/**
+ * Combine different types of bypass data
+ * @param generator - The generator object involved
+ * @param bypassArr - The array of overwritten properties
+ * @param plopArgV - The original args passed to plop without using names
+ */
+function combineBypassData(generator, bypassArr, plopArgV) {
+  // skip bypass if prompts is a function
+  if (typeof generator.prompts === "function") {
+    return [];
+  }
+
+  // Get named prompts that are passed to the command line
+  const promptNames = generator.prompts.map((prompt) => prompt.name);
+  // Check if bypassArr is too long for promptNames
+  if (bypassArr.length > promptNames.length) {
+    console.error(
+      chalk.red("[PLOP] ") +
+        'Too many bypass arguments passed for "' +
+        generator.name +
+        '"',
+    );
+    out.getHelpMessage(generator);
+    process.exit(1);
+  }
+
+  let namedBypassArr = [];
+  if (Object.keys(plopArgV).length > 0) {
+    // Let's make sure we made no whoopsy-poos (AKA passing incorrect inputs)
+    let errors = false;
+    Object.keys(plopArgV).forEach((arg) => {
+      if (!promptNames.find((name) => name === arg) && arg !== "_") {
+        console.error(
+          chalk.red("[PLOP] ") +
+            '"' +
+            arg +
+            '"' +
+            ' is an invalid argument for "' +
+            generator.name +
+            '"',
+        );
+        errors = true;
+      }
+    });
+    if (errors) {
+      out.getHelpMessage(generator);
+      process.exit(1);
+    }
+    namedBypassArr = promptNames.map((name) =>
+      plopArgV[name] !== undefined ? plopArgV[name] : undefined,
+    );
+  }
+
+  // merge the bypass data with named bypass values
+  const mergedBypass = mergeArrays(bypassArr, namedBypassArr);
+  // clean up `undefined` values
+  return mergedBypass.map((v) => (v === undefined ? "_" : v));
+}
+
+function mergeArrays(baseArr, overlay) {
+  const length = Math.max(baseArr.length, overlay.length);
+  return new Array(length)
+    .fill()
+    .map((v, i) => (overlay[i] !== undefined ? overlay[i] : baseArr[i]));
+}

server/node_modules/plop/src/console-out.js

@@ -0,0 +1,132 @@
+import chalk from "chalk";
+import nodePlop from "node-plop";
+import fs from "node:fs";
+
+const defaultChoosingMessage =
+  chalk.blue("[PLOP]") + " Please choose a generator.";
+
+function getHelpMessage(generator) {
+  const maxLen = Math.max(
+    ...generator.prompts.map((prompt) => prompt.name.length),
+  );
+  console.log(
+    [
+      "",
+      chalk.bold("Options:"),
+      ...generator.prompts.map(
+        (prompt) =>
+          "  --" +
+          prompt.name +
+          " ".repeat(maxLen - prompt.name.length + 2) +
+          chalk.dim(prompt.help ? prompt.help : prompt.message),
+      ),
+    ].join("\n"),
+  );
+}
+
+async function chooseOptionFromList(plopList, message) {
+  const plop = await nodePlop();
+  const generator = plop.setGenerator("choose", {
+    prompts: [
+      {
+        type: "list",
+        name: "generator",
+        message: message || defaultChoosingMessage,
+        choices: plopList.map(function (p) {
+          return {
+            name:
+              p.name + chalk.gray(!!p.description ? " - " + p.description : ""),
+            value: p.name,
+          };
+        }),
+      },
+    ],
+  });
+  return generator.runPrompts().then((results) => results.generator);
+}
+
+function displayHelpScreen() {
+  console.log(
+    [
+      "",
+      chalk.bold("Usage:"),
+      "  $ plop                 " +
+        chalk.dim("Select from a list of available generators"),
+      "  $ plop <name>          " +
+        chalk.dim("Run a generator registered under that name"),
+      "  $ plop <name> [input]  " +
+        chalk.dim("Run the generator with input data to bypass prompts"),
+      "",
+      chalk.bold("Options:"),
+      "  -h, --help             " + chalk.dim("Show this help display"),
+      "  -t, --show-type-names  " +
+        chalk.dim("Show type names instead of abbreviations"),
+      "  -i, --init             " + chalk.dim("Generate a basic plopfile.js"),
+      "  -v, --version          " + chalk.dim("Print current version"),
+      "  -f, --force            " + chalk.dim("Run the generator forcefully"),
+      "",
+      chalk.dim(" ------------------------------------------------------"),
+      chalk.dim("  ⚠  danger waits for those who venture below the line"),
+      "",
+      chalk.dim("  --plopfile             Path to the plopfile"),
+      chalk.dim(
+        "  --cwd                  Directory from which relative paths are calculated against while locating the plopfile",
+      ),
+      chalk.dim(
+        "  --preload              String or array of modules to require before running plop",
+      ),
+      chalk.dim(
+        "  --dest                 Output to this directory instead of the plopfile's parent directory",
+      ),
+      chalk.dim("  --no-progress          Disable the progress bar"),
+      "",
+      chalk.bold("Examples:"),
+      "  $ " + chalk.blue("plop"),
+      "  $ " + chalk.blue("plop component"),
+      "  $ " + chalk.blue('plop component "name of component"'),
+      "",
+    ].join("\n"),
+  );
+}
+
+function createInitPlopfile(force = false) {
+  var initString =
+    "export default function (plop) {\n\n" +
+    "\tplop.setGenerator('basics', {\n" +
+    "\t\tdescription: 'this is a skeleton plopfile',\n" +
+    "\t\tprompts: [],\n" +
+    "\t\tactions: []\n" +
+    "\t});\n\n" +
+    "};";
+
+  if (fs.existsSync(process.cwd() + "/plopfile.js") && force === false) {
+    throw Error('"plopfile.js" already exists at this location.');
+  }
+
+  if (fs.existsSync(process.cwd() + "/plopfile.cjs") && force === false) {
+    throw Error('"plopfile.cjs" already exists at this location.');
+  }
+
+  fs.writeFileSync(process.cwd() + "/plopfile.js", initString);
+}
+
+const typeDisplay = {
+  function: chalk.yellow("->"),
+  add: chalk.green("++"),
+  addMany: chalk.green("+!"),
+  modify: `${chalk.green("+")}${chalk.red("-")}`,
+  append: chalk.green("_+"),
+  skip: chalk.green("--"),
+};
+const typeMap = (name, noMap) => {
+  const dimType = chalk.dim(name);
+  return noMap ? dimType : typeDisplay[name] || dimType;
+};
+
+export {
+  chooseOptionFromList,
+  displayHelpScreen,
+  createInitPlopfile,
+  typeMap,
+  getHelpMessage,
+};

server/node_modules/plop/src/input-processing.js

@@ -0,0 +1,105 @@
+import chalk from "chalk";
+import minimist from "minimist";
+import * as out from "./console-out.js";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const globalPkg = require("../package.json");
+const args = process.argv.slice(2);
+const argv = minimist(args);
+
+/**
+ * Parses the user input to identify the generator to run and any bypass data
+ * @param plop - The plop context
+ * @param passArgsBeforeDashes - Should we pass args before `--` to the generator API
+ */
+function getBypassAndGenerator(plop, passArgsBeforeDashes) {
+  // See if there are args to pass to generator
+  const eoaIndex = args.indexOf("--");
+  const { plopArgV, eoaArg } = passArgsBeforeDashes
+    ? { plopArgV: argv }
+    : eoaIndex === -1
+    ? { plopArgV: [] }
+    : {
+        plopArgV: minimist(args.slice(eoaIndex + 1, args.length)),
+        eoaArg: args[eoaIndex + 1],
+      };
+
+  // locate the generator name based on input and take the rest of the
+  // user's input as prompt bypass data to be passed into the generator
+  let generatorName = "";
+  let bypassArr = [];
+
+  const generatorNames = plop.getGeneratorList().map((v) => v.name);
+  for (let i = 0; i < argv._.length; i++) {
+    const nameTest =
+      (generatorName.length ? generatorName + " " : "") + argv._[i];
+    if (listHasOptionThatStartsWith(generatorNames, nameTest)) {
+      generatorName = nameTest;
+    } else {
+      let index = argv._.findIndex((arg) => arg === eoaArg);
+      // If can't find index, slice until the very end - allowing all `_` to be passed
+      index = index !== -1 ? index : argv._.length;
+      // Force `'_'` to become undefined in nameless bypassArr
+      bypassArr = argv._.slice(i, index).map((arg) =>
+        /^_+$/.test(arg) ? undefined : arg,
+      );
+      break;
+    }
+  }
+
+  return { generatorName, bypassArr, plopArgV };
+}
+
+function listHasOptionThatStartsWith(list, prefix) {
+  return list.some(function (txt) {
+    return txt.indexOf(prefix) === 0;
+  });
+}
+
+/**
+ * Handles all basic argument flags
+ * @param env - Values parsed by Liftoff
+ */
+function handleArgFlags(env) {
+  // Make sure that we're not overwriting `help`, `init,` or `version` args in generators
+  if (argv._.length === 0) {
+    // handle request for usage and options
+    if (argv.help || argv.h) {
+      out.displayHelpScreen();
+      process.exit(0);
+    }
+
+    // handle request for initializing a new plopfile
+    if (argv.init || argv.i) {
+      const force = argv.force === true || argv.f === true || false;
+      try {
+        out.createInitPlopfile(force);
+        process.exit(0);
+      } catch (err) {
+        console.error(chalk.red("[PLOP] ") + err.message);
+        process.exit(1);
+      }
+    }
+
+    // handle request for version number
+    if (argv.version || argv.v) {
+      const localVersion = env.modulePackage.version;
+      if (localVersion !== globalPkg.version && localVersion != null) {
+        console.log(chalk.yellow("CLI version"), globalPkg.version);
+        console.log(chalk.yellow("Local version"), localVersion);
+      } else {
+        console.log(globalPkg.version);
+      }
+      process.exit(0);
+    }
+  }
+
+  // abort if there's no plopfile found
+  if (env.configPath == null) {
+    console.error(chalk.red("[PLOP] ") + "No plopfile found");
+    out.displayHelpScreen();
+    process.exit(1);
+  }
+}
+
+export { getBypassAndGenerator, handleArgFlags };

server/node_modules/plop/src/plop.d.ts

@@ -0,0 +1,22 @@
+import * as Liftoff from "liftoff";
+
+export {
+  ActionConfig,
+  ActionType,
+  AddActionConfig,
+  AddManyActionConfig,
+  AppendActionConfig,
+  CustomActionFunction,
+  ModifyActionConfig,
+  PlopCfg,
+  PlopGenerator,
+  NodePlopAPI,
+  PlopGeneratorConfig,
+} from "node-plop";
+
+export const Plop: Liftoff;
+export const run: (
+  env: Liftoff.LiftoffEnv,
+  _: any,
+  passArgsBeforeDashes: boolean,
+) => Promise<void>;

server/node_modules/plop/src/plop.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+import ora from "ora";
+import path from "node:path";
+import Liftoff from "liftoff";
+import minimist from "minimist";
+import v8flags from "v8flags";
+import interpret from "interpret";
+import chalk from "chalk";
+const args = process.argv.slice(2);
+const argv = minimist(args);
+
+import nodePlop from "node-plop";
+import * as out from "./console-out.js";
+import { combineBypassData } from "./bypass.js";
+import { getBypassAndGenerator, handleArgFlags } from "./input-processing.js";
+
+const Plop = new Liftoff({
+  name: "plop",
+  extensions: interpret.jsVariants,
+  v8flags: v8flags,
+});
+
+const isInJest = process.env.NODE_ENV === "test";
+
+const progressSpinner = ora({
+  // Default is stderr
+  stream: isInJest ? process.stdout : process.stderr,
+  isEnabled: !isInJest && argv.progress !== false,
+});
+
+/**
+ * The function to pass as the second argument to `Plop.execute`
+ * @param env - This is passed implicitly
+ * @param _ - Passed implicitly. Not needed, but allows for `passArgsBeforeDashes` to be explicitly passed
+ * @param passArgsBeforeDashes - An opt-in `true` boolean that will allow merging of plop CLI API and generator API
+ * @example
+ * Plop.execute(env => run(env, undefined, true))
+ *
+ * !!!!!! WARNING !!!!!!
+ * One of the reasons we default generator arguments as anything past `--` is a few reasons:
+ * Primarily that there may be name-spacing issues when combining the arg order and named arg passing
+ */
+async function run(env, _, passArgsBeforeDashes) {
+  const plopfilePath = env.configPath;
+
+  // handle basic argument flags like --help, --version, etc
+  handleArgFlags(env);
+
+  // use base path from argv or env if any is present, otherwise set it to the plopfile directory
+  const destBasePath = argv.dest || env.dest;
+  let plop;
+  try {
+    plop = await nodePlop(plopfilePath, {
+      destBasePath: destBasePath ? path.resolve(destBasePath) : undefined,
+      force: argv.force === true || argv.f === true || false,
+    });
+  } catch (e) {
+    console.error(
+      chalk.red("[PLOP] ") + "Something went wrong with reading your plop file",
+      e,
+    );
+    return;
+  }
+  const generators = plop.getGeneratorList();
+  const generatorNames = generators.map((v) => v.name);
+  const { generatorName, bypassArr, plopArgV } = getBypassAndGenerator(
+    plop,
+    passArgsBeforeDashes,
+  );
+
+  // look up a generator and run it with calculated bypass data
+  const runGeneratorByName = (name) => {
+    const generator = plop.getGenerator(name);
+    const bypassData = combineBypassData(generator, bypassArr, plopArgV);
+    doThePlop(generator, bypassData);
+  };
+
+  // hmmmm, couldn't identify a generator in the user's input
+  if (!generators.length) {
+    // no generators?! there's clearly something wrong here
+    console.error(chalk.red("[PLOP] ") + "No generator found in plopfile");
+    process.exit(1);
+  } else if (!generatorName && generators.length === 1) {
+    // only one generator in this plopfile... let's assume they
+    // want to run that one!
+    runGeneratorByName(generatorNames[0]);
+  } else if (!generatorName && generators.length > 1 && !bypassArr.length) {
+    // more than one generator? we'll have to ask the user which
+    // one they want to run.
+    out
+      .chooseOptionFromList(generators, plop.getWelcomeMessage())
+      .then(runGeneratorByName)
+      .catch((err) => {
+        console.error(
+          chalk.red("[PLOP] ") +
+            "Something went wrong with selecting a generator",
+          err,
+        );
+      });
+  } else if (generatorNames.includes(generatorName)) {
+    // we have found the generator, run it!
+    runGeneratorByName(generatorName);
+  } else {
+    // we just can't make sense of your input... sorry :-(
+    const fuzzyGenName = (generatorName + " " + args.join(" ")).trim();
+    console.error(
+      chalk.red("[PLOP] ") +
+        'Could not find a generator for "' +
+        fuzzyGenName +
+        '"',
+    );
+    process.exit(1);
+  }
+  return plop;
+}
+
+/////
+// everybody to the plop!
+//
+function doThePlop(generator, bypassArr) {
+  let failedActions = false;
+  generator
+    .runPrompts(bypassArr)
+    .then(async (answers) => {
+      return answers;
+    })
+    .then((answers) => {
+      const noMap = argv["show-type-names"] || argv.t;
+      const onComment = (msg) => {
+        progressSpinner.info(msg);
+        progressSpinner.start();
+      };
+      const onSuccess = (change) => {
+        let line = "";
+        if (change.type) {
+          line += ` ${out.typeMap(change.type, noMap)}`;
+        }
+        if (change.path) {
+          line += ` ${change.path}`;
+        }
+        progressSpinner.succeed(line);
+        progressSpinner.start();
+      };
+      const onFailure = (fail) => {
+        let line = "";
+        if (fail.type) {
+          line += ` ${out.typeMap(fail.type, noMap)}`;
+        }
+        if (fail.path) {
+          line += ` ${fail.path}`;
+        }
+        const errMsg = fail.error || fail.message;
+        if (errMsg) {
+          line += ` ${errMsg}`;
+        }
+        progressSpinner.fail(line);
+        failedActions = true;
+        progressSpinner.start();
+      };
+      progressSpinner.start();
+      return generator
+        .runActions(answers, { onSuccess, onFailure, onComment })
+        .then(() => {
+          progressSpinner.stop();
+          if (failedActions) process.exit(1);
+        });
+    })
+    .catch(function (err) {
+      console.error(chalk.red("[ERROR]"), err.message);
+      process.exit(1);
+    });
+}
+
+export { Plop, run, progressSpinner };