@quilted/create 0.1.20 → 0.1.23

package/build/esm/app.mjs

@@ -0,0 +1,286 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { s as stripIndent, c as cyan_1, b as bold_1, p as printHelp, g as getCreateAsMonorepo, a as getShouldInstall, d as getPackageManager, e as getExtrasToSetup, f as dim_1, u as underline_1, m as magenta_1, h as arg_1, i as prompt } from './index.mjs';
+import { e as emptyDirectory, t as toValidPackageName, 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';
+
+let _ = t => t,
+    _t,
+    _t2,
+    _t3;
+async function createApp() {
+  const argv = getArgv();
+
+  if (argv['--help']) {
+    var _argv$PackageManag;
+
+    const additionalOptions = stripIndent(_t || (_t = _`
+      ${0}
+      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:
+
+       - ${0}, a web app with a minimal file structure
+       - ${0}, an entire web app in a single file
+    `), cyan_1(`--template`), bold_1('basic'), bold_1('single-file'));
+    printHelp({
+      kind: 'app',
+      options: additionalOptions,
+      packageManager: (_argv$PackageManag = argv['--package-manager']) === null || _argv$PackageManag === void 0 ? void 0 : _argv$PackageManag.toLowerCase()
+    });
+    return;
+  }
+
+  const inWorkspace = fs.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 getCreateAsMonorepo(argv));
+  const shouldInstall = await getShouldInstall(argv);
+  const packageManager = await getPackageManager(argv);
+  const setupExtras = await getExtrasToSetup(argv, {
+    inWorkspace
+  });
+  const partOfMonorepo = inWorkspace || createAsMonorepo;
+  const appDirectory = createAsMonorepo ? path.join(directory, 'app') : directory;
+
+  if (fs.existsSync(directory)) {
+    await emptyDirectory(directory);
+
+    if (appDirectory !== directory) {
+      fs.mkdirSync(appDirectory, {
+        recursive: true
+      });
+    }
+  } else {
+    fs.mkdirSync(appDirectory, {
+      recursive: true
+    });
+  }
+
+  const rootDirectory = inWorkspace ? process.cwd() : directory;
+  const outputRoot = createOutputTarget(rootDirectory);
+  const appTemplate = loadTemplate(template === 'basic' ? 'app-basic' : 'app-single-file');
+  const workspaceTemplate = 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 = toValidPackageName(name);
+
+      if (packageManager === 'pnpm') {
+        await outputRoot.write('pnpm-workspace.yaml', await format(`
+              packages:
+              - './packages/*'
+            `, {
+          as: 'yaml'
+        }));
+      } else {
+        workspacePackageJson.workspaces = ['packages/*'];
+      }
+
+      await outputRoot.write('package.json', await 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 = 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 format(quiltProject, {
+        as: 'typescript'
+      }));
+      await outputRoot.write('package.json', await format(JSON.stringify(workspacePackageJson), {
+        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 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.basename(appDirectory);
+    await outputRoot.write(path.join(appDirectory, 'package.json'), await format(JSON.stringify(projectPackageJson), {
+      as: 'json-stringify'
+    }));
+    await Promise.all([addToTsConfig(appDirectory, outputRoot), addToPackageManagerWorkspaces(appDirectory, 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 commands = [];
+
+  if (!inWorkspace && directory !== process.cwd()) {
+    commands.push(`cd ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), directory)))} ${dim_1('# Move into your new app’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)')}`);
+  }
+
+  commands.push(`pnpm develop ${dim_1('# Start the development server')}`);
+  const whatsNext = stripIndent(_t2 || (_t2 = _`
+    Your new app is ready to go! There’s just ${0} you’ll need to take
+    in order to start developing:
+  `), commands.length > 1 ? 'a few more steps' : 'one more step');
+  console.log();
+  console.log(whatsNext);
+  console.log();
+  console.log(commands.map(command => `  ${command}`).join('\n'));
+  const followUp = stripIndent(_t3 || (_t3 = _`
+    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:
+    ${0}
+
+    Have fun! 🎉
+  `), underline_1(magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation')));
+  console.log();
+  console.log(followUp);
+} // Argument handling
+
+function getArgv() {
+  const argv = arg_1({
+    '--yes': Boolean,
+    '-y': '--yes',
+    '--name': String,
+    '--template': String,
+    '--directory': String,
+    '--install': Boolean,
+    '--no-install': Boolean,
+    '--monorepo': Boolean,
+    '--no-monorepo': Boolean,
+    '--package-manager': String,
+    '--extras': [String],
+    '--no-extras': Boolean,
+    '--help': Boolean,
+    '-h': '--help'
+  }, {
+    permissive: true
+  });
+  return argv;
+}
+
+async function getName(argv, {
+  inWorkspace
+}) {
+  let {
+    '--name': name
+  } = argv;
+
+  if (name == null) {
+    name = await prompt({
+      type: 'text',
+      message: 'What would you like to name your new app?',
+      initial: inWorkspace ? 'app' : 'my-quilt-app'
+    });
+  }
+
+  return name;
+}
+
+async function getDirectory(argv, {
+  name
+}) {
+  var _argv$Directory;
+
+  let directory = path.resolve((_argv$Directory = argv['--directory']) !== null && _argv$Directory !== void 0 ? _argv$Directory : toValidPackageName(name));
+
+  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 new app in?'
+      });
+      directory = path.resolve(promptDirectory);
+    } else {
+      break;
+    }
+  }
+
+  return directory;
+}
+
+const VALID_TEMPLATES = new Set(['basic', 'single-file']);
+
+async function getTemplate(argv) {
+  if (argv['--template'] && VALID_TEMPLATES.has(argv['--template'])) {
+    return argv['--template'];
+  }
+
+  const template = await prompt({
+    type: 'select',
+    message: 'What template would you like to use?',
+    hint: `Use ${bold_1('arrow keys')} to select, and ${bold_1('return')} to submit`,
+    choices: [{
+      title: `${bold_1('The basics')}, a web app with a minimal file structure`,
+      value: 'basic'
+    }, {
+      title: `${bold_1('Itty-bitty')}, an entire web app in a single file`,
+      value: 'single-file'
+    } // TODO: GraphQL API
+    ]
+  });
+  return template;
+}
+
+export { createApp };