@quilted/create 0.1.0 → 0.1.3

package/build/esm/index.mjs

@@ -4,6 +4,7 @@ import { EOL } from 'os';
 import { fileURLToPath as fileURLToPath$1 } from 'url';
 import require$$0 from 'readline';
 import require$$2 from 'events';
+import require$$0$1 from 'tty';
 import path$1 from 'node:path';
 import { fileURLToPath } from 'node:url';
 import process$1 from 'node:process';
@@ -5850,79 +5851,219 @@ var arg_1 = arg;
 
 var colorette = {};
 
-let enabled =
-  !("NO_COLOR" in process.env) &&
-  ("FORCE_COLOR" in process.env ||
-    process.platform === "win32" ||
-    (process.stdout != null &&
-      process.stdout.isTTY &&
-      process.env.TERM &&
-      process.env.TERM !== "dumb"));
-
-const raw = (open, close, searchRegex, replaceValue) => (s) =>
-  enabled
-    ? open +
-      (~(s += "").indexOf(close, 4) // skip opening \x1b[
-        ? s.replace(searchRegex, replaceValue)
-        : s) +
-      close
-    : s;
-
-const init = (open, close) => {
-  return raw(
-    `\x1b[${open}m`,
-    `\x1b[${close}m`,
-    new RegExp(`\\x1b\\[${close}m`, "g"),
-    `\x1b[${open}m`
-  )
-};
+Object.defineProperty(colorette, '__esModule', { value: true });
 
