@quilted/create 0.1.29 → 0.1.31

package/build/esm/package-manager.mjs

@@ -1,299 +0,0 @@
-import * as path from 'node:path';
-import { relative } from 'node:path';
-import * as fs from 'node:fs';
-import { fileURLToPath } from 'node: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: typescript
-  }, {
-    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-typescript.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, 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 = 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, mergeDependencies as m, relativeDirectoryForDisplay as r, toValidPackageName as t };