@quilted/create 0.1.50 → 0.1.52

package/build/cjs/module.cjs

@@ -0,0 +1,318 @@
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var index$1 = require('./index2.cjs');
+var packageManager = require('./shared/package-manager.cjs');
+var index = require('./index.cjs');
+require('node:tty');
+require('node:child_process');
+require('node:url');
+require('node:readline');
+require('node:events');
+
+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);
+
+async function createModule() {
+  const argv = getArgv();
+  if (argv['--help']) {
+    index.printHelp({
+      kind: 'module',
+      packageManager: argv['--package-manager']?.toLowerCase()
+    });
+    return;
+  }
+  const inWorkspace = await packageManager.getInWorkspace(argv);
+  const name = await getName(argv);
+  const directory = await getDirectory(argv, {
+    name
+  });
+  const entry = await getEntry(argv, {
+    name
+  });
+  const useReact = await getReact(argv);
+  const createAsMonorepo = !inWorkspace && (await packageManager.getCreateAsMonorepo(argv, {
+    type: 'module',
+    default: false
+  }));
+  const setupExtras = await packageManager.getExtrasToSetup(argv, {
+    inWorkspace
+  });
+  const shouldInstall = await packageManager.getShouldInstall(argv, {
+    type: 'module'
+  });
+  const packageManager$1 = await packageManager.getPackageManager(argv, {
+    root: directory
+  });
+  const partOfMonorepo = inWorkspace || createAsMonorepo;
+  const moduleDirectory = createAsMonorepo ? path__namespace.join(directory, 'app') : directory;
+  if (fs__namespace.existsSync(directory)) {
+    await packageManager.emptyDirectory(directory);
+    if (moduleDirectory !== directory) {
+      fs__namespace.mkdirSync(moduleDirectory, {
+        recursive: true
+      });
+    }
+  } else {
+    fs__namespace.mkdirSync(moduleDirectory, {
+      recursive: true
+    });
+  }
+  const rootDirectory = inWorkspace ? process.cwd() : directory;
+  const outputRoot = packageManager.createOutputTarget(rootDirectory);
+  const moduleTemplate = packageManager.loadTemplate('module');
+  const workspaceTemplate = packageManager.loadTemplate('workspace');
+
+  // If we aren’t already in a workspace, copy the workspace files over, which
+  // are needed if we are making a monorepo or not.
+  if (!inWorkspace) {
+    await workspaceTemplate.copy(directory, file => {
+      // When this is a single project, we use the project’s Quilt  configuration as the base.
+      if (file === 'quilt.workspace.ts') return createAsMonorepo;
+
+      // We need to make some adjustments to the root package.json
+      if (file === 'package.json') return false;
+      return true;
+    });
+
+    // If we are creating a monorepo, we need to add the root package.json and
+    // package manager workspace configuration.
+    if (createAsMonorepo) {
+      const moduleRelativeToRoot = packageManager.relativeDirectoryForDisplay(path__namespace.relative(directory, moduleDirectory));
+      const workspacePackageJson = JSON.parse(await workspaceTemplate.read('package.json'));
+      workspacePackageJson.name = packageManager.toValidPackageName(name);
+      workspacePackageJson.workspaces = [moduleRelativeToRoot, './packages/*'];
+      if (packageManager$1.type === 'pnpm') {
+        await outputRoot.write('pnpm-workspace.yaml', await packageManager.format(`
+              packages:
+              - '${moduleRelativeToRoot}'
+              - './packages/*'
+            `, {
+          as: 'yaml'
+        }));
+      }
+      await outputRoot.write('package.json', await packageManager.format(JSON.stringify(workspacePackageJson), {
+        as: 'json-stringify'
+      }));
+    } else {
+      const [projectPackageJson, projectTSConfig, workspacePackageJson] = await Promise.all([moduleTemplate.read('package.json').then(content => JSON.parse(content)), moduleTemplate.read('tsconfig.json').then(content => JSON.parse(content)), workspaceTemplate.read('package.json').then(content => JSON.parse(content))]);
+      const combinedPackageJson = packageManager.mergeWorkspaceAndProjectPackageJsons(projectPackageJson, workspacePackageJson);
+      adjustPackageJson(combinedPackageJson, {
+        name,
+        entry,
+        react: useReact
+      });
+      delete combinedPackageJson.workspaces;
+      let quiltProject = await moduleTemplate.read('quilt.project.ts');
+      quiltProject = quiltProject.replace('quiltModule', 'quiltWorkspace, quiltModule').replace('quiltModule(', 'quiltWorkspace(), quiltModule(');
+      if (!useReact) {
+        quiltProject = quiltProject.replace('quiltPackage()', 'quiltPackage({react: false})');
+      }
+      await outputRoot.write('quilt.project.ts', await packageManager.format(quiltProject, {
+        as: 'typescript'
+      }));
+      await outputRoot.write('package.json', await packageManager.format(JSON.stringify(combinedPackageJson), {
+        as: 'json-stringify'
+      }));
+      await outputRoot.write('tsconfig.json', await packageManager.format(JSON.stringify(projectTSConfig), {
+        as: 'json'
+      }));
+    }
+    if (setupExtras.has('github')) {
+      await packageManager.loadTemplate('github').copy(directory);
+    }
+    if (setupExtras.has('vscode')) {
+      await packageManager.loadTemplate('vscode').copy(directory);
+    }
+  }
+  await moduleTemplate.copy(moduleDirectory, file => {
+    // If we are in a monorepo, we can use all the template files as they are
+    if (file === 'quilt.project.ts' || file === 'tsconfig.json') {
+      return partOfMonorepo;
+    }
+
+    // We will adjust the entry file
+    if (file === 'module.ts') {
+      return false;
+    }
+
+    // We need to make some adjustments the project’s package.json
+    return file !== 'package.json';
+  });
+  await outputRoot.write(path__namespace.join(moduleDirectory, entry), await moduleTemplate.read('module.ts'));
+  if (partOfMonorepo) {
+    // Write the app’s package.json (the root one was already created)
+    const projectPackageJson = JSON.parse(await moduleTemplate.read('package.json'));
+    adjustPackageJson(projectPackageJson, {
+      name,
+      entry,
+      react: useReact
+    });
+    await outputRoot.write(path__namespace.join(moduleDirectory, 'package.json'), await packageManager.format(JSON.stringify(projectPackageJson), {
+      as: 'json-stringify'
+    }));
+    await Promise.all([packageManager.addToTsConfig(moduleDirectory, outputRoot), packageManager.addToPackageManagerWorkspaces(moduleDirectory, outputRoot, packageManager$1.type)]);
+  }
+  if (shouldInstall) {
+    console.log();
+    // TODO: better loading, handle errors
+    await packageManager$1.install();
+  }
+  const commands = [];
+  if (!inWorkspace && directory !== process.cwd()) {
+    commands.push(`cd ${packageManager.cyan_1(packageManager.relativeDirectoryForDisplay(path__namespace.relative(process.cwd(), directory)))} ${packageManager.dim_1('# Move into your new module’s directory')}`);
+  }
+  if (!shouldInstall) {
+    commands.push(`${packageManager$1.commands.install()} ${packageManager.dim_1('# Install all your dependencies')}`);
+  }
+  if (commands.length === 0) {
+    console.log();
+    console.log('Your new module is ready to go!');
+  } else {
+    const whatsNext = index.stripIndent`
+      Your new module is ready to go! There’s just ${commands.length > 1 ? 'a few more steps' : 'one more step'} you’ll need to take
+      in order to start developing:
+    `;
+    console.log();
+    console.log(whatsNext);
+    console.log();
+    console.log(commands.map(command => `  ${command}`).join('\n'));
+  }
+  const followUp = index.stripIndent`
+    Quilt can also help you build, test, lint, and type-check your new module.
+    You can learn more about building modules with Quilt by reading the documentation:
+    ${packageManager.underline_1(packageManager.magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation'))}
+
+    Have fun! 🎉
+  `;
+  console.log();
+  console.log(followUp);
+}
+
+// Argument handling
+
+function getArgv() {
+  const argv = index$1.arg_1({
+    '--yes': Boolean,
+    '-y': '--yes',
+    '--name': String,
+    '--directory': String,
+    '--entry': String,
+    '--install': Boolean,
+    '--no-install': Boolean,
+    '--monorepo': Boolean,
+    '--no-monorepo': Boolean,
+    '--package-manager': String,
+    '--extras': [String],
+    '--no-extras': Boolean,
+    '--react': Boolean,
+    '--no-react': Boolean,
+    '--help': Boolean,
+    '-h': '--help'
+  }, {
+    permissive: true
+  });
+  return argv;
+}
+async function getName(argv) {
+  let {
+    '--name': name
+  } = argv;
+  if (name == null) {
+    name = await index.prompt({
+      type: 'text',
+      message: 'What would you like to name your new module?',
+      initial: 'my-module'
+    });
+  }
+  return name;
+}
+async function getEntry(argv, {
+  name
+}) {
+  if (argv['--entry']) {
+    return argv['--entry'];
+  }
+  const entry = await index.prompt({
+    type: 'text',
+    message: 'What do you want to name your entry file?',
+    initial: `${packageManager.toValidPackageName(name)}.ts`
+  });
+  return entry;
+}
+async function getDirectory(argv, {
+  name
+}) {
+  let directory = path__namespace.resolve(argv['--directory'] ?? packageManager.toValidPackageName(name));
+  while (!argv['--yes']) {
+    if (fs__namespace.existsSync(directory) && !(await packageManager.isEmpty(directory))) {
+      const relativeDirectory = path__namespace.relative(process.cwd(), directory);
+      const empty = await index.prompt({
+        type: 'confirm',
+        message: `Directory ${packageManager.bold_1(packageManager.relativeDirectoryForDisplay(relativeDirectory))} is not empty, is it safe to empty it?`,
+        initial: true
+      });
+      if (empty) break;
+      const promptDirectory = await index.prompt({
+        type: 'text',
+        message: 'What directory do you want to create your new module in?'
+      });
+      directory = path__namespace.resolve(promptDirectory);
+    } else {
+      break;
+    }
+  }
+  return directory;
+}
+async function getReact(args) {
+  let useReact;
+  if (args['--react'] || args['--yes']) {
+    useReact = true;
+  } else if (args['--no-react']) {
+    useReact = false;
+  } else {
+    useReact = await index.prompt({
+      type: 'confirm',
+      message: 'Will this module depend on React?',
+      initial: false
+    });
+  }
+  return useReact;
+}
+function adjustPackageJson(packageJson, {
+  name,
+  entry,
+  react
+}) {
+  packageJson.name = name;
+  packageJson.main = `./${entry}`;
+  if (!react) {
+    delete packageJson.devDependencies['@types/react'];
+    delete packageJson.devDependencies['@types/react-dom'];
+    delete packageJson.devDependencies['preact'];
+    delete packageJson.devDependencies['react'];
+    delete packageJson.devDependencies['react-dom'];
+    packageJson.eslintConfig.extends = packageJson.eslintConfig.extends.filter(extend => !extend.includes('react'));
+  }
+  return packageJson;
+}
+
+exports.createModule = createModule;

