create-docusaurus 2.0.0-beta.13 → 2.0.0-beta.16

package/bin/index.js

@@ -6,62 +6,70 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-const chalk = require('chalk');
-const semver = require('semver');
-const path = require('path');
-const program = require('commander');
-const {default: init} = require('../lib');
-const requiredVersion = require('../package.json').engines.node;
+// @ts-check
+
+import logger from '@docusaurus/logger';
+import semver from 'semver';
+import path from 'path';
+import {program} from 'commander';
+import {createRequire} from 'module';
+import init from '../lib/index.js';
+
+const packageJson = createRequire(import.meta.url)('../package.json');
+const requiredVersion = packageJson.engines.node;
 
 if (!semver.satisfies(process.version, requiredVersion)) {
-  console.log(
-    chalk.red(`\nMinimum Node.js version not met :)`) +
-      chalk.yellow(
-        `\nYou are using Node.js ${process.version}, Requirement: Node.js ${requiredVersion}.\n`,
-      ),
-  );
+  logger.error('Minimum Node.js version not met :(');
+  logger.info`You are using Node.js number=${process.version}, Requirement: Node.js number=${requiredVersion}.`;
   process.exit(1);
 }
 
 function wrapCommand(fn) {
   return (...args) =>
     fn(...args).catch((err) => {
-      console.error(chalk.red(err.stack));
+      logger.error(err.stack);
       process.exitCode = 1;
     });
 }
 
-program
-  .version(require('../package.json').version)
-  .usage('<command> [options]');
+program.version(packageJson.version);
 
 program
-  .command('init [siteName] [template] [rootDir]', {isDefault: true})
-  .option('--use-npm')
-  .option('--skip-install')
-  .option('--typescript')
+  .arguments('[siteName] [template] [rootDir]')
+  .option(
+    '-p, --package-manager <manager>',
+    'The package manager used to install dependencies. One of yarn, npm, and pnpm.',
+  )
+  .option(
+    '-s, --skip-install',
+    'Do not run package manager immediately after scaffolding',
+  )
+  .option('-t, --typescript', 'Use the TypeScript template variant')
+  .option(
+    '-g, --git-strategy <strategy>',
+    `Only used if the template is a git repository.
+\`deep\`: preserve full history
+\`shallow\`: clone with --depth=1
+\`copy\`: do a shallow clone, but do not create a git repo
+\`custom\`: enter your custom git clone command. We will prompt you for it.`,
+  )
   .description('Initialize website.')
   .action(
     (
       siteName,
       template,
       rootDir = '.',
-      {useNpm, skipInstall, typescript} = {},
+      {packageManager, skipInstall, typescript, gitStrategy} = {},
     ) => {
       wrapCommand(init)(path.resolve(rootDir), siteName, template, {
-        useNpm,
+        packageManager,
         skipInstall,
         typescript,
+        gitStrategy,
       });
     },
   );
 
