@docusaurus/plugin-content-blog 2.0.0-beta.1ec2c95e3 → 2.0.0-beta.21

package/lib/authors.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.
+ */
+import type { BlogContentPaths } from './types';
+import type { Author, BlogPostFrontMatter } from '@docusaurus/plugin-content-blog';
+export declare type AuthorsMap = {
+    [authorKey: string]: Author;
+};
+export declare function validateAuthorsMap(content: unknown): AuthorsMap;
+export declare function getAuthorsMap(params: {
+    authorsMapPath: string;
+    contentPaths: BlogContentPaths;
+}): Promise<AuthorsMap | undefined>;
+declare type AuthorsParam = {
+    frontMatter: BlogPostFrontMatter;
+    authorsMap: AuthorsMap | undefined;
+};
+export declare function getBlogPostAuthors(params: AuthorsParam): Author[];
+export {};

package/lib/authors.js

@@ -0,0 +1,122 @@
+"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.getBlogPostAuthors = exports.getAuthorsMap = exports.validateAuthorsMap = void 0;
+const utils_1 = require("@docusaurus/utils");
+const utils_validation_1 = require("@docusaurus/utils-validation");
+const AuthorsMapSchema = utils_validation_1.Joi.object()
+    .pattern(utils_validation_1.Joi.string(), utils_validation_1.Joi.object({
+    name: utils_validation_1.Joi.string(),
+    url: utils_validation_1.URISchema,
+    imageURL: utils_validation_1.URISchema,
+    title: utils_validation_1.Joi.string(),
+    email: utils_validation_1.Joi.string(),
+})
+    .rename('image_url', 'imageURL')
+    .or('name', 'imageURL')
+    .unknown()
+    .required()
+    .messages({
+    'object.base': '{#label} should be an author object containing properties like name, title, and imageURL.',
+    'any.required': '{#label} cannot be undefined. It should be an author object containing properties like name, title, and imageURL.',
+}))
+    .messages({
+    'object.base': "The authors map file should contain an object where each entry contains an author key and the corresponding author's data.",
+});
+function validateAuthorsMap(content) {
+    const { error, value } = AuthorsMapSchema.validate(content);
+    if (error) {
+        throw error;
+    }
+    return value;
+}
+exports.validateAuthorsMap = validateAuthorsMap;
+async function getAuthorsMap(params) {
+    return (0, utils_1.getDataFileData)({
+        filePath: params.authorsMapPath,
+        contentPaths: params.contentPaths,
+        fileType: 'authors map',
+    }, validateAuthorsMap);
+}
+exports.getAuthorsMap = getAuthorsMap;
+// Legacy v1/early-v2 front matter fields
+// We may want to deprecate those in favor of using only frontMatter.authors
+function getFrontMatterAuthorLegacy(frontMatter) {
+    const name = frontMatter.author;
+    const title = frontMatter.author_title ?? frontMatter.authorTitle;
+    const url = frontMatter.author_url ?? frontMatter.authorURL;
+    const imageURL = frontMatter.author_image_url ?? frontMatter.authorImageURL;
+    if (name || title || url || imageURL) {
+        return {
+            name,
+            title,
+            url,
+            imageURL,
+        };
+    }
+    return undefined;
+}
+function normalizeFrontMatterAuthors(frontMatterAuthors = []) {
+    function normalizeAuthor(authorInput) {
+        if (typeof authorInput === 'string') {
+            // Technically, we could allow users to provide an author's name here, but
+            // we only support keys, otherwise, a typo in a key would fallback to
+            // becoming a name and may end up unnoticed
+            return { key: authorInput };
+        }
+        return authorInput;
+    }
+    return Array.isArray(frontMatterAuthors)
+        ? frontMatterAuthors.map(normalizeAuthor)
+        : [normalizeAuthor(frontMatterAuthors)];
+}
+function getFrontMatterAuthors(params) {
+    const { authorsMap } = params;
+    const frontMatterAuthors = normalizeFrontMatterAuthors(params.frontMatter.authors);
+    function getAuthorsMapAuthor(key) {
+        if (key) {
+            if (!authorsMap || Object.keys(authorsMap).length === 0) {
+                throw new Error(`Can't reference blog post authors by a key (such as '${key}') because no authors map file could be loaded.
+Please double-check your blog plugin config (in particular 'authorsMapPath'), ensure the file exists at the configured path, is not empty, and is valid!`);
+            }
+            const author = authorsMap[key];
+            if (!author) {
+                throw Error(`Blog author with key "${key}" not found in the authors map file.
+Valid author keys are:
+${Object.keys(authorsMap)
+                    .map((validKey) => `- ${validKey}`)
+                    .join('\n')}`);
+            }
+            return author;
+        }
+        return undefined;
+    }
+    function toAuthor(frontMatterAuthor) {
+        return {
+            // Author def from authorsMap can be locally overridden by front matter
+            ...getAuthorsMapAuthor(frontMatterAuthor.key),
+            ...frontMatterAuthor,
+        };
+    }
+    return frontMatterAuthors.map(toAuthor);
+}
+function getBlogPostAuthors(params) {
+    const authorLegacy = getFrontMatterAuthorLegacy(params.frontMatter);
+    const authors = getFrontMatterAuthors(params);
+    if (authorLegacy) {
+        // Technically, we could allow mixing legacy/authors front matter, but do we
+        // really want to?
+        if (authors.length > 0) {
+            throw new Error(`To declare blog post authors, use the 'authors' front matter in priority.
+Don't mix 'authors' with other existing 'author_*' front matter. Choose one or the other, not both at the same time.`);
+        }
+        return [authorLegacy];
+    }
+    return authors;
+}
+exports.getBlogPostAuthors = getBlogPostAuthors;

