@docusaurus/plugin-content-pages 3.2.1 → 3.3.0

package/lib/content.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+/// <reference path="../src/plugin-content-pages.d.ts" />
+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/frontMatter.d.ts

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+/// <reference path="../src/plugin-content-pages.d.ts" />
 import type { PageFrontMatter } from '@docusaurus/plugin-content-pages';
 export declare function validatePageFrontMatter(frontMatter: {
     [key: string]: unknown;

package/lib/frontMatter.js

@@ -18,6 +18,7 @@ const PageFrontMatterSchema = utils_validation_1.Joi.object({
     wrapperClassName: utils_validation_1.Joi.string(),
     hide_table_of_contents: utils_validation_1.Joi.boolean(),
     ...utils_validation_1.FrontMatterTOCHeadingLevels,
+    last_update: utils_validation_1.FrontMatterLastUpdateSchema,
 }).concat(utils_validation_1.ContentVisibilitySchema);
 function validatePageFrontMatter(frontMatter) {
     return (0, utils_validation_1.validateFrontMatter)(frontMatter, PageFrontMatterSchema);

package/lib/index.d.ts

@@ -4,9 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+/// <reference path="../src/plugin-content-pages.d.ts" />
 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,147 +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 } = 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 } = 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);
-                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,
-                    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) {
-                return {
-                    sourceFilePath: (0, utils_1.aliasedSitePathToRelativePath)(metadata.source),
-                    // TODO add support for last updated date in the page plugin
-                    //  at least for Markdown files
-                    // lastUpdatedAt: metadata.lastUpdatedAt,
-                    lastUpdatedAt: undefined,
-                };
-            }
-            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/options.d.ts

@@ -4,6 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+/// <reference path="../src/plugin-content-pages.d.ts" />
 import type { OptionValidationContext } from '@docusaurus/types';
 import type { PluginOptions, Options } from '@docusaurus/plugin-content-pages';
 export declare const DEFAULT_OPTIONS: PluginOptions;

package/lib/options.js

