@quilted/create 0.1.28 → 0.1.30

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @quilted/create
 
+## 0.1.30
+
+### Patch Changes
+
+- [`0a69e630`](https://github.com/lemonmade/quilt/commit/0a69e630d9da9233e676f6a5de863b3f836a667e) Thanks [@lemonmade](https://github.com/lemonmade)! - Add cli-kit package
+
+## 0.1.29
+
+### Patch Changes
+
+- [`df633042`](https://github.com/lemonmade/quilt/commit/df633042aecadc8c978c5b492cc1d17d1d168690) Thanks [@lemonmade](https://github.com/lemonmade)! - Add explicit preact dependency
+
 ## 0.1.28
 
 ### Patch Changes

package/build/cjs/app.cjs

@@ -3,34 +3,230 @@
 var fs = require('node:fs');
 var path = require('node:path');
 var node_child_process = require('node:child_process');
-var index = require('./index.cjs');
 var packageManager = require('./package-manager.cjs');
+var index = require('./index.cjs');
 require('node:tty');
 require('node:url');
 require('node:readline');
 require('node:events');
 
 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);
+	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 fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 
+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,
@@ -48,7 +244,7 @@ async function createApp() {
 
        - ${0}, a web app with a minimal file structure
        - ${0}, an entire web app in a single file
-    `), index.cyan_1(`--template`), index.bold_1('basic'), index.bold_1('single-file'));
+    `), packageManager.cyan_1(`--template`), packageManager.bold_1('basic'), packageManager.bold_1('single-file'));
     index.printHelp({
       kind: 'app',
       options: additionalOptions,
@@ -65,10 +261,10 @@ async function createApp() {
     name
   });
   const template = await getTemplate(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 createAsMonorepo = !inWorkspace && (await packageManager.getCreateAsMonorepo(argv));
+  const shouldInstall = await packageManager.getShouldInstall(argv);
+  const packageManager$1 = await packageManager.getPackageManager(argv);
+  const setupExtras = await packageManager.getExtrasToSetup(argv, {
     inWorkspace
   });
   const partOfMonorepo = inWorkspace || createAsMonorepo;
@@ -185,19 +381,19 @@ async function createApp() {
   const packageManagerRun = command => packageManager$1 === 'npm' ? `npm run ${command}` : `pnpm ${command}`;
 
   if (!inWorkspace && directory !== process.cwd()) {
-    commands.push(`cd ${index.cyan_1(packageManager.relativeDirectoryForDisplay(path__namespace.relative(process.cwd(), directory)))} ${index.dim_1('# Move into your new app’s directory')}`);
+    commands.push(`cd ${packageManager.cyan_1(packageManager.relativeDirectoryForDisplay(path__namespace.relative(process.cwd(), directory)))} ${packageManager.dim_1('# Move into your new app’s directory')}`);
   }
 
   if (!shouldInstall) {
-    commands.push(`${packageManager$1} install ${index.dim_1('# Install all your dependencies')}`);
+    commands.push(`${packageManager$1} install ${packageManager.dim_1('# Install all your dependencies')}`);
   }
 
   if (!inWorkspace) {
     // TODO: change this condition to check if git was initialized already
-    commands.push(`git init && git add -A && git commit -m "Initial commit" ${index.dim_1('# Start your git history (optional)')}`);
+    commands.push(`git init && git add -A && git commit -m "Initial commit" ${packageManager.dim_1('# Start your git history (optional)')}`);
   }
 
-  commands.push(`${packageManagerRun('develop')} ${index.dim_1('# Start the development server')}`);
+  commands.push(`${packageManagerRun('develop')} ${packageManager.dim_1('# Start the development server')}`);
   const whatsNext = index.stripIndent(_t2 || (_t2 = _`
     Your new app is ready to go! There’s just ${0} you’ll need to take
     in order to start developing:
@@ -212,13 +408,13 @@ async function createApp() {
     ${0}
 
     Have fun! 🎉
-  `), index.underline_1(index.magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation')));
+  `), packageManager.underline_1(packageManager.magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation')));
   console.log();
   console.log(followUp);
 } // Argument handling
 
 function getArgv() {
-  const argv = index.arg_1({
+  const argv = arg_1({
     '--yes': Boolean,
     '-y': '--yes',
     '--name': String,
@@ -269,7 +465,7 @@ async function getDirectory(argv, {
       const relativeDirectory = path__namespace.relative(process.cwd(), directory);
       const empty = await index.prompt({
         type: 'confirm',
-        message: `Directory ${index.bold_1(packageManager.relativeDirectoryForDisplay(relativeDirectory))} is not empty, is it safe to empty it?`,
+        message: `Directory ${packageManager.bold_1(packageManager.relativeDirectoryForDisplay(relativeDirectory))} is not empty, is it safe to empty it?`,
         initial: true
       });
       if (empty) break;
@@ -296,12 +492,12 @@ async function getTemplate(argv) {
   const template = await index.prompt({
     type: 'select',
     message: 'What template would you like to use?',
-    hint: `Use ${index.bold_1('arrow keys')} to select, and ${index.bold_1('return')} to submit`,
+    hint: `Use ${packageManager.bold_1('arrow keys')} to select, and ${packageManager.bold_1('return')} to submit`,
     choices: [{
-      title: `${index.bold_1('The basics')}, a web app with a minimal file structure`,
+      title: `${packageManager.bold_1('The basics')}, a web app with a minimal file structure`,
       value: 'basic'
     }, {
-      title: `${index.bold_1('Itty-bitty')}, an entire web app in a single file`,
+      title: `${packageManager.bold_1('Itty-bitty')}, an entire web app in a single file`,
       value: 'single-file'
     } // TODO: GraphQL API
     ]