@quilted/create 0.1.29 → 0.1.31

package/build/cjs/shared/package-manager.cjs

@@ -0,0 +1,677 @@
+'use strict';
+
+var require$$0 = require('node:tty');
+var index = require('../index.cjs');
+var fs = require('node:fs');
+var node_child_process = require('node:child_process');
+var path = require('node:path');
+var node_url = require('node:url');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+const VALID_PACKAGE_MANAGERS = new Set(['npm', 'pnpm', 'yarn']);
+function createPackageManagerRunner(type, {
+  root = process.cwd()
+} = {}) {
+  return {
+    type,
+    commands: {
+      run(command, ...args) {
+        return type === 'npm' ? `npm run ${command}${stringifyArgs(args)}` : `${type} ${command}${stringifyArgs(args)}`;
+      },
+
+      install(...args) {
+        return `${type} install${stringifyArgs(args)}`;
+      }
+
+    },
+
+    async install() {
+      node_child_process.execSync(`${type} install`, {
+        cwd: root
+      });
+    },
+
+    async run(command, args) {
+      node_child_process.execSync(`${type} ${command} ${args.join(' ')}`, {
+        cwd: root
+      });
+    }
+
+  };
+}
+
+function stringifyArgs(args) {
+  return args.length === 0 ? '' : ` ${args.join(' ')}`;
+}
+
+async function getPackageManager$1(explicitPackageManager) {
+  if (explicitPackageManager) {
+    const normalizedPackageManager = explicitPackageManager.toLowerCase();
+    return VALID_PACKAGE_MANAGERS.has(normalizedPackageManager) ? normalizedPackageManager : undefined;
+  }
+
+  const npmUserAgent = process.env['npm_config_user_agent'];
+
+  if (npmUserAgent !== null && npmUserAgent !== void 0 && npmUserAgent.includes('pnpm') || fs.existsSync('pnpm-lock.yaml')) {
+    return 'pnpm';
+  } else if (npmUserAgent !== null && npmUserAgent !== void 0 && npmUserAgent.includes('yarn') || fs.existsSync('yarn.lock')) {
+    return 'yarn';
+  } else if (npmUserAgent !== null && npmUserAgent !== void 0 && npmUserAgent.includes('npm') || fs.existsSync('package-lock.json')) {
+    return 'npm';
+  }
+}
+
+function loadTemplate(name) {
+  let templateRootPromise;
+  return {
+    async copy(to, handleFile) {
+      var _templateRootPromise;
+
+      (_templateRootPromise = templateRootPromise) !== null && _templateRootPromise !== void 0 ? _templateRootPromise : templateRootPromise = templateDirectory(name);
+      const templateRoot = await templateRootPromise;
+      const targetRoot = path__namespace.resolve(to);
+      const files = fs__namespace.readdirSync(templateRoot).filter(file => !path__namespace.basename(file).startsWith('.'));
+
+      for (const file of files) {
+        if (handleFile) {
+          if (!handleFile(file)) {
+            continue;
+          }
+        }
+
+        const targetPath = path__namespace.join(targetRoot, file.startsWith('_') ? `.${file.slice(1)}` : file);
+        copy(path__namespace.join(templateRoot, file), targetPath);
+      }
+    },
+
+    async read(file) {
+      var _templateRootPromise2;
+
+      (_templateRootPromise2 = templateRootPromise) !== null && _templateRootPromise2 !== void 0 ? _templateRootPromise2 : templateRootPromise = templateDirectory(name);
+      const templateRoot = await templateRootPromise;
+      return fs__namespace.readFileSync(path__namespace.join(templateRoot, file), {
+        encoding: 'utf8'
+      });
+    }
+
+  };
+}
+function createOutputTarget(target) {
+  return {
+    root: target,
+
+    read(file) {
+      return fs__namespace.promises.readFile(path__namespace.resolve(target, file), {
+        encoding: 'utf8'
+      });
+    },
+
+    async write(file, content) {
+      await writeFile(path__namespace.resolve(target, file), content);
+    }
+
+  };
+}
+let packageRootPromise;
+
+async function templateDirectory(name) {
+  return path__namespace.join(await getPackageRoot(), 'templates', name);
+}
+
+async function getPackageRoot() {
+  if (!packageRootPromise) {
+    packageRootPromise = (async () => {
+      const {
+        packageDirectory
+      } = await Promise.resolve().then(function () { return require('../index2.cjs'); });
+      return packageDirectory({
+        cwd: path__namespace.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('shared/package-manager.cjs', document.baseURI).href))))
+      });
+    })();
+  }
+
+  return packageRootPromise;
+}
+
+function toValidPackageName(projectName) {
+  return projectName.trim().toLowerCase().replace(/\s+/g, '-').replace(/^[._]/, '').replace(/[^a-z0-9-~@/]+/g, '-');
+}
+
+function copy(source, destination) {
+  const stat = fs__namespace.statSync(source);
+
+  if (stat.isDirectory()) {
+    copyDirectory(source, destination);
+  } else {
+    fs__namespace.copyFileSync(source, destination);
+  }
+}
+
+async function copyDirectory(source, destination) {
+  fs__namespace.mkdirSync(destination, {
+    recursive: true
+  });
+
+  for (const file of fs__namespace.readdirSync(source)) {
+    const srcFile = path__namespace.resolve(source, file);
+    const destFile = path__namespace.resolve(destination, file);
+    copy(srcFile, destFile);
+  }
+}
+
+async function writeFile(file, content) {
+  await fs__namespace.promises.writeFile(file, content);
+}
+async function isEmpty(path) {
+  return fs__namespace.readdirSync(path).length === 0;
+}
+async function emptyDirectory(dir) {
+  if (!fs__namespace.existsSync(dir)) {
+    return;
+  }
+
+  for (const file of fs__namespace.readdirSync(dir)) {
+    fs__namespace.rmSync(path__namespace.resolve(dir, file), {
+      force: true,
+      recursive: true
+    });
+  }
+}
+function relativeDirectoryForDisplay(relativeDirectory) {
+  return relativeDirectory.startsWith('.') ? relativeDirectory : `.${path__namespace.sep}${relativeDirectory}`;
+}
+async function format(content, {
+  as: parser
+}) {
+  const [{
+    format
+  }, {
+    default: babel
+  }, {
+    default: typescript
+  }, {
+    default: yaml
+  }] = await Promise.all([Promise.resolve().then(function () { return require('../standalone.cjs'); }).then(function (n) { return n.standalone; }), Promise.resolve().then(function () { return require('../parser-babel.cjs'); }).then(function (n) { return n.parserBabel; }), Promise.resolve().then(function () { return require('../parser-typescript.cjs'); }).then(function (n) { return n.parserTypescript; }), Promise.resolve().then(function () { return require('../parser-yaml.cjs'); }).then(function (n) { return n.parserYaml; })]);
+  return format(content, {
+    arrowParens: 'always',
+    bracketSpacing: false,
+    singleQuote: true,
+    trailingComma: 'all',
+    parser,
+    plugins: [babel, typescript, yaml]
+  });
+}
+function mergeDependencies(first = {}, second = {}) {
+  const all = { ...first,
+    ...second
+  };
+  const merged = {};
+
+  for (const [key, value] of Object.entries(all).sort(([keyOne], [keyTwo]) => keyOne.localeCompare(keyTwo))) {
+    merged[key] = value;
+  }
+
+  return merged;
+}
+
+var colorette = {};
+
+Object.defineProperty(colorette, '__esModule', { value: true });
+
+var tty = require$$0__default["default"];
+
+function _interopNamespace$1(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var tty__namespace = /*#__PURE__*/_interopNamespace$1(tty);
+
+const env = process.env || {};
+const argv = process.argv || [];
+
+const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+const isWindows = process.platform === "win32";
+
+const isCompatibleTerminal =
+  tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && env.TERM !== "dumb";
+
+const isCI =
+  "CI" in env &&
+  ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+
+const isColorSupported =
+  !isDisabled && (isForced || isWindows || isCompatibleTerminal || isCI);
+
+const replaceClose = (
+  index,
+  string,
+  close,
+  replace,
+  head = string.substring(0, index) + replace,
+  tail = string.substring(index + close.length),
+  next = tail.indexOf(close)
+) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+
+const clearBleed = (index, string, open, close, replace) =>
+  index < 0
+    ? open + string + close
+    : open + replaceClose(index, string, close, replace) + close;
+
+const filterEmpty =
+  (open, close, replace = open, at = open.length + 1) =>
+  (string) =>
+    string || !(string === "" || string === undefined)
+      ? clearBleed(
+          ("" + string).indexOf(close, at),
+          string,
+          open,
+          close,
+          replace
+        )
+      : "";
+
+const init = (open, close, replace) =>
+  filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+
+const colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1b[22m\x1b[1m"),
+  dim: init(2, 22, "\x1b[22m\x1b[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49),
+};
+
+const none = (any) => any;
+
+const createColors = ({ useColor = isColorSupported } = {}) =>
+  useColor
+    ? colors
+    : Object.keys(colors).reduce(
+        (colors, key) => ({ ...colors, [key]: none }),
+        {}
+      );
+
+const {
+  reset,
+  bold,
+  dim,
+  italic,
+  underline,
+  inverse,
+  hidden,
+  strikethrough,
+  black,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  blackBright,
+  redBright,
+  greenBright,
+  yellowBright,
+  blueBright,
+  magentaBright,
+  cyanBright,
+  whiteBright,
+  bgBlackBright,
+  bgRedBright,
+  bgGreenBright,
+  bgYellowBright,
+  bgBlueBright,
+  bgMagentaBright,
+  bgCyanBright,
+  bgWhiteBright,
+} = createColors();
+
+colorette.bgBlack = bgBlack;
+colorette.bgBlackBright = bgBlackBright;
+colorette.bgBlue = bgBlue;
+colorette.bgBlueBright = bgBlueBright;
+colorette.bgCyan = bgCyan;
+colorette.bgCyanBright = bgCyanBright;
+colorette.bgGreen = bgGreen;
+colorette.bgGreenBright = bgGreenBright;
+colorette.bgMagenta = bgMagenta;
+colorette.bgMagentaBright = bgMagentaBright;
+colorette.bgRed = bgRed;
+colorette.bgRedBright = bgRedBright;
+colorette.bgWhite = bgWhite;
+colorette.bgWhiteBright = bgWhiteBright;
+colorette.bgYellow = bgYellow;
+colorette.bgYellowBright = bgYellowBright;
+colorette.black = black;
+colorette.blackBright = blackBright;
+colorette.blue = blue;
+colorette.blueBright = blueBright;
+var bold_1 = colorette.bold = bold;
+colorette.createColors = createColors;
+var cyan_1 = colorette.cyan = cyan;
+colorette.cyanBright = cyanBright;
+var dim_1 = colorette.dim = dim;
+colorette.gray = gray;
+colorette.green = green;
+colorette.greenBright = greenBright;
+colorette.hidden = hidden;
+colorette.inverse = inverse;
+colorette.isColorSupported = isColorSupported;
+colorette.italic = italic;
+var magenta_1 = colorette.magenta = magenta;
+colorette.magentaBright = magentaBright;
+colorette.red = red;
+colorette.redBright = redBright;
+colorette.reset = reset;
+colorette.strikethrough = strikethrough;
+var underline_1 = colorette.underline = underline;
+colorette.white = white;
+colorette.whiteBright = whiteBright;
+colorette.yellow = yellow;
+colorette.yellowBright = yellowBright;
+
+async function getCreateAsMonorepo(argv) {
+  let createAsMonorepo;
+
+  if (argv['--monorepo' ]) {
+    createAsMonorepo = true;
+  } else if (argv['--no-monorepo']) {
+    createAsMonorepo = false;
+  } else {
+    createAsMonorepo = await index.prompt({
+      type: 'confirm',
+      message: 'Do you want to create this app as a monorepo, with room for more projects?',
+      initial: true
+    });
+  }
+
+  return createAsMonorepo;
+}
+async function getShouldInstall(argv) {
+  let shouldInstall;
+
+  if (argv['--install'] || argv['--yes']) {
+    shouldInstall = true;
+  } else if (argv['--no-install']) {
+    shouldInstall = false;
+  } else {
+    shouldInstall = await index.prompt({
+      type: 'confirm',
+      message: 'Do you want to install dependencies for this app after creating it?',
+      initial: true
+    });
+  }
+
+  return shouldInstall;
+}
+async function getPackageManager(argv, options) {
+  const packageManager = await getPackageManager$1(argv['--package-manager']);
+  return createPackageManagerRunner(packageManager !== null && packageManager !== void 0 ? packageManager : 'npm', options);
+}
+const VALID_EXTRAS = new Set(['github', 'vscode']);
+async function getExtrasToSetup(argv, {
+  inWorkspace
+}) {
+  if (inWorkspace || argv['--no-extras']) return new Set();
+
+  if (argv['--extras']) {
+    return new Set(argv['--extras'].filter(extra => VALID_EXTRAS.has(extra)));
+  }
+
+  const setupExtras = await index.prompt({
+    type: 'multiselect',
+    message: 'Which additional tools would you like to configure?',
+    instructions: dim_1(`\n  Use ${bold_1('space')} to select, ${bold_1('a')} to select all, ${bold_1('return')} to submit`),
+    choices: [{
+      title: 'VSCode',
+      value: 'vscode'
+    }, {
+      title: 'GitHub',
+      value: 'github'
+    }]
+  });
+  const extrasToSetup = new Set(setupExtras);
+  return extrasToSetup;
+}
+
+const ENDS_WITH_TSCONFIG = /[/]?tsconfig[.a-z0-9]*[.]json/i;
+async function addToTsConfig(directory, output) {
+  var _tsconfig$references;
+
+  const tsconfig = JSON.parse(await output.read('tsconfig.json'));
+  (_tsconfig$references = tsconfig.references) !== null && _tsconfig$references !== void 0 ? _tsconfig$references : tsconfig.references = [];
+  const relativePath = path.relative(output.root, directory);
+  const relativeForDisplay = relativeDirectoryForDisplay(relativePath);
+
+  if (tsconfig.references.length === 0) {
+    tsconfig.references.push({
+      path: relativeForDisplay
+    });
+  } else {
+    let hasExistingReference = false;
+    let referenceFormat = 'pretty-relative';
+
+    for (const {
+      path
+    } of tsconfig.references) {
+      if (path.startsWith('./')) {
+        if (ENDS_WITH_TSCONFIG.test(path)) {
+          referenceFormat = 'pretty-tsconfig';
+
+          if (path === `${relativeForDisplay}/tsconfig.json`) {
+            hasExistingReference = true;
+            break;
+          }
+        }
+
+        referenceFormat = 'pretty-relative';
+
+        if (path === relativeForDisplay) {
+          hasExistingReference = true;
+          break;
+        }
+      } else if (ENDS_WITH_TSCONFIG.test(path)) {
+        referenceFormat = 'tsconfig';
+
+        if (path === `${relativePath}/tsconfig.json`) {
+          hasExistingReference = true;
+          break;
+        }
+      } else {
+        referenceFormat = 'relative';
+
+        if (path === relativePath) {
+          hasExistingReference = true;
+          break;
+        }
+      }
+    }
+
+    if (!hasExistingReference) {
+      let path;
+
+      if (referenceFormat === 'pretty-tsconfig') {
+        path = `${relativeForDisplay}/tsconfig.json`;
+      } else if (referenceFormat === 'pretty-relative') {
+        path = relativeForDisplay;
+      } else if (referenceFormat === 'tsconfig') {
+        path = `${relativePath}/tsconfig.json`;
+      } else {
+        path = relativePath;
+      }
+
+      tsconfig.references.push({
+        path
+      });
+    }
+  }
+
+  tsconfig.references = tsconfig.references.sort(({
+    path: pathOne
+  }, {
+    path: pathTwo
+  }) => pathOne.localeCompare(pathTwo));
+  await output.write('tsconfig.json', await format(JSON.stringify(tsconfig), {
+    as: 'json'
+  }));
+}
+
+async function addToPackageManagerWorkspaces(directory, output, packageManager) {
+  if (packageManager === 'pnpm') {
+    var _workspaceYaml$packag;
+
+    const {
+      parse,
+      stringify
+    } = await Promise.resolve().then(function () { return require('../index3.cjs'); }).then(function (n) { return n.index; });
+    const workspaceYaml = parse(await output.read('pnpm-workspace.yaml'));
+    workspaceYaml.packages = await addToWorkspaces(path.relative(output.root, directory), (_workspaceYaml$packag = workspaceYaml.packages) !== null && _workspaceYaml$packag !== void 0 ? _workspaceYaml$packag : []);
+    await output.write('pnpm-workspace.yaml', await format(stringify(workspaceYaml), {
+      as: 'yaml'
+    }));
+  } else {
+    var _packageJson$workspac;
+
+    const packageJson = JSON.parse(await output.read('package.json'));
+    packageJson.workspaces = await addToWorkspaces(path.relative(output.root, directory), (_packageJson$workspac = packageJson.workspaces) !== null && _packageJson$workspac !== void 0 ? _packageJson$workspac : []);
+    await output.write('package.json', await format(JSON.stringify(packageJson), {
+      as: 'json-stringify'
+    }));
+  }
+}
+
+async function addToWorkspaces(relative, workspaces) {
+  if (workspaces.length === 0) {
+    return [relative];
+  } // Default documentation seems to generally exclude leading `./` on paths
+
+
+  let pretty = false;
+  let hasMatch = false;
+  const {
+    default: minimatch
+  } = await Promise.resolve().then(function () { return require('../minimatch.cjs'); }).then(function (n) { return n.minimatch; });
+
+  for (const pattern of workspaces) {
+    let normalizedPattern = pattern;
+
+    if (pattern.startsWith('./')) {
+      pretty = true;
+      normalizedPattern = pattern.slice(2);
+    }
+
+    if (minimatch(relative, normalizedPattern)) {
+      hasMatch = true;
+      break;
+    }
+  }
+
+  if (hasMatch) {
+    return workspaces;
+  }
+
+  return [...workspaces, pretty ? relativeDirectoryForDisplay(relative) : relative].sort((patternOne, patternTwo) => patternOne.localeCompare(patternTwo));
+}
+
+exports.addToPackageManagerWorkspaces = addToPackageManagerWorkspaces;
+exports.addToTsConfig = addToTsConfig;
+exports.bold_1 = bold_1;
+exports.createOutputTarget = createOutputTarget;
+exports.cyan_1 = cyan_1;
+exports.dim_1 = dim_1;
+exports.emptyDirectory = emptyDirectory;
+exports.format = format;
+exports.getCreateAsMonorepo = getCreateAsMonorepo;
+exports.getExtrasToSetup = getExtrasToSetup;
+exports.getPackageManager = getPackageManager;
+exports.getShouldInstall = getShouldInstall;
+exports.isEmpty = isEmpty;
+exports.loadTemplate = loadTemplate;
+exports.magenta_1 = magenta_1;
+exports.mergeDependencies = mergeDependencies;
+exports.relativeDirectoryForDisplay = relativeDirectoryForDisplay;
+exports.toValidPackageName = toValidPackageName;
+exports.underline_1 = underline_1;