@@ -10,9 +10,9 @@ exports.validateOptions = exports.DEFAULT_OPTIONS = void 0;
 const utils_validation_1 = require("@docusaurus/utils-validation");
 const utils_1 = require("@docusaurus/utils");
 exports.DEFAULT_OPTIONS = {
-    path: 'src/pages',
-    routeBasePath: '/',
-    include: ['**/*.{js,jsx,ts,tsx,md,mdx}'],
+    path: 'src/pages', // Path to data on filesystem, relative to site dir.
+    routeBasePath: '/', // URL Route.
+    include: ['**/*.{js,jsx,ts,tsx,md,mdx}'], // Extensions to include.
     exclude: utils_1.GlobExcludeDefault,
     mdxPageComponent: '@theme/MDXPage',
     remarkPlugins: [],
@@ -20,6 +20,9 @@ exports.DEFAULT_OPTIONS = {
     beforeDefaultRehypePlugins: [],
     beforeDefaultRemarkPlugins: [],
     admonitions: true,
+    showLastUpdateTime: false,
+    showLastUpdateAuthor: false,
+    editLocalizedFiles: false,
 };
 const PluginOptionSchema = utils_validation_1.Joi.object({
     path: utils_validation_1.Joi.string().default(exports.DEFAULT_OPTIONS.path),
@@ -32,6 +35,10 @@ const PluginOptionSchema = utils_validation_1.Joi.object({
     beforeDefaultRehypePlugins: utils_validation_1.RehypePluginsSchema.default(exports.DEFAULT_OPTIONS.beforeDefaultRehypePlugins),
     beforeDefaultRemarkPlugins: utils_validation_1.RemarkPluginsSchema.default(exports.DEFAULT_OPTIONS.beforeDefaultRemarkPlugins),
     admonitions: utils_validation_1.AdmonitionsSchema.default(exports.DEFAULT_OPTIONS.admonitions),
+    showLastUpdateTime: utils_validation_1.Joi.bool().default(exports.DEFAULT_OPTIONS.showLastUpdateTime),
+    showLastUpdateAuthor: utils_validation_1.Joi.bool().default(exports.DEFAULT_OPTIONS.showLastUpdateAuthor),
+    editUrl: utils_validation_1.Joi.alternatives().try(utils_validation_1.URISchema, utils_validation_1.Joi.function()),
+    editLocalizedFiles: utils_validation_1.Joi.boolean().default(exports.DEFAULT_OPTIONS.editLocalizedFiles),
 });
 function validateOptions({ validate, options, }) {
     const validatedOptions = validate(PluginOptionSchema, options);

package/lib/routes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+/// <reference path="../src/plugin-content-pages.d.ts" />
+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": "3.2.1",
+  "version": "3.3.0",
   "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": "3.2.1",
-    "@docusaurus/mdx-loader": "3.2.1",
-    "@docusaurus/types": "3.2.1",
-    "@docusaurus/utils": "3.2.1",
-    "@docusaurus/utils-validation": "3.2.1",
+    "@docusaurus/core": "3.3.0",
+    "@docusaurus/mdx-loader": "3.3.0",
+    "@docusaurus/types": "3.3.0",
+    "@docusaurus/utils": "3.3.0",
+    "@docusaurus/utils-validation": "3.3.0",
     "fs-extra": "^11.1.1",
     "tslib": "^2.6.0",
     "webpack": "^5.88.1"
@@ -34,5 +34,5 @@
   "engines": {
     "node": ">=18.0"
   },
-  "gitHead": "f268e15264e208e6faf26117258162e988b53773"
+  "gitHead": "2ec4e078b5ca0c57f2cc04f2fe564d524bb5e858"
 }

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/frontMatter.ts

@@ -11,6 +11,7 @@ import {
   FrontMatterTOCHeadingLevels,
   ContentVisibilitySchema,
   URISchema,
+  FrontMatterLastUpdateSchema,
 } from '@docusaurus/utils-validation';
 import type {PageFrontMatter} from '@docusaurus/plugin-content-pages';
 
@@ -24,6 +25,7 @@ const PageFrontMatterSchema = Joi.object<PageFrontMatter>({
   wrapperClassName: Joi.string(),
   hide_table_of_contents: Joi.boolean(),
   ...FrontMatterTOCHeadingLevels,
+  last_update: FrontMatterLastUpdateSchema,
 }).concat(ContentVisibilitySchema);
 
 export function validatePageFrontMatter(frontMatter: {

package/src/index.ts

@@ -8,53 +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,
 } 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} = 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,
@@ -73,135 +52,17 @@ export default function pluginContentPages(
     },
 
     async loadContent() {
-      const {include} = 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);
-
-        if (isDraft({frontMatter})) {
-          return undefined;
-        }
-        const unlisted = isUnlisted({frontMatter});
-
-        return {
-          type: 'mdx',
-          permalink,
-          source: aliasedSourcePath,
-          title: frontMatter.title ?? contentTitle,
-          description: frontMatter.description ?? excerpt,
-          frontMatter,
-          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 {
-        return {
-          sourceFilePath: aliasedSitePathToRelativePath(metadata.source),
-          // TODO add support for last updated date in the page plugin
-          //  at least for Markdown files
-          // lastUpdatedAt: metadata.lastUpdatedAt,
-          lastUpdatedAt: undefined,
-        };
-      }
-
-      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() {
@@ -214,11 +75,6 @@ export default function pluginContentPages(
       } = options;
       const contentDirs = getContentPathList(contentPaths);
       return {
-        resolve: {
-          alias: {
-            '~pages': pluginDataDirRoot,
-          },
-        },
         module: {
           rules: [
             {

package/src/options.ts

@@ -11,6 +11,7 @@ import {
   RehypePluginsSchema,
   AdmonitionsSchema,
   RouteBasePathSchema,
+  URISchema,
 } from '@docusaurus/utils-validation';
 import {GlobExcludeDefault} from '@docusaurus/utils';
 import type {OptionValidationContext} from '@docusaurus/types';
@@ -27,6 +28,9 @@ export const DEFAULT_OPTIONS: PluginOptions = {
   beforeDefaultRehypePlugins: [],
   beforeDefaultRemarkPlugins: [],
   admonitions: true,
+  showLastUpdateTime: false,
+  showLastUpdateAuthor: false,
+  editLocalizedFiles: false,
 };
 
 const PluginOptionSchema = Joi.object<PluginOptions>({
@@ -44,6 +48,12 @@ const PluginOptionSchema = Joi.object<PluginOptions>({
     DEFAULT_OPTIONS.beforeDefaultRemarkPlugins,
   ),
   admonitions: AdmonitionsSchema.default(DEFAULT_OPTIONS.admonitions),
+  showLastUpdateTime: Joi.bool().default(DEFAULT_OPTIONS.showLastUpdateTime),
+  showLastUpdateAuthor: Joi.bool().default(
+    DEFAULT_OPTIONS.showLastUpdateAuthor,
+  ),
+  editUrl: Joi.alternatives().try(URISchema, Joi.function()),
+  editLocalizedFiles: Joi.boolean().default(DEFAULT_OPTIONS.editLocalizedFiles),
 });
 
 export function validateOptions({

package/src/plugin-content-pages.d.ts

@@ -8,6 +8,7 @@
 declare module '@docusaurus/plugin-content-pages' {
   import type {MDXOptions} from '@docusaurus/mdx-loader';
   import type {LoadContext, Plugin} from '@docusaurus/types';
+  import type {FrontMatterLastUpdate, LastUpdateData} from '@docusaurus/utils';
 
   export type Assets = {
     image?: string;
@@ -20,6 +21,10 @@ declare module '@docusaurus/plugin-content-pages' {
     include: string[];
     exclude: string[];
     mdxPageComponent: string;
+    showLastUpdateTime: boolean;
+    showLastUpdateAuthor: boolean;
+    editUrl?: string | EditUrlFunction;
+    editLocalizedFiles?: boolean;
   };
 
   export type Options = Partial<PluginOptions>;
@@ -35,6 +40,7 @@ declare module '@docusaurus/plugin-content-pages' {
     readonly toc_max_heading_level?: number;
     readonly draft?: boolean;
     readonly unlisted?: boolean;
+    readonly last_update?: FrontMatterLastUpdate;
   };
 
   export type JSXPageMetadata = {
@@ -43,16 +49,31 @@ declare module '@docusaurus/plugin-content-pages' {
     source: string;
   };
 
-  export type MDXPageMetadata = {
+  export type MDXPageMetadata = LastUpdateData & {
     type: 'mdx';
     permalink: string;
     source: string;
     frontMatter: PageFrontMatter & {[key: string]: unknown};
+    editUrl?: string;
     title?: string;
     description?: string;
     unlisted: boolean;
   };
 
+  export type EditUrlFunction = (editUrlParams: {
+    /**
+     * The root content directory containing this post file, relative to the
+     * site path. Usually the same as `options.path` but can be localized
+     */
+    pagesDirPath: string;
+    /** Path to this pages file, relative to `pagesDirPath`. */
+    pagesPath: string;
+    /** @see {@link PagesPostMetadata.permalink} */
+    permalink: string;
+    /** Locale name. */
+    locale: string;
+  }) => string | undefined;
+
   export type Metadata = JSXPageMetadata | MDXPageMetadata;
 
   export type LoadedContent = Metadata[];

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));
+}