@docusaurus/plugin-content-blog 2.0.0-beta.138b4c997 → 2.0.0-beta.14

package/lib/authors.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { Author, BlogContentPaths } from './types';
+import { BlogPostFrontMatter } from './blogFrontMatter';
+export declare type AuthorsMap = Record<string, Author>;
+export declare function validateAuthorsMapFile(content: unknown): AuthorsMap;
+export declare function readAuthorsMapFile(filePath: string): Promise<AuthorsMap | undefined>;
+declare type AuthorsMapParams = {
+    authorsMapPath: string;
+    contentPaths: BlogContentPaths;
+};
+export declare function getAuthorsMapFilePath({ authorsMapPath, contentPaths, }: AuthorsMapParams): Promise<string | undefined>;
+export declare function getAuthorsMap(params: AuthorsMapParams): 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,147 @@
+"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.getAuthorsMapFilePath = exports.readAuthorsMapFile = exports.validateAuthorsMapFile = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = (0, tslib_1.__importDefault)(require("fs-extra"));
+const logger_1 = (0, tslib_1.__importDefault)(require("@docusaurus/logger"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const utils_1 = require("@docusaurus/utils");
+const utils_validation_1 = require("@docusaurus/utils-validation");
+const blogUtils_1 = require("./blogUtils");
+const js_yaml_1 = (0, tslib_1.__importDefault)(require("js-yaml"));
+const AuthorsMapSchema = utils_validation_1.Joi.object().pattern(utils_validation_1.Joi.string(), utils_validation_1.Joi.object({
+    name: utils_validation_1.Joi.string().required(),
+    url: utils_validation_1.URISchema,
+    imageURL: utils_validation_1.URISchema,
+    title: utils_validation_1.Joi.string(),
+})
+    .rename('image_url', 'imageURL')
+    .unknown()
+    .required());
+function validateAuthorsMapFile(content) {
+    return utils_validation_1.Joi.attempt(content, AuthorsMapSchema);
+}
+exports.validateAuthorsMapFile = validateAuthorsMapFile;
+async function readAuthorsMapFile(filePath) {
+    if (await fs_extra_1.default.pathExists(filePath)) {
+        const contentString = await fs_extra_1.default.readFile(filePath, { encoding: 'utf8' });
+        try {
+            const unsafeContent = js_yaml_1.default.load(contentString);
+            return validateAuthorsMapFile(unsafeContent);
+        }
+        catch (e) {
+            // TODO replace later by error cause: see https://v8.dev/features/error-cause
+            logger_1.default.error('The author list file looks invalid!');
+            throw e;
+        }
+    }
+    return undefined;
+}
+exports.readAuthorsMapFile = readAuthorsMapFile;
+async function getAuthorsMapFilePath({ authorsMapPath, contentPaths, }) {
+    // Useful to load an eventually localize authors map
+    const contentPath = await (0, utils_1.findFolderContainingFile)((0, blogUtils_1.getContentPathList)(contentPaths), authorsMapPath);
+    if (contentPath) {
+        return path_1.default.join(contentPath, authorsMapPath);
+    }
+    return undefined;
+}
+exports.getAuthorsMapFilePath = getAuthorsMapFilePath;
+async function getAuthorsMap(params) {
+    const filePath = await getAuthorsMapFilePath(params);
+    if (!filePath) {
+        return undefined;
+    }
+    try {
+        return await readAuthorsMapFile(filePath);
+    }
+    catch (e) {
+        // TODO replace later by error cause, see https://v8.dev/features/error-cause
+        logger_1.default.error `Couldn't read blog authors map at path=${filePath}`;
+        throw e;
+    }
+}
+exports.getAuthorsMap = getAuthorsMap;
+// Legacy v1/early-v2 frontmatter fields
+// We may want to deprecate those in favor of using only frontMatter.authors
+function getFrontMatterAuthorLegacy(frontMatter) {
+    var _a, _b, _c;
+    const name = frontMatter.author;
+    const title = (_a = frontMatter.author_title) !== null && _a !== void 0 ? _a : frontMatter.authorTitle;
+    const url = (_b = frontMatter.author_url) !== null && _b !== void 0 ? _b : frontMatter.authorURL;
+    const imageURL = (_c = frontMatter.author_image_url) !== null && _c !== void 0 ? _c : frontMatter.authorImageURL;
+    // Shouldn't we require at least an author name?
+    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
+            // IMHO it's better to only support keys here
+            // Reason: a typo in a key would fallback to becoming a name and may end-up un-noticed
+            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 frontmatter
+            ...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 frontmatter, but do we really want to?
+        if (authors.length > 0) {
+            throw new Error(`To declare blog post authors, use the 'authors' FrontMatter in priority.
+Don't mix 'authors' with other existing 'author_*' FrontMatter. Choose one or the other, not both at the same time.`);
+        }
+        return [authorLegacy];
+    }
+    return authors;
+}
+exports.getBlogPostAuthors = getBlogPostAuthors;

package/lib/blogFrontMatter.d.ts

@@ -4,25 +4,38 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { Tag } from './types';
+import type { FrontMatterTag } from '@docusaurus/utils';
+export declare type BlogPostFrontMatterAuthor = Record<string, unknown> & {
+    key?: string;
+    name?: string;
+    imageURL?: string;
+    url?: string;
+    title?: string;
+};
+export declare type BlogPostFrontMatterAuthors = string | BlogPostFrontMatterAuthor | (string | BlogPostFrontMatterAuthor)[];
 export declare type BlogPostFrontMatter = {
     id?: string;
     title?: string;
     description?: string;
-    tags?: (string | Tag)[];
+    tags?: FrontMatterTag[];
     slug?: string;
     draft?: boolean;
-    date?: Date;
+    date?: Date | string;
+    authors?: BlogPostFrontMatterAuthors;
     author?: string;
     author_title?: string;
     author_url?: string;
     author_image_url?: string;
-    image?: string;
-    keywords?: string[];
-    hide_table_of_contents?: boolean;
     /** @deprecated */
     authorTitle?: string;
+    /** @deprecated */
     authorURL?: string;
+    /** @deprecated */
     authorImageURL?: string;
+    image?: string;
+    keywords?: string[];
+    hide_table_of_contents?: boolean;
+    toc_min_heading_level?: number;
+    toc_max_heading_level?: number;
 };
 export declare function validateBlogPostFrontMatter(frontMatter: Record<string, unknown>): BlogPostFrontMatter;

package/lib/blogFrontMatter.js

@@ -7,44 +7,56 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateBlogPostFrontMatter = void 0;
-/* eslint-disable camelcase */
 const utils_validation_1 = require("@docusaurus/utils-validation");
-// NOTE: we don't add any default value on purpose here
-// We don't want default values to magically appear in doc metadatas and props
-// While the user did not provide those values explicitly
-// We use default values in code instead
-const BlogTagSchema = utils_validation_1.JoiFrontMatter.alternatives().try(utils_validation_1.JoiFrontMatter.string().required(), utils_validation_1.JoiFrontMatter.object({
-    label: utils_validation_1.JoiFrontMatter.string().required(),
-    permalink: utils_validation_1.JoiFrontMatter.string().required(),
-}));
+const BlogPostFrontMatterAuthorSchema = utils_validation_1.JoiFrontMatter.object({
+    key: utils_validation_1.JoiFrontMatter.string(),
+    name: utils_validation_1.JoiFrontMatter.string(),
+    title: utils_validation_1.JoiFrontMatter.string(),
+    url: utils_validation_1.URISchema,
+    imageURL: utils_validation_1.JoiFrontMatter.string(),
+})
+    .or('key', 'name')
+    .rename('image_url', 'imageURL', { alias: true });
+const FrontMatterAuthorErrorMessage = '{{#label}} does not look like a valid blog post author. Please use an author key or an author object (with a key and/or name).';
 const BlogFrontMatterSchema = utils_validation_1.JoiFrontMatter.object({
     id: utils_validation_1.JoiFrontMatter.string(),
     title: utils_validation_1.JoiFrontMatter.string().allow(''),
     description: utils_validation_1.JoiFrontMatter.string().allow(''),
-    tags: utils_validation_1.JoiFrontMatter.array().items(BlogTagSchema),
+    tags: utils_validation_1.FrontMatterTagsSchema,
     draft: utils_validation_1.JoiFrontMatter.boolean(),
     date: utils_validation_1.JoiFrontMatter.date().raw(),
+    // New multi-authors frontmatter:
+    authors: utils_validation_1.JoiFrontMatter.alternatives()
+        .try(utils_validation_1.JoiFrontMatter.string(), BlogPostFrontMatterAuthorSchema, utils_validation_1.JoiFrontMatter.array()
+        .items(utils_validation_1.JoiFrontMatter.string(), BlogPostFrontMatterAuthorSchema)
+        .messages({
+        'array.sparse': FrontMatterAuthorErrorMessage,
+        'array.includes': FrontMatterAuthorErrorMessage,
+    }))
+        .messages({
+        'alternatives.match': FrontMatterAuthorErrorMessage,
+    }),
+    // Legacy author frontmatter
     author: utils_validation_1.JoiFrontMatter.string(),
     author_title: utils_validation_1.JoiFrontMatter.string(),
     author_url: utils_validation_1.URISchema,
     author_image_url: utils_validation_1.URISchema,
-    slug: utils_validation_1.JoiFrontMatter.string(),
-    image: utils_validation_1.URISchema,
-    keywords: utils_validation_1.JoiFrontMatter.array().items(utils_validation_1.JoiFrontMatter.string().required()),
-    hide_table_of_contents: utils_validation_1.JoiFrontMatter.boolean(),
-    // TODO re-enable warnings later, our v1 blog posts use those older frontmatter fields
+    // TODO enable deprecation warnings later
     authorURL: utils_validation_1.URISchema,
     // .warning('deprecate.error', { alternative: '"author_url"'}),
     authorTitle: utils_validation_1.JoiFrontMatter.string(),
     // .warning('deprecate.error', { alternative: '"author_title"'}),
     authorImageURL: utils_validation_1.URISchema,
     // .warning('deprecate.error', { alternative: '"author_image_url"'}),
-})
-    .unknown()
-    .messages({
+    slug: utils_validation_1.JoiFrontMatter.string(),
+    image: utils_validation_1.URISchema,
+    keywords: utils_validation_1.JoiFrontMatter.array().items(utils_validation_1.JoiFrontMatter.string().required()),
+    hide_table_of_contents: utils_validation_1.JoiFrontMatter.boolean(),
+    ...utils_validation_1.FrontMatterTOCHeadingLevels,
+}).messages({
     'deprecate.error': '{#label} blog frontMatter field is deprecated. Please use {#alternative} instead.',
 });
 function validateBlogPostFrontMatter(frontMatter) {
-    return utils_validation_1.validateFrontMatter(frontMatter, BlogFrontMatterSchema);
+    return (0, utils_validation_1.validateFrontMatter)(frontMatter, BlogFrontMatterSchema);
 }
 exports.validateBlogPostFrontMatter = validateBlogPostFrontMatter;

package/lib/blogUtils.d.ts

@@ -4,16 +4,22 @@
  * 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 { PluginOptions, BlogPost, BlogContentPaths, BlogMarkdownLoaderOptions, BlogTags } from './types';
 import { LoadContext } from '@docusaurus/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 getBlogTags(blogPosts: BlogPost[]): 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,34 +6,52 @@
  * 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.getContentPathList = exports.linkify = exports.generateBlogPosts = exports.parseBlogFileName = exports.getBlogTags = 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 reading_time_1 = tslib_1.__importDefault(require("reading-time"));
-const feed_1 = require("feed");
+const fs_extra_1 = (0, tslib_1.__importDefault)(require("fs-extra"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const reading_time_1 = (0, tslib_1.__importDefault)(require("reading-time"));
 const lodash_1 = require("lodash");
 const utils_1 = require("@docusaurus/utils");
 const blogFrontMatter_1 = require("./blogFrontMatter");
+const authors_1 = require("./authors");
+const logger_1 = (0, tslib_1.__importDefault)(require("@docusaurus/logger"));
 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 (0, lodash_1.mapValues)((0, lodash_1.keyBy)(blogPosts, (item) => item.metadata.source), (v) => v.metadata.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 getBlogTags(blogPosts) {
+    const groups = (0, utils_1.groupTaggedItems)(blogPosts, (blogPost) => blogPost.metadata.tags);
+    return (0, lodash_1.mapValues)(groups, (group) => ({
+        name: group.tag.label,
+        items: group.items.map((item) => item.id),
+        permalink: group.tag.permalink,
+    }));
+}
+exports.getBlogTags = getBlogTags;
+const DATE_FILENAME_REGEX = /^(?<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 dateString = dateFilenameMatch.groups.date;
+        const text = dateFilenameMatch.groups.text;
+        // Always treat dates as UTC by adding the `Z`
+        const date = new Date(`${dateString}Z`);
+        const slugDate = dateString.replace(/-/g, '/');
+        const slug = `/${slugDate}/${text}`;
+        return { date, text, slug };
+    }
+    else {
+        const text = blogSourceRelative.replace(/(\/index)?\.mdx?$/, '');
+        const slug = `/${text}`;
+        return { date: undefined, text, slug };
+    }
 }
+exports.parseBlogFileName = parseBlogFileName;
 function formatBlogPostDate(locale, date) {
     try {
         return new Intl.DateTimeFormat(locale, {
@@ -47,146 +65,133 @@ function formatBlogPostDate(locale, date) {
         throw new Error(`Can't format blog post date "${date}"`);
     }
 }
-async function generateBlogFeed(contentPaths, context, options) {
-    if (!options.feedOptions) {
-        throw new Error('Invalid options: "feedOptions" is not expected to be null.');
-    }
-    const { siteConfig } = context;
-    const blogPosts = await generateBlogPosts(contentPaths, context, options);
-    if (!blogPosts.length) {
-        return null;
-    }
-    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,
-        });
+async function parseBlogPostMarkdownFile(blogSourceAbsolute) {
+    const result = await (0, utils_1.parseMarkdownFile)(blogSourceAbsolute, {
+        removeContentTitle: true,
     });
-    return feed;
+    return {
+        ...result,
+        frontMatter: (0, blogFrontMatter_1.validateBlogPostFrontMatter)(result.frontMatter),
+    };
 }
-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) {
+    var _a, _b, _c, _d;
+    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)(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;
+            return new 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;
-            }
+        else if (parsedBlogFileName.date) {
+            return parsedBlogFileName.date;
         }
-        blogPosts.push({
-            id: (_e = frontMatter.slug) !== null && _e !== void 0 ? _e : title,
-            metadata: {
+        // Fallback to file create time
+        return (await fs_extra_1.default.stat(blogSourceAbsolute)).birthtime;
+    }
+    const date = await getDate();
+    const formattedDate = formatBlogPostDate(i18n.currentLocale, date);
+    const title = (_b = (_a = frontMatter.title) !== null && _a !== void 0 ? _a : contentTitle) !== null && _b !== void 0 ? _b : parsedBlogFileName.text;
+    const description = (_d = (_c = frontMatter.description) !== null && _c !== void 0 ? _c : excerpt) !== null && _d !== void 0 ? _d : '';
+    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;
+    }
+    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 === null || truncateMarker === void 0 ? void 0 : truncateMarker.test(content)) || false,
+            authors,
+        },
+        content,
+    };
+}
+async function generateBlogPosts(contentPaths, context, options) {
+    const { include, exclude } = options;
+    if (!fs_extra_1.default.existsSync(contentPaths.contentPath)) {
+        return [];
     }
-    await Promise.all(blogSourceFiles.map(async (blogSourceFile) => {
+    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}"`));
+            logger_1.default.error `Processing of blog source file failed for path path=${blogSourceFile}.`;
             throw e;
         }
-    }));
+    }))).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,