@quilted/create 0.1.17 → 0.1.20

package/build/esm/package-manager.mjs

@@ -1,275 +0,0 @@
-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) {
-      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) {
-      templateRootPromise ?? (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) {
-  const tsconfig = JSON.parse(await output.read('tsconfig.json'));
-  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') {
-    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.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('./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

@@ -1,401 +0,0 @@
-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';
-
-async function createPackage() {
-  const argv = getArgv();
-
-  if (argv['--help']) {
-    const additionalOptions = stripIndent`
-      ${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(`--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: argv['--package-manager']?.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']
-      });
-      const addBackToTSConfigInclude = new Set(['quilt.project.ts', '*.test.ts', '*.test.tsx']);
-      projectTSConfig.exclude = projectTSConfig.exclude.filter(excluded => !addBackToTSConfigInclude.has(excluded));
-      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`
-    Your new package is ready to go! However, before you go too much further,
-    you should update the following fields in ${cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), path.join(packageDirectory, 'package.json'))))}:
-
-     - ${bold_1(`"description"`)}, where you provide a description of what your package does
-     - ${bold_1(`"repository"`)}, where you should include the ${bold_1(`"url"`)} of your project’s repo
-  `;
-  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`
-      After you update your package.json, there’s ${commands.length > 1 ? 'a few more steps' : 'one more step'} you’ll need to take
-      in order to start building:
-    `;
-    console.log();
-    console.log(whatsNext);
-    console.log();
-    console.log(commands.map(command => `  ${command}`).join('\n'));
-  }
-
-  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 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 ?? '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 { createPackage };