@quilted/create 0.1.90 → 0.2.1

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

@@ -0,0 +1,52 @@
+import { existsSync } from 'fs';
+import { execSync } from 'child_process';
+
+const VALID_PACKAGE_MANAGERS = /* @__PURE__ */ 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() {
+      try {
+        execSync(`corepack use ${type}@latest`, {
+          cwd: root,
+          stdio: "inherit"
+        });
+      } catch {
+      }
+      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 : void 0;
+  }
+  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/build/esnext/prompt.esnext.esnext

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

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

@@ -0,0 +1,12 @@
+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/server.esnext

@@ -0,0 +1,298 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import arg from './node_modules/.pnpm/arg@5.0.2/node_modules/arg/index.esnext';
+import { cyan, dim, underline, magenta, bold } from './node_modules/.pnpm/colorette@2.0.19/node_modules/colorette/index.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 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/stripIndents/stripIndents.esnext';
+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 { prompt } from './packages/cli-kit/build/esnext/prompt.esnext.esnext';
+
+async function createServer() {
+  const argv = getArgv();
+  if (argv["--help"]) {
+    printHelp({
+      kind: "server",
+      packageManager: argv["--package-manager"]?.toLowerCase()
+    });
+    return;
+  }
+  const inWorkspace = await getInWorkspace(argv);
+  const name = await getName(argv);
+  const directory = await getDirectory(argv, { name });
+  const entry = await getEntry(argv, { name });
+  const createAsMonorepo = !inWorkspace && await getCreateAsMonorepo(argv, {
+    type: "server",
+    default: false
+  });
+  const setupExtras = await getExtrasToSetup(argv, { inWorkspace });
+  const shouldInstall = await getShouldInstall(argv);
+  const packageManager = await getPackageManager(argv, { root: directory });
+  const partOfMonorepo = inWorkspace || createAsMonorepo;
+  const serviceDirectory = createAsMonorepo ? path.join(directory, toValidPackageName(name)) : directory;
+  if (fs.existsSync(directory)) {
+    await emptyDirectory(directory);
+    if (serviceDirectory !== directory) {
+      fs.mkdirSync(serviceDirectory, { recursive: true });
+    }
+  } else {
+    fs.mkdirSync(serviceDirectory, { recursive: true });
+  }
+  const rootDirectory = inWorkspace ? process.cwd() : directory;
+  const outputRoot = createOutputTarget(rootDirectory);
+  const serverTemplate = loadTemplate("server-basic");
+  const workspaceTemplate = loadTemplate("workspace");
+  if (!inWorkspace) {
+    await workspaceTemplate.copy(directory, (file) => {
+      if (file === "quilt.workspace.ts")
+        return createAsMonorepo;
+      if (file === "package.json")
+        return false;
+      return true;
+    });
+    if (createAsMonorepo) {
+      const serviceRelativeToRoot = relativeDirectoryForDisplay(
+        path.relative(directory, serviceDirectory)
+      );
+      const workspacePackageJson = JSON.parse(
+        await workspaceTemplate.read("package.json")
+      );
+      workspacePackageJson.name = toValidPackageName(name);
+      workspacePackageJson.workspaces = [serviceRelativeToRoot, "./packages/*"];
+      if (packageManager.type === "pnpm") {
+        await outputRoot.write(
+          "pnpm-workspace.yaml",
+          await format(
+            `
+              packages:
+              - '${serviceRelativeToRoot}'
+              - './packages/*'
+            `,
+            { as: "yaml" }
+          )
+        );
+      }
+      await outputRoot.write(
+        "package.json",
+        await format(JSON.stringify(workspacePackageJson), {
+          as: "json-stringify"
+        })
+      );
+    } else {
+      const [projectPackageJson, projectTSConfig, workspacePackageJson] = await Promise.all([
+        serverTemplate.read("package.json").then((content) => JSON.parse(content)),
+        serverTemplate.read("tsconfig.json").then((content) => JSON.parse(content)),
+        workspaceTemplate.read("package.json").then((content) => JSON.parse(content))
+      ]);
+      const combinedPackageJson = mergeWorkspaceAndProjectPackageJsons(
+        projectPackageJson,
+        workspacePackageJson
+      );
+      adjustPackageJson(combinedPackageJson, { name, entry });
+      delete combinedPackageJson.workspaces;
+      await outputRoot.write(
+        "package.json",
+        await format(JSON.stringify(combinedPackageJson), {
+          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 serverTemplate.copy(serviceDirectory, (file) => {
+    if (file === "tsconfig.json") {
+      return partOfMonorepo;
+    }
+    if (file === "service.ts" || file === "quilt.project.ts") {
+      return false;
+    }
+    return file !== "package.json";
+  });
+  let quiltProject = await serverTemplate.read("quilt.project.ts");
+  if (!partOfMonorepo) {
+    quiltProject = quiltProject.replace("quiltService", "quiltWorkspace, quiltService").replace("quiltService(", "quiltWorkspace(), quiltService(");
+  }
+  quiltProject = quiltProject.replace(
+    "service.ts",
+    entry.replace(/^\.[/]/, "")
+  );
+  await outputRoot.write(
+    path.join(serviceDirectory, "quilt.project.ts"),
+    await format(quiltProject, { as: "typescript" })
+  );
+  await outputRoot.write(
+    path.join(serviceDirectory, entry),
+    await serverTemplate.read("service.ts")
+  );
+  if (partOfMonorepo) {
+    const projectPackageJson = JSON.parse(
+      await serverTemplate.read("package.json")
+    );
+    adjustPackageJson(projectPackageJson, { name, entry });
+    await outputRoot.write(
+      path.join(serviceDirectory, "package.json"),
+      await format(JSON.stringify(projectPackageJson), {
+        as: "json-stringify"
+      })
+    );
+    await Promise.all([
+      addToTsConfig(serviceDirectory, outputRoot),
+      addToPackageManagerWorkspaces(
+        serviceDirectory,
+        outputRoot,
+        packageManager.type
+      )
+    ]);
+  }
+  if (shouldInstall) {
+    console.log();
+    await packageManager.install();
+  }
+  const commands = [];
+  if (!inWorkspace && directory !== process.cwd()) {
+    commands.push(
+      `cd ${cyan(
+        relativeDirectoryForDisplay(path.relative(process.cwd(), directory))
+      )} ${dim("# Move into your new service\u2019s directory")}`
+    );
+  }
+  if (!shouldInstall) {
+    commands.push(
+      `${packageManager.commands.install()} ${dim(
+        "# Install all your dependencies"
+      )}`
+    );
+  }
+  if (commands.length === 0) {
+    console.log();
+    console.log("Your new service is ready to go!");
+  } else {
+    const whatsNext = stripIndent`
+      Your new service 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 = stripIndent`
+    Quilt can also help you build, develop, test, lint, and type-check your new service.
+    You can learn more about building services with Quilt by reading the documentation:
+    ${underline(
+    magenta(
+      "https://github.com/lemonmade/quilt/tree/main/documentation"
+    )
+  )}
+
+    Have fun! 🎉
+  `;
+  console.log();
+  console.log(followUp);
+}
+function getArgv() {
+  const argv = arg(
+    {
+      "--yes": Boolean,
+      "-y": "--yes",
+      "--name": String,
+      "--directory": String,
+      "--entry": String,
+      "--install": Boolean,
+      "--no-install": Boolean,
+      "--monorepo": Boolean,
+      "--no-monorepo": Boolean,
+      "--package-manager": String,
+      "--extras": [String],
+      "--no-extras": Boolean,
+      "--help": Boolean,
+      "-h": "--help"
+    },
+    { permissive: true }
+  );
+  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 service?",
+      initial: "my-service"
+    });
+  }
+  return name;
+}
+async function getEntry(argv, { name }) {
+  if (argv["--entry"]) {
+    return argv["--entry"];
+  }
+  const defaultEntry = `${toValidPackageName(name)}.ts`;
+  const entry = await prompt({
+    type: "text",
+    message: "What do you want to name your entry file?",
+    initial: defaultEntry
+  });
+  return entry;
+}
+async function getDirectory(argv, { name }) {
+  let directory = path.resolve(
+    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(
+          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 service in?"
+      });
+      directory = path.resolve(promptDirectory);
+    } else {
+      break;
+    }
+  }
+  return directory;
+}
+function adjustPackageJson(packageJson, {
+  name
+}) {
+  packageJson.name = name;
+  packageJson.main = `./build/runtime/runtime.js`;
+  return packageJson;
+}
+
+export { createServer };

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

@@ -1,44 +1,46 @@
-import { relative } from 'node:path';
+import { relative } from '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').then(function (n) { return n.i; });
-    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'
-    }));
+  if (packageManager === "pnpm") {
+    const { parse, stringify } = await import('../node_modules/.pnpm/yaml@2.1.1/node_modules/yaml/browser/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'
-    }));
+    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) {
+async function addToWorkspaces(relative2, workspaces) {
   if (workspaces.length === 0) {
-    return [relative];
+    return [relative2];
   }
-
-  // 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').then(function (n) { return n.m; });
+  const { default: minimatch } = await import('../node_modules/.pnpm/minimatch@5.1.0/node_modules/minimatch/minimatch.esnext').then(n => n.m);
   for (const pattern of workspaces) {
     let normalizedPattern = pattern;
-    if (pattern.startsWith('./')) {
+    if (pattern.startsWith("./")) {
       pretty = true;
       normalizedPattern = pattern.slice(2);
     }
-    if (minimatch(relative, normalizedPattern)) {
+    if (minimatch(relative2, normalizedPattern)) {
       hasMatch = true;
       break;
     }
@@ -46,7 +48,10 @@ async function addToWorkspaces(relative, workspaces) {
   if (hasMatch) {
     return workspaces;
   }
-  return [...workspaces, pretty ? relativeDirectoryForDisplay(relative) : relative].sort((patternOne, patternTwo) => patternOne.localeCompare(patternTwo));
+  return [
+    ...workspaces,
+    pretty ? relativeDirectoryForDisplay(relative2) : relative2
+  ].sort((patternOne, patternTwo) => patternOne.localeCompare(patternTwo));
 }
 
 export { addToPackageManagerWorkspaces };

package/build/esnext/shared/prompts.esnext

@@ -1,25 +1,27 @@
-import * as fs from 'node:fs';
-import { dim as dim_1, bold as bold_1 } from '../node_modules/.pnpm/colorette@2.0.19/node_modules/colorette/index.esnext';
-import { prompt } from '../packages/cli-kit/source/prompt.esnext';
-import { getPackageManager as getPackageManager$1, createPackageManagerRunner } from '../packages/cli-kit/source/package-manager.esnext';
+import * as fs from 'fs';
+import { dim, bold } from '../node_modules/.pnpm/colorette@2.0.19/node_modules/colorette/index.esnext';
+import { prompt } from '../packages/cli-kit/build/esnext/prompt.esnext.esnext';
+import { getPackageManager as getPackageManager$1, createPackageManagerRunner } from '../packages/cli-kit/build/esnext/package-manager.esnext.esnext';
 
 async function getInWorkspace(argv) {
-  if (argv['--in-workspace']) return true;
-  if (argv['--not-in-workspace']) return false;
-  return fs.existsSync('pnpm-workspace.yaml');
+  if (argv["--in-workspace"])
+    return true;
+  if (argv["--not-in-workspace"])
+    return false;
+  return fs.existsSync("pnpm-workspace.yaml");
 }
 async function getCreateAsMonorepo(argv, {
   type,
   default: defaultCreateAsMonorepo = true
 }) {
   let createAsMonorepo;
-  if (argv['--monorepo' ]) {
+  if (argv["--monorepo"]) {
     createAsMonorepo = true;
-  } else if (argv['--no-monorepo']) {
+  } else if (argv["--no-monorepo"]) {
     createAsMonorepo = false;
   } else {
     createAsMonorepo = await prompt({
-      type: 'confirm',
+      type: "confirm",
       message: `Do you want to create this ${type} as a monorepo, with room for more projects?`,
       initial: defaultCreateAsMonorepo
     });
@@ -27,31 +29,36 @@ async function getCreateAsMonorepo(argv, {
   return createAsMonorepo;
 }
 async function getShouldInstall(argv) {
-  return !argv['--no-install'];
+  return !argv["--no-install"];
 }
 async function getPackageManager(argv, options) {
-  const packageManager = await getPackageManager$1(argv['--package-manager']);
-  return createPackageManagerRunner(packageManager ?? 'pnpm', options);
+  const packageManager = await getPackageManager$1(argv["--package-manager"]);
+  return createPackageManagerRunner(packageManager ?? "pnpm", 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 VALID_EXTRAS = /* @__PURE__ */ new Set(["github", "vscode"]);
+async function getExtrasToSetup(argv, { inWorkspace }) {
+  if (inWorkspace || argv["--no-extras"])
+    return /* @__PURE__ */ 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'
-    }]
+    type: "multiselect",
+    message: "Which additional tools would you like to configure?",
+    instructions: dim(
+      `
+  Use ${bold("space")} to select, ${bold(
+        "a"
+      )} to select all, ${bold("return")} to submit`
+    ),
+    choices: [
+      { title: "VSCode", value: "vscode" },
+      { title: "GitHub", value: "github" }
+    ]
   });
   const extrasToSetup = new Set(setupExtras);
   return extrasToSetup;

package/build/esnext/shared/tsconfig.esnext

@@ -1,43 +1,39 @@
-import { relative } from 'node:path';
+import { relative } from 'path';
 import { relativeDirectoryForDisplay, format } from '../shared.esnext';
 
 const ENDS_WITH_TSCONFIG = /[/]?tsconfig[.a-z0-9]*[.]json/i;
 async function addToTsConfig(directory, output) {
-  const tsconfig = JSON.parse(await output.read('tsconfig.json'));
+  const tsconfig = JSON.parse(await output.read("tsconfig.json"));
   tsconfig.references ??= [];
   const relativePath = relative(output.root, directory);
   const relativeForDisplay = relativeDirectoryForDisplay(relativePath);
   if (tsconfig.references.length === 0) {
-    tsconfig.references.push({
-      path: relativeForDisplay
-    });
+    tsconfig.references.push({ path: relativeForDisplay });
   } else {
     let hasExistingReference = false;
-    let referenceFormat = 'pretty-relative';
-    for (const {
-      path
-    } of tsconfig.references) {
-      if (path.startsWith('./')) {
+    let referenceFormat = "pretty-relative";
+    for (const { path } of tsconfig.references) {
+      if (path.startsWith("./")) {
         if (ENDS_WITH_TSCONFIG.test(path)) {
-          referenceFormat = 'pretty-tsconfig';
+          referenceFormat = "pretty-tsconfig";
           if (path === `${relativeForDisplay}/tsconfig.json`) {
             hasExistingReference = true;
             break;
           }
         }
-        referenceFormat = 'pretty-relative';
+        referenceFormat = "pretty-relative";
         if (path === relativeForDisplay) {
           hasExistingReference = true;
           break;
         }
       } else if (ENDS_WITH_TSCONFIG.test(path)) {
-        referenceFormat = 'tsconfig';
+        referenceFormat = "tsconfig";
         if (path === `${relativePath}/tsconfig.json`) {
           hasExistingReference = true;
           break;
         }
       } else {
-        referenceFormat = 'relative';
+        referenceFormat = "relative";
         if (path === relativePath) {
           hasExistingReference = true;
           break;
@@ -46,28 +42,25 @@ async function addToTsConfig(directory, output) {
     }
     if (!hasExistingReference) {
       let path;
-      if (referenceFormat === 'pretty-tsconfig') {
+      if (referenceFormat === "pretty-tsconfig") {
         path = `${relativeForDisplay}/tsconfig.json`;
-      } else if (referenceFormat === 'pretty-relative') {
+      } else if (referenceFormat === "pretty-relative") {
         path = relativeForDisplay;
-      } else if (referenceFormat === 'tsconfig') {
+      } else if (referenceFormat === "tsconfig") {
         path = `${relativePath}/tsconfig.json`;
       } else {
         path = relativePath;
       }
-      tsconfig.references.push({
-        path
-      });
+      tsconfig.references.push({ path });
     }
   }
-  tsconfig.references = tsconfig.references.sort(({
-    path: pathOne
-  }, {
-    path: pathTwo
-  }) => pathOne.localeCompare(pathTwo));
-  await output.write('tsconfig.json', await format(JSON.stringify(tsconfig), {
-    as: 'json'
-  }));
+  tsconfig.references = tsconfig.references.sort(
+    ({ path: pathOne }, { path: pathTwo }) => pathOne.localeCompare(pathTwo)
+  );
+  await output.write(
+    "tsconfig.json",
+    await format(JSON.stringify(tsconfig), { as: "json" })
+  );
 }
 
 export { addToTsConfig };