package/lib/blogUtils.d.ts

@@ -4,16 +4,36 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { Feed } from 'feed';
-import { PluginOptions, BlogPost, BlogContentPaths, BlogMarkdownLoaderOptions } from './types';
-import { LoadContext } from '@docusaurus/types';
+import type { LoadContext } from '@docusaurus/types';
+import type { PluginOptions, BlogPost, BlogTags, BlogPaginated } from '@docusaurus/plugin-content-blog';
+import type { BlogContentPaths, BlogMarkdownLoaderOptions } from './types';
 export declare function truncate(fileString: string, truncateMarker: RegExp): string;
-export declare function getSourceToPermalink(blogPosts: BlogPost[]): Record<string, string>;
-export declare function generateBlogFeed(contentPaths: BlogContentPaths, context: LoadContext, options: PluginOptions): Promise<Feed | null>;
-export declare function generateBlogPosts(contentPaths: BlogContentPaths, { siteConfig, siteDir, i18n }: LoadContext, options: PluginOptions): Promise<BlogPost[]>;
+export declare function getSourceToPermalink(blogPosts: BlogPost[]): {
+    [aliasedPath: string]: string;
+};
+export declare function paginateBlogPosts({ blogPosts, basePageUrl, blogTitle, blogDescription, postsPerPageOption, }: {
+    blogPosts: BlogPost[];
+    basePageUrl: string;
+    blogTitle: string;
+    blogDescription: string;
+    postsPerPageOption: number | 'ALL';
+}): BlogPaginated[];
+export declare function getBlogTags({ blogPosts, ...params }: {
+    blogPosts: BlogPost[];
+    blogTitle: string;
+    blogDescription: string;
+    postsPerPageOption: number | 'ALL';
+}): BlogTags;
+declare type ParsedBlogFileName = {
+    date: Date | undefined;
+    text: string;
+    slug: string;
+};
+export declare function parseBlogFileName(blogSourceRelative: string): ParsedBlogFileName;
+export declare function generateBlogPosts(contentPaths: BlogContentPaths, context: LoadContext, options: PluginOptions): Promise<BlogPost[]>;
 export declare type LinkifyParams = {
     filePath: string;
     fileString: string;
 } & Pick<BlogMarkdownLoaderOptions, 'sourceToPermalink' | 'siteDir' | 'contentPaths' | 'onBrokenMarkdownLink'>;
 export declare function linkify({ filePath, contentPaths, fileString, siteDir, sourceToPermalink, onBrokenMarkdownLink, }: LinkifyParams): string;
