@quilted/create 0.1.18 → 0.1.21

package/build/esm/package.mjs

@@ -1,245 +1,437 @@
+import { _ as _asyncToGenerator, r as regenerator, s as stripIndent, a as _taggedTemplateLiteral, c as cyan_1, h as bold_1, d as dim_1, u as underline_1, m as magenta_1, g as getExtrasToSetup, b as getPackageManager, e as getShouldInstall, f as getCreateAsMonorepo, p as printHelp, i as arg_1, j as prompt, k as _defineProperty } from './index.mjs';
+import { r as relativeDirectoryForDisplay, a as addToTsConfig, b as addToPackageManagerWorkspaces, t as toValidPackageName, f as format, l as loadTemplate, _ as _slicedToArray, c as createOutputTarget, e as emptyDirectory, i as isEmpty } from './package-manager.mjs';
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
-import { s as stripIndent, c as cyan_1, p as printHelp, g as getCreateAsMonorepo, a as getShouldInstall, d as getPackageManager, e as getExtrasToSetup, b as bold_1, f as dim_1, u as underline_1, m as magenta_1, h as arg_1, i as prompt } from './index.mjs';
-import { t as toValidPackageName, e as emptyDirectory, f as format, l as loadTemplate, a as addToTsConfig, b as addToPackageManagerWorkspaces, r as relativeDirectoryForDisplay, i as isEmpty, c as createOutputTarget } from './package-manager.mjs';
 import 'tty';
 import 'url';
 import 'readline';
 import 'events';
 
