@quilted/create 0.1.28 → 0.1.30

package/build/cjs/package-manager.cjs

@@ -1,9 +1,12 @@
 'use strict';
 
-var path = require('node:path');
+var require$$0 = require('node:tty');
+var index = require('./index.cjs');
 var fs = require('node:fs');
+var path = require('node:path');
 var node_url = require('node:url');
-require('./index.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -23,8 +26,27 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
+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']);
+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;
@@ -179,6 +201,286 @@ function mergeDependencies(first = {}, second = {}) {
   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) {
+  const packageManager = await getPackageManager$1(argv['--package-manager']);
+  return packageManager !== null && packageManager !== void 0 ? packageManager : 'npm';
+}
+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;
@@ -320,11 +622,20 @@ async function addToWorkspaces(relative, workspaces) {
 
 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;

package/build/cjs/package.cjs

@@ -37,10 +37,10 @@ let _ = t => t,
     _t3,
     _t4;
 async function createProject() {
-  const argv = getArgv();
+  const args = getArguments();
 
-  if (argv['--help']) {
-    var _argv$PackageManag;
+  if (args['--help']) {
+    var _args$PackageManag;
 
     const additionalOptions = index.stripIndent(_t || (_t = _`
       ${0}, ${0}
@@ -58,23 +58,23 @@ async function createProject() {
     index.printHelp({
       kind: 'package',
       options: additionalOptions,
-      packageManager: (_argv$PackageManag = argv['--package-manager']) === null || _argv$PackageManag === void 0 ? void 0 : _argv$PackageManag.toLowerCase()
+      packageManager: (_args$PackageManag = args['--package-manager']) === null || _args$PackageManag === void 0 ? void 0 : _args$PackageManag.toLowerCase()
     });
     return;
   }
 
   const inWorkspace = fs__namespace.existsSync('quilt.workspace.ts');
-  const name = await getName(argv);
-  const directory = await getDirectory(argv, {
+  const name = await getName(args);
+  const directory = await getDirectory(args, {
     name,
     inWorkspace
   });
-  const isPublic = await getPublic(argv);
-  const useReact = await getReact(argv);
-  const createAsMonorepo = !inWorkspace && (await index.getCreateAsMonorepo(argv));
-  const shouldInstall = await index.getShouldInstall(argv);
-  const packageManager$1 = await index.getPackageManager(argv);
-  const setupExtras = await index.getExtrasToSetup(argv, {
+  const isPublic = await getPublic(args);
+  const useReact = await getReact(args);
+  const createAsMonorepo = !inWorkspace && (await packageManager.getCreateAsMonorepo(args));
+  const shouldInstall = await packageManager.getShouldInstall(args);
+  const packageManager$1 = await packageManager.getPackageManager(args);
+  const setupExtras = await packageManager.getExtrasToSetup(args, {
     inWorkspace
   });
   const partOfMonorepo = inWorkspace || createAsMonorepo;
@@ -151,7 +151,7 @@ async function createProject() {
         name: packageManager.toValidPackageName(name),
         react: useReact,
         isPublic,
-        registry: argv['--registry']
+        registry: args['--registry']
       });
       quiltProject = quiltProject.replace('quiltPackage', 'quiltWorkspace, quiltPackage').replace('quiltPackage(', 'quiltWorkspace(), quiltPackage(');
       await outputRoot.write('quilt.project.ts', await packageManager.format(quiltProject, {
@@ -192,7 +192,7 @@ async function createProject() {
       name: packageManager.toValidPackageName(name),
       react: useReact,
       isPublic,
-      registry: argv['--registry']
+      registry: args['--registry']
     });
     await outputRoot.write(path__namespace.join(packageDirectory, 'package.json'), await packageManager.format(JSON.stringify(projectPackageJson), {
       as: 'json-stringify'
@@ -261,8 +261,8 @@ async function createProject() {
   console.log(followUp);
 } // Argument handling
 
-function getArgv() {
-  const argv = index.arg_1({
+function getArguments() {
+  const args = index.parseArguments({
     '--yes': Boolean,
     '-y': '--yes',
     '--name': String,
@@ -284,13 +284,13 @@ function getArgv() {
   }, {
     permissive: true
   });
-  return argv;
+  return args;
 }
 
-async function getName(argv) {
+async function getName(args) {
   let {
     '--name': name
-  } = argv;
+  } = args;
 
   if (name == null) {
     name = await index.prompt({
@@ -303,11 +303,11 @@ async function getName(argv) {
   return name;
 }
 
-async function getDirectory(argv, {
+async function getDirectory(args, {
   name,
   inWorkspace
 }) {
-  let directory = argv['--directory'] ? path__namespace.resolve(argv['--directory']) : undefined;
+  let directory = args['--directory'] ? path__namespace.resolve(args['--directory']) : undefined;
 
   if (directory == null) {
     const basePackageName = packageManager.toValidPackageName(name.split('/').pop());
@@ -319,7 +319,7 @@ async function getDirectory(argv, {
     }));
   }
 
-  while (!argv['--yes']) {
+  while (!args['--yes']) {
     if (fs__namespace.existsSync(directory) && !(await packageManager.isEmpty(directory))) {
       const relativeDirectory = path__namespace.relative(process.cwd(), directory);
       const empty = await index.prompt({
@@ -341,12 +341,12 @@ async function getDirectory(argv, {
   return directory;
 }
 
-async function getPublic(argv) {
+async function getPublic(args) {
   let isPublic;
 
-  if (argv['--public'] || argv['--yes']) {
+  if (args['--public'] || args['--yes']) {
     isPublic = true;
-  } else if (argv['--private']) {
+  } else if (args['--private']) {
     isPublic = false;
   } else {
     isPublic = await index.prompt({
@@ -359,12 +359,12 @@ async function getPublic(argv) {
   return isPublic;
 }
 
-async function getReact(argv) {
+async function getReact(args) {
   let useReact;
 
-  if (argv['--react'] || argv['--yes']) {
+  if (args['--react'] || args['--yes']) {
     useReact = true;
-  } else if (argv['--no-react']) {
+  } else if (args['--no-react']) {
     useReact = false;
   } else {
     useReact = await index.prompt({

package/build/esm/app.mjs

@@ -1,13 +1,209 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execSync } from 'node:child_process';
-import { s as stripIndent, c as cyan_1, b as bold_1, p as printHelp, g as getCreateAsMonorepo, a as getShouldInstall, d as getPackageManager, e as getExtrasToSetup, f as dim_1, u as underline_1, m as magenta_1, h as arg_1, i as prompt } from './index.mjs';
-import { e as emptyDirectory, t as toValidPackageName, f as format, m as mergeDependencies, l as loadTemplate, a as addToTsConfig, b as addToPackageManagerWorkspaces, r as relativeDirectoryForDisplay, i as isEmpty, c as createOutputTarget } from './package-manager.mjs';
+import { c as cyan_1, b as bold_1, g as getCreateAsMonorepo, a as getShouldInstall, d as getPackageManager, e as getExtrasToSetup, f as emptyDirectory, t as toValidPackageName, h as format, m as mergeDependencies, l as loadTemplate, i as addToTsConfig, j as addToPackageManagerWorkspaces, r as relativeDirectoryForDisplay, k as dim_1, u as underline_1, n as magenta_1, o as isEmpty, p as createOutputTarget } from './package-manager.mjs';
+import { s as stripIndent, p as printHelp, a as prompt } from './index.mjs';
 import 'node:tty';
 import 'node:url';
 import 'node:readline';
 import 'node:events';
 
+const flagSymbol = Symbol('arg flag');
+
+class ArgError extends Error {
+	constructor(msg, code) {
+		super(msg);
+		this.name = 'ArgError';
+		this.code = code;
+
+		Object.setPrototypeOf(this, ArgError.prototype);
+	}
+}
+
+function arg(
+	opts,
+	{
+		argv = process.argv.slice(2),
+		permissive = false,
+		stopAtPositional = false
+	} = {}
+) {
+	if (!opts) {
+		throw new ArgError(
+			'argument specification object is required',
+			'ARG_CONFIG_NO_SPEC'
+		);
+	}
+
+	const result = { _: [] };
+
+	const aliases = {};
+	const handlers = {};
+
+	for (const key of Object.keys(opts)) {
+		if (!key) {
+			throw new ArgError(
+				'argument key cannot be an empty string',
+				'ARG_CONFIG_EMPTY_KEY'
+			);
+		}
+
+		if (key[0] !== '-') {
+			throw new ArgError(
+				`argument key must start with '-' but found: '${key}'`,
+				'ARG_CONFIG_NONOPT_KEY'
+			);
+		}
+
+		if (key.length === 1) {
+			throw new ArgError(
+				`argument key must have a name; singular '-' keys are not allowed: ${key}`,
+				'ARG_CONFIG_NONAME_KEY'
+			);
+		}
+
+		if (typeof opts[key] === 'string') {
+			aliases[key] = opts[key];
+			continue;
+		}
+
+		let type = opts[key];
+		let isFlag = false;
+
+		if (
+			Array.isArray(type) &&
+			type.length === 1 &&
+			typeof type[0] === 'function'
+		) {
+			const [fn] = type;
+			type = (value, name, prev = []) => {
+				prev.push(fn(value, name, prev[prev.length - 1]));
+				return prev;
+			};
+			isFlag = fn === Boolean || fn[flagSymbol] === true;
+		} else if (typeof type === 'function') {
+			isFlag = type === Boolean || type[flagSymbol] === true;
+		} else {
+			throw new ArgError(
+				`type missing or not a function or valid array type: ${key}`,
+				'ARG_CONFIG_VAD_TYPE'
+			);
+		}
+
+		if (key[1] !== '-' && key.length > 2) {
+			throw new ArgError(
+				`short argument keys (with a single hyphen) must have only one character: ${key}`,
+				'ARG_CONFIG_SHORTOPT_TOOLONG'
+			);
+		}
+
+		handlers[key] = [type, isFlag];
+	}
+
+	for (let i = 0, len = argv.length; i < len; i++) {
+		const wholeArg = argv[i];
+
+		if (stopAtPositional && result._.length > 0) {
+			result._ = result._.concat(argv.slice(i));
+			break;
+		}
+
+		if (wholeArg === '--') {
+			result._ = result._.concat(argv.slice(i + 1));
+			break;
+		}
+
+		if (wholeArg.length > 1 && wholeArg[0] === '-') {
+			/* eslint-disable operator-linebreak */
+			const separatedArguments =
+				wholeArg[1] === '-' || wholeArg.length === 2
+					? [wholeArg]
+					: wholeArg
+							.slice(1)
+							.split('')
+							.map((a) => `-${a}`);
+			/* eslint-enable operator-linebreak */
+
+			for (let j = 0; j < separatedArguments.length; j++) {
+				const arg = separatedArguments[j];
+				const [originalArgName, argStr] =
+					arg[1] === '-' ? arg.split(/=(.*)/, 2) : [arg, undefined];
+
+				let argName = originalArgName;
+				while (argName in aliases) {
+					argName = aliases[argName];
+				}
+
+				if (!(argName in handlers)) {
+					if (permissive) {
+						result._.push(arg);
+						continue;
+					} else {
+						throw new ArgError(
+							`unknown or unexpected option: ${originalArgName}`,
+							'ARG_UNKNOWN_OPTION'
+						);
+					}
+				}
+
+				const [type, isFlag] = handlers[argName];
+
+				if (!isFlag && j + 1 < separatedArguments.length) {
+					throw new ArgError(
+						`option requires argument (but was followed by another short argument): ${originalArgName}`,
+						'ARG_MISSING_REQUIRED_SHORTARG'
+					);
+				}
+
+				if (isFlag) {
+					result[argName] = type(true, argName, result[argName]);
+				} else if (argStr === undefined) {
+					if (
+						argv.length < i + 2 ||
+						(argv[i + 1].length > 1 &&
+							argv[i + 1][0] === '-' &&
+							!(
+								argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) &&
+								(type === Number ||
+									// eslint-disable-next-line no-undef
+									(typeof BigInt !== 'undefined' && type === BigInt))
+							))
+					) {
+						const extended =
+							originalArgName === argName ? '' : ` (alias for ${argName})`;
+						throw new ArgError(
+							`option requires argument: ${originalArgName}${extended}`,
+							'ARG_MISSING_REQUIRED_LONGARG'
+						);
+					}
+
+					result[argName] = type(argv[i + 1], argName, result[argName]);
+					++i;
+				} else {
+					result[argName] = type(argStr, argName, result[argName]);
+				}
+			}
+		} else {
+			result._.push(wholeArg);
+		}
+	}
+
+	return result;
+}
+
+arg.flag = (fn) => {
+	fn[flagSymbol] = true;
+	return fn;
+};
+
+// Utility types
+arg.COUNT = arg.flag((v, name, existingCount) => (existingCount || 0) + 1);
+
+// Expose error class
+arg.ArgError = ArgError;
+
+var arg_1 = arg;
+
 let _ = t => t,
     _t,
     _t2,