-export declare function getContentPathList(contentPaths: BlogContentPaths): string[];
+export {};

package/lib/blogUtils.js

@@ -6,187 +6,248 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getContentPathList = exports.linkify = exports.generateBlogPosts = exports.generateBlogFeed = exports.getSourceToPermalink = exports.truncate = void 0;
+exports.linkify = exports.generateBlogPosts = exports.parseBlogFileName = exports.getBlogTags = exports.paginateBlogPosts = exports.getSourceToPermalink = exports.truncate = void 0;
 const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
-const globby_1 = tslib_1.__importDefault(require("globby"));
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const path_1 = tslib_1.__importDefault(require("path"));
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const reading_time_1 = tslib_1.__importDefault(require("reading-time"));
-const feed_1 = require("feed");
-const lodash_1 = require("lodash");
 const utils_1 = require("@docusaurus/utils");
-const blogFrontMatter_1 = require("./blogFrontMatter");
+const frontMatter_1 = require("./frontMatter");
+const authors_1 = require("./authors");
 function truncate(fileString, truncateMarker) {
     return fileString.split(truncateMarker, 1).shift();
 }
 exports.truncate = truncate;
 function getSourceToPermalink(blogPosts) {
-    return lodash_1.mapValues(lodash_1.keyBy(blogPosts, (item) => item.metadata.source), (v) => v.metadata.permalink);
+    return Object.fromEntries(blogPosts.map(({ metadata: { source, permalink } }) => [source, permalink]));
 }
 exports.getSourceToPermalink = getSourceToPermalink;
