@quilted/create 0.1.20 → 0.1.23

package/build/esm/package-manager.mjs

@@ -0,0 +1,285 @@
+import * as path from 'path';
+import { relative } from 'path';
+import * as fs from 'fs';
+import { fileURLToPath } from 'url';
+import './index.mjs';
+
+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.resolve(to);
+      const files = fs.readdirSync(templateRoot).filter(file => !path.basename(file).startsWith('.'));
+
+      for (const file of files) {
+        if (handleFile) {
+          if (!handleFile(file)) {
+            continue;
+          }
+        }
+
+        const targetPath = path.join(targetRoot, file.startsWith('_') ? `.${file.slice(1)}` : file);
+        copy(path.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.readFileSync(path.join(templateRoot, file), {
+        encoding: 'utf8'
+      });
+    }
+
+  };
+}
+function createOutputTarget(target) {
+  return {
+    root: target,
+
+    read(file) {
+      return fs.promises.readFile(path.resolve(target, file), {
+        encoding: 'utf8'
+      });
+    },
+
+    async write(file, content) {
+      await writeFile(path.resolve(target, file), content);
+    }
+
+  };
+}
+let packageRootPromise;
+
+async function templateDirectory(name) {
+  return path.join(await getPackageRoot(), 'templates', name);
+}
+
+async function getPackageRoot() {
+  if (!packageRootPromise) {
+    packageRootPromise = (async () => {
+      const {
+        packageDirectory
+      } = await import('./index2.mjs');
+      return packageDirectory({
+        cwd: path.dirname(fileURLToPath(import.meta.url))
+      });
+    })();
+  }
+
+  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.statSync(source);
+
+  if (stat.isDirectory()) {
+    copyDirectory(source, destination);
+  } else {
+    fs.copyFileSync(source, destination);
+  }
+}
+
+async function copyDirectory(source, destination) {
+  fs.mkdirSync(destination, {
+    recursive: true
+  });
+
+  for (const file of fs.readdirSync(source)) {
+    const srcFile = path.resolve(source, file);
+    const destFile = path.resolve(destination, file);
+    copy(srcFile, destFile);
+  }
+}
+
+async function writeFile(file, content) {
+  await fs.promises.writeFile(file, content);
+}
+async function isEmpty(path) {
+  return fs.readdirSync(path).length === 0;
+}
+async function emptyDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+
+  for (const file of fs.readdirSync(dir)) {
+    fs.rmSync(path.resolve(dir, file), {
+      force: true,
+      recursive: true
+    });
+  }
+}
+function relativeDirectoryForDisplay(relativeDirectory) {
+  return relativeDirectory.startsWith('.') ? relativeDirectory : `.${path.sep}${relativeDirectory}`;
+}
+async function format(content, {
+  as: parser
+}) {
+  const [{
+    format
+  }, {
+    default: babel
+  }, {
+    default: yaml
+  }] = await Promise.all([import('./standalone.mjs').then(function (n) { return n.s; }), import('./parser-babel.mjs').then(function (n) { return n.p; }), import('./parser-yaml.mjs').then(function (n) { return n.p; })]);
+  return format(content, {
+    arrowParens: 'always',
+    bracketSpacing: false,
+    singleQuote: true,
+    trailingComma: 'all',
+    parser,
+    plugins: [babel, yaml]
+  });
+}
+
+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 = 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 import('./index3.mjs').then(function (n) { return n.i; });
+    const workspaceYaml = parse(await output.read('pnpm-workspace.yaml'));
+    workspaceYaml.packages = await addToWorkspaces(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(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 import('./minimatch.mjs').then(function (n) { return n.m; });
+
+  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 { addToTsConfig as a, addToPackageManagerWorkspaces as b, createOutputTarget as c, emptyDirectory as e, format as f, isEmpty as i, loadTemplate as l, relativeDirectoryForDisplay as r, toValidPackageName as t };

package/build/esm/package.mjs

@@ -0,0 +1,409 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { s as stripIndent, c as cyan_1, p as printHelp, g as getCreateAsMonorepo, a as getShouldInstall, d as getPackageManager, e as getExtrasToSetup, b as bold_1, f as dim_1, u as underline_1, m as magenta_1, h as arg_1, i as prompt } from './index.mjs';
+import { t as toValidPackageName, e as emptyDirectory, 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,
+    _t4;
+async function createProject() {
+  const argv = getArgv();
+
+  if (argv['--help']) {
+    var _argv$PackageManag;
+
+    const additionalOptions = stripIndent(_t || (_t = _`
+      ${0}, ${0}
+      Whether this package will use React. If you don’t provide this option, the command
+      will ask you about it later.
+
+      ${0}, ${0}
+      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.
+
+      ${0}
+      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.
+    `), cyan_1(`--react`), cyan_1(`--no-react`), cyan_1(`--public`), cyan_1(`--private`), cyan_1(`--registry`));
+    printHelp({
+      kind: 'package',
+      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);
+  const directory = await getDirectory(argv, {
+    name,
+    inWorkspace
+  });
+  const isPublic = await getPublic(argv);
+  const useReact = await getReact(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 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('react: false', 'react: true');
+  } // 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([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))]);
+      workspacePackageJson.eslintConfig = projectPackageJson.eslintConfig;
+      workspacePackageJson.browserslist = projectPackageJson.browserslist;
+      const newPackageJson = {}; // We want to put the project’s dependencies in the package.json, respecting
+      // the preferred ordering (dependencies, peer dependencies, dev dependencies).
+
+      for (const [key, value] of Object.entries(projectPackageJson)) {
+        if (key !== 'devDependencies') {
+          newPackageJson[key] = value;
+          continue;
+        }
+
+        newPackageJson.dependencies = projectPackageJson.dependencies;
+        newPackageJson.peerDependencies = projectPackageJson.peerDependencies;
+        newPackageJson.peerDependenciesMeta = projectPackageJson.peerDependenciesMeta;
+        newPackageJson.devDependencies = sortKeys({ ...workspacePackageJson.devDependencies,
+          ...projectPackageJson.devDependencies
+        });
+      }
+
+      adjustPackageJson(newPackageJson, {
+        name: toValidPackageName(name),
+        react: useReact,
+        isPublic,
+        registry: argv['--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(newPackageJson), {
+        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 and Quilt config
+
+
+    return file !== 'package.json' && file !== 'quilt.project.ts';
+  });
+
+  if (partOfMonorepo) {
+    // Write the package’s package.json (the root one was already created)
+    const projectPackageJson = JSON.parse(await packageTemplate.read('package.json'));
+    projectPackageJson.repository.directory = path.relative(directory, packageDirectory);
+    adjustPackageJson(projectPackageJson, {
+      name: toValidPackageName(name),
+      react: useReact,
+      isPublic,
+      registry: argv['--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)]);
+  }
+
+  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 packageJsonInstructions = stripIndent(_t2 || (_t2 = _`
+    Your new package is ready to go! However, before you go too much further,
+    you should update the following fields in ${0}:
+
+     - ${0}, where you provide a description of what your package does
+     - ${0}, where you should include the ${0} of your project’s repo
+
+    Before you publish your package, you will also want to update the ${0}
+    field in the package.json file.
+  `), cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), path.join(packageDirectory, 'package.json')))), bold_1(`"description"`), bold_1(`"repository"`), bold_1(`"url"`), bold_1(`"version"`));
+  console.log();
+  console.log(packageJsonInstructions);
+  const commands = [];
+
+  if (!inWorkspace && directory !== process.cwd()) {
+    commands.push(`cd ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), directory)))} ${dim_1('# Move into your new package’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)')}`);
+  }
+
+  if (commands.length > 0) {
+    const whatsNext = stripIndent(_t3 || (_t3 = _`
+      After you update your package.json, there’s ${0} you’ll need to take
+      in order to start building:
+    `), 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(_t4 || (_t4 = _`
+    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:
+    ${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,
+    '--directory': String,
+    '--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 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 package?',
+      initial: '@my-team/package'
+    });
+  }
+
+  return name;
+}
+
+async function getDirectory(argv, {
+  name,
+  inWorkspace
+}) {
+  let directory = argv['--directory'] ? path.resolve(argv['--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 (!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 package in?'
+      });
+      directory = path.resolve(promptDirectory);
+    } else {
+      break;
+    }
+  }
+
+  return directory;
+}
+
+async function getPublic(argv) {
+  let isPublic;
+
+  if (argv['--public'] || argv['--yes']) {
+    isPublic = true;
+  } else if (argv['--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(argv) {
+  let useReact;
+
+  if (argv['--react'] || argv['--yes']) {
+    useReact = true;
+  } else if (argv['--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,
+  react,
+  isPublic,
+  registry
+}) {
+  packageJson.name = name;
+  const packageParts = name.split('/');
+  const scope = packageParts[0].startsWith('@') ? packageParts[0] : undefined;
+  const finalRegistry = registry !== null && registry !== void 0 ? registry : 'https://registry.npmjs.org';
+
+  if (scope) {
+    packageJson.publishConfig[`${scope}/registry`] = finalRegistry;
+  } else if (registry) {
+    packageJson.publishConfig.registry = finalRegistry;
+  }
+
+  if (isPublic) {
+    delete packageJson.private;
+  } else {
+    delete packageJson.publishConfig;
+  }
+
+  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;
+}
+
+function sortKeys(object) {
+  const newObject = {};
+  const sortedEntries = Object.entries(object).sort(([keyOne], [keyTwo]) => keyOne.localeCompare(keyTwo));
+
+  for (const [key, value] of sortedEntries) {
+    newObject[key] = value;
+  }
+
+  return newObject;
+}
+
+export { createProject };