-program.arguments('<command>').action((cmd) => {
-  program.outputHelp();
-  console.log(`  ${chalk.red(`\n  Unknown command ${chalk.yellow(cmd)}.`)}`);
-  console.log();
-});
-
 program.parse(process.argv);
 
 if (!process.argv.slice(1).length) {

package/lib/index.d.ts

@@ -4,8 +4,17 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+declare const SupportedPackageManagers: {
+    npm: string;
+    yarn: string;
+    pnpm: string;
+};
+declare type SupportedPackageManager = keyof typeof SupportedPackageManagers;
+declare const gitStrategies: readonly ["deep", "shallow", "copy", "custom"];
 export default function init(rootDir: string, siteName?: string, reqTemplate?: string, cliOptions?: Partial<{
-    useNpm: boolean;
+    packageManager: SupportedPackageManager;
     skipInstall: boolean;
     typescript: boolean;
+    gitStrategy: typeof gitStrategies[number];
 }>): Promise<void>;
+export {};

package/lib/index.js

@@ -1,49 +1,82 @@
-"use strict";
 /**
  * Copyright (c) Facebook, Inc. and its affiliates.
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const chalk_1 = (0, tslib_1.__importDefault)(require("chalk"));
-const fs_extra_1 = (0, tslib_1.__importDefault)(require("fs-extra"));
-const child_process_1 = require("child_process");
-const prompts_1 = (0, tslib_1.__importDefault)(require("prompts"));
-const path_1 = (0, tslib_1.__importDefault)(require("path"));
-const shelljs_1 = (0, tslib_1.__importDefault)(require("shelljs"));
-const lodash_1 = require("lodash");
-const supports_color_1 = (0, tslib_1.__importDefault)(require("supports-color"));
+import logger from '@docusaurus/logger';
+import fs from 'fs-extra';
+import prompts from 'prompts';
+import path from 'path';
+import shell from 'shelljs';
+import _ from 'lodash';
+import supportsColor from 'supports-color';
+import { fileURLToPath } from 'url';
 const RecommendedTemplate = 'classic';
 const TypeScriptTemplateSuffix = '-typescript';
-function hasYarn() {
-    try {
-        (0, child_process_1.execSync)('yarnpkg --version', { stdio: 'ignore' });
-        return true;
+// Only used in the rare, rare case of running globally installed create +
+// using --skip-install. We need a default name to show the tip text
+const DefaultPackageManager = 'npm';
+const SupportedPackageManagers = {
+    npm: 'package-lock.json',
+    yarn: 'yarn.lock',
+    pnpm: 'pnpm-lock.yaml',
+};
+const PackageManagersList = Object.keys(SupportedPackageManagers);
+async function findPackageManagerFromLockFile() {
+    for (const packageManager of PackageManagersList) {
+        const lockFilePath = path.resolve(process.cwd(), SupportedPackageManagers[packageManager]);
+        if (await fs.pathExists(lockFilePath)) {
+            return packageManager;
+        }
     }
-    catch (e) {
-        return false;
+    return undefined;
+}
+function findPackageManagerFromUserAgent() {
+    return PackageManagersList.find((packageManager) => { var _a; return (_a = process.env.npm_config_user_agent) === null || _a === void 0 ? void 0 : _a.startsWith(packageManager); });
+}
+async function askForPackageManagerChoice() {
+    const hasYarn = shell.exec('yarn --version', { silent: true }).code === 0;
+    const hasPNPM = shell.exec('pnpm --version', { silent: true }).code === 0;
+    if (!hasYarn && !hasPNPM) {
+        return 'npm';
+    }
+    const choices = ['npm', hasYarn && 'yarn', hasPNPM && 'pnpm']
+        .filter((p) => Boolean(p))
+        .map((p) => ({ title: p, value: p }));
+    return (await prompts({
+        type: 'select',
+        name: 'packageManager',
+        message: 'Select a package manager...',
+        choices,
+    })).packageManager;
+}
+async function getPackageManager(packageManagerChoice, skipInstall = false) {
+    var _a, _b;
+    if (packageManagerChoice &&
+        !PackageManagersList.includes(packageManagerChoice)) {
+        throw new Error(`Invalid package manager choice ${packageManagerChoice}. Must be one of ${PackageManagersList.join(', ')}`);
     }
+    return ((_b = (_a = packageManagerChoice !== null && packageManagerChoice !== void 0 ? packageManagerChoice : (await findPackageManagerFromLockFile())) !== null && _a !== void 0 ? _a : findPackageManagerFromUserAgent()) !== null && _b !== void 0 ? _b : 
+    // This only happens if the user has a global installation in PATH
+    (skipInstall ? DefaultPackageManager : askForPackageManagerChoice()));
 }
 function isValidGitRepoUrl(gitRepoUrl) {
     return ['https://', 'git@'].some((item) => gitRepoUrl.startsWith(item));
 }
 async function updatePkg(pkgPath, obj) {
-    const content = await fs_extra_1.default.readFile(pkgPath, 'utf-8');
+    const content = await fs.readFile(pkgPath, 'utf-8');
     const pkg = JSON.parse(content);
     const newPkg = Object.assign(pkg, obj);
-    await fs_extra_1.default.outputFile(pkgPath, JSON.stringify(newPkg, null, 2));
+    await fs.outputFile(pkgPath, `${JSON.stringify(newPkg, null, 2)}\n`);
 }
-function readTemplates(templatesDir) {
-    const templates = fs_extra_1.default
-        .readdirSync(templatesDir)
-        .filter((d) => !d.startsWith('.') &&
+async function readTemplates(templatesDir) {
+    const templates = (await fs.readdir(templatesDir)).filter((d) => !d.startsWith('.') &&
         !d.startsWith('README') &&
         !d.endsWith(TypeScriptTemplateSuffix) &&
         d !== 'shared');
     // Classic should be first in list!
-    return (0, lodash_1.sortBy)(templates, (t) => t !== RecommendedTemplate);
+    return _.sortBy(templates, (t) => t !== RecommendedTemplate);
 }
 function createTemplateChoices(templates) {
     function makeNameAndValueChoice(value) {
@@ -63,31 +96,52 @@ function getTypeScriptBaseTemplate(template) {
     return undefined;
 }
 async function copyTemplate(templatesDir, template, dest) {
-    await fs_extra_1.default.copy(path_1.default.resolve(templatesDir, 'shared'), dest);
-    // TypeScript variants will copy duplicate resources like CSS & config from base template
+    await fs.copy(path.resolve(templatesDir, 'shared'), dest);
+    // TypeScript variants will copy duplicate resources like CSS & config from
+    // base template
     const tsBaseTemplate = getTypeScriptBaseTemplate(template);
     if (tsBaseTemplate) {
-        const tsBaseTemplatePath = path_1.default.resolve(templatesDir, tsBaseTemplate);
-        await fs_extra_1.default.copy(tsBaseTemplatePath, dest, {
-            filter: (filePath) => fs_extra_1.default.statSync(filePath).isDirectory() ||
-                path_1.default.extname(filePath) === '.css' ||
-                path_1.default.basename(filePath) === 'docusaurus.config.js',
+        const tsBaseTemplatePath = path.resolve(templatesDir, tsBaseTemplate);
+        await fs.copy(tsBaseTemplatePath, dest, {
+            filter: async (filePath) => (await fs.stat(filePath)).isDirectory() ||
+                path.extname(filePath) === '.css' ||
+                path.basename(filePath) === 'docusaurus.config.js',
         });
     }
-    await fs_extra_1.default.copy(path_1.default.resolve(templatesDir, template), dest, {
-        // Symlinks don't exist in published NPM packages anymore, so this is only to prevent errors during local testing
-        filter: (filePath) => !fs_extra_1.default.lstatSync(filePath).isSymbolicLink(),
+    await fs.copy(path.resolve(templatesDir, template), dest, {
+        // Symlinks don't exist in published NPM packages anymore, so this is only
+        // to prevent errors during local testing
+        filter: async (filePath) => !(await fs.lstat(filePath)).isSymbolicLink(),
     });
 }
-async function init(rootDir, siteName, reqTemplate, cliOptions = {}) {
-    const useYarn = cliOptions.useNpm ? false : hasYarn();
-    const templatesDir = path_1.default.resolve(__dirname, '../templates');
-    const templates = readTemplates(templatesDir);
-    const hasTS = (templateName) => fs_extra_1.default.pathExistsSync(path_1.default.resolve(templatesDir, `${templateName}${TypeScriptTemplateSuffix}`));
+const gitStrategies = ['deep', 'shallow', 'copy', 'custom'];
+async function getGitCommand(gitStrategy) {
+    switch (gitStrategy) {
+        case 'shallow':
+        case 'copy':
+            return 'git clone --recursive --depth 1';
+        case 'custom': {
+            const { command } = await prompts({
+                type: 'text',
+                name: 'command',
+                message: 'Write your own git clone command. The repository URL and destination directory will be supplied. E.g. "git clone --depth 10"',
+            });
+            return command;
+        }
+        case 'deep':
+        default:
+            return 'git clone';
+    }
+}
+export default async function init(rootDir, siteName, reqTemplate, cliOptions = {}) {
+    var _a;
+    const templatesDir = fileURLToPath(new URL('../templates', import.meta.url));
+    const templates = await readTemplates(templatesDir);
+    const hasTS = (templateName) => fs.pathExists(path.resolve(templatesDir, `${templateName}${TypeScriptTemplateSuffix}`));
     let name = siteName;
     // Prompt if siteName is not passed from CLI.
     if (!name) {
-        const prompt = await (0, prompts_1.default)({
+        const prompt = await prompts({
             type: 'text',
             name: 'name',
             message: 'What should we name this site?',
@@ -96,25 +150,27 @@ async function init(rootDir, siteName, reqTemplate, cliOptions = {}) {
         name = prompt.name;
     }
     if (!name) {
-        throw new Error(chalk_1.default.red('A website name is required.'));
+        logger.error('A website name is required.');
+        process.exit(1);
     }
-    const dest = path_1.default.resolve(rootDir, name);
-    if (fs_extra_1.default.existsSync(dest)) {
-        throw new Error(`Directory already exists at "${dest}"!`);
+    const dest = path.resolve(rootDir, name);
+    if (await fs.pathExists(dest)) {
+        logger.error `Directory already exists at path=${dest}!`;
+        process.exit(1);
     }
     let template = reqTemplate;
     let useTS = cliOptions.typescript;
     // Prompt if template is not provided from CLI.
     if (!template) {
-        const templatePrompt = await (0, prompts_1.default)({
+        const templatePrompt = await prompts({
             type: 'select',
             name: 'template',
             message: 'Select a template below...',
             choices: createTemplateChoices(templates),
         });
         template = templatePrompt.template;
-        if (template && !useTS && hasTS(template)) {
-            const tsPrompt = await (0, prompts_1.default)({
+        if (template && !useTS && (await hasTS(template))) {
+            const tsPrompt = await prompts({
                 type: 'confirm',
                 name: 'useTS',
                 message: 'This template is available in TypeScript. Do you want to use the TS variant?',
@@ -123,57 +179,81 @@ async function init(rootDir, siteName, reqTemplate, cliOptions = {}) {
             useTS = tsPrompt.useTS;
         }
     }
+    let gitStrategy = (_a = cliOptions.gitStrategy) !== null && _a !== void 0 ? _a : 'deep';
     // If user choose Git repository, we'll prompt for the url.
     if (template === 'Git repository') {
-        const repoPrompt = await (0, prompts_1.default)({
+        const repoPrompt = await prompts({
             type: 'text',
             name: 'gitRepoUrl',
             validate: (url) => {
                 if (url && isValidGitRepoUrl(url)) {
                     return true;
                 }
-                return chalk_1.default.red(`Invalid repository URL`);
+                return logger.red('Invalid repository URL');
             },
-            message: 'Enter a repository URL from GitHub, Bitbucket, GitLab, or any other public repo.\n(e.g: https://github.com/ownerName/repoName.git)',
+            message: logger.interpolate `Enter a repository URL from GitHub, Bitbucket, GitLab, or any other public repo.
+(e.g: path=${'https://github.com/ownerName/repoName.git'})`,
         });
+        ({ gitStrategy } = await prompts({
+            type: 'select',
+            name: 'gitStrategy',
+            message: 'How should we clone this repo?',
+            choices: [
+                { title: 'Deep clone: preserve full history', value: 'deep' },
+                { title: 'Shallow clone: clone with --depth=1', value: 'shallow' },
+                {
+                    title: 'Copy: do a shallow clone, but do not create a git repo',
+                    value: 'copy',
+                },
+                { title: 'Custom: enter your custom git clone command', value: 'custom' },
+            ],
+        }));
         template = repoPrompt.gitRepoUrl;
     }
     else if (template === 'Local template') {
-        const dirPrompt = await (0, prompts_1.default)({
+        const dirPrompt = await prompts({
             type: 'text',
             name: 'templateDir',
-            validate: (dir) => {
+            validate: async (dir) => {
                 if (dir) {
-                    const fullDir = path_1.default.resolve(process.cwd(), dir);
-                    if (fs_extra_1.default.existsSync(fullDir)) {
+                    const fullDir = path.resolve(process.cwd(), dir);
+                    if (await fs.pathExists(fullDir)) {
                         return true;
                     }
-                    return chalk_1.default.red(`The path ${chalk_1.default.magenta(fullDir)} does not exist.`);
+                    return logger.red(logger.interpolate `path=${fullDir} does not exist.`);
                 }
-                return chalk_1.default.red('Please enter a valid path.');
+                return logger.red('Please enter a valid path.');
             },
             message: 'Enter a local folder path, relative to the current working directory.',
         });
         template = dirPrompt.templateDir;
     }
     if (!template) {
-        throw new Error('Template should not be empty');
+        logger.error('Template should not be empty');
+        process.exit(1);
     }
-    console.log(`
-${chalk_1.default.cyan('Creating new Docusaurus project...')}
-`);
+    logger.info('Creating new Docusaurus project...');
     if (isValidGitRepoUrl(template)) {
-        console.log(`Cloning Git template ${chalk_1.default.cyan(template)}...`);
-        if (shelljs_1.default.exec(`git clone --recursive ${template} ${dest}`, { silent: true })
-            .code !== 0) {
-            throw new Error(chalk_1.default.red(`Cloning Git template ${template} failed!`));
+        logger.info `Cloning Git template path=${template}...`;
+        if (!gitStrategies.includes(gitStrategy)) {
+            logger.error `Invalid git strategy: name=${gitStrategy}. Value must be one of ${gitStrategies.join(', ')}.`;
+            process.exit(1);
+        }
+        const command = await getGitCommand(gitStrategy);
+        if (shell.exec(`${command} ${template} ${dest}`).code !== 0) {
+            logger.error `Cloning Git template name=${template} failed!`;
+            process.exit(1);
+        }
+        if (gitStrategy === 'copy') {
+            await fs.remove(path.join(dest, '.git'));
         }
     }
     else if (templates.includes(template)) {
         // Docusaurus templates.
         if (useTS) {
-            if (!hasTS(template)) {
-                throw new Error(`Template ${template} doesn't provide the Typescript variant.`);
+            if (!(await hasTS(template))) {
+                logger.error `Template name=${template} doesn't provide the Typescript variant.`;
+                process.exit(1);
             }
             template = `${template}${TypeScriptTemplateSuffix}`;
         }
@@ -181,87 +261,87 @@ ${chalk_1.default.cyan('Creating new Docusaurus project...')}
             await copyTemplate(templatesDir, template, dest);
         }
         catch (err) {
-            console.log(`Copying Docusaurus template ${chalk_1.default.cyan(template)} failed!`);
+            logger.error `Copying Docusaurus template name=${template} failed!`;
             throw err;
         }
     }
-    else if (fs_extra_1.default.existsSync(path_1.default.resolve(process.cwd(), template))) {
-        const templateDir = path_1.default.resolve(process.cwd(), template);
+    else if (await fs.pathExists(path.resolve(process.cwd(), template))) {
+        const templateDir = path.resolve(process.cwd(), template);
         try {
-            await fs_extra_1.default.copy(templateDir, dest);
+            await fs.copy(templateDir, dest);
         }
         catch (err) {
-            console.log(`Copying local template ${templateDir} failed!`);
+            logger.error `Copying local template path=${templateDir} failed!`;
             throw err;
         }
     }
     else {
-        throw new Error('Invalid template.');
+        logger.error('Invalid template.');
+        process.exit(1);
     }
     // Update package.json info.
     try {
-        await updatePkg(path_1.default.join(dest, 'package.json'), {
-            name: (0, lodash_1.kebabCase)(name),
+        await updatePkg(path.join(dest, 'package.json'), {
+            name: _.kebabCase(name),
             version: '0.0.0',
             private: true,
         });
     }
     catch (err) {
-        console.log(chalk_1.default.red('Failed to update package.json.'));
+        logger.error('Failed to update package.json.');
         throw err;
     }
     // We need to rename the gitignore file to .gitignore
-    if (!fs_extra_1.default.pathExistsSync(path_1.default.join(dest, '.gitignore')) &&
-        fs_extra_1.default.pathExistsSync(path_1.default.join(dest, 'gitignore'))) {
-        await fs_extra_1.default.move(path_1.default.join(dest, 'gitignore'), path_1.default.join(dest, '.gitignore'));
+    if (!(await fs.pathExists(path.join(dest, '.gitignore'))) &&
+        (await fs.pathExists(path.join(dest, 'gitignore')))) {
+        await fs.move(path.join(dest, 'gitignore'), path.join(dest, '.gitignore'));
     }
-    if (fs_extra_1.default.pathExistsSync(path_1.default.join(dest, 'gitignore'))) {
-        fs_extra_1.default.removeSync(path_1.default.join(dest, 'gitignore'));
+    if (await fs.pathExists(path.join(dest, 'gitignore'))) {
+        await fs.remove(path.join(dest, 'gitignore'));
     }
-    const pkgManager = useYarn ? 'yarn' : 'npm';
+    // Display the most elegant way to cd.
+    const cdpath = path.relative('.', dest);
+    const pkgManager = await getPackageManager(cliOptions.packageManager, cliOptions.skipInstall);
     if (!cliOptions.skipInstall) {
-        console.log(`Installing dependencies with ${chalk_1.default.cyan(pkgManager)}...`);
-        try {
-            // Use force coloring the output, since the command is invoked by shelljs, which is not the interactive shell
-            shelljs_1.default.exec(`cd "${name}" && ${useYarn ? 'yarn' : 'npm install --color always'}`, {
-                env: {
-                    ...process.env,
-                    ...(supports_color_1.default.stdout ? { FORCE_COLOR: '1' } : {}),
-                },
-            });
-        }
-        catch (err) {
-            console.log(chalk_1.default.red('Installation failed.'));
-            throw err;
+        shell.cd(dest);
+        logger.info `Installing dependencies with name=${pkgManager}...`;
+        if (shell.exec(pkgManager === 'yarn' ? 'yarn' : `${pkgManager} install --color always`, {
+            env: {
+                ...process.env,
+                // Force coloring the output, since the command is invoked,
+                // by shelljs which is not the interactive shell
+                ...(supportsColor.stdout ? { FORCE_COLOR: '1' } : {}),
+            },
+        }).code !== 0) {
+            logger.error('Dependency installation failed.');
+            logger.info `The site directory has already been created, and you can retry by typing:
+
+  code=${`cd ${cdpath}`}
+  code=${`${pkgManager} install`}`;
+            process.exit(0);
         }
     }
-    console.log();
-    // Display the most elegant way to cd.
-    const cdpath = path_1.default.join(process.cwd(), name) === dest
-        ? name
-        : path_1.default.relative(process.cwd(), name);
-    console.log(`
-Successfully created "${chalk_1.default.cyan(cdpath)}".
-Inside that directory, you can run several commands:
+    const useNpm = pkgManager === 'npm';
+    logger.success `Created path=${cdpath}.`;
+    logger.info `Inside that directory, you can run several commands:
 
-  ${chalk_1.default.cyan(`${pkgManager} start`)}
+  code=${`${pkgManager} start`}
     Starts the development server.
 
-  ${chalk_1.default.cyan(`${pkgManager} ${useYarn ? '' : 'run '}build`)}
+  code=${`${pkgManager} ${useNpm ? 'run ' : ''}build`}
     Bundles your website into static files for production.
 
-  ${chalk_1.default.cyan(`${pkgManager} ${useYarn ? '' : 'run '}serve`)}
+  code=${`${pkgManager} ${useNpm ? 'run ' : ''}serve`}
     Serves the built website locally.
 
-  ${chalk_1.default.cyan(`${pkgManager} deploy`)}
+  code=${`${pkgManager} deploy`}
     Publishes the website to GitHub pages.
 
 We recommend that you begin by typing:
 
-  ${chalk_1.default.cyan('cd')} ${cdpath}
-  ${chalk_1.default.cyan(`${pkgManager} start`)}
+  code=${`cd ${cdpath}`}
+  code=${`${pkgManager} start`}
 
 Happy building awesome websites!
-`);
+`;
 }
-exports.default = init;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "create-docusaurus",
-  "version": "2.0.0-beta.13",
+  "version": "2.0.0-beta.16",
   "description": "Create Docusaurus apps easily.",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/docusaurus.git",
@@ -15,29 +16,27 @@
     "build": "tsc",
     "watch": "tsc --watch"
   },
-  "bin": {
-    "create-docusaurus": "bin/index.js"
-  },
+  "bin": "bin/index.js",
   "publishConfig": {
     "access": "public"
   },
   "license": "MIT",
   "dependencies": {
-    "chalk": "^4.1.2",
+    "@docusaurus/logger": "2.0.0-beta.16",
     "commander": "^5.1.0",
-    "fs-extra": "^10.0.0",
-    "lodash": "^4.17.20",
-    "prompts": "^2.4.1",
-    "semver": "^7.3.4",
-    "shelljs": "^0.8.4",
-    "supports-color": "^8.1.1",
+    "fs-extra": "^10.0.1",
+    "lodash": "^4.17.21",
+    "prompts": "^2.4.2",
+    "semver": "^7.3.5",
+    "shelljs": "^0.8.5",
+    "supports-color": "^9.2.1",
     "tslib": "^2.3.1"
   },
-  "engines": {
-    "node": ">=14"
-  },
   "devDependencies": {
     "@types/supports-color": "^8.1.1"
   },
-  "gitHead": "b6ca12aedf10a10c2375f4f8b7e7380cfd7c7202"
+  "engines": {
+    "node": ">=14"
+  },
+  "gitHead": "eb43c4d4f95a4fb97dc9bb9dc615413e0dc2e1e7"
 }

package/templates/classic/docusaurus.config.js

@@ -24,13 +24,13 @@ const config = {
         docs: {
           sidebarPath: require.resolve('./sidebars.js'),
           // Please change this to your repo.
-          editUrl: 'https://github.com/facebook/docusaurus/edit/main/website/',
+          editUrl: 'https://github.com/facebook/docusaurus/tree/main/packages/create-docusaurus/templates/shared/',
         },
         blog: {
           showReadingTime: true,
           // Please change this to your repo.
           editUrl:
-            'https://github.com/facebook/docusaurus/edit/main/website/blog/',
+            'https://github.com/facebook/docusaurus/tree/main/packages/create-docusaurus/templates/shared/',
         },
         theme: {
           customCss: require.resolve('./src/css/custom.css'),

package/templates/classic/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docusaurus-2-classic-template",
-  "version": "2.0.0-beta.13",
+  "version": "2.0.0-beta.16",
   "private": true,
   "scripts": {
     "docusaurus": "docusaurus",
@@ -14,9 +14,9 @@
     "write-heading-ids": "docusaurus write-heading-ids"
   },
   "dependencies": {
-    "@docusaurus/core": "2.0.0-beta.13",
-    "@docusaurus/preset-classic": "2.0.0-beta.13",
-    "@mdx-js/react": "^1.6.21",
+    "@docusaurus/core": "2.0.0-beta.16",
+    "@docusaurus/preset-classic": "2.0.0-beta.16",
+    "@mdx-js/react": "^1.6.22",
     "clsx": "^1.1.1",
     "prism-react-renderer": "^1.2.1",
     "react": "^17.0.1",