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

Add shared configs to your project.

import path from 'node:path';
import { fileURLToPath } from 'node:url';
import prompts from 'prompts';
import { exec } from 'node:child_process';
import fs from 'node: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.existsSync(toFolder)) {
      fs.mkdirSync(toFolder, { recursive: true });
    }
    fs.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.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}`);
  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(
      [
        {
          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.resolve(fileURLToPath(import.meta.url), "../..", "files");
  const targetRootPath = path.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);
});