-// YYYY-MM-DD-{name}.mdx?
-// Prefer named capture, but older Node versions do not support it.
-const DATE_FILENAME_PATTERN = /^(\d{4}-\d{1,2}-\d{1,2})-?(.*?).mdx?$/;
-function toUrl({ date, link }) {
-    return `${date
-        .toISOString()
-        .substring(0, '2019-01-01'.length)
-        .replace(/-/g, '/')}/${link}`;
+function paginateBlogPosts({ blogPosts, basePageUrl, blogTitle, blogDescription, postsPerPageOption, }) {
+    const totalCount = blogPosts.length;
+    const postsPerPage = postsPerPageOption === 'ALL' ? totalCount : postsPerPageOption;
+    const numberOfPages = Math.ceil(totalCount / postsPerPage);
+    const pages = [];
+    function permalink(page) {
+        return page > 0
+            ? (0, utils_1.normalizeUrl)([basePageUrl, `page/${page + 1}`])
+            : basePageUrl;
+    }
+    for (let page = 0; page < numberOfPages; page += 1) {
+        pages.push({
+            items: blogPosts
+                .slice(page * postsPerPage, (page + 1) * postsPerPage)
+                .map((item) => item.id),
+            metadata: {
+                permalink: permalink(page),
+                page: page + 1,
+                postsPerPage,
+                totalPages: numberOfPages,
+                totalCount,
+                previousPage: page !== 0 ? permalink(page - 1) : undefined,
+                nextPage: page < numberOfPages - 1 ? permalink(page + 1) : undefined,
+                blogDescription,
+                blogTitle,
+            },
+        });
+    }
+    return pages;
+}
+exports.paginateBlogPosts = paginateBlogPosts;
+function getBlogTags({ blogPosts, ...params }) {
+    const groups = (0, utils_1.groupTaggedItems)(blogPosts, (blogPost) => blogPost.metadata.tags);
+    return lodash_1.default.mapValues(groups, ({ tag, items: tagBlogPosts }) => ({
+        label: tag.label,
+        items: tagBlogPosts.map((item) => item.id),
+        permalink: tag.permalink,
+        pages: paginateBlogPosts({
+            blogPosts: tagBlogPosts,
+            basePageUrl: tag.permalink,
+            ...params,
+        }),
+    }));
+}
+exports.getBlogTags = getBlogTags;
+const DATE_FILENAME_REGEX = /^(?<folder>.*)(?<date>\d{4}[-/]\d{1,2}[-/]\d{1,2})[-/]?(?<text>.*?)(?:\/index)?.mdx?$/;
+function parseBlogFileName(blogSourceRelative) {
+    const dateFilenameMatch = blogSourceRelative.match(DATE_FILENAME_REGEX);
+    if (dateFilenameMatch) {
+        const { folder, text, date: dateString } = dateFilenameMatch.groups;
+        // Always treat dates as UTC by adding the `Z`
+        const date = new Date(`${dateString}Z`);
+        const slugDate = dateString.replace(/-/g, '/');
+        const slug = `/${slugDate}/${folder}${text}`;
+        return { date, text: text, slug };
+    }
+    const text = blogSourceRelative.replace(/(?:\/index)?\.mdx?$/, '');
+    const slug = `/${text}`;
+    return { date: undefined, text, slug };
 }
-function formatBlogPostDate(locale, date) {
+exports.parseBlogFileName = parseBlogFileName;
+function formatBlogPostDate(locale, date, calendar) {
     try {
         return new Intl.DateTimeFormat(locale, {
             day: 'numeric',
             month: 'long',
             year: 'numeric',
             timeZone: 'UTC',
+            calendar,
         }).format(date);
     }
-    catch (e) {
-        throw new Error(`Can't format blog post date "${date}"`);
+    catch (err) {
+        logger_1.default.error `Can't format blog post date "${String(date)}"`;
+        throw err;
     }
 }
-async function generateBlogFeed(contentPaths, context, options) {
-    if (!options.feedOptions) {
-        throw new Error('Invalid options: "feedOptions" is not expected to be null.');
+async function parseBlogPostMarkdownFile(blogSourceAbsolute) {
+    const markdownString = await fs_extra_1.default.readFile(blogSourceAbsolute, 'utf-8');
+    try {
+        const result = (0, utils_1.parseMarkdownString)(markdownString, {
+            removeContentTitle: true,
+        });
+        return {
+            ...result,
+            frontMatter: (0, frontMatter_1.validateBlogPostFrontMatter)(result.frontMatter),
+        };
     }
-    const { siteConfig } = context;
-    const blogPosts = await generateBlogPosts(contentPaths, context, options);
-    if (!blogPosts.length) {
-        return null;
+    catch (err) {
+        logger_1.default.error `Error while parsing blog post file path=${blogSourceAbsolute}.`;
+        throw err;
     }
-    const { feedOptions, routeBasePath } = options;
-    const { url: siteUrl, baseUrl, title, favicon } = siteConfig;
-    const blogBaseUrl = utils_1.normalizeUrl([siteUrl, baseUrl, routeBasePath]);
-    const updated = (blogPosts[0] && blogPosts[0].metadata.date) ||
-        new Date('2015-10-25T16:29:00.000-07:00');
-    const feed = new feed_1.Feed({
-        id: blogBaseUrl,
-        title: feedOptions.title || `${title} Blog`,
-        updated,
-        language: feedOptions.language,
-        link: blogBaseUrl,
-        description: feedOptions.description || `${siteConfig.title} Blog`,
-        favicon: favicon ? utils_1.normalizeUrl([siteUrl, baseUrl, favicon]) : undefined,
-        copyright: feedOptions.copyright,
-    });
-    blogPosts.forEach((post) => {
-        const { id, metadata: { title: metadataTitle, permalink, date, description }, } = post;
-        feed.addItem({
-            title: metadataTitle,
-            id,
-            link: utils_1.normalizeUrl([siteUrl, permalink]),
-            date,
-            description,
-        });
-    });
-    return feed;
 }
-exports.generateBlogFeed = generateBlogFeed;
-async function generateBlogPosts(contentPaths, { siteConfig, siteDir, i18n }, options) {
-    const { include, routeBasePath, truncateMarker, showReadingTime, editUrl, } = options;
-    if (!fs_extra_1.default.existsSync(contentPaths.contentPath)) {
-        return [];
+const defaultReadingTime = ({ content, options }) => (0, reading_time_1.default)(content, options).minutes;
+async function processBlogSourceFile(blogSourceRelative, contentPaths, context, options, authorsMap) {
+    const { siteConfig: { baseUrl }, siteDir, i18n, } = context;
+    const { routeBasePath, tagsBasePath: tagsRouteBasePath, truncateMarker, showReadingTime, editUrl, } = options;
+    // Lookup in localized folder in priority
+    const blogDirPath = await (0, utils_1.getFolderContainingFile)((0, utils_1.getContentPathList)(contentPaths), blogSourceRelative);
+    const blogSourceAbsolute = path_1.default.join(blogDirPath, blogSourceRelative);
+    const { frontMatter, content, contentTitle, excerpt } = await parseBlogPostMarkdownFile(blogSourceAbsolute);
+    const aliasedSource = (0, utils_1.aliasedSitePath)(blogSourceAbsolute, siteDir);
+    if (frontMatter.draft && process.env.NODE_ENV === 'production') {
+        return undefined;
     }
-    const { baseUrl = '' } = siteConfig;
-    const blogSourceFiles = await globby_1.default(include, {
-        cwd: contentPaths.contentPath,
-    });
-    const blogPosts = [];
-    async function processBlogSourceFile(blogSourceFile) {
-        var _a, _b, _c, _d, _e, _f;
-        // Lookup in localized folder in priority
-        const blogDirPath = await utils_1.getFolderContainingFile(getContentPathList(contentPaths), blogSourceFile);
-        const source = path_1.default.join(blogDirPath, blogSourceFile);
-        const { frontMatter: unsafeFrontMatter, content, contentTitle, excerpt, } = await utils_1.parseMarkdownFile(source, { removeContentTitle: true });
-        const frontMatter = blogFrontMatter_1.validateBlogPostFrontMatter(unsafeFrontMatter);
-        const aliasedSource = utils_1.aliasedSitePath(source, siteDir);
-        const blogFileName = path_1.default.basename(blogSourceFile);
-        if (frontMatter.draft && process.env.NODE_ENV === 'production') {
-            return;
-        }
-        if (frontMatter.id) {
-            console.warn(chalk_1.default.yellow(`"id" header option is deprecated in ${blogFileName} file. Please use "slug" option instead.`));
-        }
-        let date;
-        // Extract date and title from filename.
-        const dateFilenameMatch = blogFileName.match(DATE_FILENAME_PATTERN);
-        let linkName = blogFileName.replace(/\.mdx?$/, '');
-        if (dateFilenameMatch) {
-            const [, dateString, name] = dateFilenameMatch;
-            // Always treat dates as UTC by adding the `Z`
-            date = new Date(`${dateString}Z`);
-            linkName = name;
-        }
+    if (frontMatter.id) {
+        logger_1.default.warn `name=${'id'} header option is deprecated in path=${blogSourceRelative} file. Please use name=${'slug'} option instead.`;
+    }
+    const parsedBlogFileName = parseBlogFileName(blogSourceRelative);
+    async function getDate() {
         // Prefer user-defined date.
         if (frontMatter.date) {
-            date = frontMatter.date;
-        }
-        // Use file create time for blog.
-        date = date !== null && date !== void 0 ? date : (await fs_extra_1.default.stat(source)).birthtime;
-        const formattedDate = formatBlogPostDate(i18n.currentLocale, date);
-        const title = (_b = (_a = frontMatter.title) !== null && _a !== void 0 ? _a : contentTitle) !== null && _b !== void 0 ? _b : linkName;
-        const description = (_d = (_c = frontMatter.description) !== null && _c !== void 0 ? _c : excerpt) !== null && _d !== void 0 ? _d : '';
-        const slug = frontMatter.slug ||
-            (dateFilenameMatch ? toUrl({ date, link: linkName }) : linkName);
-        const permalink = utils_1.normalizeUrl([baseUrl, routeBasePath, slug]);
-        function getBlogEditUrl() {
-            const blogPathRelative = path_1.default.relative(blogDirPath, path_1.default.resolve(source));
-            if (typeof editUrl === 'function') {
-                return editUrl({
-                    blogDirPath: utils_1.posixPath(path_1.default.relative(siteDir, blogDirPath)),
-                    blogPath: utils_1.posixPath(blogPathRelative),
-                    permalink,
-                    locale: i18n.currentLocale,
-                });
-            }
-            else if (typeof editUrl === 'string') {
-                const isLocalized = blogDirPath === contentPaths.contentPathLocalized;
-                const fileContentPath = isLocalized && options.editLocalizedFiles
-                    ? contentPaths.contentPathLocalized
-                    : contentPaths.contentPath;
-                const contentPathEditUrl = utils_1.normalizeUrl([
-                    editUrl,
-                    utils_1.posixPath(path_1.default.relative(siteDir, fileContentPath)),
-                ]);
-                return utils_1.getEditUrl(blogPathRelative, contentPathEditUrl);
-            }
-            else {
-                return undefined;
+            if (typeof frontMatter.date === 'string') {
+                // Always treat dates as UTC by adding the `Z`
+                return new Date(`${frontMatter.date}Z`);
             }
+            // YAML only converts YYYY-MM-DD to dates and leaves others as strings.
+            return frontMatter.date;
         }
-        blogPosts.push({
-            id: (_e = frontMatter.slug) !== null && _e !== void 0 ? _e : title,
-            metadata: {
+        else if (parsedBlogFileName.date) {
+            return parsedBlogFileName.date;
+        }
+        try {
+            const result = (0, utils_1.getFileCommitDate)(blogSourceAbsolute, {
+                age: 'oldest',
+                includeAuthor: false,
+            });
+            return result.date;
+        }
+        catch (err) {
+            logger_1.default.warn(err);
+            return (await fs_extra_1.default.stat(blogSourceAbsolute)).birthtime;
+        }
+    }
+    const date = await getDate();
+    const formattedDate = formatBlogPostDate(i18n.currentLocale, date, i18n.localeConfigs[i18n.currentLocale].calendar);
+    const title = frontMatter.title ?? contentTitle ?? parsedBlogFileName.text;
+    const description = frontMatter.description ?? excerpt ?? '';
+    const slug = frontMatter.slug ?? parsedBlogFileName.slug;
+    const permalink = (0, utils_1.normalizeUrl)([baseUrl, routeBasePath, slug]);
+    function getBlogEditUrl() {
+        const blogPathRelative = path_1.default.relative(blogDirPath, path_1.default.resolve(blogSourceAbsolute));
+        if (typeof editUrl === 'function') {
+            return editUrl({
+                blogDirPath: (0, utils_1.posixPath)(path_1.default.relative(siteDir, blogDirPath)),
+                blogPath: (0, utils_1.posixPath)(blogPathRelative),
                 permalink,
-                editUrl: getBlogEditUrl(),
-                source: aliasedSource,
-                title,
-                description,
-                date,
-                formattedDate,
-                tags: (_f = frontMatter.tags) !== null && _f !== void 0 ? _f : [],
-                readingTime: showReadingTime ? reading_time_1.default(content).minutes : undefined,
-                truncated: (truncateMarker === null || truncateMarker === void 0 ? void 0 : truncateMarker.test(content)) || false,
-            },
-        });
+                locale: i18n.currentLocale,
+            });
+        }
+        else if (typeof editUrl === 'string') {
+            const isLocalized = blogDirPath === 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)(blogPathRelative, contentPathEditUrl);
+        }
+        return undefined;
     }
-    await Promise.all(blogSourceFiles.map(async (blogSourceFile) => {
+    const tagsBasePath = (0, utils_1.normalizeUrl)([
+        baseUrl,
+        routeBasePath,
+        tagsRouteBasePath,
+    ]);
+    const authors = (0, authors_1.getBlogPostAuthors)({ authorsMap, frontMatter });
+    return {
+        id: slug,
+        metadata: {
+            permalink,
+            editUrl: getBlogEditUrl(),
+            source: aliasedSource,
+            title,
+            description,
+            date,
+            formattedDate,
+            tags: (0, utils_1.normalizeFrontMatterTags)(tagsBasePath, frontMatter.tags),
+            readingTime: showReadingTime
+                ? options.readingTime({
+                    content,
+                    frontMatter,
+                    defaultReadingTime,
+                })
+                : undefined,
+            truncated: truncateMarker.test(content),
+            authors,
+            frontMatter,
+        },
+        content,
+    };
+}
+async function generateBlogPosts(contentPaths, context, options) {
+    const { include, exclude } = options;
+    if (!(await fs_extra_1.default.pathExists(contentPaths.contentPath))) {
+        return [];
+    }
+    const blogSourceFiles = await (0, utils_1.Globby)(include, {
+        cwd: contentPaths.contentPath,
+        ignore: exclude,
+    });
+    const authorsMap = await (0, authors_1.getAuthorsMap)({
+        contentPaths,
+        authorsMapPath: options.authorsMapPath,
+    });
+    const blogPosts = (await Promise.all(blogSourceFiles.map(async (blogSourceFile) => {
         try {
-            return await processBlogSourceFile(blogSourceFile);
+            return await processBlogSourceFile(blogSourceFile, contentPaths, context, options, authorsMap);
         }
-        catch (e) {
-            console.error(chalk_1.default.red(`Processing of blog source file failed for path "${blogSourceFile}"`));
-            throw e;
+        catch (err) {
+            logger_1.default.error `Processing of blog source file path=${blogSourceFile} failed.`;
+            throw err;
         }
-    }));
+    }))).filter(Boolean);
     blogPosts.sort((a, b) => b.metadata.date.getTime() - a.metadata.date.getTime());
+    if (options.sortPosts === 'ascending') {
+        return blogPosts.reverse();
+    }
     return blogPosts;
 }
 exports.generateBlogPosts = generateBlogPosts;
 function linkify({ filePath, contentPaths, fileString, siteDir, sourceToPermalink, onBrokenMarkdownLink, }) {
-    const { newContent, brokenMarkdownLinks } = utils_1.replaceMarkdownLinks({
+    const { newContent, brokenMarkdownLinks } = (0, utils_1.replaceMarkdownLinks)({
         siteDir,
         fileString,
         filePath,
@@ -197,8 +258,3 @@ function linkify({ filePath, contentPaths, fileString, siteDir, sourceToPermalin
     return newContent;
 }
 exports.linkify = linkify;
-// Order matters: we look in priority in localized folder
-function getContentPathList(contentPaths) {
-    return [contentPaths.contentPathLocalized, contentPaths.contentPath];
-}
-exports.getContentPathList = getContentPathList;

package/lib/feed.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 { DocusaurusConfig } from '@docusaurus/types';
+import type { PluginOptions, BlogPost } from '@docusaurus/plugin-content-blog';
+export declare function createBlogFeedFiles({ blogPosts, options, siteConfig, outDir, locale, }: {
+    blogPosts: BlogPost[];
+    options: PluginOptions;
+    siteConfig: DocusaurusConfig;
+    outDir: string;
+    locale: string;
+}): Promise<void>;