@docusaurus/plugin-content-docs 2.0.0-beta.ff31de0ff → 2.0.0-rc.1

package/lib/index.js

@@ -9,37 +9,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOptions = void 0;
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
-const constants_1 = require("@docusaurus/core/lib/constants");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const utils_1 = require("@docusaurus/utils");
 const sidebars_1 = require("./sidebars");
+const generator_1 = require("./sidebars/generator");
 const docs_1 = require("./docs");
 const versions_1 = require("./versions");
 const cli_1 = require("./cli");
-const constants_2 = require("./constants");
-const lodash_1 = require("lodash");
+const constants_1 = require("./constants");
 const globalData_1 = require("./globalData");
 const props_1 = require("./props");
+const categoryGeneratedIndex_1 = require("./categoryGeneratedIndex");
 const translations_1 = require("./translations");
-const sidebarItemsGenerator_1 = require("./sidebarItemsGenerator");
-function pluginContentDocs(context, options) {
-    var _a;
+const tags_1 = require("./tags");
+const routes_1 = require("./routes");
+const utils_2 = require("./sidebars/utils");
+async function pluginContentDocs(context, options) {
     const { siteDir, generatedFilesDir, baseUrl, siteConfig } = context;
-    const versionsMetadata = versions_1.readVersionsMetadata({ context, options });
-    const sourceToPermalink = {};
-    const pluginId = (_a = options.id) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_PLUGIN_ID;
+    // Mutate options to resolve sidebar path according to siteDir
+    options.sidebarPath = (0, sidebars_1.resolveSidebarPathOption)(siteDir, options.sidebarPath);
+    const versionsMetadata = await (0, versions_1.readVersionsMetadata)({ context, options });
+    const pluginId = options.id;
     const pluginDataDirRoot = path_1.default.join(generatedFilesDir, 'docusaurus-plugin-content-docs');
     const dataDir = path_1.default.join(pluginDataDirRoot, pluginId);
-    const aliasedSource = (source) => `~docs/${utils_1.posixPath(path_1.default.relative(pluginDataDirRoot, source))}`;
+    const aliasedSource = (source) => `~docs/${(0, utils_1.posixPath)(path_1.default.relative(pluginDataDirRoot, source))}`;
     return {
         name: 'docusaurus-plugin-content-docs',
-        getThemePath() {
-            return path_1.default.resolve(__dirname, './theme');
-        },
-        getTypeScriptThemePath() {
-            return path_1.default.resolve(__dirname, '..', 'src', 'theme');
-        },
         extendCli(cli) {
-            const isDefaultPluginId = pluginId === constants_1.DEFAULT_PLUGIN_ID;
+            const isDefaultPluginId = pluginId === utils_1.DEFAULT_PLUGIN_ID;
             // Need to create one distinct command per plugin instance
             // otherwise 2 instances would try to execute the command!
             const command = isDefaultPluginId
@@ -52,221 +50,214 @@ function pluginContentDocs(context, options) {
                 .command(command)
                 .arguments('<version>')
                 .description(commandDescription)
-                .action((version) => {
-                cli_1.cliDocsVersionCommand(version, siteDir, pluginId, {
-                    path: options.path,
-                    sidebarPath: options.sidebarPath,
-                });
-            });
+                .action((version) => (0, cli_1.cliDocsVersionCommand)(version, options, context));
         },
-        async getTranslationFiles({ content }) {
-            return translations_1.getLoadedContentTranslationFiles(content);
-        },
-        getClientModules() {
-            const modules = [];
-            if (options.admonitions) {
-                modules.push(require.resolve('remark-admonitions/styles/infima.css'));
-            }
-            return modules;
+        getTranslationFiles({ content }) {
+            return (0, translations_1.getLoadedContentTranslationFiles)(content);
         },
         getPathsToWatch() {
             function getVersionPathsToWatch(version) {
                 const result = [
-                    ...lodash_1.flatten(options.include.map((pattern) => versions_1.getDocsDirPaths(version).map((docsDirPath) => `${docsDirPath}/${pattern}`))),
-                    `${version.contentPath}/**/${sidebarItemsGenerator_1.CategoryMetadataFilenamePattern}`,
+                    ...options.include.flatMap((pattern) => (0, utils_1.getContentPathList)(version).map((docsDirPath) => `${docsDirPath}/${pattern}`)),
+                    `${version.contentPath}/**/${generator_1.CategoryMetadataFilenamePattern}`,
                 ];
                 if (typeof version.sidebarFilePath === 'string') {
                     result.unshift(version.sidebarFilePath);
                 }
                 return result;
             }
-            return lodash_1.flatten(versionsMetadata.map(getVersionPathsToWatch));
+            return versionsMetadata.flatMap(getVersionPathsToWatch);
         },
         async loadContent() {
             async function loadVersionDocsBase(versionMetadata) {
-                const docFiles = await docs_1.readVersionDocs(versionMetadata, options);
+                const docFiles = await (0, docs_1.readVersionDocs)(versionMetadata, options);
                 if (docFiles.length === 0) {
-                    throw new Error(`Docs version ${versionMetadata.versionName} has no docs! At least one doc should exist at path=[${path_1.default.relative(siteDir, versionMetadata.contentPath)}]`);
+                    throw new Error(`Docs version "${versionMetadata.versionName}" has no docs! At least one doc should exist at "${path_1.default.relative(siteDir, versionMetadata.contentPath)}".`);
                 }
-                async function processVersionDoc(docFile) {
-                    return docs_1.processDocMetadata({
+                function processVersionDoc(docFile) {
+                    return (0, docs_1.processDocMetadata)({
                         docFile,
                         versionMetadata,
                         context,
                         options,
+                        env: process.env.NODE_ENV,
                     });
                 }
                 return Promise.all(docFiles.map(processVersionDoc));
             }
-            async function loadVersion(versionMetadata) {
-                const unprocessedSidebars = sidebars_1.loadSidebars(versionMetadata.sidebarFilePath);
+            async function doLoadVersion(versionMetadata) {
                 const docsBase = await loadVersionDocsBase(versionMetadata);
-                const docsBaseById = lodash_1.keyBy(docsBase, (doc) => doc.id);
-                const sidebars = await sidebars_1.processSidebars({
+                const [drafts, docs] = lodash_1.default.partition(docsBase, (doc) => doc.draft);
+                const sidebars = await (0, sidebars_1.loadSidebars)(versionMetadata.sidebarFilePath, {
                     sidebarItemsGenerator: options.sidebarItemsGenerator,
                     numberPrefixParser: options.numberPrefixParser,
-                    unprocessedSidebars,
-                    docs: docsBase,
+                    docs,
+                    drafts,
                     version: versionMetadata,
+                    sidebarOptions: {
+                        sidebarCollapsed: options.sidebarCollapsed,
+                        sidebarCollapsible: options.sidebarCollapsible,
+                    },
+                    categoryLabelSlugger: (0, utils_1.createSlugger)(),
                 });
-                const sidebarsUtils = sidebars_1.createSidebarsUtils(sidebars);
-                const validDocIds = Object.keys(docsBaseById);
-                sidebarsUtils.checkSidebarsDocIds(validDocIds);
-                // Add sidebar/next/previous to the docs
-                function addNavData(doc) {
-                    const { sidebarName, previousId, nextId, } = sidebarsUtils.getDocNavigation(doc.id);
-                    const toDocNavLink = (navDocId) => ({
-                        title: docsBaseById[navDocId].title,
-                        permalink: docsBaseById[navDocId].permalink,
-                    });
-                    return {
-                        ...doc,
-                        sidebar: sidebarName,
-                        previous: previousId ? toDocNavLink(previousId) : undefined,
-                        next: nextId ? toDocNavLink(nextId) : undefined,
-                    };
-                }
-                const docs = docsBase.map(addNavData);
-                // sort to ensure consistent output for tests
-                docs.sort((a, b) => a.id.localeCompare(b.id));
-                // TODO annoying side effect!
-                Object.values(docs).forEach((loadedDoc) => {
-                    const { source, permalink } = loadedDoc;
-                    sourceToPermalink[source] = permalink;
-                });
-                // TODO really useful? replace with global state logic?
-                const permalinkToSidebar = {};
-                Object.values(docs).forEach((doc) => {
-                    if (doc.sidebar) {
-                        permalinkToSidebar[doc.permalink] = doc.sidebar;
-                    }
-                });
-                // The "main doc" is the "version entry point"
-                // We browse this doc by clicking on a version:
-                // - the "home" doc (at '/docs/')
-                // - the first doc of the first sidebar
-                // - a random doc (if no docs are in any sidebar... edge case)
-                function getMainDoc() {
-                    const versionHomeDoc = docs.find((doc) => doc.unversionedId === options.homePageId || doc.slug === '/');
-                    const firstDocIdOfFirstSidebar = sidebarsUtils.getFirstDocIdOfFirstSidebar();
-                    if (versionHomeDoc) {
-                        return versionHomeDoc;
-                    }
-                    else if (firstDocIdOfFirstSidebar) {
-                        return docs.find((doc) => doc.id === firstDocIdOfFirstSidebar);
-                    }
-                    else {
-                        return docs[0];
-                    }
-                }
+                const sidebarsUtils = (0, utils_2.createSidebarsUtils)(sidebars);
                 return {
                     ...versionMetadata,
-                    mainDocId: getMainDoc().unversionedId,
+                    docs: (0, docs_1.addDocNavigation)(docs, sidebarsUtils, versionMetadata.sidebarFilePath),
+                    drafts,
                     sidebars,
-                    permalinkToSidebar,
-                    docs: docs.map(addNavData),
                 };
             }
+            async function loadVersion(versionMetadata) {
+                try {
+                    return await doLoadVersion(versionMetadata);
+                }
+                catch (err) {
+                    logger_1.default.error `Loading of version failed for version name=${versionMetadata.versionName}`;
+                    throw err;
+                }
+            }
             return {
                 loadedVersions: await Promise.all(versionsMetadata.map(loadVersion)),
             };
         },
         translateContent({ content, translationFiles }) {
-            return translations_1.translateLoadedContent(content, translationFiles);
+            return (0, translations_1.translateLoadedContent)(content, translationFiles);
         },
         async contentLoaded({ content, actions }) {
             const { loadedVersions } = content;
-            const { docLayoutComponent, docItemComponent } = options;
+            const { docLayoutComponent, docItemComponent, docCategoryGeneratedIndexComponent, breadcrumbs, } = options;
             const { addRoute, createData, setGlobalData } = actions;
-            const createDocRoutes = async (docs) => {
-                const routes = await Promise.all(docs.map(async (metadataItem) => {
-                    await createData(
-                    // Note that this created data path must be in sync with
-                    // metadataPath provided to mdx-loader.
-                    `${utils_1.docuHash(metadataItem.source)}.json`, JSON.stringify(metadataItem, null, 2));
-                    return {
-                        path: metadataItem.permalink,
-                        component: docItemComponent,
+            const versions = loadedVersions.map((version) => {
+                const sidebarsUtils = (0, utils_2.createSidebarsUtils)(version.sidebars);
+                return {
+                    ...version,
+                    sidebarsUtils,
+                    categoryGeneratedIndices: (0, categoryGeneratedIndex_1.getCategoryGeneratedIndexMetadataList)({
+                        docs: version.docs,
+                        sidebarsUtils,
+                    }),
+                };
+            });
+            async function createVersionTagsRoutes(version) {
+                const versionTags = (0, tags_1.getVersionTags)(version.docs);
+                // TODO tags should be a sub route of the version route
+                async function createTagsListPage() {
+                    const tagsProp = Object.values(versionTags).map((tagValue) => ({
+                        label: tagValue.label,
+                        permalink: tagValue.permalink,
+                        count: tagValue.docIds.length,
+                    }));
+                    // Only create /tags page if there are tags.
+                    if (tagsProp.length > 0) {
+                        const tagsPropPath = await createData(`${(0, utils_1.docuHash)(`tags-list-${version.versionName}-prop`)}.json`, JSON.stringify(tagsProp, null, 2));
+                        addRoute({
+                            path: version.tagsPath,
+                            exact: true,
+                            component: options.docTagsListComponent,
+                            modules: {
+                                tags: aliasedSource(tagsPropPath),
+                            },
+                        });
+                    }
+                }
+                // TODO tags should be a sub route of the version route
+                async function createTagDocListPage(tag) {
+                    const tagProps = (0, props_1.toTagDocListProp)({
+                        allTagsPath: version.tagsPath,
+                        tag,
+                        docs: version.docs,
+                    });
+                    const tagPropPath = await createData(`${(0, utils_1.docuHash)(`tag-${tag.permalink}`)}.json`, JSON.stringify(tagProps, null, 2));
+                    addRoute({
+                        path: tag.permalink,
+                        component: options.docTagDocListComponent,
                         exact: true,
                         modules: {
-                            content: metadataItem.source,
+                            tag: aliasedSource(tagPropPath),
                         },
-                    };
-                }));
-                return routes.sort((a, b) => a.path.localeCompare(b.path));
-            };
-            async function handleVersion(loadedVersion) {
-                const versionMetadataPropPath = await createData(`${utils_1.docuHash(`version-${loadedVersion.versionName}-metadata-prop`)}.json`, JSON.stringify(props_1.toVersionMetadataProp(pluginId, loadedVersion), null, 2));
-                addRoute({
-                    path: loadedVersion.versionPath,
-                    // allow matching /docs/* as well
-                    exact: false,
-                    // main docs component (DocPage)
-                    component: docLayoutComponent,
-                    // sub-routes for each doc
-                    routes: await createDocRoutes(loadedVersion.docs),
-                    modules: {
-                        versionMetadata: aliasedSource(versionMetadataPropPath),
-                    },
-                    priority: loadedVersion.routePriority,
-                });
+                    });
+                }
+                await createTagsListPage();
+                await Promise.all(Object.values(versionTags).map(createTagDocListPage));
             }
-            await Promise.all(loadedVersions.map(handleVersion));
+            await Promise.all(versions.map((version) => (0, routes_1.createVersionRoutes)({
+                version,
+                docItemComponent,
+                docLayoutComponent,
+                docCategoryGeneratedIndexComponent,
+                pluginId,
+                aliasedSource,
+                actions,
+            })));
+            // TODO tags should be a sub route of the version route
+            await Promise.all(versions.map(createVersionTagsRoutes));
             setGlobalData({
-                path: utils_1.normalizeUrl([baseUrl, options.routeBasePath]),
-                versions: loadedVersions.map(globalData_1.toGlobalDataVersion),
+                path: (0, utils_1.normalizeUrl)([baseUrl, options.routeBasePath]),
+                versions: versions.map(globalData_1.toGlobalDataVersion),
+                breadcrumbs,
             });
         },
-        configureWebpack(_config, isServer, utils) {
+        configureWebpack(_config, isServer, utils, content) {
             const { getJSLoader } = utils;
             const { rehypePlugins, remarkPlugins, beforeDefaultRehypePlugins, beforeDefaultRemarkPlugins, } = options;
+            function getSourceToPermalink() {
+                const allDocs = content.loadedVersions.flatMap((v) => v.docs);
+                return Object.fromEntries(allDocs.map(({ source, permalink }) => [source, permalink]));
+            }
             const docsMarkdownOptions = {
                 siteDir,
-                sourceToPermalink,
+                sourceToPermalink: getSourceToPermalink(),
                 versionsMetadata,
                 onBrokenMarkdownLink: (brokenMarkdownLink) => {
-                    if (siteConfig.onBrokenMarkdownLinks === 'ignore') {
-                        return;
-                    }
-                    utils_1.reportMessage(`Docs markdown link couldn't be resolved: (${brokenMarkdownLink.link}) in ${brokenMarkdownLink.filePath} for version ${brokenMarkdownLink.contentPaths.versionName}`, siteConfig.onBrokenMarkdownLinks);
+                    logger_1.default.report(siteConfig.onBrokenMarkdownLinks) `Docs markdown link couldn't be resolved: (url=${brokenMarkdownLink.link}) in path=${brokenMarkdownLink.filePath} for version number=${brokenMarkdownLink.contentPaths.versionName}`;
                 },
             };
             function createMDXLoaderRule() {
+                const contentDirs = versionsMetadata.flatMap(utils_1.getContentPathList);
                 return {
-                    test: /(\.mdx?)$/,
-                    include: lodash_1.flatten(versionsMetadata.map(versions_1.getDocsDirPaths))
+                    test: /\.mdx?$/i,
+                    include: contentDirs
                         // Trailing slash is important, see https://github.com/facebook/docusaurus/pull/3970
                         .map(utils_1.addTrailingPathSeparator),
-                    use: lodash_1.compact([
+                    use: [
                         getJSLoader({ isServer }),
                         {
                             loader: require.resolve('@docusaurus/mdx-loader'),
                             options: {
+                                admonitions: options.admonitions,
                                 remarkPlugins,
                                 rehypePlugins,
                                 beforeDefaultRehypePlugins,
                                 beforeDefaultRemarkPlugins,
-                                staticDir: path_1.default.join(siteDir, constants_1.STATIC_DIR_NAME),
+                                staticDirs: siteConfig.staticDirectories.map((dir) => path_1.default.resolve(siteDir, dir)),
+                                siteDir,
+                                isMDXPartial: (0, utils_1.createAbsoluteFilePathMatcher)(options.exclude, contentDirs),
                                 metadataPath: (mdxPath) => {
                                     // Note that metadataPath must be the same/in-sync as
                                     // the path from createData for each MDX.
-                                    const aliasedPath = utils_1.aliasedSitePath(mdxPath, siteDir);
-                                    return path_1.default.join(dataDir, `${utils_1.docuHash(aliasedPath)}.json`);
+                                    const aliasedPath = (0, utils_1.aliasedSitePath)(mdxPath, siteDir);
+                                    return path_1.default.join(dataDir, `${(0, utils_1.docuHash)(aliasedPath)}.json`);
                                 },
+                                // Assets allow to convert some relative images paths to
+                                // require(...) calls
+                                createAssets: ({ frontMatter, }) => ({
+                                    image: frontMatter.image,
+                                }),
                             },
                         },
                         {
                             loader: path_1.default.resolve(__dirname, './markdown/index.js'),
                             options: docsMarkdownOptions,
                         },
-                    ]),
+                    ].filter(Boolean),
                 };
             }
             return {
                 ignoreWarnings: [
                     // Suppress warnings about non-existing of versions file.
                     (e) => e.message.includes("Can't resolve") &&
-                        e.message.includes(constants_2.VERSIONS_JSON_FILE),
+                        e.message.includes(constants_1.VERSIONS_JSON_FILE),
                 ],
                 resolve: {
                     alias: {

package/lib/lastUpdate.d.ts

@@ -4,9 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-declare type FileLastUpdateData = {
-    timestamp?: number;
-    author?: string;
-};
-export declare function getFileLastUpdate(filePath?: string): Promise<FileLastUpdateData | null>;
-export {};
+export declare function getFileLastUpdate(filePath: string): Promise<{
+    timestamp: number;
+    author: string;
+} | null>;

package/lib/lastUpdate.js

@@ -8,44 +8,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFileLastUpdate = void 0;
 const tslib_1 = require("tslib");
-const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
-const execa_1 = tslib_1.__importDefault(require("execa"));
-const GIT_COMMIT_TIMESTAMP_AUTHOR_REGEX = /^(\d+), (.+)$/;
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const utils_1 = require("@docusaurus/utils");
 let showedGitRequirementError = false;
+let showedFileNotTrackedError = false;
 async function getFileLastUpdate(filePath) {
     if (!filePath) {
         return null;
     }
-    function getTimestampAndAuthor(str) {
-        if (!str) {
-            return null;
-        }
-        const temp = str.match(GIT_COMMIT_TIMESTAMP_AUTHOR_REGEX);
-        return !temp || temp.length < 3
-            ? null
-            : { timestamp: +temp[1], author: temp[2] };
-    }
     // Wrap in try/catch in case the shell commands fail
     // (e.g. project doesn't use Git, etc).
     try {
-        if (!shelljs_1.default.which('git')) {
+        const result = (0, utils_1.getFileCommitDate)(filePath, {
+            age: 'newest',
+            includeAuthor: true,
+        });
+        return { timestamp: result.timestamp, author: result.author };
+    }
+    catch (err) {
+        if (err instanceof utils_1.GitNotFoundError) {
             if (!showedGitRequirementError) {
+                logger_1.default.warn('Sorry, the docs plugin last update options require Git.');
                 showedGitRequirementError = true;
-                console.warn('Sorry, the docs plugin last update options require Git.');
             }
-            return null;
         }
-        const { stdout } = await execa_1.default('git', [
-            'log',
-            '-1',
-            '--format=%ct, %an',
-            filePath,
-        ]);
-        return getTimestampAndAuthor(stdout);
-    }
-    catch (error) {
-        console.error(error);
+        else if (err instanceof utils_1.FileNotTrackedError) {
+            if (!showedFileNotTrackedError) {
+                logger_1.default.warn('Cannot infer the update date for some files, as they are not tracked by git.');
+                showedFileNotTrackedError = true;
+            }
+        }
+        else {
+            logger_1.default.warn(err);
+        }
+        return null;
     }
-    return null;
 }
 exports.getFileLastUpdate = getFileLastUpdate;

package/lib/markdown/index.d.ts

@@ -4,9 +4,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-/// <reference types="node" />
-interface Loader extends Function {
-    (this: any, source: string): string | Buffer | void | undefined;
-}
-declare const markdownLoader: Loader;
-export default markdownLoader;
+import type { DocsMarkdownOption } from '../types';
+import type { LoaderContext } from 'webpack';
+export default function markdownLoader(this: LoaderContext<DocsMarkdownOption>, source: string): void;

package/lib/markdown/index.js

@@ -7,10 +7,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const linkify_1 = require("./linkify");
-const markdownLoader = function (source) {
+function markdownLoader(source) {
     const fileString = source;
     const callback = this.async();
     const options = this.getOptions();
-    return (callback && callback(null, linkify_1.linkify(fileString, this.resourcePath, options)));
-};
+    return callback(null, (0, linkify_1.linkify)(fileString, this.resourcePath, options));
+}
 exports.default = markdownLoader;

package/lib/markdown/linkify.d.ts

@@ -4,5 +4,5 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { DocsMarkdownOption } from '../types';
+import type { DocsMarkdownOption } from '../types';
 export declare function linkify(fileString: string, filePath: string, options: DocsMarkdownOption): string;

package/lib/markdown/linkify.js

@@ -7,18 +7,21 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.linkify = void 0;
-const versions_1 = require("../versions");
 const utils_1 = require("@docusaurus/utils");
 function getVersion(filePath, options) {
-    const versionFound = options.versionsMetadata.find((version) => versions_1.getDocsDirPaths(version).some((docsDirPath) => filePath.startsWith(docsDirPath)));
+    const versionFound = options.versionsMetadata.find((version) => (0, utils_1.getContentPathList)(version).some((docsDirPath) => filePath.startsWith(docsDirPath)));
+    // At this point, this should never happen, because the MDX loaders' paths are
+    // literally using the version content paths; but if we allow sourcing content
+    // from outside the docs directory (through the `include` option, for example;
+    // is there a compelling use-case?), this would actually be testable
     if (!versionFound) {
-        throw new Error(`Unexpected, markdown file does not belong to any docs version! file=${filePath}`);
+        throw new Error(`Unexpected error: Markdown file at "${filePath}" does not belong to any docs version!`);
     }
     return versionFound;
 }
 function linkify(fileString, filePath, options) {
     const { siteDir, sourceToPermalink, onBrokenMarkdownLink } = options;
-    const { newContent, brokenMarkdownLinks } = utils_1.replaceMarkdownLinks({
+    const { newContent, brokenMarkdownLinks } = (0, utils_1.replaceMarkdownLinks)({
         siteDir,
         fileString,
         filePath,

package/lib/numberPrefix.d.ts

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { NumberPrefixParser } from './types';
+import type { NumberPrefixParser } from '@docusaurus/plugin-content-docs';
 export declare const DefaultNumberPrefixParser: NumberPrefixParser;
 export declare const DisabledNumberPrefixParser: NumberPrefixParser;
 export declare function stripNumberPrefix(str: string, parser: NumberPrefixParser): string;

package/lib/numberPrefix.js

@@ -8,33 +8,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripPathNumberPrefixes = exports.stripNumberPrefix = exports.DisabledNumberPrefixParser = exports.DefaultNumberPrefixParser = void 0;
 // Best-effort to avoid parsing some patterns as number prefix
-const IgnoredPrefixPatterns = (function () {
-    // ignore common date-like patterns: https://github.com/facebook/docusaurus/issues/4640
-    const DateLikePrefixRegex = /^((\d{2}|\d{4})[-_.]\d{2}([-_.](\d{2}|\d{4}))?)(.*)$/;
-    // ignore common versioning patterns: https://github.com/facebook/docusaurus/issues/4653
-    // note: we could try to parse float numbers in filenames but that is probably not worth it
-    // as a version such as "8.0" can be interpreted as both a version and a float
-    // User can configure his own NumberPrefixParser if he wants 8.0 to be interpreted as a float
-    const VersionLikePrefixRegex = /^(\d+[-_.]\d+)(.*)$/;
-    return new RegExp(`${DateLikePrefixRegex.source}|${VersionLikePrefixRegex.source}`);
-})();
-const NumberPrefixRegex = /^(?<numberPrefix>\d+)(?<separator>\s*[-_.]+\s*)(?<suffix>.*)$/;
+// ignore common date-like patterns: https://github.com/facebook/docusaurus/issues/4640
+// ignore common versioning patterns: https://github.com/facebook/docusaurus/issues/4653
+// Both of them would look like 7.0-foo or 2021-11-foo
+// note: we could try to parse float numbers in filenames, but that is probably
+// not worth it, as a version such as "8.0" can be interpreted as either a
+// version or a float. User can configure her own NumberPrefixParser if she
+// wants 8.0 to be interpreted as a float
+const ignoredPrefixPattern = /^\d+[-_.]\d+/;
+const numberPrefixPattern = /^(?<numberPrefix>\d+)\s*[-_.]+\s*(?<suffix>[^-_.\s].*)$/;
 // 0-myDoc => {filename: myDoc, numberPrefix: 0}
 // 003 - myDoc => {filename: myDoc, numberPrefix: 3}
 const DefaultNumberPrefixParser = (filename) => {
-    var _a, _b, _c;
-    if (IgnoredPrefixPatterns.exec(filename)) {
+    if (ignoredPrefixPattern.test(filename)) {
+        return { filename, numberPrefix: undefined };
+    }
+    const match = numberPrefixPattern.exec(filename);
+    if (!match) {
         return { filename, numberPrefix: undefined };
     }
-    const match = NumberPrefixRegex.exec(filename);
-    const cleanFileName = (_b = (_a = match === null || match === void 0 ? void 0 : match.groups) === null || _a === void 0 ? void 0 : _a.suffix) !== null && _b !== void 0 ? _b : filename;
-    const numberPrefixString = (_c = match === null || match === void 0 ? void 0 : match.groups) === null || _c === void 0 ? void 0 : _c.numberPrefix;
-    const numberPrefix = numberPrefixString
-        ? parseInt(numberPrefixString, 10)
-        : undefined;
     return {
-        filename: cleanFileName,
-        numberPrefix,
+        filename: match.groups.suffix,
+        numberPrefix: parseInt(match.groups.numberPrefix, 10),
     };
 };
 exports.DefaultNumberPrefixParser = DefaultNumberPrefixParser;

package/lib/options.d.ts

@@ -4,9 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { PluginOptions } from './types';
-import { Joi } from '@docusaurus/utils-validation';
-import { OptionValidationContext, ValidationResult } from '@docusaurus/types';
+import type { OptionValidationContext } from '@docusaurus/types';
+import type { PluginOptions, Options } from '@docusaurus/plugin-content-docs';
 export declare const DEFAULT_OPTIONS: Omit<PluginOptions, 'id' | 'sidebarPath'>;
-export declare const OptionsSchema: Joi.ObjectSchema<any>;
-export declare function validateOptions({ validate, options, }: OptionValidationContext<PluginOptions>): ValidationResult<PluginOptions>;
+export declare function validateOptions({ validate, options: userOptions, }: OptionValidationContext<Options, PluginOptions>): PluginOptions;