@quilted/create 0.1.29 → 0.1.31

package/source/shared/prompts.ts

@@ -1,24 +1,10 @@
-import * as fs from 'fs';
-
 import type {Result as ArgvResult} from 'arg';
-import prompts from 'prompts';
-import type {PromptObject} from 'prompts';
 import * as color from 'colorette';
-
-import {AbortError} from '@quilted/events';
-
-export async function prompt(prompt: Omit<PromptObject, 'name'>) {
-  const result = await prompts<'value'>(
-    {name: 'value', ...prompt},
-    {
-      onCancel() {
-        throw new AbortError();
-      },
-    },
-  );
-
-  return result.value;
-}
+import {
+  prompt,
+  getPackageManager as baseGetPackageManager,
+  createPackageManagerRunner,
+} from '@quilted/cli-kit';
 
 type BaseArguments = ArgvResult<{
   '--yes': BooleanConstructor;
@@ -31,6 +17,8 @@ type BaseArguments = ArgvResult<{
   '--package-manager': StringConstructor;
 }>;
 
+export {prompt};
+
 export async function getCreateAsMonorepo(argv: BaseArguments) {
   let createAsMonorepo: boolean;
 
@@ -69,31 +57,12 @@ export async function getShouldInstall(argv: BaseArguments) {
   return shouldInstall;
 }
 
-const VALID_PACKAGE_MANAGERS = new Set(['pnpm', 'npm', 'yarn']);
-
-export async function getPackageManager(argv: BaseArguments) {
-  let packageManager!: 'yarn' | 'npm' | 'pnpm';
-
-  if (argv['--package-manager']) {
-    const explicitPackageManager =
-      argv['--package-manager'].toLocaleLowerCase();
-
-    packageManager = VALID_PACKAGE_MANAGERS.has(explicitPackageManager)
-      ? (explicitPackageManager as any)
-      : 'npm';
-  } else {
-    const npmUserAgent = process.env['npm_config_user_agent'] ?? 'npm';
-
-    if (npmUserAgent.includes('pnpm') || fs.existsSync('pnpm-lock.yaml')) {
-      packageManager = 'pnpm';
-    } else if (npmUserAgent.includes('yarn') || fs.existsSync('yarn.lock')) {
-      packageManager = 'yarn';
-    } else {
-      packageManager = 'npm';
-    }
-  }
-
-  return packageManager;
+export async function getPackageManager(
+  argv: BaseArguments,
+  options?: Parameters<typeof createPackageManagerRunner>[1],
+) {
+  const packageManager = await baseGetPackageManager(argv['--package-manager']);
+  return createPackageManagerRunner(packageManager ?? 'npm', options);
 }
 
 type Extra = 'github' | 'vscode';

package/source/shared.ts

@@ -2,8 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import {fileURLToPath} from 'url';
 import type {BuiltInParserName} from 'prettier';
-
-export {prompt} from './shared/prompts';
+export {prompt} from '@quilted/cli-kit';
 
 export function loadTemplate(
   name:

package/tsconfig.json

@@ -6,5 +6,10 @@
   },
   "include": ["source"],
   "exclude": ["quilt.project.ts", "**/*.test.ts", "**/*.test.tsx"],
-  "references": [{"path": "../quilt"}, {"path": "../craft"}]
+  "references": [
+    {"path": "../quilt"},
+    {"path": "../craft"},
+    {"path": "../cli-kit"},
+    {"path": "../events"}
+  ]
 }

package/build/cjs/package-manager.cjs

@@ -1,330 +0,0 @@
-'use strict';
-
-var path = require('node:path');
-var fs = require('node:fs');
-var node_url = require('node:url');
-require('./index.cjs');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-
-function loadTemplate(name) {
-  let templateRootPromise;
-  return {
-    async copy(to, handleFile) {
-      var _templateRootPromise;
-
-      (_templateRootPromise = templateRootPromise) !== null && _templateRootPromise !== void 0 ? _templateRootPromise : templateRootPromise = templateDirectory(name);
-      const templateRoot = await templateRootPromise;
-      const targetRoot = path__namespace.resolve(to);
-      const files = fs__namespace.readdirSync(templateRoot).filter(file => !path__namespace.basename(file).startsWith('.'));
-
-      for (const file of files) {
-        if (handleFile) {
-          if (!handleFile(file)) {
-            continue;
-          }
-        }
-
-        const targetPath = path__namespace.join(targetRoot, file.startsWith('_') ? `.${file.slice(1)}` : file);
-        copy(path__namespace.join(templateRoot, file), targetPath);
-      }
-    },
-
-    async read(file) {
-      var _templateRootPromise2;
-
-      (_templateRootPromise2 = templateRootPromise) !== null && _templateRootPromise2 !== void 0 ? _templateRootPromise2 : templateRootPromise = templateDirectory(name);
-      const templateRoot = await templateRootPromise;
-      return fs__namespace.readFileSync(path__namespace.join(templateRoot, file), {
-        encoding: 'utf8'
-      });
-    }
-
-  };
-}
-function createOutputTarget(target) {
-  return {
-    root: target,
-
-    read(file) {
-      return fs__namespace.promises.readFile(path__namespace.resolve(target, file), {
-        encoding: 'utf8'
-      });
-    },
-
-    async write(file, content) {
-      await writeFile(path__namespace.resolve(target, file), content);
-    }
-
-  };
-}
-let packageRootPromise;
-
-async function templateDirectory(name) {
-  return path__namespace.join(await getPackageRoot(), 'templates', name);
-}
-
-async function getPackageRoot() {
-  if (!packageRootPromise) {
-    packageRootPromise = (async () => {
-      const {
-        packageDirectory
-      } = await Promise.resolve().then(function () { return require('./index2.cjs'); });
-      return packageDirectory({
-        cwd: path__namespace.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('package-manager.cjs', document.baseURI).href))))
-      });
-    })();
-  }
-
-  return packageRootPromise;
-}
-
-function toValidPackageName(projectName) {
-  return projectName.trim().toLowerCase().replace(/\s+/g, '-').replace(/^[._]/, '').replace(/[^a-z0-9-~@/]+/g, '-');
-}
-
-function copy(source, destination) {
-  const stat = fs__namespace.statSync(source);
-
-  if (stat.isDirectory()) {
-    copyDirectory(source, destination);
-  } else {
-    fs__namespace.copyFileSync(source, destination);
-  }
-}
-
-async function copyDirectory(source, destination) {
-  fs__namespace.mkdirSync(destination, {
-    recursive: true
-  });
-
-  for (const file of fs__namespace.readdirSync(source)) {
-    const srcFile = path__namespace.resolve(source, file);
-    const destFile = path__namespace.resolve(destination, file);
-    copy(srcFile, destFile);
-  }
-}
-
-async function writeFile(file, content) {
-  await fs__namespace.promises.writeFile(file, content);
-}
-async function isEmpty(path) {
-  return fs__namespace.readdirSync(path).length === 0;
-}
-async function emptyDirectory(dir) {
-  if (!fs__namespace.existsSync(dir)) {
-    return;
-  }
-
-  for (const file of fs__namespace.readdirSync(dir)) {
-    fs__namespace.rmSync(path__namespace.resolve(dir, file), {
-      force: true,
-      recursive: true
-    });
-  }
-}
-function relativeDirectoryForDisplay(relativeDirectory) {
-  return relativeDirectory.startsWith('.') ? relativeDirectory : `.${path__namespace.sep}${relativeDirectory}`;
-}
-async function format(content, {
-  as: parser
-}) {
-  const [{
-    format
-  }, {
-    default: babel
-  }, {
-    default: typescript
-  }, {
-    default: yaml
-  }] = await Promise.all([Promise.resolve().then(function () { return require('./standalone.cjs'); }).then(function (n) { return n.standalone; }), Promise.resolve().then(function () { return require('./parser-babel.cjs'); }).then(function (n) { return n.parserBabel; }), Promise.resolve().then(function () { return require('./parser-typescript.cjs'); }).then(function (n) { return n.parserTypescript; }), Promise.resolve().then(function () { return require('./parser-yaml.cjs'); }).then(function (n) { return n.parserYaml; })]);
-  return format(content, {
-    arrowParens: 'always',
-    bracketSpacing: false,
-    singleQuote: true,
-    trailingComma: 'all',
-    parser,
-    plugins: [babel, typescript, yaml]
-  });
-}
-function mergeDependencies(first = {}, second = {}) {
-  const all = { ...first,
-    ...second
-  };
-  const merged = {};
-
-  for (const [key, value] of Object.entries(all).sort(([keyOne], [keyTwo]) => keyOne.localeCompare(keyTwo))) {
-    merged[key] = value;
-  }
-
-  return merged;
-}
-
-const ENDS_WITH_TSCONFIG = /[/]?tsconfig[.a-z0-9]*[.]json/i;
-async function addToTsConfig(directory, output) {
-  var _tsconfig$references;
-
-  const tsconfig = JSON.parse(await output.read('tsconfig.json'));
-  (_tsconfig$references = tsconfig.references) !== null && _tsconfig$references !== void 0 ? _tsconfig$references : tsconfig.references = [];
-  const relativePath = path.relative(output.root, directory);
-  const relativeForDisplay = relativeDirectoryForDisplay(relativePath);
-
-  if (tsconfig.references.length === 0) {
-    tsconfig.references.push({
-      path: relativeForDisplay
-    });
-  } else {
-    let hasExistingReference = false;
-    let referenceFormat = 'pretty-relative';
-
-    for (const {
-      path
-    } of tsconfig.references) {
-      if (path.startsWith('./')) {
-        if (ENDS_WITH_TSCONFIG.test(path)) {
-          referenceFormat = 'pretty-tsconfig';
-
-          if (path === `${relativeForDisplay}/tsconfig.json`) {
-            hasExistingReference = true;
-            break;
-          }
-        }
-
-        referenceFormat = 'pretty-relative';
-
-        if (path === relativeForDisplay) {
-          hasExistingReference = true;
-          break;
-        }
-      } else if (ENDS_WITH_TSCONFIG.test(path)) {
-        referenceFormat = 'tsconfig';
-
-        if (path === `${relativePath}/tsconfig.json`) {
-          hasExistingReference = true;
-          break;
-        }
-      } else {
-        referenceFormat = 'relative';
-
-        if (path === relativePath) {
-          hasExistingReference = true;
-          break;
-        }
-      }
-    }
-
-    if (!hasExistingReference) {
-      let path;
-
-      if (referenceFormat === 'pretty-tsconfig') {
-        path = `${relativeForDisplay}/tsconfig.json`;
-      } else if (referenceFormat === 'pretty-relative') {
-        path = relativeForDisplay;
-      } else if (referenceFormat === 'tsconfig') {
-        path = `${relativePath}/tsconfig.json`;
-      } else {
-        path = relativePath;
-      }
-
-      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'
-  }));
-}
-
-async function addToPackageManagerWorkspaces(directory, output, packageManager) {
-  if (packageManager === 'pnpm') {
-    var _workspaceYaml$packag;
-
-    const {
-      parse,
-      stringify
-    } = await Promise.resolve().then(function () { return require('./index3.cjs'); }).then(function (n) { return n.index; });
-    const workspaceYaml = parse(await output.read('pnpm-workspace.yaml'));
-    workspaceYaml.packages = await addToWorkspaces(path.relative(output.root, directory), (_workspaceYaml$packag = workspaceYaml.packages) !== null && _workspaceYaml$packag !== void 0 ? _workspaceYaml$packag : []);
-    await output.write('pnpm-workspace.yaml', await format(stringify(workspaceYaml), {
-      as: 'yaml'
-    }));
-  } else {
-    var _packageJson$workspac;
-
-    const packageJson = JSON.parse(await output.read('package.json'));
-    packageJson.workspaces = await addToWorkspaces(path.relative(output.root, directory), (_packageJson$workspac = packageJson.workspaces) !== null && _packageJson$workspac !== void 0 ? _packageJson$workspac : []);
-    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 Promise.resolve().then(function () { return require('./minimatch.cjs'); }).then(function (n) { return n.minimatch; });
-
-  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));
-}
-
-exports.addToPackageManagerWorkspaces = addToPackageManagerWorkspaces;
-exports.addToTsConfig = addToTsConfig;
-exports.createOutputTarget = createOutputTarget;
-exports.emptyDirectory = emptyDirectory;
-exports.format = format;
-exports.isEmpty = isEmpty;
-exports.loadTemplate = loadTemplate;
-exports.mergeDependencies = mergeDependencies;
-exports.relativeDirectoryForDisplay = relativeDirectoryForDisplay;
-exports.toValidPackageName = toValidPackageName;