@quilted/create 0.1.56 → 0.1.58

package/build/esnext/package.esnext

@@ -0,0 +1,467 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { printHelp } from './help.esnext';
+import { toValidPackageName, emptyDirectory, relativeDirectoryForDisplay, format, mergeWorkspaceAndProjectPackageJsons, loadTemplate, isEmpty, createOutputTarget } from './shared.esnext';
+import { getInWorkspace, getCreateAsMonorepo, getExtrasToSetup, getShouldInstall, getPackageManager } from './shared/prompts.esnext';
+import { addToTsConfig } from './shared/tsconfig.esnext';
+import { addToPackageManagerWorkspaces } from './shared/package-manager.esnext';
+import stripIndent from './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndent/stripIndent.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/TemplateTag/TemplateTag.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaLists/commaLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsAnd/commaListsAnd.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/commaListsOr/commaListsOr.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/html/html.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/safeHtml/safeHtml.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLine/oneLine.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineTrim/oneLineTrim.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaLists/oneLineCommaLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsOr/oneLineCommaListsOr.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineCommaListsAnd/oneLineCommaListsAnd.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/inlineLists/inlineLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/oneLineInlineLists/oneLineInlineLists.esnext';
+import './node_modules/.pnpm/common-tags@1.8.2/node_modules/common-tags/es/stripIndents/stripIndents.esnext';
+import parseArguments from './node_modules/.pnpm/arg@5.0.2/node_modules/arg/index.esnext';
+import { prompt } from './packages/cli-kit/source/prompt.esnext';
+import { cyan as cyan_1, dim as dim_1, bold as bold_1, underline as underline_1, magenta as magenta_1 } from './node_modules/.pnpm/colorette@2.0.19/node_modules/colorette/index.esnext';
+
+async function createProject() {
+  const args = getArguments();
+  if (args['--help']) {
+    const additionalOptions = stripIndent`
+      ${cyan_1(`--description`)}, ${cyan_1(`--no-description`)}
+      A short description of the package. If you don’t provide this option, the command will ask
+      you for a description later.
+      ${dim_1(`@see https://docs.npmjs.com/cli/v9/configuring-npm/package-json#description`)}
+
+      ${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(`--repository`)}, ${cyan_1(`--no-repository`)}
+      The URL of a git repository where your code lives. If you do not provide this option,
+      this command will try to guess the correct repository to use based on existing packages.
+      ${dim_1(`@see https://docs.npmjs.com/cli/v9/configuring-npm/package-json#repository`)}
+
+      ${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: args['--package-manager']?.toLowerCase()
+    });
+    return;
+  }
+  const name = await getName(args);
+  const description = await getDescription(args);
+  const inWorkspace = await getInWorkspace(args);
+  const directory = await getDirectory(args, {
+    name,
+    inWorkspace
+  });
+  const isPublic = await getPublic(args);
+  const repository = await getRepository(args, {
+    inWorkspace
+  });
+  const useReact = await getReact(args);
+  const createAsMonorepo = !inWorkspace && (await getCreateAsMonorepo(args, {
+    type: 'package'
+  }));
+  const setupExtras = await getExtrasToSetup(args, {
+    inWorkspace
+  });
+  const shouldInstall = await getShouldInstall(args, {
+    type: 'package'
+  });
+  const packageManager = await getPackageManager(args, {
+    root: directory
+  });
+  const partOfMonorepo = inWorkspace || createAsMonorepo;
+  const packageDirectory = createAsMonorepo ? path.join(directory, `packages/${toValidPackageName(name.split('/').pop())}`) : directory;
+  if (fs.existsSync(directory)) {
+    await emptyDirectory(directory);
+    if (packageDirectory !== directory) {
+      fs.mkdirSync(packageDirectory, {
+        recursive: true
+      });
+    }
+  } else {
+    fs.mkdirSync(packageDirectory, {
+      recursive: true
+    });
+  }
+  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('quiltPackage()', 'quiltPackage({react: false})');
+  }
+
+  // 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 packageRelativeToRoot = path.relative(rootDirectory, packageDirectory);
+      const packageGlobRelativeToRoot = relativeDirectoryForDisplay(path.join(packageRelativeToRoot, '*'));
+      const workspacePackageJson = JSON.parse(await workspaceTemplate.read('package.json'));
+      workspacePackageJson.name = toValidPackageName(name);
+      workspacePackageJson.workspaces = [packageGlobRelativeToRoot];
+      if (packageManager.type === 'pnpm') {
+        await outputRoot.write('pnpm-workspace.yaml', await format(`
+              packages:
+              - '${packageGlobRelativeToRoot}'
+            `, {
+          as: 'yaml'
+        }));
+      }
+      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))]);
+      const mergedPackageJson = mergeWorkspaceAndProjectPackageJsons(projectPackageJson, workspacePackageJson);
+      delete mergedPackageJson.workspaces;
+      adjustPackageJson(mergedPackageJson, {
+        name: toValidPackageName(name),
+        description,
+        react: useReact,
+        isPublic,
+        registry: args['--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(mergedPackageJson), {
+        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, README, and Quilt config
+    return file !== 'package.json' && file !== 'quilt.project.ts' && file !== 'README.md';
+  });
+  await outputRoot.write(path.join(packageDirectory, 'README.md'), (await packageTemplate.read('README.md')).replaceAll('{{name}}', toValidPackageName(name)));
+  if (partOfMonorepo) {
+    // Write the package’s package.json (the root one was already created)
+    const projectPackageJson = JSON.parse(await packageTemplate.read('package.json'));
+    if (repository === false) {
+      delete projectPackageJson.repository;
+    } else {
+      const directory = path.relative(rootDirectory, packageDirectory);
+      if (typeof repository === 'string') {
+        projectPackageJson.repository = {
+          type: 'git',
+          url: repository,
+          directory
+        };
+      } else if (repository != null) {
+        projectPackageJson.repository = {
+          type: 'git',
+          ...repository,
+          directory
+        };
+      } else {
+        projectPackageJson.repository.directory = directory;
+      }
+    }
+    adjustPackageJson(projectPackageJson, {
+      name: toValidPackageName(name),
+      description,
+      react: useReact,
+      isPublic,
+      registry: args['--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.type)]);
+  }
+  if (shouldInstall) {
+    console.log();
+    // TODO: better loading, handle errors
+    await packageManager.install();
+  }
+  console.log();
+  console.log(stripIndent`
+      Your new package, ${bold_1(name)}, is ready to go! You can edit the code
+      for your package in ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), path.join(packageDirectory, 'source'))))}.
+    `);
+  if (isPublic) {
+    const needsPackageJsonKeys = [];
+    if (!description) {
+      needsPackageJsonKeys.push({
+        field: 'description',
+        url: 'https://docs.npmjs.com/cli/v9/configuring-npm/package-json#description'
+      });
+    }
+    if (repository == null) {
+      needsPackageJsonKeys.push({
+        field: 'repository.url',
+        url: 'https://docs.npmjs.com/cli/v9/configuring-npm/package-json#repository'
+      });
+    }
+    console.log();
+    const logPackageJsonField = (field, url) => {
+      console.log(`  - ${bold_1(JSON.stringify(field))} ${dim_1(`(${underline_1(url)})`)}`);
+    };
+    if (needsPackageJsonKeys.length > 0) {
+      console.log(stripIndent`
+          Before you publish your package, you will need to add the following key${needsPackageJsonKeys.length > 1 ? 's' : ''}
+          to ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), path.join(packageDirectory, 'package.json'))))}:
+        `);
+      console.log();
+      for (const {
+        field,
+        url
+      } of needsPackageJsonKeys) {
+        logPackageJsonField(field, url);
+      }
+      console.log();
+      console.log('In that same file, make sure the contents of these fields are right for your package:');
+      console.log();
+    } else {
+      console.log(stripIndent`
+          Before you publish your package, make the following fields look right
+          in ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), path.join(packageDirectory, 'package.json'))))}:
+        `);
+      console.log();
+    }
+    logPackageJsonField('version', 'https://docs.npmjs.com/cli/v9/configuring-npm/package-json#version');
+    logPackageJsonField('license', 'https://docs.npmjs.com/cli/v9/configuring-npm/package-json#license');
+    logPackageJsonField('exports', 'https://nodejs.org/api/packages.html#package-entry-points');
+  }
+  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
+
+function getArguments() {
+  const args = parseArguments({
+    '--yes': Boolean,
+    '-y': '--yes',
+    '--name': String,
+    '--directory': String,
+    '--description': String,
+    '--no-description': Boolean,
+    '--repository': String,
+    '--no-repository': Boolean,
+    '--install': Boolean,
+    '--no-install': Boolean,
+    '--monorepo': Boolean,
+    '--no-monorepo': Boolean,
+    '--package-manager': String,
+    '--extras': [String],
+    '--no-extras': Boolean,
+    '--react': Boolean,
+    '--no-react': Boolean,
+    '--public': Boolean,
+    '--private': Boolean,
+    '--registry': String,
+    '--help': Boolean,
+    '-h': '--help'
+  }, {
+    permissive: true
+  });
+  return args;
+}
+async function getName(args) {
+  let {
+    '--name': name
+  } = args;
+  if (name == null) {
+    name = await prompt({
+      type: 'text',
+      message: 'What would you like to name your new package?',
+      initial: '@my-team/package'
+    });
+  }
+  return name;
+}
+async function getDirectory(args, {
+  name,
+  inWorkspace
+}) {
+  let directory = args['--directory'] ? path.resolve(args['--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 (!args['--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;
+}
+async function getDescription(args) {
+  if (args['--description']) return args['--description'];
+  if (args['--no-description']) return false;
+  const description = await prompt({
+    type: 'text',
+    message: 'What is a short description of what this package will do?'
+  });
+  return description;
+}
+async function getRepository(args, {
+  inWorkspace = false
+} = {}) {
+  if (args['--repository']) return args['--repository'];
+  if (args['--no-repository']) return false;
+  if (!inWorkspace) return;
+  const {
+    globby
+  } = await import('./node_modules/.pnpm/globby@13.1.1/node_modules/globby/index.esnext');
+  const files = await globby('**/package.json', {
+    ignore: ['**/node_modules']
+  });
+  for (const file of files) {
+    try {
+      const json = JSON.parse(await fs.promises.readFile(file, 'utf8'));
+      if (json.repository) return json.repository;
+    } catch {
+      // noop
+    }
+  }
+}
+async function getPublic(args) {
+  let isPublic;
+  if (args['--public'] || args['--yes']) {
+    isPublic = true;
+  } else if (args['--private']) {
+    isPublic = false;
+  } else {
+    isPublic = await prompt({
+      type: 'confirm',
+      message: 'Will you publish this package to use in other projects?',
+      initial: true
+    });
+  }
+  return isPublic;
+}
+async function getReact(args) {
+  let useReact;
+  if (args['--react'] || args['--yes']) {
+    useReact = true;
+  } else if (args['--no-react']) {
+    useReact = false;
+  } else {
+    useReact = await prompt({
+      type: 'confirm',
+      message: 'Will this package depend on React?',
+      initial: true
+    });
+  }
+  return useReact;
+}
+function adjustPackageJson(packageJson, {
+  name,
+  description,
+  react,
+  isPublic,
+  registry
+}) {
+  packageJson.name = name;
+  const packageParts = name.split('/');
+  const scope = packageParts[0].startsWith('@') ? packageParts[0] : undefined;
+  const finalRegistry = registry ?? 'https://registry.npmjs.org';
+  if (description) {
+    packageJson.description = description;
+  } else {
+    delete packageJson.description;
+  }
+  if (scope) {
+    packageJson.publishConfig[`${scope}/registry`] = finalRegistry;
+  } else if (registry) {
+    packageJson.publishConfig.registry = finalRegistry;
+  }
+  if (isPublic) {
+    delete packageJson.private;
+  } else {
+    delete packageJson.license;
+    delete packageJson.repository;
+    delete packageJson.publishConfig;
+
+    // in private packages, we just need to reference the source.
+    const newExports = {};
+    for (const [key, value] of Object.entries(packageJson.exports)) {
+      if (typeof value === 'string') {
+        newExports[key] = value;
+      }
+      const sourceEntry = value?.['quilt:source'];
+      if (typeof sourceEntry === 'string') {
+        newExports[key] = sourceEntry;
+      }
+    }
+    packageJson.exports = newExports;
+  }
+  if (!react) {
+    delete packageJson.dependencies['@types/react'];
+    delete packageJson.devDependencies['react'];
+    delete packageJson.peerDependencies['react'];
+    delete packageJson.peerDependenciesMeta['react'];
+    packageJson.eslintConfig.extends = packageJson.eslintConfig.extends.filter(extend => !extend.includes('react'));
+  }
+  return packageJson;
+}
+
+export { createProject };

package/build/esnext/packages/cli-kit/source/package-manager.esnext

@@ -0,0 +1,50 @@
+import { existsSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+
+const VALID_PACKAGE_MANAGERS = new Set(['npm', 'pnpm', 'yarn']);
+function createPackageManagerRunner(type, {
+  root = process.cwd()
+} = {}) {
+  return {
+    type,
+    commands: {
+      run(command, ...args) {
+        return type === 'npm' ? `npm run ${command}${stringifyArgs(args)}` : `${type} ${command}${stringifyArgs(args)}`;
+      },
+      install(...args) {
+        return `${type} install${stringifyArgs(args)}`;
+      }
+    },
+    async install() {
+      execSync(`${type} install`, {
+        cwd: root,
+        stdio: 'inherit'
+      });
+    },
+    async run(command, args) {
+      execSync(`${type} ${command} ${args.join(' ')}`, {
+        cwd: root,
+        stdio: 'inherit'
+      });
+    }
+  };
+}
+function stringifyArgs(args) {
+  return args.length === 0 ? '' : ` ${args.join(' ')}`;
+}
+async function getPackageManager(explicitPackageManager) {
+  if (explicitPackageManager) {
+    const normalizedPackageManager = explicitPackageManager.toLowerCase();
+    return VALID_PACKAGE_MANAGERS.has(normalizedPackageManager) ? normalizedPackageManager : undefined;
+  }
+  const npmUserAgent = process.env['npm_config_user_agent'];
+  if (npmUserAgent?.includes('pnpm') || existsSync('pnpm-lock.yaml')) {
+    return 'pnpm';
+  } else if (npmUserAgent?.includes('yarn') || existsSync('yarn.lock')) {
+    return 'yarn';
+  } else if (npmUserAgent?.includes('npm') || existsSync('package-lock.json')) {
+    return 'npm';
+  }
+}
+
+export { createPackageManagerRunner, getPackageManager };

package/build/esnext/packages/cli-kit/source/prompt.esnext

@@ -0,0 +1,16 @@
+import prompts from '../../../node_modules/.pnpm/prompts@2.4.2/node_modules/prompts/index.esnext';
+import { AbortError } from '../../events/source/abort.esnext';
+
+async function prompt(prompt) {
+  const result = await prompts({
+    name: 'value',
+    ...prompt
+  }, {
+    onCancel() {
+      throw new AbortError();
+    }
+  });
+  return result.value;
+}
+
+export { prompt };

package/build/esnext/packages/events/source/abort.esnext

@@ -0,0 +1,13 @@
+// @see https://github.com/nodejs/node/blob/master/lib/internal/errors.js#L822-L834
+class AbortError extends Error {
+  static test(error) {
+    return error != null && error.code === 'ABORT_ERR';
+  }
+  code = 'ABORT_ERR';
+  name = 'AbortError';
+  constructor(message = 'The operation was aborted') {
+    super(message);
+  }
+}
+
+export { AbortError };

package/build/esnext/shared/package-manager.esnext

@@ -0,0 +1,52 @@
+import { relative } from 'node:path';
+import { format, relativeDirectoryForDisplay } from '../shared.esnext';
+
+async function addToPackageManagerWorkspaces(directory, output, packageManager) {
+  if (packageManager === 'pnpm') {
+    // @ts-expect-error Yaml doesn’t implement `exports.types`
+    const {
+      parse,
+      stringify
+    } = await import('../node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/dist/index.esnext');
+    const workspaceYaml = parse(await output.read('pnpm-workspace.yaml'));
+    workspaceYaml.packages = await addToWorkspaces(relative(output.root, directory), workspaceYaml.packages ?? []);
+    await output.write('pnpm-workspace.yaml', await format(stringify(workspaceYaml), {
+      as: 'yaml'
+    }));
+  } else {
+    const packageJson = JSON.parse(await output.read('package.json'));
+    packageJson.workspaces = await addToWorkspaces(relative(output.root, directory), packageJson.workspaces ?? []);
+    await output.write('package.json', await format(JSON.stringify(packageJson), {
+      as: 'json-stringify'
+    }));
+  }
+}
+async function addToWorkspaces(relative, workspaces) {
+  if (workspaces.length === 0) {
+    return [relative];
+  }
+
+  // Default documentation seems to generally exclude leading `./` on paths
+  let pretty = false;
+  let hasMatch = false;
+  const {
+    default: minimatch
+  } = await import('../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.esnext');
+  for (const pattern of workspaces) {
+    let normalizedPattern = pattern;
+    if (pattern.startsWith('./')) {
+      pretty = true;
+      normalizedPattern = pattern.slice(2);
+    }
+    if (minimatch(relative, normalizedPattern)) {
+      hasMatch = true;
+      break;
+    }
+  }
+  if (hasMatch) {
+    return workspaces;
+  }
+  return [...workspaces, pretty ? relativeDirectoryForDisplay(relative) : relative].sort((patternOne, patternTwo) => patternOne.localeCompare(patternTwo));
+}
+
+export { addToPackageManagerWorkspaces };

package/build/esnext/shared/prompts.esnext

@@ -0,0 +1,75 @@
+import * as fs from 'node:fs';
+import { dim as dim_1, bold as bold_1 } from '../node_modules/.pnpm/colorette@2.0.16/node_modules/colorette/index.esnext';
+import { prompt } from '../packages/cli-kit/source/prompt.esnext';
+export { prompt } from '../packages/cli-kit/source/prompt.esnext';
+import { getPackageManager as getPackageManager$1, createPackageManagerRunner } from '../packages/cli-kit/source/package-manager.esnext';
+
+async function getInWorkspace(argv) {
+  if (argv['--in-workspace']) return true;
+  if (argv['--not-in-workspace']) return false;
+  return fs.existsSync('quilt.workspace.ts');
+}
+async function getCreateAsMonorepo(argv, {
+  type,
+  default: defaultCreateAsMonorepo = true
+}) {
+  let createAsMonorepo;
+  if (argv['--monorepo' ]) {
+    createAsMonorepo = true;
+  } else if (argv['--no-monorepo']) {
+    createAsMonorepo = false;
+  } else {
+    createAsMonorepo = await prompt({
+      type: 'confirm',
+      message: `Do you want to create this ${type} as a monorepo, with room for more projects?`,
+      initial: defaultCreateAsMonorepo
+    });
+  }
+  return createAsMonorepo;
+}
+async function getShouldInstall(argv, {
+  type
+}) {
+  let shouldInstall;
+  if (argv['--install'] || argv['--yes']) {
+    shouldInstall = true;
+  } else if (argv['--no-install']) {
+    shouldInstall = false;
+  } else {
+    shouldInstall = await prompt({
+      type: 'confirm',
+      message: `Do you want to install dependencies for this ${type} after creating it?`,
+      initial: true
+    });
+  }
+  return shouldInstall;
+}
+async function getPackageManager(argv, options) {
+  const packageManager = await getPackageManager$1(argv['--package-manager']);
+  return createPackageManagerRunner(packageManager ?? 'npm', options);
+}
+const VALID_EXTRAS = new Set(['github', 'vscode']);
+async function getExtrasToSetup(argv, {
+  inWorkspace
+}) {
+  if (inWorkspace || argv['--no-extras']) return new Set();
+  if (argv['--extras']) {
+    return new Set(argv['--extras'].filter(extra => VALID_EXTRAS.has(extra)));
+  }
+  const setupExtras = await prompt({
+    type: 'multiselect',
+    message: 'Which additional tools would you like to configure?',
+    instructions: dim_1(`\n  Use ${bold_1('space')} to select, ${bold_1('a')} to select all, ${bold_1('return')} to submit`),
+    choices: [{
+      title: 'VSCode',
+      value: 'vscode'
+    }, {
+      title: 'GitHub',
+      value: 'github'
+    }]
+  });
+  const extrasToSetup = new Set(setupExtras);
+  return extrasToSetup;
+}
+
+export { getCreateAsMonorepo, getExtrasToSetup, getInWorkspace, getPackageManager, getShouldInstall };