@quilted/create 0.1.20 → 0.1.21

package/build/esm/package.mjs

@@ -0,0 +1,784 @@
+import { _ as _asyncToGenerator, r as regenerator, s as stripIndent, a as _taggedTemplateLiteral, c as cyan_1, h as bold_1, d as dim_1, u as underline_1, m as magenta_1, g as getExtrasToSetup, b as getPackageManager, e as getShouldInstall, f as getCreateAsMonorepo, p as printHelp, i as arg_1, j as prompt, k as _defineProperty } from './index.mjs';
+import { r as relativeDirectoryForDisplay, a as addToTsConfig, b as addToPackageManagerWorkspaces, t as toValidPackageName, f as format, l as loadTemplate, _ as _slicedToArray, c as createOutputTarget, e as emptyDirectory, i as isEmpty } from './package-manager.mjs';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import 'tty';
+import 'url';
+import 'readline';
+import 'events';
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function createProject() {
+  return _createProject.apply(this, arguments);
+} // Argument handling
+
+function _createProject() {
+  _createProject = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee() {
+    var argv, _argv$PackageManag, additionalOptions, inWorkspace, name, directory, isPublic, useReact, createAsMonorepo, shouldInstall, packageManager, setupExtras, partOfMonorepo, packageDirectory, rootDirectory, outputRoot, packageTemplate, workspaceTemplate, quiltProject, workspacePackageJson, _yield$Promise$all, _yield$Promise$all2, projectPackageJson, projectTSConfig, _workspacePackageJson, newPackageJson, _i, _Object$entries, _Object$entries$_i, key, value, _projectPackageJson, packageJsonInstructions, commands, whatsNext, followUp;
+
+    return regenerator.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            argv = getArgv();
+
+            if (!argv['--help']) {
+              _context.next = 5;
+              break;
+            }
+
+            additionalOptions = stripIndent(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      ", ", ", "\n      Whether this package will use React. If you don\u2019t provide this option, the command\n      will ask you about it later.\n\n      ", ", ", "\n      Whether this package will be published for other projects to install. If you do not\n      provide this option, the command will ask you about it later.\n\n      ", "\n      The package registry to publish this package to. This option only applies if you create\n      a public package. If you do not provide this option, it will use the default NPM registry.\n    "])), 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 _context.abrupt("return");
+
+          case 5:
+            inWorkspace = fs.existsSync('quilt.workspace.ts');
+            _context.next = 8;
+            return getName(argv);
+
+          case 8:
+            name = _context.sent;
+            _context.next = 11;
+            return getDirectory(argv, {
+              name: name,
+              inWorkspace: inWorkspace
+            });
+
+          case 11:
+            directory = _context.sent;
+            _context.next = 14;
+            return getPublic(argv);
+
+          case 14:
+            isPublic = _context.sent;
+            _context.next = 17;
+            return getReact(argv);
+
+          case 17:
+            useReact = _context.sent;
+            _context.t0 = !inWorkspace;
+
+            if (!_context.t0) {
+              _context.next = 23;
+              break;
+            }
+
+            _context.next = 22;
+            return getCreateAsMonorepo(argv);
+
+          case 22:
+            _context.t0 = _context.sent;
+
+          case 23:
+            createAsMonorepo = _context.t0;
+            _context.next = 26;
+            return getShouldInstall(argv);
+
+          case 26:
+            shouldInstall = _context.sent;
+            _context.next = 29;
+            return getPackageManager(argv);
+
+          case 29:
+            packageManager = _context.sent;
+            _context.next = 32;
+            return getExtrasToSetup(argv, {
+              inWorkspace: inWorkspace
+            });
+
+          case 32:
+            setupExtras = _context.sent;
+            partOfMonorepo = inWorkspace || createAsMonorepo;
+            packageDirectory = createAsMonorepo ? path.join(directory, "packages/".concat(toValidPackageName(name.split('/').pop()))) : directory;
+
+            if (!fs.existsSync(directory)) {
+              _context.next = 41;
+              break;
+            }
+
+            _context.next = 38;
+            return emptyDirectory(directory);
+
+          case 38:
+            if (packageDirectory !== directory) {
+              fs.mkdirSync(packageDirectory, {
+                recursive: true
+              });
+            }
+
+            _context.next = 42;
+            break;
+
+          case 41:
+            fs.mkdirSync(packageDirectory, {
+              recursive: true
+            });
+
+          case 42:
+            rootDirectory = inWorkspace ? process.cwd() : directory;
+            outputRoot = createOutputTarget(rootDirectory);
+            packageTemplate = loadTemplate('package');
+            workspaceTemplate = loadTemplate('workspace');
+            _context.next = 48;
+            return packageTemplate.read('quilt.project.ts');
+
+          case 48:
+            quiltProject = _context.sent;
+
+            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) {
+              _context.next = 127;
+              break;
+            }
+
+            _context.next = 53;
+            return workspaceTemplate.copy(directory, function (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';
+            });
+
+          case 53:
+            if (!createAsMonorepo) {
+              _context.next = 78;
+              break;
+            }
+
+            _context.t1 = JSON;
+            _context.next = 57;
+            return workspaceTemplate.read('package.json');
+
+          case 57:
+            _context.t2 = _context.sent;
+            workspacePackageJson = _context.t1.parse.call(_context.t1, _context.t2);
+            workspacePackageJson.name = toValidPackageName(name);
+
+            if (!(packageManager === 'pnpm')) {
+              _context.next = 69;
+              break;
+            }
+
+            _context.t3 = outputRoot;
+            _context.next = 64;
+            return format("\n              packages:\n              - './packages/*'\n            ", {
+              as: 'yaml'
+            });
+
+          case 64:
+            _context.t4 = _context.sent;
+            _context.next = 67;
+            return _context.t3.write.call(_context.t3, 'pnpm-workspace.yaml', _context.t4);
+
+          case 67:
+            _context.next = 70;
+            break;
+
+          case 69:
+            workspacePackageJson.workspaces = ['packages/*'];
+
+          case 70:
+            _context.t5 = outputRoot;
+            _context.next = 73;
+            return format(JSON.stringify(workspacePackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 73:
+            _context.t6 = _context.sent;
+            _context.next = 76;
+            return _context.t5.write.call(_context.t5, 'package.json', _context.t6);
+
+          case 76:
+            _context.next = 121;
+            break;
+
+          case 78:
+            _context.next = 80;
+            return Promise.all([packageTemplate.read('package.json').then(function (content) {
+              return JSON.parse(content);
+            }), packageTemplate.read('tsconfig.json').then(function (content) {
+              return JSON.parse(content);
+            }), workspaceTemplate.read('package.json').then(function (content) {
+              return JSON.parse(content);
+            })]);
+
+          case 80:
+            _yield$Promise$all = _context.sent;
+            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 3);
+            projectPackageJson = _yield$Promise$all2[0];
+            projectTSConfig = _yield$Promise$all2[1];
+            _workspacePackageJson = _yield$Promise$all2[2];
+            _workspacePackageJson.eslintConfig = projectPackageJson.eslintConfig;
+            _workspacePackageJson.browserslist = projectPackageJson.browserslist;
+            newPackageJson = {}; // We want to put the project’s dependencies in the package.json, respecting
+            // the preferred ordering (dependencies, peer dependencies, dev dependencies).
+
+            _i = 0, _Object$entries = Object.entries(projectPackageJson);
+
+          case 89:
+            if (!(_i < _Object$entries.length)) {
+              _context.next = 101;
+              break;
+            }
+
+            _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), key = _Object$entries$_i[0], value = _Object$entries$_i[1];
+
+            if (!(key !== 'devDependencies')) {
+              _context.next = 94;
+              break;
+            }
+
+            newPackageJson[key] = value;
+            return _context.abrupt("continue", 98);
+
+          case 94:
+            newPackageJson.dependencies = projectPackageJson.dependencies;
+            newPackageJson.peerDependencies = projectPackageJson.peerDependencies;
+            newPackageJson.peerDependenciesMeta = projectPackageJson.peerDependenciesMeta;
+            newPackageJson.devDependencies = sortKeys(_objectSpread(_objectSpread({}, _workspacePackageJson.devDependencies), projectPackageJson.devDependencies));
+
+          case 98:
+            _i++;
+            _context.next = 89;
+            break;
+
+          case 101:
+            adjustPackageJson(newPackageJson, {
+              name: toValidPackageName(name),
+              react: useReact,
+              isPublic: isPublic,
+              registry: argv['--registry']
+            });
+            quiltProject = quiltProject.replace('quiltPackage', 'quiltWorkspace, quiltPackage').replace('quiltPackage(', 'quiltWorkspace(), quiltPackage(');
+            _context.t7 = outputRoot;
+            _context.next = 106;
+            return format(quiltProject, {
+              as: 'typescript'
+            });
+
+          case 106:
+            _context.t8 = _context.sent;
+            _context.next = 109;
+            return _context.t7.write.call(_context.t7, 'quilt.project.ts', _context.t8);
+
+          case 109:
+            _context.t9 = outputRoot;
+            _context.next = 112;
+            return format(JSON.stringify(newPackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 112:
+            _context.t10 = _context.sent;
+            _context.next = 115;
+            return _context.t9.write.call(_context.t9, 'package.json', _context.t10);
+
+          case 115:
+            _context.t11 = outputRoot;
+            _context.next = 118;
+            return format(JSON.stringify(projectTSConfig), {
+              as: 'json'
+            });
+
+          case 118:
+            _context.t12 = _context.sent;
+            _context.next = 121;
+            return _context.t11.write.call(_context.t11, 'tsconfig.json', _context.t12);
+
+          case 121:
+            if (!setupExtras.has('github')) {
+              _context.next = 124;
+              break;
+            }
+
+            _context.next = 124;
+            return loadTemplate('github').copy(directory);
+
+          case 124:
+            if (!setupExtras.has('vscode')) {
+              _context.next = 127;
+              break;
+            }
+
+            _context.next = 127;
+            return loadTemplate('vscode').copy(directory);
+
+          case 127:
+            _context.next = 129;
+            return packageTemplate.copy(packageDirectory, function (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';
+            });
+
+          case 129:
+            if (!partOfMonorepo) {
+              _context.next = 148;
+              break;
+            }
+
+            _context.t13 = JSON;
+            _context.next = 133;
+            return packageTemplate.read('package.json');
+
+          case 133:
+            _context.t14 = _context.sent;
+            _projectPackageJson = _context.t13.parse.call(_context.t13, _context.t14);
+            _projectPackageJson.repository.directory = path.relative(directory, packageDirectory);
+            adjustPackageJson(_projectPackageJson, {
+              name: toValidPackageName(name),
+              react: useReact,
+              isPublic: isPublic,
+              registry: argv['--registry']
+            });
+            _context.t15 = outputRoot;
+            _context.t16 = path.join(packageDirectory, 'package.json');
+            _context.next = 141;
+            return format(JSON.stringify(_projectPackageJson), {
+              as: 'json-stringify'
+            });
+
+          case 141:
+            _context.t17 = _context.sent;
+            _context.next = 144;
+            return _context.t15.write.call(_context.t15, _context.t16, _context.t17);
+
+          case 144:
+            _context.next = 146;
+            return outputRoot.write(path.join(packageDirectory, 'quilt.project.ts'), quiltProject);
+
+          case 146:
+            _context.next = 148;
+            return Promise.all([addToTsConfig(packageDirectory, outputRoot), addToPackageManagerWorkspaces(packageDirectory, outputRoot, packageManager)]);
+
+          case 148:
+            if (shouldInstall) {
+              process.stdout.write('\nInstalling dependencies...\n'); // TODO: better loading, handle errors
+
+              execSync("".concat(packageManager, " install"), {
+                cwd: rootDirectory
+              });
+              process.stdout.moveCursor(0, -1);
+              process.stdout.clearLine(1);
+              console.log('Installed dependencies.');
+            }
+
+            packageJsonInstructions = stripIndent(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    Your new package is ready to go! However, before you go too much further,\n    you should update the following fields in ", ":\n\n     - ", ", where you provide a description of what your package does\n     - ", ", where you should include the ", " of your project\u2019s repo\n\n    Before you publish your package, you will also want to update the ", "\n    field in the package.json file.\n  "])), 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);
+            commands = [];
+
+            if (!inWorkspace && directory !== process.cwd()) {
+              commands.push("cd ".concat(cyan_1(relativeDirectoryForDisplay(path.relative(process.cwd(), directory))), " ").concat(dim_1('# Move into your new package’s directory')));
+            }
+
+            if (!shouldInstall) {
+              commands.push("pnpm install ".concat(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\" ".concat(dim_1('# Start your git history (optional)')));
+            }
+
+            if (commands.length > 0) {
+              whatsNext = stripIndent(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n      After you update your package.json, there\u2019s ", " you\u2019ll need to take\n      in order to start building:\n    "])), commands.length > 1 ? 'a few more steps' : 'one more step');
+              console.log();
+              console.log(whatsNext);
+              console.log();
+              console.log(commands.map(function (command) {
+                return "  ".concat(command);
+              }).join('\n'));
+            }
+
+            followUp = stripIndent(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n    Quilt can help you build, test, lint, and type-check your new package. You\n    can learn more about building packages with Quilt by reading the documentation:\n    ", "\n\n    Have fun! \uD83C\uDF89\n  "])), underline_1(magenta_1('https://github.com/lemonmade/quilt/tree/main/documentation')));
+            console.log();
+            console.log(followUp);
+
+          case 160:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _createProject.apply(this, arguments);
+}
+
+function getArgv() {
+  var 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;
+}
+
+function getName(_x) {
+  return _getName.apply(this, arguments);
+}
+
+function _getName() {
+  _getName = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(argv) {
+    var name;
+    return regenerator.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            name = argv['--name'];
+
+            if (!(name == null)) {
+              _context2.next = 5;
+              break;
+            }
+
+            _context2.next = 4;
+            return prompt({
+              type: 'text',
+              message: 'What would you like to name your new package?',
+              initial: '@my-team/package'
+            });
+
+          case 4:
+            name = _context2.sent;
+
+          case 5:
+            return _context2.abrupt("return", name);
+
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getName.apply(this, arguments);
+}
+
+function getDirectory(_x2, _x3) {
+  return _getDirectory.apply(this, arguments);
+}
+
+function _getDirectory() {
+  _getDirectory = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee3(argv, _ref) {
+    var name, inWorkspace, directory, basePackageName, defaultDirectory, relativeDirectory, empty, promptDirectory;
+    return regenerator.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            name = _ref.name, inWorkspace = _ref.inWorkspace;
+            directory = argv['--directory'] ? path.resolve(argv['--directory']) : undefined;
+
+            if (!(directory == null)) {
+              _context3.next = 10;
+              break;
+            }
+
+            basePackageName = toValidPackageName(name.split('/').pop());
+            defaultDirectory = inWorkspace ? "packages/".concat(basePackageName) : basePackageName;
+            _context3.t0 = path;
+            _context3.next = 8;
+            return prompt({
+              type: 'text',
+              message: 'Where would you like to create your new package?',
+              initial: defaultDirectory
+            });
+
+          case 8:
+            _context3.t1 = _context3.sent;
+            directory = _context3.t0.resolve.call(_context3.t0, _context3.t1);
+
+          case 10:
+            if (argv['--yes']) {
+              _context3.next = 32;
+              break;
+            }
+
+            _context3.t2 = fs.existsSync(directory);
+
+            if (!_context3.t2) {
+              _context3.next = 16;
+              break;
+            }
+
+            _context3.next = 15;
+            return isEmpty(directory);
+
+          case 15:
+            _context3.t2 = !_context3.sent;
+
+          case 16:
+            if (!_context3.t2) {
+              _context3.next = 29;
+              break;
+            }
+
+            relativeDirectory = path.relative(process.cwd(), directory);
+            _context3.next = 20;
+            return prompt({
+              type: 'confirm',
+              message: "Directory ".concat(bold_1(relativeDirectoryForDisplay(relativeDirectory)), " is not empty, is it safe to empty it?"),
+              initial: true
+            });
+
+          case 20:
+            empty = _context3.sent;
+
+            if (!empty) {
+              _context3.next = 23;
+              break;
+            }
+
+            return _context3.abrupt("break", 32);
+
+          case 23:
+            _context3.next = 25;
+            return prompt({
+              type: 'text',
+              message: 'What directory do you want to create your package in?'
+            });
+
+          case 25:
+            promptDirectory = _context3.sent;
+            directory = path.resolve(promptDirectory);
+            _context3.next = 30;
+            break;
+
+          case 29:
+            return _context3.abrupt("break", 32);
+
+          case 30:
+            _context3.next = 10;
+            break;
+
+          case 32:
+            return _context3.abrupt("return", directory);
+
+          case 33:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _getDirectory.apply(this, arguments);
+}
+
+function getPublic(_x4) {
+  return _getPublic.apply(this, arguments);
+}
+
+function _getPublic() {
+  _getPublic = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee4(argv) {
+    var isPublic;
+    return regenerator.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            if (!(argv['--public'] || argv['--yes'])) {
+              _context4.next = 4;
+              break;
+            }
+
+            isPublic = true;
+            _context4.next = 11;
+            break;
+
+          case 4:
+            if (!argv['--private']) {
+              _context4.next = 8;
+              break;
+            }
+
+            isPublic = false;
+            _context4.next = 11;
+            break;
+
+          case 8:
+            _context4.next = 10;
+            return prompt({
+              type: 'confirm',
+              message: 'Will you publish this package to use in other projects?',
+              initial: true
+            });
+
+          case 10:
+            isPublic = _context4.sent;
+
+          case 11:
+            return _context4.abrupt("return", isPublic);
+
+          case 12:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _getPublic.apply(this, arguments);
+}
+
+function getReact(_x5) {
+  return _getReact.apply(this, arguments);
+}
+
+function _getReact() {
+  _getReact = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee5(argv) {
+    var useReact;
+    return regenerator.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            if (!(argv['--react'] || argv['--yes'])) {
+              _context5.next = 4;
+              break;
+            }
+
+            useReact = true;
+            _context5.next = 11;
+            break;
+
+          case 4:
+            if (!argv['--no-react']) {
+              _context5.next = 8;
+              break;
+            }
+
+            useReact = false;
+            _context5.next = 11;
+            break;
+
+          case 8:
+            _context5.next = 10;
+            return prompt({
+              type: 'confirm',
+              message: 'Will this package depend on React?',
+              initial: true
+            });
+
+          case 10:
+            useReact = _context5.sent;
+
+          case 11:
+            return _context5.abrupt("return", useReact);
+
+          case 12:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _getReact.apply(this, arguments);
+}
+
+function adjustPackageJson(packageJson, _ref2) {
+  var name = _ref2.name,
+      react = _ref2.react,
+      isPublic = _ref2.isPublic,
+      registry = _ref2.registry;
+  packageJson.name = name;
+  var packageParts = name.split('/');
+  var scope = packageParts[0].startsWith('@') ? packageParts[0] : undefined;
+  var finalRegistry = registry !== null && registry !== void 0 ? registry : 'https://registry.npmjs.org';
+
+  if (scope) {
+    packageJson.publishConfig["".concat(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(function (extend) {
+      return !extend.includes('react');
+    });
+  }
+
+  return packageJson;
+}
+
+function sortKeys(object) {
+  var newObject = {};
+  var sortedEntries = Object.entries(object).sort(function (_ref3, _ref4) {
+    var _ref5 = _slicedToArray(_ref3, 1),
+        keyOne = _ref5[0];
+
+    var _ref6 = _slicedToArray(_ref4, 1),
+        keyTwo = _ref6[0];
+
+    return keyOne.localeCompare(keyTwo);
+  });
+
+  var _iterator = _createForOfIteratorHelper(sortedEntries),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _slicedToArray(_step.value, 2),
+          key = _step$value[0],
+          value = _step$value[1];
+
+      newObject[key] = value;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return newObject;
+}
+
+export { createProject };