-async function createPackage() {
-  const argv = getArgv();
-
-  if (argv['--help']) {
-    const additionalOptions = stripIndent`
-      ${cyan_1(`--react`)}, ${cyan_1(`--no-react`)}
-      Whether this package will use React. If you don’t provide this option, the command
-      will ask you about it later.
-
-      ${cyan_1(`--public`)}, ${cyan_1(`--private`)}
-      Whether this package will be published for other projects to install. If you do not
-      provide this option, the command will ask you about it later.
-
-      ${cyan_1(`--registry`)}
-      The package registry to publish this package to. This option only applies if you create
-      a public package. If you do not provide this option, it will use the default NPM registry.
-    `;
-    printHelp({
-      kind: 'package',
-      options: additionalOptions,
-      packageManager: argv['--package-manager']?.toLowerCase()
-    });
-    return;
-  }
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
 
-  const inWorkspace = fs.existsSync('quilt.workspace.ts');
-  const name = await getName(argv);
-  const directory = await getDirectory(argv, {
-    name,
-    inWorkspace
-  });
-  const isPublic = await getPublic(argv);
-  const useReact = await getReact(argv);
-  const createAsMonorepo = !inWorkspace && (await getCreateAsMonorepo(argv));
-  const shouldInstall = await getShouldInstall(argv);
-  const packageManager = await getPackageManager(argv);
-  const setupExtras = await getExtrasToSetup(argv, {
-    inWorkspace
-  });
-  const partOfMonorepo = inWorkspace || createAsMonorepo;
-  const packageDirectory = createAsMonorepo ? path.join(directory, `packages/${toValidPackageName(name.split('/').pop())}`) : directory;
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-  if (fs.existsSync(directory)) {
-    await emptyDirectory(directory);
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-    if (packageDirectory !== directory) {
-      fs.mkdirSync(packageDirectory, {
-        recursive: true
-      });
-    }
-  } else {
-    fs.mkdirSync(packageDirectory, {
-      recursive: true
-    });
-  }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
-  const rootDirectory = inWorkspace ? process.cwd() : directory;
-  const outputRoot = createOutputTarget(rootDirectory);
-  const packageTemplate = loadTemplate('package');
-  const workspaceTemplate = loadTemplate('workspace');
-  let quiltProject = await packageTemplate.read('quilt.project.ts');
-
-  if (useReact) {
-    quiltProject = quiltProject.replace('react: false', 'react: true');
-  } // 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
-
-      return file !== 'package.json';
-    }); // If we are creating a monorepo, we need to add the root package.json and
-    // package manager workspace configuration.
-
-    if (createAsMonorepo) {
-      const workspacePackageJson = JSON.parse(await workspaceTemplate.read('package.json'));
-      workspacePackageJson.name = toValidPackageName(name);
-
-      if (packageManager === 'pnpm') {
-        await outputRoot.write('pnpm-workspace.yaml', await format(`
-              packages:
-              - './packages/*'
-            `, {
-          as: 'yaml'
-        }));
-      } else {
-        workspacePackageJson.workspaces = ['packages/*'];
-      }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-      await outputRoot.write('package.json', await format(JSON.stringify(workspacePackageJson), {
-        as: 'json-stringify'
-      }));
-    } else {
-      const [projectPackageJson, projectTSConfig, workspacePackageJson] = await Promise.all([packageTemplate.read('package.json').then(content => JSON.parse(content)), packageTemplate.read('tsconfig.json').then(content => JSON.parse(content)), workspaceTemplate.read('package.json').then(content => JSON.parse(content))]);
-      workspacePackageJson.eslintConfig = projectPackageJson.eslintConfig;
-      workspacePackageJson.browserslist = projectPackageJson.browserslist;
-      const newPackageJson = {}; // We want to put the project’s dependencies in the package.json, respecting
-      // the preferred ordering (dependencies, peer dependencies, dev dependencies).
-
-      for (const [key, value] of Object.entries(projectPackageJson)) {
-        if (key !== 'devDependencies') {
-          newPackageJson[key] = value;
-          continue;
-        }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function createProject() {
+  return _createProject.apply(this, arguments);
+} // Argument handling
 
-        newPackageJson.dependencies = projectPackageJson.dependencies;
-        newPackageJson.peerDependencies = projectPackageJson.peerDependencies;
-        newPackageJson.peerDependenciesMeta = projectPackageJson.peerDependenciesMeta;
-        newPackageJson.devDependencies = sortKeys({ ...workspacePackageJson.devDependencies,
-          ...projectPackageJson.devDependencies
-        });
+function _createProject() {
+  _createProject = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
+    var argv, _argv$PackageManag, additionalOptions, inWorkspace, name, directory, isPublic, useReact, createAsMonorepo, shouldInstall, packageManager, setupExtras, partOfMonorepo, packageDirectory, rootDirectory, outputRoot, packageTemplate, workspaceTemplate, quiltProject, workspacePackageJson, _yield$Promise$all, _yield$Promise$all2, projectPackageJson, projectTSConfig, _workspacePackageJson, newPackageJson, _i, _Object$entries, _Object$entries$_i, key, value, _projectPackageJson, packageJsonInstructions, commands, whatsNext, followUp;
+
+    return regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            argv = getArgv();
+
+            if (!argv['--help']) {
+              _context.next = 5;
+              break;
+            }
+
+            additionalOptions = stripIndent(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      ", ", ", "\n      Whether this package will use React. If you don\u2019t provide this option, the command\n      will ask you about it later.\n\n      ", ", ", "\n      Whether this package will be published for other projects to install. If you do not\n      provide this option, the command will ask you about it later.\n\n      ", "\n      The package registry to publish this package to. This option only applies if you create\n      a public package. If you do not provide this option, it will use the default NPM registry.\n    "])), cyan_1("--react"), cyan_1("--no-react"), cyan_1("--public"), cyan_1("--private"), cyan_1("--registry"));
+            printHelp({
+              kind: 'package',
+              options: additionalOptions,
+              packageManager: (_argv$PackageManag = argv['--package-manager']) === null || _argv$PackageManag === void 0 ? void 0 : _argv$PackageManag.toLowerCase()
+            });
+            return _context.abrupt("return");
+
+          case 5:
+            inWorkspace = fs.existsSync('quilt.workspace.ts');
+            _context.next = 8;
+            return getName(argv);
+
+          case 8:
+            name = _context.sent;
+            _context.next = 11;
+            return getDirectory(argv, {
+              name: name,
+              inWorkspace: inWorkspace
+            });
+
+          case 11:
+            directory = _context.sent;
+            _context.next = 14;
+            return getPublic(argv);
+
+          case 14:
+            isPublic = _context.sent;
+            _context.next = 17;
+            return getReact(argv);
+
+          case 17:
+            useReact = _context.sent;
+            _context.t0 = !inWorkspace;
+
+            if (!_context.t0) {
+              _context.next = 23;
+              break;
+            }
+
+            _context.next = 22;
+            return getCreateAsMonorepo(argv);
+
+          case 22:
+            _context.t0 = _context.sent;
+
+          case 23:
+            createAsMonorepo = _context.t0;
+            _context.next = 26;
+            return getShouldInstall(argv);
+
+          case 26:
+            shouldInstall = _context.sent;
+            _context.next = 29;
+            return getPackageManager(argv);
+
+          case 29:
+            packageManager = _context.sent;
+            _context.next = 32;
+            return getExtrasToSetup(argv, {
+              inWorkspace: inWorkspace
+            });
+
+          case 32:
+            setupExtras = _context.sent;
+            partOfMonorepo = inWorkspace || createAsMonorepo;
+            packageDirectory = createAsMonorepo ? path.join(directory, "packages/".concat(toValidPackageName(name.split('/').pop()))) : directory;
+
+            if (!fs.existsSync(directory)) {
+              _context.next = 41;
+              break;
+            }
+
+            _context.next = 38;
+            return emptyDirectory(directory);
+
+          case 38:
+            if (packageDirectory !== directory) {
+              fs.mkdirSync(packageDirectory, {
+                recursive: true
+              });
+            }
+
+            _context.next = 42;
+            break;
+
+          case 41:
+            fs.mkdirSync(packageDirectory, {
+              recursive: true
+            });
+
+          case 42:
+            rootDirectory = inWorkspace ? process.cwd() : directory;
+            outputRoot = createOutputTarget(rootDirectory);
+            packageTemplate = loadTemplate('package');
+            workspaceTemplate = loadTemplate('workspace');
+            _context.next = 48;
+            return packageTemplate.read('quilt.project.ts');
+
+          case 48:
+            quiltProject = _context.sent;
+
+            if (useReact) {
+              quiltProject = quiltProject.replace('react: false', 'react: true');
+            } // 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) {
+              _context.next = 127;
+              break;
+            }
+
+            _context.next = 53;
+            return workspaceTemplate.copy(directory, function (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
+
+              return file !== 'package.json';
+            });
+
+          case 53:
+            if (!createAsMonorepo) {
+              _context.next = 78;
+              break;
+            }
+
+            _context.t1 = JSON;
+            _context.next = 57;
+            return workspaceTemplate.read('package.json');
+
+          case 57:
+            _context.t2 = _context.sent;
+            workspacePackageJson = _context.t1.parse.call(_context.t1, _context.t2);
+            workspacePackageJson.name = toValidPackageName(name);
+
+            if (!(packageManager === 'pnpm')) {
+              _context.next = 69;
+              break;
+            }
+
+            _context.t3 = outputRoot;
+            _context.next = 64;
+            return format("\n              packages:\n              - './packages/*'\n            ", {
+              as: 'yaml'
+            });
+
+          case 64:
+            _context.t4 = _context.sent;
+            _context.next = 67;
+            return _context.t3.write.call(_context.t3, 'pnpm-workspace.yaml', _context.t4);
+
+          case 67:
+            _context.next = 70;
+            break;
+
+          case 69:
+            workspacePackageJson.workspaces = ['packages/*'];
+
+          case 70:
+            _context.t5 = outputRoot;
+            _context.next = 73;
+            return format(JSON.stringify(workspacePackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 73:
+            _context.t6 = _context.sent;
+            _context.next = 76;
+            return _context.t5.write.call(_context.t5, 'package.json', _context.t6);
+
+          case 76:
+            _context.next = 121;
+            break;
+
+          case 78:
+            _context.next = 80;
+            return Promise.all([packageTemplate.read('package.json').then(function (content) {
+              return JSON.parse(content);
+            }), packageTemplate.read('tsconfig.json').then(function (content) {
+              return JSON.parse(content);
+            }), workspaceTemplate.read('package.json').then(function (content) {
+              return JSON.parse(content);
+            })]);
+
+          case 80:
+            _yield$Promise$all = _context.sent;
+            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 3);
+            projectPackageJson = _yield$Promise$all2[0];
+            projectTSConfig = _yield$Promise$all2[1];
+            _workspacePackageJson = _yield$Promise$all2[2];
+            _workspacePackageJson.eslintConfig = projectPackageJson.eslintConfig;
+            _workspacePackageJson.browserslist = projectPackageJson.browserslist;
+            newPackageJson = {}; // We want to put the project’s dependencies in the package.json, respecting
+            // the preferred ordering (dependencies, peer dependencies, dev dependencies).
+
+            _i = 0, _Object$entries = Object.entries(projectPackageJson);
+
+          case 89:
+            if (!(_i < _Object$entries.length)) {
+              _context.next = 101;
+              break;
+            }
+
+            _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), key = _Object$entries$_i[0], value = _Object$entries$_i[1];
+
+            if (!(key !== 'devDependencies')) {
+              _context.next = 94;
+              break;
+            }
+
+            newPackageJson[key] = value;
+            return _context.abrupt("continue", 98);
+
+          case 94:
+            newPackageJson.dependencies = projectPackageJson.dependencies;
+            newPackageJson.peerDependencies = projectPackageJson.peerDependencies;
+            newPackageJson.peerDependenciesMeta = projectPackageJson.peerDependenciesMeta;
+            newPackageJson.devDependencies = sortKeys(_objectSpread(_objectSpread({}, _workspacePackageJson.devDependencies), projectPackageJson.devDependencies));
+
+          case 98:
+            _i++;
+            _context.next = 89;
+            break;
+
+          case 101:
+            adjustPackageJson(newPackageJson, {
+              name: toValidPackageName(name),
+              react: useReact,
+              isPublic: isPublic,
+              registry: argv['--registry']
+            });
+            quiltProject = quiltProject.replace('quiltPackage', 'quiltWorkspace, quiltPackage').replace('quiltPackage(', 'quiltWorkspace(), quiltPackage(');
+            _context.t7 = outputRoot;
+            _context.next = 106;
+            return format(quiltProject, {
+              as: 'typescript'
+            });
+
+          case 106:
+            _context.t8 = _context.sent;
+            _context.next = 109;
+            return _context.t7.write.call(_context.t7, 'quilt.project.ts', _context.t8);
+
+          case 109:
+            _context.t9 = outputRoot;
+            _context.next = 112;
+            return format(JSON.stringify(newPackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 112:
+            _context.t10 = _context.sent;
+            _context.next = 115;
+            return _context.t9.write.call(_context.t9, 'package.json', _context.t10);
+
+          case 115:
+            _context.t11 = outputRoot;
+            _context.next = 118;
+            return format(JSON.stringify(projectTSConfig), {
+              as: 'json'
+            });
+
+          case 118:
+            _context.t12 = _context.sent;
+            _context.next = 121;
+            return _context.t11.write.call(_context.t11, 'tsconfig.json', _context.t12);
+
+          case 121:
+            if (!setupExtras.has('github')) {
+              _context.next = 124;
+              break;
+            }
+
+            _context.next = 124;
+            return loadTemplate('github').copy(directory);
+
+          case 124:
+            if (!setupExtras.has('vscode')) {
+              _context.next = 127;
+              break;
+            }
+
+            _context.next = 127;
+            return loadTemplate('vscode').copy(directory);
+
+          case 127:
+            _context.next = 129;
+            return packageTemplate.copy(packageDirectory, function (file) {
+              // If we are in a monorepo, we can use all the template files as they are
+              if (file === 'tsconfig.json') {
+                return partOfMonorepo;
+              } // We need to make some adjustments the project’s package.json and Quilt config
+
+
+              return file !== 'package.json' && file !== 'quilt.project.ts';
+            });
+
+          case 129:
+            if (!partOfMonorepo) {
+              _context.next = 148;
+              break;
+            }
+
+            _context.t13 = JSON;
+            _context.next = 133;
+            return packageTemplate.read('package.json');
+
+          case 133:
+            _context.t14 = _context.sent;
+            _projectPackageJson = _context.t13.parse.call(_context.t13, _context.t14);
+            _projectPackageJson.repository.directory = path.relative(directory, packageDirectory);
+            adjustPackageJson(_projectPackageJson, {
+              name: toValidPackageName(name),
+              react: useReact,
+              isPublic: isPublic,
+              registry: argv['--registry']
+            });
+            _context.t15 = outputRoot;
+            _context.t16 = path.join(packageDirectory, 'package.json');
+            _context.next = 141;
+            return format(JSON.stringify(_projectPackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 141:
+            _context.t17 = _context.sent;
+            _context.next = 144;
+            return _context.t15.write.call(_context.t15, _context.t16, _context.t17);
+
+          case 144:
+            _context.next = 146;
+            return outputRoot.write(path.join(packageDirectory, 'quilt.project.ts'), quiltProject);
+
+          case 146:
+            _context.next = 148;
+            return Promise.all([addToTsConfig(packageDirectory, outputRoot), addToPackageManagerWorkspaces(packageDirectory, outputRoot, packageManager)]);
+
+          case 148:
+            if (shouldInstall) {
+              process.stdout.write('\nInstalling dependencies...\n'); // TODO: better loading, handle errors
+
+              execSync("".concat(packageManager, " install"), {
+                cwd: rootDirectory
+              });
+              process.stdout.moveCursor(0, -1);
+              process.stdout.clearLine(1);
+              console.log('Installed dependencies.');
+            }
+
+            packageJsonInstructions = stripIndent(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    Your new package is ready to go! However, before you go too much further,\n    you should update the following fields in ", ":\n\n     - ", ", where you provide a description of what your package does\n     - ", ", where you should include the ", " of your project\u2019s repo\n\n    Before you publish your package, you will also want to update the ", "\n    field in the package.json file.\n  "])), cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), path.join(packageDirectory, 'package.json')))), bold_1("\"description\""), bold_1("\"repository\""), bold_1("\"url\""), bold_1("\"version\""));
+            console.log();
+            console.log(packageJsonInstructions);
+            commands = [];
+
+            if (!inWorkspace && directory !== process.cwd()) {
+              commands.push("cd ".concat(cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), directory))), " ").concat(dim_1('# Move into your new package’s directory')));
+            }
+
+            if (!shouldInstall) {
+              commands.push("pnpm install ".concat(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\" ".concat(dim_1('# Start your git history (optional)')));
+            }
+
+            if (commands.length > 0) {
+              whatsNext = stripIndent(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n      After you update your package.json, there\u2019s ", " you\u2019ll need to take\n      in order to start building:\n    "])), commands.length > 1 ? 'a few more steps' : 'one more step');
+              console.log();
+              console.log(whatsNext);
+              console.log();
+              console.log(commands.map(function (command) {
+                return "  ".concat(command);
+              }).join('\n'));
+            }
+
+            followUp = stripIndent(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n    Quilt can help you build, test, lint, and type-check your new package. You\n    can learn more about building packages with Quilt by reading the documentation:\n    ", "\n\n    Have fun! \uD83C\uDF89\n  "])), underline_1(magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation')));
+            console.log();
+            console.log(followUp);
+
+          case 160:
+          case "end":
+            return _context.stop();
+        }
       }
-
-      adjustPackageJson(newPackageJson, {
-        name: toValidPackageName(name),
-        react: useReact,
-        isPublic,
-        registry: argv['--registry']
-      });
-      quiltProject = quiltProject.replace('quiltPackage', 'quiltWorkspace, quiltPackage').replace('quiltPackage(', 'quiltWorkspace(), quiltPackage(');
-      await outputRoot.write('quilt.project.ts', await format(quiltProject, {
-        as: 'typescript'
-      }));
-      await outputRoot.write('package.json', await format(JSON.stringify(newPackageJson), {
-        as: 'json-stringify'
-      }));
-      await outputRoot.write('tsconfig.json', await format(JSON.stringify(projectTSConfig), {
-        as: 'json'
-      }));
-    }
-
-    if (setupExtras.has('github')) {
-      await loadTemplate('github').copy(directory);
-    }
-
-    if (setupExtras.has('vscode')) {
-      await loadTemplate('vscode').copy(directory);
-    }
-  }
-
-  await packageTemplate.copy(packageDirectory, file => {
-    // If we are in a monorepo, we can use all the template files as they are
-    if (file === 'tsconfig.json') {
-      return partOfMonorepo;
-    } // We need to make some adjustments the project’s package.json and Quilt config
-
-
-    return file !== 'package.json' && file !== 'quilt.project.ts';
-  });
-
-  if (partOfMonorepo) {
-    // Write the package’s package.json (the root one was already created)
-    const projectPackageJson = JSON.parse(await packageTemplate.read('package.json'));
-    projectPackageJson.repository.directory = path.relative(directory, packageDirectory);
-    adjustPackageJson(projectPackageJson, {
-      name: toValidPackageName(name),
-      react: useReact,
-      isPublic,
-      registry: argv['--registry']
-    });
-    await outputRoot.write(path.join(packageDirectory, 'package.json'), await format(JSON.stringify(projectPackageJson), {
-      as: 'json-stringify'
-    }));
-    await outputRoot.write(path.join(packageDirectory, 'quilt.project.ts'), quiltProject);
-    await Promise.all([addToTsConfig(packageDirectory, outputRoot), addToPackageManagerWorkspaces(packageDirectory, outputRoot, packageManager)]);
-  }
-
-  if (shouldInstall) {
-    process.stdout.write('\nInstalling dependencies...\n'); // TODO: better loading, handle errors
-
-    execSync(`${packageManager} install`, {
-      cwd: rootDirectory
-    });
-    process.stdout.moveCursor(0, -1);
-    process.stdout.clearLine(1);
-    console.log('Installed dependencies.');
-  }
-
-  const packageJsonInstructions = stripIndent`
-    Your new package is ready to go! However, before you go too much further,
-    you should update the following fields in ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), path.join(packageDirectory, 'package.json'))))}:
-
-     - ${bold_1(`"description"`)}, where you provide a description of what your package does
-     - ${bold_1(`"repository"`)}, where you should include the ${bold_1(`"url"`)} of your project’s repo
-
-    Before you publish your package, you will also want to update the ${bold_1(`"version"`)}
-    field in the package.json file.
-  `;
-  console.log();
-  console.log(packageJsonInstructions);
-  const commands = [];
-
-  if (!inWorkspace && directory !== process.cwd()) {
-    commands.push(`cd ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), directory)))} ${dim_1('# Move into your new package’s directory')}`);
-  }
-
-  if (!shouldInstall) {
-    commands.push(`pnpm install ${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" ${dim_1('# Start your git history (optional)')}`);
-  }
-
-  if (commands.length > 0) {
-    const whatsNext = stripIndent`
-      After you update your package.json, there’s ${commands.length > 1 ? 'a few more steps' : 'one more step'} you’ll need to take
-      in order to start building:
-    `;
-    console.log();
-    console.log(whatsNext);
-    console.log();
-    console.log(commands.map(command => `  ${command}`).join('\n'));
-  }
-
-  const followUp = stripIndent`
-    Quilt can help you build, test, lint, and type-check your new package. You
-    can learn more about building packages with Quilt by reading the documentation:
-    ${underline_1(magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation'))}
-
-    Have fun! 🎉
-  `;
-  console.log();
-  console.log(followUp);
-} // Argument handling
+    }, _callee);
+  }));
+  return _createProject.apply(this, arguments);
+}
 
 function getArgv() {
-  const argv = arg_1({
+  var argv = arg_1({
     '--yes': Boolean,
     '-y': '--yes',
     '--name': String,
@@ -264,115 +456,282 @@ function getArgv() {
   return argv;
 }
 
-async function getName(argv) {
-  let {
-    '--name': name
-  } = argv;
-
-  if (name == null) {
-    name = await prompt({
-      type: 'text',
-      message: 'What would you like to name your new package?',
-      initial: '@my-team/package'
-    });
-  }
-
-  return name;
+function getName(_x) {
+  return _getName.apply(this, arguments);
 }
 
-async function getDirectory(argv, {
-  name,
-  inWorkspace
-}) {
-  let directory = argv['--directory'] ? path.resolve(argv['--directory']) : undefined;
-
-  if (directory == null) {
-    const basePackageName = toValidPackageName(name.split('/').pop());
-    const defaultDirectory = inWorkspace ? `packages/${basePackageName}` : basePackageName;
-    directory = path.resolve(await prompt({
-      type: 'text',
-      message: 'Where would you like to create your new package?',
-      initial: defaultDirectory
-    }));
-  }
-
-  while (!argv['--yes']) {
-    if (fs.existsSync(directory) && !(await isEmpty(directory))) {
-      const relativeDirectory = path.relative(process.cwd(), directory);
-      const empty = await prompt({
-        type: 'confirm',
-        message: `Directory ${bold_1(relativeDirectoryForDisplay(relativeDirectory))} is not empty, is it safe to empty it?`,
-        initial: true
-      });
-      if (empty) break;
-      const promptDirectory = await prompt({
-        type: 'text',
-        message: 'What directory do you want to create your package in?'
-      });
-      directory = path.resolve(promptDirectory);
-    } else {
-      break;
-    }
-  }
-
-  return directory;
+function _getName() {
+  _getName = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(argv) {
+    var name;
+    return regenerator.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            name = argv['--name'];
+
+            if (!(name == null)) {
+              _context2.next = 5;
+              break;
+            }
+
+            _context2.next = 4;
+            return prompt({
+              type: 'text',
+              message: 'What would you like to name your new package?',
+              initial: '@my-team/package'
+            });
+
+          case 4:
+            name = _context2.sent;
+
+          case 5:
+            return _context2.abrupt("return", name);
+
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getName.apply(this, arguments);
 }
 
-async function getPublic(argv) {
-  let isPublic;
+function getDirectory(_x2, _x3) {
+  return _getDirectory.apply(this, arguments);
+}
 
-  if (argv['--public'] || argv['--yes']) {
-    isPublic = true;
-  } else if (argv['--private']) {
-    isPublic = false;
-  } else {
-    isPublic = await prompt({
-      type: 'confirm',
-      message: 'Will you publish this package to use in other projects?',
-      initial: true
-    });
-  }
+function _getDirectory() {
+  _getDirectory = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(argv, _ref) {
+    var name, inWorkspace, directory, basePackageName, defaultDirectory, relativeDirectory, empty, promptDirectory;
+    return regenerator.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            name = _ref.name, inWorkspace = _ref.inWorkspace;
+            directory = argv['--directory'] ? path.resolve(argv['--directory']) : undefined;
+
+            if (!(directory == null)) {
+              _context3.next = 10;
+              break;
+            }
+
+            basePackageName = toValidPackageName(name.split('/').pop());
+            defaultDirectory = inWorkspace ? "packages/".concat(basePackageName) : basePackageName;
+            _context3.t0 = path;
+            _context3.next = 8;
+            return prompt({
+              type: 'text',
+              message: 'Where would you like to create your new package?',
+              initial: defaultDirectory
+            });
+
+          case 8:
+            _context3.t1 = _context3.sent;
+            directory = _context3.t0.resolve.call(_context3.t0, _context3.t1);
+
+          case 10:
+            if (argv['--yes']) {
+              _context3.next = 32;
+              break;
+            }
+
+            _context3.t2 = fs.existsSync(directory);
+
+            if (!_context3.t2) {
+              _context3.next = 16;
+              break;
+            }
+
+            _context3.next = 15;
+            return isEmpty(directory);
+
+          case 15:
+            _context3.t2 = !_context3.sent;
+
+          case 16:
+            if (!_context3.t2) {
+              _context3.next = 29;
+              break;
+            }
+
+            relativeDirectory = path.relative(process.cwd(), directory);
+            _context3.next = 20;
+            return prompt({
+              type: 'confirm',
+              message: "Directory ".concat(bold_1(relativeDirectoryForDisplay(relativeDirectory)), " is not empty, is it safe to empty it?"),
+              initial: true
+            });
+
+          case 20:
+            empty = _context3.sent;
+
+            if (!empty) {
+              _context3.next = 23;
+              break;
+            }
+
+            return _context3.abrupt("break", 32);
+
+          case 23:
+            _context3.next = 25;
+            return prompt({
+              type: 'text',
+              message: 'What directory do you want to create your package in?'
+            });
+
+          case 25:
+            promptDirectory = _context3.sent;
+            directory = path.resolve(promptDirectory);
+            _context3.next = 30;
+            break;
+
+          case 29:
+            return _context3.abrupt("break", 32);
+
+          case 30:
+            _context3.next = 10;
+            break;
+
+          case 32:
+            return _context3.abrupt("return", directory);
+
+          case 33:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _getDirectory.apply(this, arguments);
+}
 
-  return isPublic;
+function getPublic(_x4) {
+  return _getPublic.apply(this, arguments);
 }
 
-async function getReact(argv) {
-  let useReact;
+function _getPublic() {
+  _getPublic = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(argv) {
+    var isPublic;
+    return regenerator.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!(argv['--public'] || argv['--yes'])) {
+              _context4.next = 4;
+              break;
+            }
+
+            isPublic = true;
+            _context4.next = 11;
+            break;
+
+          case 4:
+            if (!argv['--private']) {
+              _context4.next = 8;
+              break;
+            }
+
+            isPublic = false;
+            _context4.next = 11;
+            break;
+
+          case 8:
+            _context4.next = 10;
+            return prompt({
+              type: 'confirm',
+              message: 'Will you publish this package to use in other projects?',
+              initial: true
+            });
+
+          case 10:
+            isPublic = _context4.sent;
+
+          case 11:
+            return _context4.abrupt("return", isPublic);
+
+          case 12:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _getPublic.apply(this, arguments);
+}
 
-  if (argv['--react'] || argv['--yes']) {
-    useReact = true;
-  } else if (argv['--no-react']) {
-    useReact = false;
-  } else {
-    useReact = await prompt({
-      type: 'confirm',
-      message: 'Will this package depend on React?',
-      initial: true
-    });
-  }
+function getReact(_x5) {
+  return _getReact.apply(this, arguments);
+}
 
-  return useReact;
+function _getReact() {
+  _getReact = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5(argv) {
+    var useReact;
+    return regenerator.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            if (!(argv['--react'] || argv['--yes'])) {
+              _context5.next = 4;
+              break;
+            }
+
+            useReact = true;
+            _context5.next = 11;
+            break;
+
+          case 4:
+            if (!argv['--no-react']) {
+              _context5.next = 8;
+              break;
+            }
+
+            useReact = false;
+            _context5.next = 11;
+            break;
+
+          case 8:
+            _context5.next = 10;
+            return prompt({
+              type: 'confirm',
+              message: 'Will this package depend on React?',
+              initial: true
+            });
+
+          case 10:
+            useReact = _context5.sent;
+
+          case 11:
+            return _context5.abrupt("return", useReact);
+
+          case 12:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _getReact.apply(this, arguments);
 }
 
-function adjustPackageJson(packageJson, {
-  name,
-  react,
-  isPublic,
-  registry
-}) {
+function adjustPackageJson(packageJson, _ref2) {
+  var name = _ref2.name,
+      react = _ref2.react,
+      isPublic = _ref2.isPublic,
+      registry = _ref2.registry;
   packageJson.name = name;
-  const packageParts = name.split('/');
-  const scope = packageParts[0].startsWith('@') ? packageParts[0] : undefined;
-  const finalRegistry = registry ?? 'https://registry.npmjs.org';
+  var packageParts = name.split('/');
+  var scope = packageParts[0].startsWith('@') ? packageParts[0] : undefined;
+  var finalRegistry = registry !== null && registry !== void 0 ? registry : 'https://registry.npmjs.org';
 
   if (scope) {
-    packageJson.publishConfig[`${scope}/registry`] = finalRegistry;
+    packageJson.publishConfig["".concat(scope, "/registry")] = finalRegistry;
   } else if (registry) {
     packageJson.publishConfig.registry = finalRegistry;
   }
 
   if (isPublic) {
-    delete packageJson.private;
+    delete packageJson["private"];
   } else {
     delete packageJson.publishConfig;
   }
@@ -382,21 +741,44 @@ function adjustPackageJson(packageJson, {
     delete packageJson.devDependencies['react'];
     delete packageJson.peerDependencies['react'];
     delete packageJson.peerDependenciesMeta['react'];
-    packageJson.eslintConfig.extends = packageJson.eslintConfig.extends.filter(extend => !extend.includes('react'));
+    packageJson.eslintConfig["extends"] = packageJson.eslintConfig["extends"].filter(function (extend) {
+      return !extend.includes('react');
+    });
   }
 
   return packageJson;
 }
 
 function sortKeys(object) {
-  const newObject = {};
-  const sortedEntries = Object.entries(object).sort(([keyOne], [keyTwo]) => keyOne.localeCompare(keyTwo));
+  var newObject = {};
+  var sortedEntries = Object.entries(object).sort(function (_ref3, _ref4) {
+    var _ref5 = _slicedToArray(_ref3, 1),
+        keyOne = _ref5[0];
 
-  for (const [key, value] of sortedEntries) {
-    newObject[key] = value;
+    var _ref6 = _slicedToArray(_ref4, 1),
+        keyTwo = _ref6[0];
+
+    return keyOne.localeCompare(keyTwo);
+  });
+
+  var _iterator = _createForOfIteratorHelper(sortedEntries),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+          key = _step$value[0],
+          value = _step$value[1];
+
+      newObject[key] = value;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
 
   return newObject;
 }
 
-export { createPackage };
+export { createProject };