@quilted/create 0.1.20 → 0.1.23

package/build/cjs/package-manager.cjs

@@ -0,0 +1,315 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var url = require('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(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: 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-yaml.cjs'); }).then(function (n) { return n.parserYaml; })]);
+  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 = 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.relativeDirectoryForDisplay = relativeDirectoryForDisplay;
+exports.toValidPackageName = toValidPackageName;