@boehringer-ingelheim/create-config/dist/index.cjs

Add shared configs to your project.

'use strict';

const path = require('node:path');
const node_url = require('node:url');
const prompts = require('prompts');
const node_child_process = require('node:child_process');
const fs = require('node:fs');

var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }

const path__default = /*#__PURE__*/_interopDefaultCompat(path);
const prompts__default = /*#__PURE__*/_interopDefaultCompat(prompts);
const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);

const configFileDict = [
  {
    formName: "Editorconfig",
    name: ".editorconfig",
    targetFolder: "."
  },
  {
    formName: "settings.json (VSCode)",
    name: "settings.json",
    targetFolder: ".vscode"
  },
  {
    formName: "Eslint config",
    name: "eslint.config.mjs",
    targetFolder: "."
  },
  {
    formName: "Prettier config",
    name: ".prettierrc.cjs",
    targetFolder: "."
  }
];
const FILE_PREFIX = "__";

function copyFile(filesLocation, file, location) {
  const from = `${filesLocation}/${FILE_PREFIX}${file.name}`;
  const toFolder = getTo(location, file.targetFolder);
  const to = getTo(location, file.targetFolder, file.name);
  try {
    if (!fs__default.existsSync(toFolder)) {
      fs__default.mkdirSync(toFolder, { recursive: true });
    }
    fs__default.copyFileSync(from, to);
    console.log(`Copied file ${file.name} to ${to}`);
  } catch (err) {
    console.warn(err);
  }
}
function doesFileExist(file, location) {
  const to = getTo(location, file.targetFolder, file.name);
  return fs__default.existsSync(to);
}
function installSharedPackages(packageManager, packages) {
  console.log(`Detected "${packageManager}" as your package manager`);
  switch (packageManager) {
    case "npm":
      installPackage("npm install", packages, "-D");
      break;
    case "yarn":
      installPackage("yarn add", packages, "-D");
      break;
    default:
      console.log(`Sorry, your package manager "${packageManager}" is not (yet) supported. Please reach out if you think this is a mistake.`);
      break;
  }
}
function pkgFromUserAgent(userAgent) {
  if (!userAgent) {
    return undefined;
  }
  const pkgSpec = userAgent.split(" ")[0];
  const pkgSpecArr = pkgSpec.split("/");
  return {
    name: pkgSpecArr[0],
    version: pkgSpecArr[1]
  };
}
function sayGoodbye() {
  console.log("\nThank you for using shared configuration files of Boehringer Ingelheim!\n");
}
function welcomeUser() {
  console.log("\nWelcome to shared configuration files of Boehringer Ingelheim!\n");
}
function bulkifyPackages(packages) {
  return packages.map((p) => p.packages.join(" ")).join(" ");
}
function getTo(targetRootPath, targetFolder, fileName) {
  const folder = targetFolder === "." ? targetRootPath : `${targetRootPath}/${targetFolder}`;
  const file = fileName ? `/${fileName}` : "";
  return folder + file;
}
function installPackage(baseCmd, packs, suffix) {
  const toInstall = bulkifyPackages(packs);
  console.log(`Installing packages "${toInstall}" now ... please wait`);
  const cmd = `${baseCmd} ${toInstall} ${suffix}`;
  console.log(`Running command: ${cmd}`);
  node_child_process.exec(cmd, (err, stdout, stderr) => {
    if (err) {
      console.warn(err.message);
    }
    if (stderr) {
      console.warn(stderr);
    }
    console.log(stdout);
  });
}

const packageFileDict = [
  { formName: "prettier", packages: ["prettier", "@boehringer-ingelheim/prettier-config"] },
  { formName: "eslint", packages: ["eslint", "@boehringer-ingelheim/eslint-config"] }
];

const cwd = process.cwd();
async function init() {
  let result;
  welcomeUser();
  try {
    result = await prompts__default(
      [
        {
          choices: configFileDict.map((f) => ({ title: f.formName, value: f })),
          message: "Choose config files",
          name: "files",
          type: "multiselect"
        },
        {
          initial: ".",
          message: "Where to put them (filepath)",
          name: "location",
          type: (prev) => prev.length ? "text" : null
        },
        {
          message: "Overwrite existing files?",
          name: "overwrite",
          type: (prev) => prev.length ? "confirm" : null
        },
        {
          choices: packageFileDict.map((p) => ({ title: p.formName, value: p })),
          message: "Choose packages to install",
          name: "packages",
          type: "multiselect"
        },
        {
          message: "Does this look good?",
          name: "summary",
          type: "confirm"
        }
      ],
      {
        onCancel: () => {
          throw new Error("\u2716 Operation cancelled");
        }
      }
    );
  } catch (err) {
    if (err instanceof Error) {
      console.warn(err.message);
      return;
    }
    console.warn(err);
    return;
  }
  const { files, location, overwrite, packages } = result;
  const filesChosen = files.length > 0;
  const packagesChosen = packages.length > 0;
  if (filesChosen) {
    processFiles(location, overwrite, files);
  }
  if (packagesChosen) {
    processPackages(packages);
  }
  sayGoodbye();
}
function processFiles(location, overwrite, files) {
  const filesLocation = path__default.resolve(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))), "../..", "files");
  const targetRootPath = path__default.join(cwd, location);
  if (overwrite) {
    files.forEach((file) => {
      copyFile(filesLocation, file, targetRootPath);
    });
  } else {
    files.forEach((file) => {
      if (doesFileExist(file, targetRootPath)) {
        return;
      }
      copyFile(filesLocation, file, targetRootPath);
    });
  }
}
function processPackages(packages) {
  const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent);
  const pkgManager = pkgInfo ? pkgInfo.name : "npm";
  installSharedPackages(pkgManager, packages);
}
init().catch((e) => {
  console.error(e);
});