@docusaurus/plugin-content-pages 0.0.0-5899 → 0.0.0-5901

package/lib/content.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+import type { LoadContext } from '@docusaurus/types';
+import type { PagesContentPaths } from './types';
+import type { PluginOptions, LoadedContent } from '@docusaurus/plugin-content-pages';
+export declare function createPagesContentPaths({ context, options, }: {
+    context: LoadContext;
+    options: PluginOptions;
+}): PagesContentPaths;
+export declare function getContentPathList(contentPaths: PagesContentPaths): string[];
+type LoadContentParams = {
+    context: LoadContext;
+    options: PluginOptions;
+    contentPaths: PagesContentPaths;
+};
+export declare function loadPagesContent(params: LoadContentParams): Promise<LoadedContent>;
+export {};

package/lib/content.js

@@ -0,0 +1,120 @@
+"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 });
+exports.loadPagesContent = exports.getContentPathList = exports.createPagesContentPaths = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const utils_1 = require("@docusaurus/utils");
+const frontMatter_1 = require("./frontMatter");
+function createPagesContentPaths({ context, options, }) {
+    const { siteDir, localizationDir } = context;
+    return {
+        contentPath: path_1.default.resolve(siteDir, options.path),
+        contentPathLocalized: (0, utils_1.getPluginI18nPath)({
+            localizationDir,
+            pluginName: 'docusaurus-plugin-content-pages',
+            pluginId: options.id,
+        }),
+    };
+}
+exports.createPagesContentPaths = createPagesContentPaths;
+function getContentPathList(contentPaths) {
+    return [contentPaths.contentPathLocalized, contentPaths.contentPath];
+}
+exports.getContentPathList = getContentPathList;
+const isMarkdownSource = (source) => source.endsWith('.md') || source.endsWith('.mdx');
+async function loadPagesContent(params) {
+    const { options } = params;
+    const pagesFiles = await (0, utils_1.Globby)(params.options.include, {
+        cwd: params.contentPaths.contentPath,
+        ignore: options.exclude,
+    });
+    async function doProcessPageSourceFile(relativeSource) {
+        try {
+            return await processPageSourceFile(relativeSource, params);
+        }
+        catch (err) {
+            throw new Error(`Processing of page source file path=${relativeSource} failed.`, { cause: err });
+        }
+    }
+    return (await Promise.all(pagesFiles.map(doProcessPageSourceFile))).filter((res) => {
+        return res !== undefined;
+    });
+}
+exports.loadPagesContent = loadPagesContent;
+async function processPageSourceFile(relativeSource, params) {
+    const { context, options, contentPaths } = params;
+    const { siteConfig, baseUrl, siteDir, i18n } = context;
+    const { editUrl } = options;
+    // Lookup in localized folder in priority
+    const contentPath = await (0, utils_1.getFolderContainingFile)(getContentPathList(contentPaths), relativeSource);
+    const source = path_1.default.join(contentPath, relativeSource);
+    const aliasedSourcePath = (0, utils_1.aliasedSitePath)(source, siteDir);
+    const permalink = (0, utils_1.normalizeUrl)([
+        baseUrl,
+        options.routeBasePath,
+        (0, utils_1.encodePath)((0, utils_1.fileToPath)(relativeSource)),
+    ]);
+    if (!isMarkdownSource(relativeSource)) {
+        return {
+            type: 'jsx',
+            permalink,
+            source: aliasedSourcePath,
+        };
+    }
+    const content = await fs_extra_1.default.readFile(source, 'utf-8');
+    const { frontMatter: unsafeFrontMatter, contentTitle, excerpt, } = await (0, utils_1.parseMarkdownFile)({
+        filePath: source,
+        fileContent: content,
+        parseFrontMatter: siteConfig.markdown.parseFrontMatter,
+    });
+    const frontMatter = (0, frontMatter_1.validatePageFrontMatter)(unsafeFrontMatter);
+    const pagesDirPath = await (0, utils_1.getFolderContainingFile)(getContentPathList(contentPaths), relativeSource);
+    const pagesSourceAbsolute = path_1.default.join(pagesDirPath, relativeSource);
+    function getPagesEditUrl() {
+        const pagesPathRelative = path_1.default.relative(pagesDirPath, path_1.default.resolve(pagesSourceAbsolute));
+        if (typeof editUrl === 'function') {
+            return editUrl({
+                pagesDirPath: (0, utils_1.posixPath)(path_1.default.relative(siteDir, pagesDirPath)),
+                pagesPath: (0, utils_1.posixPath)(pagesPathRelative),
+                permalink,
+                locale: i18n.currentLocale,
+            });
+        }
+        else if (typeof editUrl === 'string') {
+            const isLocalized = pagesDirPath === contentPaths.contentPathLocalized;
+            const fileContentPath = isLocalized && options.editLocalizedFiles
+                ? contentPaths.contentPathLocalized
+                : contentPaths.contentPath;
+            const contentPathEditUrl = (0, utils_1.normalizeUrl)([
+                editUrl,
+                (0, utils_1.posixPath)(path_1.default.relative(siteDir, fileContentPath)),
+            ]);
+            return (0, utils_1.getEditUrl)(pagesPathRelative, contentPathEditUrl);
+        }
+        return undefined;
+    }
+    const lastUpdatedData = await (0, utils_1.readLastUpdateData)(source, options, frontMatter.last_update);
+    if ((0, utils_1.isDraft)({ frontMatter })) {
+        return undefined;
+    }
+    const unlisted = (0, utils_1.isUnlisted)({ frontMatter });
+    return {
+        type: 'mdx',
+        permalink,
+        source: aliasedSourcePath,
+        title: frontMatter.title ?? contentTitle,
+        description: frontMatter.description ?? excerpt,
+        frontMatter,
+        lastUpdatedBy: lastUpdatedData.lastUpdatedBy,
+        lastUpdatedAt: lastUpdatedData.lastUpdatedAt,
+        editUrl: getPagesEditUrl(),
+        unlisted,
+    };
+}

