@quilted/create 0.1.55 → 0.1.57

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

@@ -1,602 +1,7 @@
 'use strict';
 
-var fs = require('node:fs');
-var require$$0 = require('node:tty');
-var index = require('../index.cjs');
-var node_child_process = require('node:child_process');
 var path = require('node:path');
-var node_url = require('node:url');
-
-function _interopNamespaceDefault(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 fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(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,
-        stdio: 'inherit'
-      });
-    },
-    async run(command, args) {
-      node_child_process.execSync(`${type} ${command} ${args.join(' ')}`, {
-        cwd: root,
-        stdio: 'inherit'
-      });
-    }
-  };
-}
-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?.includes('pnpm') || fs.existsSync('pnpm-lock.yaml')) {
-    return 'pnpm';
-  } else if (npmUserAgent?.includes('yarn') || fs.existsSync('yarn.lock')) {
-    return 'yarn';
-  } else if (npmUserAgent?.includes('npm') || fs.existsSync('package-lock.json')) {
-    return 'npm';
-  }
-}
-
-function loadTemplate(name) {
-  let templateRootPromise;
-  return {
-    async copy(to, handleFile) {
-      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) {
-      templateRootPromise ?? (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('../index3.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: rootFormat,
-    default: prettier
-  }, {
-    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; })]);
-
-  // CJS workaround
-  const format = rootFormat ?? prettier.format;
-  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;
-}
-const PACKAGE_JSON_DEPENDENCY_KEYS = new Set(['dependencies', 'devDependencies', 'peerDependencies', 'peerDependenciesMeta']);
-
-// Merges a project and workspace package.json together, with the following nitpicky preferences:
-//
-// - Take all the project’s fields in the order they appear by default
-// - Merge the relevant dependencies together
-// - Projects don’t come with `scripts` by default, but that should go before the first dependency list
-// - If there are other keys in the workspace package.json, they should go last, in the order they appeared
-function mergeWorkspaceAndProjectPackageJsons(projectPackageJson, workspacePackageJson) {
-  const newPackageJson = {};
-  const seenKeys = new Set();
-  let hasHandledScriptsField = false;
-  for (const [key, value] of Object.entries(projectPackageJson)) {
-    seenKeys.add(key);
-    const isDependencyKey = PACKAGE_JSON_DEPENDENCY_KEYS.has(key);
-    if (key === 'scripts' || isDependencyKey && !hasHandledScriptsField) {
-      newPackageJson.scripts = {
-        ...workspacePackageJson.scripts,
-        ...projectPackageJson.scripts
-      };
-      hasHandledScriptsField = true;
-      if (key === 'scripts') continue;
-    }
-    if (isDependencyKey) {
-      newPackageJson[key] = mergeDependencies(value, workspacePackageJson[key]);
-    } else {
-      newPackageJson[key] = value;
-    }
-  }
-  for (const [key, value] of Object.entries(workspacePackageJson)) {
-    if (seenKeys.has(key)) continue;
-    // Merged workspace + project package.json means we are not in a monorepo
-    if (key === 'workspaces') continue;
-    newPackageJson[key] = value;
-  }
-  return newPackageJson;
-}
-
-var colorette = {};
-
-Object.defineProperty(colorette, '__esModule', { value: true });
-
-var tty = require$$0;
-
-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 getInWorkspace(argv) {
-  if (argv['--in-workspace']) return true;
-  if (argv['--not-in-workspace']) return false;
-  return fs__namespace.existsSync('quilt.workspace.ts');
-}
-async function getCreateAsMonorepo(argv, {
-  type,
-  default: defaultCreateAsMonorepo = true
-}) {
-  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 ${type} as a monorepo, with room for more projects?`,
-      initial: defaultCreateAsMonorepo
-    });
-  }
-  return createAsMonorepo;
-}
-async function getShouldInstall(argv, {
-  type
-}) {
-  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 ${type} after creating it?`,
-      initial: true
-    });
-  }
-  return shouldInstall;
-}
-async function getPackageManager(argv, options) {
-  const packageManager = await getPackageManager$1(argv['--package-manager']);
-  return createPackageManagerRunner(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) {
-  const tsconfig = JSON.parse(await output.read('tsconfig.json'));
-  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'
-  }));
-}
+var shared = require('../shared.cjs');
 
 async function addToPackageManagerWorkspaces(directory, output, packageManager) {
   if (packageManager === 'pnpm') {
@@ -604,16 +9,16 @@ async function addToPackageManagerWorkspaces(directory, output, packageManager)
     const {
       parse,
       stringify
-    } = await Promise.resolve().then(function () { return require('../index4.cjs'); }).then(function (n) { return n.index; });
+    } = await Promise.resolve().then(function () { return require('../node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/index.cjs'); });
     const workspaceYaml = parse(await output.read('pnpm-workspace.yaml'));
     workspaceYaml.packages = await addToWorkspaces(path.relative(output.root, directory), workspaceYaml.packages ?? []);
-    await output.write('pnpm-workspace.yaml', await format(stringify(workspaceYaml), {
+    await output.write('pnpm-workspace.yaml', await shared.format(stringify(workspaceYaml), {
       as: 'yaml'
     }));
   } else {
     const packageJson = JSON.parse(await output.read('package.json'));
     packageJson.workspaces = await addToWorkspaces(path.relative(output.root, directory), packageJson.workspaces ?? []);
-    await output.write('package.json', await format(JSON.stringify(packageJson), {
+    await output.write('package.json', await shared.format(JSON.stringify(packageJson), {
       as: 'json-stringify'
     }));
   }
@@ -628,7 +33,7 @@ async function addToWorkspaces(relative, workspaces) {
   let hasMatch = false;
   const {
     default: minimatch
-  } = await Promise.resolve().then(function () { return require('../minimatch.cjs'); }).then(function (n) { return n.minimatch; });
+  } = await Promise.resolve().then(function () { return require('../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.cjs'); });
   for (const pattern of workspaces) {
     let normalizedPattern = pattern;
     if (pattern.startsWith('./')) {
@@ -643,26 +48,7 @@ async function addToWorkspaces(relative, workspaces) {
   if (hasMatch) {
     return workspaces;
   }
-  return [...workspaces, pretty ? relativeDirectoryForDisplay(relative) : relative].sort((patternOne, patternTwo) => patternOne.localeCompare(patternTwo));
+  return [...workspaces, pretty ? shared.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.getInWorkspace = getInWorkspace;
-exports.getPackageManager = getPackageManager;
-exports.getShouldInstall = getShouldInstall;
-exports.isEmpty = isEmpty;
-exports.loadTemplate = loadTemplate;
-exports.magenta_1 = magenta_1;
-exports.mergeWorkspaceAndProjectPackageJsons = mergeWorkspaceAndProjectPackageJsons;
-exports.relativeDirectoryForDisplay = relativeDirectoryForDisplay;
-exports.toValidPackageName = toValidPackageName;
-exports.underline_1 = underline_1;