-colorette.options = Object.defineProperty({}, "enabled", {
-  get: () => enabled,
-  set: (value) => (enabled = value),
-});
+var tty = require$$0$1;
+
+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 tty__namespace = /*#__PURE__*/_interopNamespace(tty);
+
+const env = process.env || {};
+const argv$1 = process.argv || [];
+
+const isDisabled = "NO_COLOR" in env || argv$1.includes("--no-color");
+const isForced = "FORCE_COLOR" in env || argv$1.includes("--color");
+const isWindows = process.platform === "win32";
+
+const isCompatibleTerminal =
+  tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && env.TERM !== "dumb";
+
+const isCI =
+  "CI" in env &&
+  ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+
+const isColorSupported =
+  !isDisabled && (isForced || isWindows || isCompatibleTerminal || isCI);
+
+const replaceClose = (
+  index,
+  string,
+  close,
+  replace,
+  head = string.substring(0, index) + replace,
+  tail = string.substring(index + close.length),
+  next = tail.indexOf(close)
+) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+
+const clearBleed = (index, string, open, close, replace) =>
+  index < 0
+    ? open + string + close
+    : open + replaceClose(index, string, close, replace) + close;
+
+const filterEmpty =
+  (open, close, replace = open, at = open.length + 1) =>
+  (string) =>
+    string || !(string === "" || string === undefined)
+      ? clearBleed(
+          ("" + string).indexOf(close, at),
+          string,
+          open,
+          close,
+          replace
+        )
+      : "";
+
+const init = (open, close, replace) =>
+  filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+
+const colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1b[22m\x1b[1m"),
+  dim: init(2, 22, "\x1b[22m\x1b[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49),
+};
 
-colorette.reset = init(0, 0);
-colorette.bold = raw("\x1b[1m", "\x1b[22m", /\x1b\[22m/g, "\x1b[22m\x1b[1m");
-colorette.dim = raw("\x1b[2m", "\x1b[22m", /\x1b\[22m/g, "\x1b[22m\x1b[2m");
-colorette.italic = init(3, 23);
-colorette.underline = init(4, 24);
-colorette.inverse = init(7, 27);
-colorette.hidden = init(8, 28);
-colorette.strikethrough = init(9, 29);
-colorette.black = init(30, 39);
-colorette.red = init(31, 39);
-colorette.green = init(32, 39);
-colorette.yellow = init(33, 39);
-colorette.blue = init(34, 39);
-colorette.magenta = init(35, 39);
-colorette.cyan = init(36, 39);
-colorette.white = init(37, 39);
-colorette.gray = init(90, 39);
-colorette.bgBlack = init(40, 49);
-colorette.bgRed = init(41, 49);
-colorette.bgGreen = init(42, 49);
-colorette.bgYellow = init(43, 49);
-colorette.bgBlue = init(44, 49);
-colorette.bgMagenta = init(45, 49);
-colorette.bgCyan = init(46, 49);
-colorette.bgWhite = init(47, 49);
-colorette.blackBright = init(90, 39);
-colorette.redBright = init(91, 39);
-colorette.greenBright = init(92, 39);
-colorette.yellowBright = init(93, 39);
-colorette.blueBright = init(94, 39);
-colorette.magentaBright = init(95, 39);
-colorette.cyanBright = init(96, 39);
-colorette.whiteBright = init(97, 39);
-colorette.bgBlackBright = init(100, 49);
-colorette.bgRedBright = init(101, 49);
-colorette.bgGreenBright = init(102, 49);
-colorette.bgYellowBright = init(103, 49);
-colorette.bgBlueBright = init(104, 49);
-colorette.bgMagentaBright = init(105, 49);
-colorette.bgCyanBright = init(106, 49);
-colorette.bgWhiteBright = init(107, 49);
+const none = (any) => any;
+
+const createColors = ({ useColor = isColorSupported } = {}) =>
+  useColor
+    ? colors
+    : Object.keys(colors).reduce(
+        (colors, key) => ({ ...colors, [key]: none }),
+        {}
+      );
+
+const {
+  reset,
+  bold,
+  dim,
+  italic,
+  underline,
+  inverse,
+  hidden,
+  strikethrough,
+  black,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  blackBright,
+  redBright,
+  greenBright,
+  yellowBright,
+  blueBright,
+  magentaBright,
+  cyanBright,
+  whiteBright,
+  bgBlackBright,
+  bgRedBright,
+  bgGreenBright,
+  bgYellowBright,
+  bgBlueBright,
+  bgMagentaBright,
+  bgCyanBright,
+  bgWhiteBright,
+} = createColors();
+
+colorette.bgBlack = bgBlack;
+colorette.bgBlackBright = bgBlackBright;
+colorette.bgBlue = bgBlue;
+colorette.bgBlueBright = bgBlueBright;
+colorette.bgCyan = bgCyan;
+colorette.bgCyanBright = bgCyanBright;
+colorette.bgGreen = bgGreen;
+colorette.bgGreenBright = bgGreenBright;
+colorette.bgMagenta = bgMagenta;
+colorette.bgMagentaBright = bgMagentaBright;
+colorette.bgRed = bgRed;
+colorette.bgRedBright = bgRedBright;
+colorette.bgWhite = bgWhite;
+colorette.bgWhiteBright = bgWhiteBright;
+colorette.bgYellow = bgYellow;
+colorette.bgYellowBright = bgYellowBright;
+colorette.black = black;
+colorette.blackBright = blackBright;
+colorette.blue = blue;
+colorette.blueBright = blueBright;
+colorette.bold = bold;
+colorette.createColors = createColors;
+var cyan_1 = colorette.cyan = cyan;
+colorette.cyanBright = cyanBright;
+colorette.dim = dim;
+colorette.gray = gray;
+colorette.green = green;
+colorette.greenBright = greenBright;
+colorette.hidden = hidden;
+colorette.inverse = inverse;
+colorette.isColorSupported = isColorSupported;
+colorette.italic = italic;
+colorette.magenta = magenta;
+colorette.magentaBright = magentaBright;
+colorette.red = red;
+colorette.redBright = redBright;
+colorette.reset = reset;
+colorette.strikethrough = strikethrough;
+colorette.underline = underline;
+colorette.white = white;
+colorette.whiteBright = whiteBright;
+colorette.yellow = yellow;
+colorette.yellowBright = yellowBright;
 
 /*
 How it works:
@@ -6230,6 +6371,8 @@ async function run() {
     } else {
       await createWorkspace();
     }
+
+    return;
   }
 
   switch (create) {
@@ -6261,6 +6404,7 @@ async function run() {
 async function createWorkspace(explicitName) {
   if (fs.existsSync('quilt.workspace.ts')) {
     console.log(`\nYou’re already in a Quilt workspace!`);
+    console.log();
     console.log(`Run one of the following to add projects to your workspace:`);
     console.log(`  pnpm create @quilted app # create a new app`);
     console.log(`  pnpm create @quilted package # create a new package`);
@@ -6308,10 +6452,12 @@ async function createWorkspace(explicitName) {
   if (overwrite) {
     emptyDirectory(root);
   } else if (!fs.existsSync(root)) {
-    fs.mkdirSync(root);
+    fs.mkdirSync(root, {
+      recursive: true
+    });
   }
 
-  console.log(`\nCreating Quilt workspace in ${colorette.magenta(root)}...`);
+  console.log(`\nCreating Quilt workspace in ${cyan_1(path.relative(cwd, root))}...`);
   const templateRoot = await templateDirectory('workspace');
   const template = createTemplateFileSystem(templateRoot, root);
 
@@ -6327,12 +6473,14 @@ async function createWorkspace(explicitName) {
   }
 
   console.log(`\nDone! Here’s what you’ll need to do next:\n`);
+  console.log();
 
   if (root !== cwd) {
     console.log(`  cd ${path.relative(cwd, root)}`);
   }
 
   console.log(`  pnpm install # install dependencies`);
+  console.log(`  git init && git add --all && git commit --message "Initial commit" # start your git history`);
   console.log(`  pnpm create @quilted app # create an app in your workspace, or`);
   console.log(`  pnpm create @quilted package # create a package in your workspace`);
   console.log();
@@ -6340,7 +6488,7 @@ async function createWorkspace(explicitName) {
 
 async function createProject() {
   const result = await prompts([{
-    type: 'list',
+    type: 'select',
     name: 'type',
     message: 'What kind of project would you like to create?',
     choices: [{
@@ -6368,8 +6516,10 @@ async function createProject() {
 }
 
 async function createPackage(explicitName) {
-  let result;
+  let name;
+  let scope;
   let targetDirectory;
+  let result;
 
   try {
     result = await prompts([{
@@ -6378,7 +6528,9 @@ async function createPackage(explicitName) {
       message: 'What would you like to name this package?',
       initial: toValidPackageName(explicitName ?? ''),
       onState: state => {
-        targetDirectory = path.join('packages', toValidPackageName(state.value));
+        name = toValidPackageName(state.value);
+        scope = name.match(/^@[^/]+/)?.[0] ?? undefined;
+        targetDirectory = path.join('packages', scope ? name.replace(`${scope}/`, '') : name);
       }
     }, {
       type: () => !fs.existsSync(targetDirectory) || isEmpty(targetDirectory) ? null : 'confirm',
@@ -6400,7 +6552,6 @@ async function createPackage(explicitName) {
   }
 
   const {
-    name,
     overwrite
   } = result;
   const root = path.join(cwd, targetDirectory);
@@ -6408,17 +6559,24 @@ async function createPackage(explicitName) {
   if (overwrite) {
     emptyDirectory(root);
   } else if (!fs.existsSync(root)) {
-    fs.mkdirSync(root);
+    fs.mkdirSync(root, {
+      recursive: true
+    });
   }
 
-  console.log(`\nCreating ${colorette.magenta(toValidPackageName(name))} package in ${colorette.magenta(root)}...`);
+  console.log(`\nCreating ${cyan_1(name)} package in ${cyan_1(path.relative(cwd, root))}...`);
   const templateRoot = await templateDirectory('package');
   const template = createTemplateFileSystem(templateRoot, root);
 
   for (const file of template.files()) {
     if (file === 'package.json') {
       const packageJson = JSON.parse(template.read(file));
-      packageJson.name = toValidPackageName(name);
+      packageJson.name = name;
+
+      if (scope) {
+        packageJson.publishConfig[`${scope}:registry`] = 'https://registry.npmjs.org';
+      }
+
       template.write(file, JSON.stringify(packageJson, null, 2) + EOL);
       continue;
     }
@@ -6426,14 +6584,15 @@ async function createPackage(explicitName) {
     template.copy(file);
   }
 
-  console.log(`\nDone! Your new package has been created.\n`);
+  console.log(`\nDone! Your new package has been created.`);
   console.log(`Get started by adding source code in the \`source\` directory.`);
+  console.log(`Make sure to edit the \`description\` and \`repository\` sections of your \`package.json\` before publishing.`);
   console.log(`Have fun!`);
   console.log();
 }
 
 async function createApp() {
-  const root = path.join('cwd', 'app');
+  const root = path.join(cwd, 'app');
 
   if (fs.existsSync(root)) {
     const {
@@ -6446,10 +6605,12 @@ async function createApp() {
     if (!overwrite) return;
     emptyDirectory(root);
   } else if (!fs.existsSync(root)) {
-    fs.mkdirSync(root);
+    fs.mkdirSync(root, {
+      recursive: true
+    });
   }
 
-  console.log(`\nCreating app in ${colorette.magenta(root)}...`);
+  console.log(`\nCreating app in ${cyan_1(path.relative(cwd, root))}...`);
   const templateRoot = await templateDirectory('app');
   const template = createTemplateFileSystem(templateRoot, root);
 
@@ -6464,7 +6625,7 @@ async function createApp() {
     template.copy(file);
   }
 
-  console.log(`\nDone! Your new app has been created.\n`);
+  console.log(`\nDone! Your new app has been created.`);
   console.log(`Get started by:`);
   console.log(`  * running \`pnpm develop\` to start the development server`);
   console.log(`  * editing code in the \`app\` directory`);
@@ -6506,7 +6667,7 @@ async function templateDirectory(name) {
 }
 
 function toValidPackageName(projectName) {
-  return projectName.trim().toLowerCase().replace(/\s+/g, '-').replace(/^[._]/, '').replace(/[^a-z0-9-~@]+/g, '-');
+  return projectName.trim().toLowerCase().replace(/\s+/g, '-').replace(/^[._]/, '').replace(/[^a-z0-9-~@/]+/g, '-');
 }
 
 function copy(source, destination) {