package/lib/index.d.ts

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 import type { LoadContext, Plugin } from '@docusaurus/types';
-import type { PagesContentPaths } from './types';
 import type { PluginOptions, LoadedContent } from '@docusaurus/plugin-content-pages';
-export declare function getContentPathList(contentPaths: PagesContentPaths): string[];
 export default function pluginContentPages(context: LoadContext, options: PluginOptions): Plugin<LoadedContent | null>;
 export { validateOptions } from './options';

package/lib/index.js

@@ -6,174 +6,40 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateOptions = exports.getContentPathList = void 0;
+exports.validateOptions = void 0;
 const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const utils_1 = require("@docusaurus/utils");
-const frontMatter_1 = require("./frontMatter");
-function getContentPathList(contentPaths) {
-    return [contentPaths.contentPathLocalized, contentPaths.contentPath];
-}
-exports.getContentPathList = getContentPathList;
-const isMarkdownSource = (source) => source.endsWith('.md') || source.endsWith('.mdx');
+const routes_1 = require("./routes");
+const content_1 = require("./content");
 function pluginContentPages(context, options) {
-    const { siteConfig, siteDir, generatedFilesDir, localizationDir, i18n } = context;
-    const contentPaths = {
-        contentPath: path_1.default.resolve(siteDir, options.path),
-        contentPathLocalized: (0, utils_1.getPluginI18nPath)({
-            localizationDir,
-            pluginName: 'docusaurus-plugin-content-pages',
-            pluginId: options.id,
-        }),
-    };
+    const { siteConfig, siteDir, generatedFilesDir } = context;
+    const contentPaths = (0, content_1.createPagesContentPaths)({ context, options });
     const pluginDataDirRoot = path_1.default.join(generatedFilesDir, 'docusaurus-plugin-content-pages');
     const dataDir = path_1.default.join(pluginDataDirRoot, options.id ?? utils_1.DEFAULT_PLUGIN_ID);
     return {
         name: 'docusaurus-plugin-content-pages',
         getPathsToWatch() {
             const { include } = options;
-            return getContentPathList(contentPaths).flatMap((contentPath) => include.map((pattern) => `${contentPath}/${pattern}`));
+            return (0, content_1.getContentPathList)(contentPaths).flatMap((contentPath) => include.map((pattern) => `${contentPath}/${pattern}`));
         },
         async loadContent() {
-            const { include, editUrl } = options;
             if (!(await fs_extra_1.default.pathExists(contentPaths.contentPath))) {
                 return null;
             }
-            const { baseUrl } = siteConfig;
-            const pagesFiles = await (0, utils_1.Globby)(include, {
-                cwd: contentPaths.contentPath,
-                ignore: options.exclude,
-            });
-            async function processPageSourceFile(relativeSource) {
-                // Lookup in localized folder in priority
-                const contentPath = await (0, utils_1.getFolderContainingFile)(getContentPathList(contentPaths), relativeSource);
-                const source = path_1.default.join(contentPath, relativeSource);
-                const aliasedSourcePath = (0, utils_1.aliasedSitePath)(source, siteDir);
-                const permalink = (0, utils_1.normalizeUrl)([
-                    baseUrl,
-                    options.routeBasePath,
-                    (0, utils_1.encodePath)((0, utils_1.fileToPath)(relativeSource)),
-                ]);
-                if (!isMarkdownSource(relativeSource)) {
-                    return {
-                        type: 'jsx',
-                        permalink,
-                        source: aliasedSourcePath,
-                    };
-                }
-                const content = await fs_extra_1.default.readFile(source, 'utf-8');
-                const { frontMatter: unsafeFrontMatter, contentTitle, excerpt, } = await (0, utils_1.parseMarkdownFile)({
-                    filePath: source,
-                    fileContent: content,
-                    parseFrontMatter: siteConfig.markdown.parseFrontMatter,
-                });
-                const frontMatter = (0, frontMatter_1.validatePageFrontMatter)(unsafeFrontMatter);
-                const pagesDirPath = await (0, utils_1.getFolderContainingFile)(getContentPathList(contentPaths), relativeSource);
-                const pagesSourceAbsolute = path_1.default.join(pagesDirPath, relativeSource);
-                function getPagesEditUrl() {
-                    const pagesPathRelative = path_1.default.relative(pagesDirPath, path_1.default.resolve(pagesSourceAbsolute));
-                    if (typeof editUrl === 'function') {
-                        return editUrl({
-                            pagesDirPath: (0, utils_1.posixPath)(path_1.default.relative(siteDir, pagesDirPath)),
-                            pagesPath: (0, utils_1.posixPath)(pagesPathRelative),
-                            permalink,
-                            locale: i18n.currentLocale,
-                        });
-                    }
-                    else if (typeof editUrl === 'string') {
-                        const isLocalized = pagesDirPath === contentPaths.contentPathLocalized;
-                        const fileContentPath = isLocalized && options.editLocalizedFiles
-                            ? contentPaths.contentPathLocalized
-                            : contentPaths.contentPath;
-                        const contentPathEditUrl = (0, utils_1.normalizeUrl)([
-                            editUrl,
-                            (0, utils_1.posixPath)(path_1.default.relative(siteDir, fileContentPath)),
-                        ]);
-                        return (0, utils_1.getEditUrl)(pagesPathRelative, contentPathEditUrl);
-                    }
-                    return undefined;
-                }
-                const lastUpdatedData = await (0, utils_1.readLastUpdateData)(source, options, frontMatter.last_update);
-                if ((0, utils_1.isDraft)({ frontMatter })) {
-                    return undefined;
-                }
-                const unlisted = (0, utils_1.isUnlisted)({ frontMatter });
-                return {
-                    type: 'mdx',
-                    permalink,
-                    source: aliasedSourcePath,
-                    title: frontMatter.title ?? contentTitle,
-                    description: frontMatter.description ?? excerpt,
-                    frontMatter,
-                    lastUpdatedBy: lastUpdatedData.lastUpdatedBy,
-                    lastUpdatedAt: lastUpdatedData.lastUpdatedAt,
-                    editUrl: getPagesEditUrl(),
-                    unlisted,
-                };
-            }
-            async function doProcessPageSourceFile(relativeSource) {
-                try {
-                    return await processPageSourceFile(relativeSource);
-                }
-                catch (err) {
-                    throw new Error(`Processing of page source file path=${relativeSource} failed.`, { cause: err });
-                }
-            }
-            return (await Promise.all(pagesFiles.map(doProcessPageSourceFile))).filter(Boolean);
+            return (0, content_1.loadPagesContent)({ context, options, contentPaths });
         },
         async contentLoaded({ content, actions }) {
             if (!content) {
                 return;
             }
-            const { addRoute, createData } = actions;
-            function createPageRouteMetadata(metadata) {
-                const lastUpdatedAt = metadata.type === 'mdx' ? metadata.lastUpdatedAt : undefined;
-                return {
-                    sourceFilePath: (0, utils_1.aliasedSitePathToRelativePath)(metadata.source),
-                    lastUpdatedAt,
-                };
-            }
-            await Promise.all(content.map(async (metadata) => {
-                const { permalink, source } = metadata;
-                const routeMetadata = createPageRouteMetadata(metadata);
-                if (metadata.type === 'mdx') {
-                    await createData(
-                    // Note that this created data path must be in sync with
-                    // metadataPath provided to mdx-loader.
-                    `${(0, utils_1.docuHash)(metadata.source)}.json`, JSON.stringify(metadata, null, 2));
-                    addRoute({
-                        path: permalink,
-                        component: options.mdxPageComponent,
-                        exact: true,
-                        metadata: routeMetadata,
-                        modules: {
-                            content: source,
-                        },
-                    });
-                }
-                else {
-                    addRoute({
-                        path: permalink,
-                        component: source,
-                        exact: true,
-                        metadata: routeMetadata,
-                        modules: {
-                            config: `@generated/docusaurus.config`,
-                        },
-                    });
-                }
-            }));
+            await (0, routes_1.createAllRoutes)({ content, options, actions });
         },
         configureWebpack() {
             const { admonitions, rehypePlugins, remarkPlugins, beforeDefaultRehypePlugins, beforeDefaultRemarkPlugins, } = options;
-            const contentDirs = getContentPathList(contentPaths);
+            const contentDirs = (0, content_1.getContentPathList)(contentPaths);
             return {
-                resolve: {
-                    alias: {
-                        '~pages': pluginDataDirRoot,
-                    },
-                },
                 module: {
                     rules: [
                         {

package/lib/routes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+import type { PluginContentLoadedActions, RouteConfig } from '@docusaurus/types';
+import type { PluginOptions, LoadedContent } from '@docusaurus/plugin-content-pages';
+type CreateAllRoutesParam = {
+    content: LoadedContent;
+    options: PluginOptions;
+    actions: PluginContentLoadedActions;
+};
+export declare function createAllRoutes(param: CreateAllRoutesParam): Promise<void>;
+export declare function buildAllRoutes({ content, actions, options, }: CreateAllRoutesParam): Promise<RouteConfig[]>;
+export {};

package/lib/routes.js

@@ -0,0 +1,58 @@
+"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 });
+exports.buildAllRoutes = exports.createAllRoutes = void 0;
+const utils_1 = require("@docusaurus/utils");
+function createPageRouteMetadata(metadata) {
+    const lastUpdatedAt = metadata.type === 'mdx' ? metadata.lastUpdatedAt : undefined;
+    return {
+        sourceFilePath: (0, utils_1.aliasedSitePathToRelativePath)(metadata.source),
+        lastUpdatedAt,
+    };
+}
+async function createAllRoutes(param) {
+    const routes = await buildAllRoutes(param);
+    routes.forEach(param.actions.addRoute);
+}
+exports.createAllRoutes = createAllRoutes;
+async function buildAllRoutes({ content, actions, options, }) {
+    const { createData } = actions;
+    async function buildMDXPageRoute(metadata) {
+        await createData(
+        // Note that this created data path must be in sync with
+        // metadataPath provided to mdx-loader.
+        `${(0, utils_1.docuHash)(metadata.source)}.json`, metadata);
+        return {
+            path: metadata.permalink,
+            component: options.mdxPageComponent,
+            exact: true,
+            metadata: createPageRouteMetadata(metadata),
+            modules: {
+                content: metadata.source,
+            },
+        };
+    }
+    async function buildJSXRoute(metadata) {
+        return {
+            path: metadata.permalink,
+            component: metadata.source,
+            exact: true,
+            metadata: createPageRouteMetadata(metadata),
+            modules: {
+                config: `@generated/docusaurus.config`,
+            },
+        };
+    }
+    async function buildPageRoute(metadata) {
+        return metadata.type === 'mdx'
+            ? buildMDXPageRoute(metadata)
+            : buildJSXRoute(metadata);
+    }
+    return Promise.all(content.map(buildPageRoute));
+}
+exports.buildAllRoutes = buildAllRoutes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docusaurus/plugin-content-pages",
-  "version": "0.0.0-5899",
+  "version": "0.0.0-5901",
   "description": "Pages plugin for Docusaurus.",
   "main": "lib/index.js",
   "types": "src/plugin-content-pages.d.ts",
@@ -18,11 +18,11 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@docusaurus/core": "0.0.0-5899",
-    "@docusaurus/mdx-loader": "0.0.0-5899",
-    "@docusaurus/types": "0.0.0-5899",
-    "@docusaurus/utils": "0.0.0-5899",
-    "@docusaurus/utils-validation": "0.0.0-5899",
+    "@docusaurus/core": "0.0.0-5901",
+    "@docusaurus/mdx-loader": "0.0.0-5901",
+    "@docusaurus/types": "0.0.0-5901",
+    "@docusaurus/utils": "0.0.0-5901",
+    "@docusaurus/utils-validation": "0.0.0-5901",
     "fs-extra": "^11.1.1",
     "tslib": "^2.6.0",
     "webpack": "^5.88.1"
@@ -34,5 +34,5 @@
   "engines": {
     "node": ">=18.0"
   },
-  "gitHead": "e8e1f914293e8dade7f4e0907d9a00bd1df80470"
+  "gitHead": "a66ccfd1b9e2716166f237995de747747885eb1d"
 }

package/src/content.ts

@@ -0,0 +1,194 @@
+/**
+ * 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.
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import {
+  encodePath,
+  fileToPath,
+  aliasedSitePath,
+  getFolderContainingFile,
+  Globby,
+  normalizeUrl,
+  parseMarkdownFile,
+  isUnlisted,
+  isDraft,
+  readLastUpdateData,
+  getEditUrl,
+  posixPath,
+  getPluginI18nPath,
+} from '@docusaurus/utils';
+import {validatePageFrontMatter} from './frontMatter';
+import type {LoadContext} from '@docusaurus/types';
+import type {PagesContentPaths} from './types';
+import type {
+  PluginOptions,
+  Metadata,
+  LoadedContent,
+} from '@docusaurus/plugin-content-pages';
+
+export function createPagesContentPaths({
+  context,
+  options,
+}: {
+  context: LoadContext;
+  options: PluginOptions;
+}): PagesContentPaths {
+  const {siteDir, localizationDir} = context;
+  return {
+    contentPath: path.resolve(siteDir, options.path),
+    contentPathLocalized: getPluginI18nPath({
+      localizationDir,
+      pluginName: 'docusaurus-plugin-content-pages',
+      pluginId: options.id,
+    }),
+  };
+}
+
+export function getContentPathList(contentPaths: PagesContentPaths): string[] {
+  return [contentPaths.contentPathLocalized, contentPaths.contentPath];
+}
+
+const isMarkdownSource = (source: string) =>
+  source.endsWith('.md') || source.endsWith('.mdx');
+
+type LoadContentParams = {
+  context: LoadContext;
+  options: PluginOptions;
+  contentPaths: PagesContentPaths;
+};
+
+export async function loadPagesContent(
+  params: LoadContentParams,
+): Promise<LoadedContent> {
+  const {options} = params;
+
+  const pagesFiles = await Globby(params.options.include, {
+    cwd: params.contentPaths.contentPath,
+    ignore: options.exclude,
+  });
+
+  async function doProcessPageSourceFile(relativeSource: string) {
+    try {
+      return await processPageSourceFile(relativeSource, params);
+    } catch (err) {
+      throw new Error(
+        `Processing of page source file path=${relativeSource} failed.`,
+        {cause: err as Error},
+      );
+    }
+  }
+
+  return (await Promise.all(pagesFiles.map(doProcessPageSourceFile))).filter(
+    (res): res is Metadata => {
+      return res !== undefined;
+    },
+  );
+}
+
+async function processPageSourceFile(
+  relativeSource: string,
+  params: LoadContentParams,
+): Promise<Metadata | undefined> {
+  const {context, options, contentPaths} = params;
+  const {siteConfig, baseUrl, siteDir, i18n} = context;
+  const {editUrl} = options;
+
+  // Lookup in localized folder in priority
+  const contentPath = await getFolderContainingFile(
+    getContentPathList(contentPaths),
+    relativeSource,
+  );
+
+  const source = path.join(contentPath, relativeSource);
+  const aliasedSourcePath = aliasedSitePath(source, siteDir);
+  const permalink = normalizeUrl([
+    baseUrl,
+    options.routeBasePath,
+    encodePath(fileToPath(relativeSource)),
+  ]);
+  if (!isMarkdownSource(relativeSource)) {
+    return {
+      type: 'jsx',
+      permalink,
+      source: aliasedSourcePath,
+    };
+  }
+
+  const content = await fs.readFile(source, 'utf-8');
+  const {
+    frontMatter: unsafeFrontMatter,
+    contentTitle,
+    excerpt,
+  } = await parseMarkdownFile({
+    filePath: source,
+    fileContent: content,
+    parseFrontMatter: siteConfig.markdown.parseFrontMatter,
+  });
+  const frontMatter = validatePageFrontMatter(unsafeFrontMatter);
+
+  const pagesDirPath = await getFolderContainingFile(
+    getContentPathList(contentPaths),
+    relativeSource,
+  );
+
+  const pagesSourceAbsolute = path.join(pagesDirPath, relativeSource);
+
+  function getPagesEditUrl() {
+    const pagesPathRelative = path.relative(
+      pagesDirPath,
+      path.resolve(pagesSourceAbsolute),
+    );
+
+    if (typeof editUrl === 'function') {
+      return editUrl({
+        pagesDirPath: posixPath(path.relative(siteDir, pagesDirPath)),
+        pagesPath: posixPath(pagesPathRelative),
+        permalink,
+        locale: i18n.currentLocale,
+      });
+    } else if (typeof editUrl === 'string') {
+      const isLocalized = pagesDirPath === contentPaths.contentPathLocalized;
+      const fileContentPath =
+        isLocalized && options.editLocalizedFiles
+          ? contentPaths.contentPathLocalized
+          : contentPaths.contentPath;
+
+      const contentPathEditUrl = normalizeUrl([
+        editUrl,
+        posixPath(path.relative(siteDir, fileContentPath)),
+      ]);
+
+      return getEditUrl(pagesPathRelative, contentPathEditUrl);
+    }
+    return undefined;
+  }
+
+  const lastUpdatedData = await readLastUpdateData(
+    source,
+    options,
+    frontMatter.last_update,
+  );
+
+  if (isDraft({frontMatter})) {
+    return undefined;
+  }
+  const unlisted = isUnlisted({frontMatter});
+
+  return {
+    type: 'mdx',
+    permalink,
+    source: aliasedSourcePath,
+    title: frontMatter.title ?? contentTitle,
+    description: frontMatter.description ?? excerpt,
+    frontMatter,
+    lastUpdatedBy: lastUpdatedData.lastUpdatedBy,
+    lastUpdatedAt: lastUpdatedData.lastUpdatedAt,
+    editUrl: getPagesEditUrl(),
+    unlisted,
+  };
+}

package/src/index.ts

@@ -8,57 +8,32 @@
 import fs from 'fs-extra';
 import path from 'path';
 import {
-  encodePath,
-  fileToPath,
   aliasedSitePath,
-  aliasedSitePathToRelativePath,
   docuHash,
-  getPluginI18nPath,
-  getFolderContainingFile,
   addTrailingPathSeparator,
-  Globby,
   createAbsoluteFilePathMatcher,
-  normalizeUrl,
   DEFAULT_PLUGIN_ID,
-  parseMarkdownFile,
-  isUnlisted,
-  isDraft,
-  readLastUpdateData,
-  getEditUrl,
-  posixPath,
 } from '@docusaurus/utils';
-import {validatePageFrontMatter} from './frontMatter';
-import type {LoadContext, Plugin, RouteMetadata} from '@docusaurus/types';
-import type {PagesContentPaths} from './types';
+import {createAllRoutes} from './routes';
+import {
+  createPagesContentPaths,
+  getContentPathList,
+  loadPagesContent,
+} from './content';
+import type {LoadContext, Plugin} from '@docusaurus/types';
 import type {
   PluginOptions,
-  Metadata,
   LoadedContent,
   PageFrontMatter,
 } from '@docusaurus/plugin-content-pages';
 
-export function getContentPathList(contentPaths: PagesContentPaths): string[] {
-  return [contentPaths.contentPathLocalized, contentPaths.contentPath];
-}
-
-const isMarkdownSource = (source: string) =>
-  source.endsWith('.md') || source.endsWith('.mdx');
-
 export default function pluginContentPages(
   context: LoadContext,
   options: PluginOptions,
 ): Plugin<LoadedContent | null> {
-  const {siteConfig, siteDir, generatedFilesDir, localizationDir, i18n} =
-    context;
+  const {siteConfig, siteDir, generatedFilesDir} = context;
 
-  const contentPaths: PagesContentPaths = {
-    contentPath: path.resolve(siteDir, options.path),
-    contentPathLocalized: getPluginI18nPath({
-      localizationDir,
-      pluginName: 'docusaurus-plugin-content-pages',
-      pluginId: options.id,
-    }),
-  };
+  const contentPaths = createPagesContentPaths({context, options});
 
   const pluginDataDirRoot = path.join(
     generatedFilesDir,
@@ -77,182 +52,17 @@ export default function pluginContentPages(
     },
 
     async loadContent() {
-      const {include, editUrl} = options;
-
       if (!(await fs.pathExists(contentPaths.contentPath))) {
         return null;
       }
-
-      const {baseUrl} = siteConfig;
-      const pagesFiles = await Globby(include, {
-        cwd: contentPaths.contentPath,
-        ignore: options.exclude,
-      });
-
-      async function processPageSourceFile(
-        relativeSource: string,
-      ): Promise<Metadata | undefined> {
-        // Lookup in localized folder in priority
-        const contentPath = await getFolderContainingFile(
-          getContentPathList(contentPaths),
-          relativeSource,
-        );
-
-        const source = path.join(contentPath, relativeSource);
-        const aliasedSourcePath = aliasedSitePath(source, siteDir);
-        const permalink = normalizeUrl([
-          baseUrl,
-          options.routeBasePath,
-          encodePath(fileToPath(relativeSource)),
-        ]);
-        if (!isMarkdownSource(relativeSource)) {
-          return {
-            type: 'jsx',
-            permalink,
-            source: aliasedSourcePath,
-          };
-        }
-        const content = await fs.readFile(source, 'utf-8');
-        const {
-          frontMatter: unsafeFrontMatter,
-          contentTitle,
-          excerpt,
-        } = await parseMarkdownFile({
-          filePath: source,
-          fileContent: content,
-          parseFrontMatter: siteConfig.markdown.parseFrontMatter,
-        });
-        const frontMatter = validatePageFrontMatter(unsafeFrontMatter);
-
-        const pagesDirPath = await getFolderContainingFile(
-          getContentPathList(contentPaths),
-          relativeSource,
-        );
-
-        const pagesSourceAbsolute = path.join(pagesDirPath, relativeSource);
-
-        function getPagesEditUrl() {
-          const pagesPathRelative = path.relative(
-            pagesDirPath,
-            path.resolve(pagesSourceAbsolute),
-          );
-
-          if (typeof editUrl === 'function') {
-            return editUrl({
-              pagesDirPath: posixPath(path.relative(siteDir, pagesDirPath)),
-              pagesPath: posixPath(pagesPathRelative),
-              permalink,
-              locale: i18n.currentLocale,
-            });
-          } else if (typeof editUrl === 'string') {
-            const isLocalized =
-              pagesDirPath === contentPaths.contentPathLocalized;
-            const fileContentPath =
-              isLocalized && options.editLocalizedFiles
-                ? contentPaths.contentPathLocalized
-                : contentPaths.contentPath;
-
-            const contentPathEditUrl = normalizeUrl([
-              editUrl,
-              posixPath(path.relative(siteDir, fileContentPath)),
-            ]);
-
-            return getEditUrl(pagesPathRelative, contentPathEditUrl);
-          }
-          return undefined;
-        }
-
-        const lastUpdatedData = await readLastUpdateData(
-          source,
-          options,
-          frontMatter.last_update,
-        );
-
-        if (isDraft({frontMatter})) {
-          return undefined;
-        }
-        const unlisted = isUnlisted({frontMatter});
-
-        return {
-          type: 'mdx',
-          permalink,
-          source: aliasedSourcePath,
-          title: frontMatter.title ?? contentTitle,
-          description: frontMatter.description ?? excerpt,
-          frontMatter,
-          lastUpdatedBy: lastUpdatedData.lastUpdatedBy,
-          lastUpdatedAt: lastUpdatedData.lastUpdatedAt,
-          editUrl: getPagesEditUrl(),
-          unlisted,
-        };
-      }
-
-      async function doProcessPageSourceFile(relativeSource: string) {
-        try {
-          return await processPageSourceFile(relativeSource);
-        } catch (err) {
-          throw new Error(
-            `Processing of page source file path=${relativeSource} failed.`,
-            {cause: err as Error},
-          );
-        }
-      }
-
-      return (
-        await Promise.all(pagesFiles.map(doProcessPageSourceFile))
-      ).filter(Boolean) as Metadata[];
+      return loadPagesContent({context, options, contentPaths});
     },
 
     async contentLoaded({content, actions}) {
       if (!content) {
         return;
       }
-
-      const {addRoute, createData} = actions;
-
-      function createPageRouteMetadata(metadata: Metadata): RouteMetadata {
-        const lastUpdatedAt =
-          metadata.type === 'mdx' ? metadata.lastUpdatedAt : undefined;
-
-        return {
-          sourceFilePath: aliasedSitePathToRelativePath(metadata.source),
-          lastUpdatedAt,
-        };
-      }
-
-      await Promise.all(
-        content.map(async (metadata) => {
-          const {permalink, source} = metadata;
-          const routeMetadata = createPageRouteMetadata(metadata);
-          if (metadata.type === 'mdx') {
-            await createData(
-              // Note that this created data path must be in sync with
-              // metadataPath provided to mdx-loader.
-              `${docuHash(metadata.source)}.json`,
-              JSON.stringify(metadata, null, 2),
-            );
-            addRoute({
-              path: permalink,
-              component: options.mdxPageComponent,
-              exact: true,
-              metadata: routeMetadata,
-              modules: {
-                content: source,
-              },
-            });
-          } else {
-            addRoute({
-              path: permalink,
-              component: source,
-              exact: true,
-              metadata: routeMetadata,
-              modules: {
-                config: `@generated/docusaurus.config`,
-              },
-            });
-          }
-        }),
-      );
+      await createAllRoutes({content, options, actions});
     },
 
     configureWebpack() {
@@ -265,11 +75,6 @@ export default function pluginContentPages(
       } = options;
       const contentDirs = getContentPathList(contentPaths);
       return {
-        resolve: {
-          alias: {
-            '~pages': pluginDataDirRoot,
-          },
-        },
         module: {
           rules: [
             {

package/src/routes.ts

@@ -0,0 +1,89 @@
+/**
+ * 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.
+ */
+
+import {aliasedSitePathToRelativePath, docuHash} from '@docusaurus/utils';
+import type {
+  PluginContentLoadedActions,
+  RouteConfig,
+  RouteMetadata,
+} from '@docusaurus/types';
+import type {
+  PluginOptions,
+  Metadata,
+  LoadedContent,
+  MDXPageMetadata,
+} from '@docusaurus/plugin-content-pages';
+
+type CreateAllRoutesParam = {
+  content: LoadedContent;
+  options: PluginOptions;
+  actions: PluginContentLoadedActions;
+};
+
+function createPageRouteMetadata(metadata: Metadata): RouteMetadata {
+  const lastUpdatedAt =
+    metadata.type === 'mdx' ? metadata.lastUpdatedAt : undefined;
+  return {
+    sourceFilePath: aliasedSitePathToRelativePath(metadata.source),
+    lastUpdatedAt,
+  };
+}
+
+export async function createAllRoutes(
+  param: CreateAllRoutesParam,
+): Promise<void> {
+  const routes = await buildAllRoutes(param);
+  routes.forEach(param.actions.addRoute);
+}
+
+export async function buildAllRoutes({
+  content,
+  actions,
+  options,
+}: CreateAllRoutesParam): Promise<RouteConfig[]> {
+  const {createData} = actions;
+
+  async function buildMDXPageRoute(
+    metadata: MDXPageMetadata,
+  ): Promise<RouteConfig> {
+    await createData(
+      // Note that this created data path must be in sync with
+      // metadataPath provided to mdx-loader.
+      `${docuHash(metadata.source)}.json`,
+      metadata,
+    );
+    return {
+      path: metadata.permalink,
+      component: options.mdxPageComponent,
+      exact: true,
+      metadata: createPageRouteMetadata(metadata),
+      modules: {
+        content: metadata.source,
+      },
+    };
+  }
+
+  async function buildJSXRoute(metadata: Metadata): Promise<RouteConfig> {
+    return {
+      path: metadata.permalink,
+      component: metadata.source,
+      exact: true,
+      metadata: createPageRouteMetadata(metadata),
+      modules: {
+        config: `@generated/docusaurus.config`,
+      },
+    };
+  }
+
+  async function buildPageRoute(metadata: Metadata): Promise<RouteConfig> {
+    return metadata.type === 'mdx'
+      ? buildMDXPageRoute(metadata)
+      : buildJSXRoute(metadata);
+  }
+
+  return Promise.all(content.map(buildPageRoute));
+}