package/build/cjs/package.cjs

@@ -376,7 +376,7 @@ async function getRepository(args, {
   if (!inWorkspace) return;
   const {
     globby
-  } = await Promise.resolve().then(function () { return require('./index4.cjs'); });
+  } = await Promise.resolve().then(function () { return require('./index5.cjs'); });
   const files = await globby('**/package.json', {
     ignore: ['**/node_modules']
   });

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

@@ -122,7 +122,7 @@ async function getPackageRoot() {
     packageRootPromise = (async () => {
       const {
         packageDirectory
-      } = await Promise.resolve().then(function () { return require('../index2.cjs'); });
+      } = 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))))
       });
@@ -603,7 +603,7 @@ async function addToPackageManagerWorkspaces(directory, output, packageManager)
     const {
       parse,
       stringify
-    } = await Promise.resolve().then(function () { return require('../index3.cjs'); }).then(function (n) { return n.index; });
+    } = await Promise.resolve().then(function () { return require('../index4.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.packages ?? []);
     await output.write('pnpm-workspace.yaml', await format(stringify(workspaceYaml), {

package/build/esm/app.mjs

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { a as arg_1 } from './index2.mjs';
 import { c as cyan_1, b as bold_1, g as getInWorkspace, a as getCreateAsMonorepo, d as getExtrasToSetup, e as getShouldInstall, f as getPackageManager, h as emptyDirectory, r as relativeDirectoryForDisplay, t as toValidPackageName, i as format, m as mergeWorkspaceAndProjectPackageJsons, l as loadTemplate, j as addToTsConfig, k as addToPackageManagerWorkspaces, n as dim_1, u as underline_1, o as magenta_1, p as isEmpty, q as createOutputTarget } from './shared/package-manager.mjs';
 import { s as stripIndent, p as printHelp, a as prompt } from './index.mjs';
 import 'node:tty';
@@ -8,202 +9,6 @@ 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;
-
 async function createApp() {
   const argv = getArgv();
   if (argv['--help']) {

package/build/esm/index.mjs

@@ -7122,6 +7122,7 @@ function printHelp({
 
      - ${magenta_1('app')}, a web application
      - ${magenta_1('package')}, a shared library of code
+     - ${magenta_1('module')}, a standalone JavaScript module for a browser
 
     You’ll be asked a few additional questions based on the kind you choose.
   `;
@@ -7194,7 +7195,7 @@ function createCommand(explicitPackageManager) {
 }
 
 /* eslint no-console: off */
-const VALID_PROJECT_KINDS = new Set(['app', 'package']);
+const VALID_PROJECT_KINDS = new Set(['app', 'package', 'module']);
 run().catch(error => {
   if (AbortError.test(error)) return;
   console.error(error);
@@ -7233,6 +7234,9 @@ async function run() {
       choices: [{
         title: 'App',
         value: 'app'
+      }, {
+        title: 'Module',
+        value: 'module'
       }, {
         title: 'Package',
         value: 'package'
@@ -7248,6 +7252,14 @@ async function run() {
         await createApp();
         break;
       }
+    case 'module':
+      {
+        const {
+          createModule
+        } = await import('./module.mjs');
+        await createModule();
+        break;
+      }
     case 'package':
       {
         const {