@quilted/create 0.1.18 → 0.1.21

package/build/cjs/app.cjs

@@ -1,12 +1,12 @@
 'use strict';
 
+var packageManager = require('./package-manager.cjs');
+var index = require('./index.cjs');
 var fs = require('fs');
 var path = require('path');
 var child_process = require('child_process');
-var index = require('./index.cjs');
-var packageManager = require('./package-manager.cjs');
-require('tty');
 require('url');
+require('tty');
 require('readline');
 require('events');
 
@@ -31,185 +31,358 @@ function _interopNamespace(e) {
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 
-async function createApp() {
-  const argv = getArgv();
-
-  if (argv['--help']) {
-    const additionalOptions = index.stripIndent`
-      ${index.cyan_1(`--template`)}
-      The template to use for your new application. If you don’t specify a template,
-      this command will ask you for one instead. Must be one of the following:
-
-       - ${index.bold_1('basic')}, a web app with a minimal file structure
-       - ${index.bold_1('single-file')}, an entire web app in a single file
-    `;
-    index.printHelp({
-      kind: 'app',
-      options: additionalOptions,
-      packageManager: argv['--package-manager']?.toLowerCase()
-    });
-    return;
-  }
-
-  const inWorkspace = fs__namespace.existsSync('quilt.workspace.ts');
-  const name = await getName(argv, {
-    inWorkspace
-  });
-  const directory = await getDirectory(argv, {
-    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, {
-    inWorkspace
-  });
-  const partOfMonorepo = inWorkspace || createAsMonorepo;
-  const appDirectory = createAsMonorepo ? path__namespace.join(directory, 'app') : directory;
-
-  if (fs__namespace.existsSync(directory)) {
-    await packageManager.emptyDirectory(directory);
-
-    if (appDirectory !== directory) {
-      fs__namespace.mkdirSync(appDirectory, {
-        recursive: true
-      });
-    }
-  } else {
-    fs__namespace.mkdirSync(appDirectory, {
-      recursive: true
-    });
-  }
+var _templateObject, _templateObject2, _templateObject3;
+function createApp() {
+  return _createApp.apply(this, arguments);
+} // Argument handling
 
-  const rootDirectory = inWorkspace ? process.cwd() : directory;
-  const outputRoot = packageManager.createOutputTarget(rootDirectory);
-  const appTemplate = packageManager.loadTemplate(template === 'basic' ? 'app-basic' : 'app-single-file');
-  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
-
-      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 = packageManager.toValidPackageName(name);
-
-      if (packageManager$1 === 'pnpm') {
-        await outputRoot.write('pnpm-workspace.yaml', await packageManager.format(`
-              packages:
-              - './packages/*'
-            `, {
-          as: 'yaml'
-        }));
-      } else {
-        workspacePackageJson.workspaces = ['packages/*'];
+function _createApp() {
+  _createApp = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee() {
+    var argv, _argv$PackageManag, additionalOptions, inWorkspace, name, directory, template, createAsMonorepo, shouldInstall, packageManager$1, setupExtras, partOfMonorepo, appDirectory, rootDirectory, outputRoot, appTemplate, workspaceTemplate, workspacePackageJson, _yield$Promise$all, _yield$Promise$all2, projectPackageJson, projectTSConfig, _workspacePackageJson, quiltProject, _projectPackageJson, commands, whatsNext, followUp;
+
+    return index.regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            argv = getArgv();
+
+            if (!argv['--help']) {
+              _context.next = 5;
+              break;
+            }
+
+            additionalOptions = index.stripIndent(_templateObject || (_templateObject = index._taggedTemplateLiteral(["\n      ", "\n      The template to use for your new application. If you don\u2019t specify a template,\n      this command will ask you for one instead. Must be one of the following:\n\n       - ", ", a web app with a minimal file structure\n       - ", ", an entire web app in a single file\n    "])), index.cyan_1("--template"), index.bold_1('basic'), index.bold_1('single-file'));
+            index.printHelp({
+              kind: 'app',
+              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__namespace.existsSync('quilt.workspace.ts');
+            _context.next = 8;
+            return getName(argv, {
+              inWorkspace: inWorkspace
+            });
+
+          case 8:
+            name = _context.sent;
+            _context.next = 11;
+            return getDirectory(argv, {
+              name: name
+            });
+
+          case 11:
+            directory = _context.sent;
+            _context.next = 14;
+            return getTemplate(argv);
+
+          case 14:
+            template = _context.sent;
+            _context.t0 = !inWorkspace;
+
+            if (!_context.t0) {
+              _context.next = 20;
+              break;
+            }
+
+            _context.next = 19;
+            return index.getCreateAsMonorepo(argv);
+
+          case 19:
+            _context.t0 = _context.sent;
+
+          case 20:
+            createAsMonorepo = _context.t0;
+            _context.next = 23;
+            return index.getShouldInstall(argv);
+
+          case 23:
+            shouldInstall = _context.sent;
+            _context.next = 26;
+            return index.getPackageManager(argv);
+
+          case 26:
+            packageManager$1 = _context.sent;
+            _context.next = 29;
+            return index.getExtrasToSetup(argv, {
+              inWorkspace: inWorkspace
+            });
+
+          case 29:
+            setupExtras = _context.sent;
+            partOfMonorepo = inWorkspace || createAsMonorepo;
+            appDirectory = createAsMonorepo ? path__namespace.join(directory, 'app') : directory;
+
+            if (!fs__namespace.existsSync(directory)) {
+              _context.next = 38;
+              break;
+            }
+
+            _context.next = 35;
+            return packageManager.emptyDirectory(directory);
+
+          case 35:
+            if (appDirectory !== directory) {
+              fs__namespace.mkdirSync(appDirectory, {
+                recursive: true
+              });
+            }
+
+            _context.next = 39;
+            break;
+
+          case 38:
+            fs__namespace.mkdirSync(appDirectory, {
+              recursive: true
+            });
+
+          case 39:
+            rootDirectory = inWorkspace ? process.cwd() : directory;
+            outputRoot = packageManager.createOutputTarget(rootDirectory);
+            appTemplate = packageManager.loadTemplate(template === 'basic' ? 'app-basic' : 'app-single-file');
+            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) {
+              _context.next = 109;
+              break;
+            }
+
+            _context.next = 46;
+            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 46:
+            if (!createAsMonorepo) {
+              _context.next = 71;
+              break;
+            }
+
+            _context.t1 = JSON;
+            _context.next = 50;
+            return workspaceTemplate.read('package.json');
+
+          case 50:
+            _context.t2 = _context.sent;
+            workspacePackageJson = _context.t1.parse.call(_context.t1, _context.t2);
+            workspacePackageJson.name = packageManager.toValidPackageName(name);
+
+            if (!(packageManager$1 === 'pnpm')) {
+              _context.next = 62;
+              break;
+            }
+
+            _context.t3 = outputRoot;
+            _context.next = 57;
+            return packageManager.format("\n              packages:\n              - './packages/*'\n            ", {
+              as: 'yaml'
+            });
+
+          case 57:
+            _context.t4 = _context.sent;
+            _context.next = 60;
+            return _context.t3.write.call(_context.t3, 'pnpm-workspace.yaml', _context.t4);
+
+          case 60:
+            _context.next = 63;
+            break;
+
+          case 62:
+            workspacePackageJson.workspaces = ['packages/*'];
+
+          case 63:
+            _context.t5 = outputRoot;
+            _context.next = 66;
+            return packageManager.format(JSON.stringify(workspacePackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 66:
+            _context.t6 = _context.sent;
+            _context.next = 69;
+            return _context.t5.write.call(_context.t5, 'package.json', _context.t6);
+
+          case 69:
+            _context.next = 103;
+            break;
+
+          case 71:
+            _context.next = 73;
+            return Promise.all([appTemplate.read('package.json').then(function (content) {
+              return JSON.parse(content);
+            }), appTemplate.read('tsconfig.json').then(function (content) {
+              return JSON.parse(content);
+            }), workspaceTemplate.read('package.json').then(function (content) {
+              return JSON.parse(content);
+            })]);
+
+          case 73:
+            _yield$Promise$all = _context.sent;
+            _yield$Promise$all2 = packageManager._slicedToArray(_yield$Promise$all, 3);
+            projectPackageJson = _yield$Promise$all2[0];
+            projectTSConfig = _yield$Promise$all2[1];
+            _workspacePackageJson = _yield$Promise$all2[2];
+            _workspacePackageJson.name = packageManager.toValidPackageName(name);
+            _workspacePackageJson.eslintConfig = projectPackageJson.eslintConfig;
+            _workspacePackageJson.browserslist = projectPackageJson.browserslist;
+            _context.next = 83;
+            return appTemplate.read('quilt.project.ts');
+
+          case 83:
+            quiltProject = _context.sent;
+            quiltProject = quiltProject.replace('quiltApp', 'quiltWorkspace, quiltApp').replace('quiltApp(', 'quiltWorkspace(), quiltApp(');
+            _context.t7 = outputRoot;
+            _context.next = 88;
+            return packageManager.format(quiltProject, {
+              as: 'typescript'
+            });
+
+          case 88:
+            _context.t8 = _context.sent;
+            _context.next = 91;
+            return _context.t7.write.call(_context.t7, 'quilt.project.ts', _context.t8);
+
+          case 91:
+            _context.t9 = outputRoot;
+            _context.next = 94;
+            return packageManager.format(JSON.stringify(_workspacePackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 94:
+            _context.t10 = _context.sent;
+            _context.next = 97;
+            return _context.t9.write.call(_context.t9, 'package.json', _context.t10);
+
+          case 97:
+            _context.t11 = outputRoot;
+            _context.next = 100;
+            return packageManager.format(JSON.stringify(projectTSConfig), {
+              as: 'json'
+            });
+
+          case 100:
+            _context.t12 = _context.sent;
+            _context.next = 103;
+            return _context.t11.write.call(_context.t11, 'tsconfig.json', _context.t12);
+
+          case 103:
+            if (!setupExtras.has('github')) {
+              _context.next = 106;
+              break;
+            }
+
+            _context.next = 106;
+            return packageManager.loadTemplate('github').copy(directory);
+
+          case 106:
+            if (!setupExtras.has('vscode')) {
+              _context.next = 109;
+              break;
+            }
+
+            _context.next = 109;
+            return packageManager.loadTemplate('vscode').copy(directory);
+
+          case 109:
+            _context.next = 111;
+            return appTemplate.copy(appDirectory, function (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 need to make some adjustments the project’s package.json
+
+
+              return file !== 'package.json';
+            });
+
+          case 111:
+            if (!partOfMonorepo) {
+              _context.next = 127;
+              break;
+            }
+
+            _context.t13 = JSON;
+            _context.next = 115;
+            return appTemplate.read('package.json');
+
+          case 115:
+            _context.t14 = _context.sent;
+            _projectPackageJson = _context.t13.parse.call(_context.t13, _context.t14);
+            _projectPackageJson.name = path__namespace.basename(appDirectory);
+            _context.t15 = outputRoot;
+            _context.t16 = path__namespace.join(appDirectory, 'package.json');
+            _context.next = 122;
+            return packageManager.format(JSON.stringify(_projectPackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 122:
+            _context.t17 = _context.sent;
+            _context.next = 125;
+            return _context.t15.write.call(_context.t15, _context.t16, _context.t17);
+
+          case 125:
+            _context.next = 127;
+            return Promise.all([packageManager.addToTsConfig(appDirectory, outputRoot), packageManager.addToPackageManagerWorkspaces(appDirectory, outputRoot, packageManager$1)]);
+
+          case 127:
+            if (shouldInstall) {
+              process.stdout.write('\nInstalling dependencies...\n'); // TODO: better loading, handle errors
+
+              child_process.execSync("".concat(packageManager$1, " install"), {
+                cwd: rootDirectory
+              });
+              process.stdout.moveCursor(0, -1);
+              process.stdout.clearLine(1);
+              console.log('Installed dependencies.');
+            }
+
+            commands = [];
+
+            if (!inWorkspace && directory !== process.cwd()) {
+              commands.push("cd ".concat(index.cyan_1(packageManager.relativeDirectoryForDisplay(path__namespace.relative(process.cwd(), directory))), " ").concat(index.dim_1('# Move into your new app’s directory')));
+            }
+
+            if (!shouldInstall) {
+              commands.push("pnpm install ".concat(index.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(index.dim_1('# Start your git history (optional)')));
+            }
+
+            commands.push("pnpm develop ".concat(index.dim_1('# Start the development server')));
+            whatsNext = index.stripIndent(_templateObject2 || (_templateObject2 = index._taggedTemplateLiteral(["\n    Your new app is ready to go! There\u2019s just ", " you\u2019ll need to take\n    in order to start developing:\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 = index.stripIndent(_templateObject3 || (_templateObject3 = index._taggedTemplateLiteral(["\n    Quilt can also help you build, test, lint, and type-check your new application.\n    You can learn more about building apps with Quilt by reading the documentation:\n    ", "\n\n    Have fun! \uD83C\uDF89\n  "])), index.underline_1(index.magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation')));
+            console.log();
+            console.log(followUp);
+
+          case 141:
+          case "end":
+            return _context.stop();
+        }
       }
-
-      await outputRoot.write('package.json', await packageManager.format(JSON.stringify(workspacePackageJson), {
-        as: 'json-stringify'
-      }));
-    } else {
-      const [projectPackageJson, projectTSConfig, workspacePackageJson] = await Promise.all([appTemplate.read('package.json').then(content => JSON.parse(content)), appTemplate.read('tsconfig.json').then(content => JSON.parse(content)), workspaceTemplate.read('package.json').then(content => JSON.parse(content))]);
-      workspacePackageJson.name = packageManager.toValidPackageName(name);
-      workspacePackageJson.eslintConfig = projectPackageJson.eslintConfig;
-      workspacePackageJson.browserslist = projectPackageJson.browserslist;
-      let quiltProject = await appTemplate.read('quilt.project.ts');
-      quiltProject = quiltProject.replace('quiltApp', 'quiltWorkspace, quiltApp').replace('quiltApp(', 'quiltWorkspace(), quiltApp(');
-      await outputRoot.write('quilt.project.ts', await packageManager.format(quiltProject, {
-        as: 'typescript'
-      }));
-      await outputRoot.write('package.json', await packageManager.format(JSON.stringify(workspacePackageJson), {
-        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 appTemplate.copy(appDirectory, 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 need to make some adjustments the project’s package.json
-
-
-    return file !== 'package.json';
-  });
-
-  if (partOfMonorepo) {
-    // Write the app’s package.json (the root one was already created)
-    const projectPackageJson = JSON.parse(await appTemplate.read('package.json'));
-    projectPackageJson.name = path__namespace.basename(appDirectory);
-    await outputRoot.write(path__namespace.join(appDirectory, 'package.json'), await packageManager.format(JSON.stringify(projectPackageJson), {
-      as: 'json-stringify'
-    }));
-    await Promise.all([packageManager.addToTsConfig(appDirectory, outputRoot), packageManager.addToPackageManagerWorkspaces(appDirectory, outputRoot, packageManager$1)]);
-  }
-
-  if (shouldInstall) {
-    process.stdout.write('\nInstalling dependencies...\n'); // TODO: better loading, handle errors
-
-    child_process.execSync(`${packageManager$1} install`, {
-      cwd: rootDirectory
-    });
-    process.stdout.moveCursor(0, -1);
-    process.stdout.clearLine(1);
-    console.log('Installed dependencies.');
-  }
-
-  const commands = [];
-
-  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')}`);
-  }
-
-  if (!shouldInstall) {
-    commands.push(`pnpm install ${index.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(`pnpm develop ${index.dim_1('# Start the development server')}`);
-  const whatsNext = index.stripIndent`
-    Your new app 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 application.
-    You can learn more about building apps with Quilt by reading the documentation:
-    ${index.underline_1(index.magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation'))}
-
-    Have fun! 🎉
-  `;
-  console.log();
-  console.log(followUp);
-} // Argument handling
+    }, _callee);
+  }));
+  return _createApp.apply(this, arguments);
+}
 
 function getArgv() {
-  const argv = index.arg_1({
+  var argv = index.arg_1({
     '--yes': Boolean,
     '-y': '--yes',
     '--name': String,
@@ -230,72 +403,188 @@ function getArgv() {
   return argv;
 }
 
-async function getName(argv, {
-  inWorkspace
-}) {
-  let {
-    '--name': name
-  } = argv;
-
-  if (name == null) {
-    name = await index.prompt({
-      type: 'text',
-      message: 'What would you like to name your new app?',
-      initial: inWorkspace ? 'app' : 'my-quilt-app'
-    });
-  }
+function getName(_x, _x2) {
+  return _getName.apply(this, arguments);
+}
 
-  return name;
+function _getName() {
+  _getName = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee2(argv, _ref) {
+    var inWorkspace, name;
+    return index.regenerator.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            inWorkspace = _ref.inWorkspace;
+            name = argv['--name'];
+
+            if (!(name == null)) {
+              _context2.next = 6;
+              break;
+            }
+
+            _context2.next = 5;
+            return index.prompt({
+              type: 'text',
+              message: 'What would you like to name your new app?',
+              initial: inWorkspace ? 'app' : 'my-quilt-app'
+            });
+
+          case 5:
+            name = _context2.sent;
+
+          case 6:
+            return _context2.abrupt("return", name);
+
+          case 7:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getName.apply(this, arguments);
 }
 
-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 ${index.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 app in?'
-      });
-      directory = path__namespace.resolve(promptDirectory);
-    } else {
-      break;
-    }
-  }
+function getDirectory(_x3, _x4) {
+  return _getDirectory.apply(this, arguments);
+}
 
-  return directory;
+function _getDirectory() {
+  _getDirectory = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee3(argv, _ref2) {
+    var _argv$Directory;
+
+    var name, directory, relativeDirectory, empty, promptDirectory;
+    return index.regenerator.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            name = _ref2.name;
+            directory = path__namespace.resolve((_argv$Directory = argv['--directory']) !== null && _argv$Directory !== void 0 ? _argv$Directory : packageManager.toValidPackageName(name));
+
+          case 2:
+            if (argv['--yes']) {
+              _context3.next = 24;
+              break;
+            }
+
+            _context3.t0 = fs__namespace.existsSync(directory);
+
+            if (!_context3.t0) {
+              _context3.next = 8;
+              break;
+            }
+
+            _context3.next = 7;
+            return packageManager.isEmpty(directory);
+
+          case 7:
+            _context3.t0 = !_context3.sent;
+
+          case 8:
+            if (!_context3.t0) {
+              _context3.next = 21;
+              break;
+            }
+
+            relativeDirectory = path__namespace.relative(process.cwd(), directory);
+            _context3.next = 12;
+            return index.prompt({
+              type: 'confirm',
+              message: "Directory ".concat(index.bold_1(packageManager.relativeDirectoryForDisplay(relativeDirectory)), " is not empty, is it safe to empty it?"),
+              initial: true
+            });
+
+          case 12:
+            empty = _context3.sent;
+
+            if (!empty) {
+              _context3.next = 15;
+              break;
+            }
+
+            return _context3.abrupt("break", 24);
+
+          case 15:
+            _context3.next = 17;
+            return index.prompt({
+              type: 'text',
+              message: 'What directory do you want to create your new app in?'
+            });
+
+          case 17:
+            promptDirectory = _context3.sent;
+            directory = path__namespace.resolve(promptDirectory);
+            _context3.next = 22;
+            break;
+
+          case 21:
+            return _context3.abrupt("break", 24);
+
+          case 22:
+            _context3.next = 2;
+            break;
+
+          case 24:
+            return _context3.abrupt("return", directory);
+
+          case 25:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _getDirectory.apply(this, arguments);
 }
 
-const VALID_TEMPLATES = new Set(['basic', 'single-file']);
+var VALID_TEMPLATES = new Set(['basic', 'single-file']);
 
-async function getTemplate(argv) {
-  if (argv['--template'] && VALID_TEMPLATES.has(argv['--template'])) {
-    return argv['--template'];
-  }
+function getTemplate(_x5) {
+  return _getTemplate.apply(this, arguments);
+}
 
-  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`,
-    choices: [{
-      title: `${index.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`,
-      value: 'single-file'
-    } // TODO: GraphQL API
-    ]
-  });
-  return template;
+function _getTemplate() {
+  _getTemplate = index._asyncToGenerator( /*#__PURE__*/index.regenerator.mark(function _callee4(argv) {
+    var template;
+    return index.regenerator.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!(argv['--template'] && VALID_TEMPLATES.has(argv['--template']))) {
+              _context4.next = 2;
+              break;
+            }
+
+            return _context4.abrupt("return", argv['--template']);
+
+          case 2:
+            _context4.next = 4;
+            return index.prompt({
+              type: 'select',
+              message: 'What template would you like to use?',
+              hint: "Use ".concat(index.bold_1('arrow keys'), " to select, and ").concat(index.bold_1('return'), " to submit"),
+              choices: [{
+                title: "".concat(index.bold_1('The basics'), ", a web app with a minimal file structure"),
+                value: 'basic'
+              }, {
+                title: "".concat(index.bold_1('Itty-bitty'), ", an entire web app in a single file"),
+                value: 'single-file'
+              } // TODO: GraphQL API
+              ]
+            });
+
+          case 4:
+            template = _context4.sent;
+            return _context4.abrupt("return", template);
+
+          case 6:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _getTemplate.apply(this, arguments);
 }
 
 exports.createApp = createApp;