@docusaurus/plugin-content-blog 2.0.0-beta.ff31de0ff → 2.0.1

package/lib/index.js

@@ -8,57 +8,57 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 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 remark_admonitions_1 = tslib_1.__importDefault(require("remark-admonitions"));
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const utils_1 = require("@docusaurus/utils");
-const constants_1 = require("@docusaurus/core/lib/constants");
-const lodash_1 = require("lodash");
-const pluginOptionSchema_1 = require("./pluginOptionSchema");
 const blogUtils_1 = require("./blogUtils");
-function pluginContentBlog(context, options) {
-    var _a;
-    if (options.admonitions) {
-        options.remarkPlugins = options.remarkPlugins.concat([
-            [remark_admonitions_1.default, options.admonitions],
-        ]);
-    }
-    const { siteDir, siteConfig: { onBrokenMarkdownLinks }, generatedFilesDir, i18n: { currentLocale }, } = context;
+const footnoteIDFixer_1 = tslib_1.__importDefault(require("./remark/footnoteIDFixer"));
+const translations_1 = require("./translations");
+const feed_1 = require("./feed");
+async function pluginContentBlog(context, options) {
+    const { siteDir, siteConfig, generatedFilesDir, localizationDir, i18n: { currentLocale }, } = context;
+    const { onBrokenMarkdownLinks, baseUrl } = siteConfig;
     const contentPaths = {
         contentPath: path_1.default.resolve(siteDir, options.path),
-        contentPathLocalized: utils_1.getPluginI18nPath({
-            siteDir,
-            locale: currentLocale,
+        contentPathLocalized: (0, utils_1.getPluginI18nPath)({
+            localizationDir,
             pluginName: 'docusaurus-plugin-content-blog',
             pluginId: options.id,
         }),
     };
-    const pluginId = (_a = options.id) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_PLUGIN_ID;
+    const pluginId = options.id ?? utils_1.DEFAULT_PLUGIN_ID;
     const pluginDataDirRoot = path_1.default.join(generatedFilesDir, 'docusaurus-plugin-content-blog');
     const dataDir = path_1.default.join(pluginDataDirRoot, pluginId);
-    const aliasedSource = (source) => `~blog/${utils_1.posixPath(path_1.default.relative(pluginDataDirRoot, source))}`;
-    let blogPosts = [];
+    const aliasedSource = (source) => `~blog/${(0, utils_1.posixPath)(path_1.default.relative(pluginDataDirRoot, source))}`;
+    const authorsMapFilePath = await (0, utils_1.getDataFilePath)({
+        filePath: options.authorsMapPath,
+        contentPaths,
+    });
     return {
         name: 'docusaurus-plugin-content-blog',
         getPathsToWatch() {
-            const { include = [] } = options;
-            return lodash_1.flatten(blogUtils_1.getContentPathList(contentPaths).map((contentPath) => {
-                return include.map((pattern) => `${contentPath}/${pattern}`);
-            }));
+            const { include } = options;
+            const contentMarkdownGlobs = (0, utils_1.getContentPathList)(contentPaths).flatMap((contentPath) => include.map((pattern) => `${contentPath}/${pattern}`));
+            return [authorsMapFilePath, ...contentMarkdownGlobs].filter(Boolean);
         },
-        getClientModules() {
-            const modules = [];
-            if (options.admonitions) {
-                modules.push(require.resolve('remark-admonitions/styles/infima.css'));
-            }
-            return modules;
+        getTranslationFiles() {
+            return (0, translations_1.getTranslationFiles)(options);
         },
         // Fetches blog contents and returns metadata for the necessary routes.
         async loadContent() {
-            const { postsPerPage, routeBasePath } = options;
-            blogPosts = await blogUtils_1.generateBlogPosts(contentPaths, context, options);
+            const { postsPerPage: postsPerPageOption, routeBasePath, tagsBasePath, blogDescription, blogTitle, blogSidebarTitle, } = options;
+            const baseBlogUrl = (0, utils_1.normalizeUrl)([baseUrl, routeBasePath]);
+            const blogTagsListPath = (0, utils_1.normalizeUrl)([baseBlogUrl, tagsBasePath]);
+            const blogPosts = await (0, blogUtils_1.generateBlogPosts)(contentPaths, context, options);
             if (!blogPosts.length) {
-                return null;
+                return {
+                    blogSidebarTitle,
+                    blogPosts: [],
+                    blogListPaginated: [],
+                    blogTags: {},
+                    blogTagsListPath,
+                    blogTagsPaginated: [],
+                };
             }
             // Colocate next and prev metadata.
             blogPosts.forEach((blogPost, index) => {
@@ -77,72 +77,21 @@ function pluginContentBlog(context, options) {
                     };
                 }
             });
-            // Blog pagination routes.
-            // Example: `/blog`, `/blog/page/1`, `/blog/page/2`
-            const totalCount = blogPosts.length;
-            const numberOfPages = Math.ceil(totalCount / postsPerPage);
-            const { siteConfig: { baseUrl = '' }, } = context;
-            const basePageUrl = utils_1.normalizeUrl([baseUrl, routeBasePath]);
-            const blogListPaginated = [];
-            function blogPaginationPermalink(page) {
-                return page > 0
-                    ? utils_1.normalizeUrl([basePageUrl, `page/${page + 1}`])
-                    : basePageUrl;
-            }
-            for (let page = 0; page < numberOfPages; page += 1) {
-                blogListPaginated.push({
-                    metadata: {
-                        permalink: blogPaginationPermalink(page),
-                        page: page + 1,
-                        postsPerPage,
-                        totalPages: numberOfPages,
-                        totalCount,
-                        previousPage: page !== 0 ? blogPaginationPermalink(page - 1) : null,
-                        nextPage: page < numberOfPages - 1
-                            ? blogPaginationPermalink(page + 1)
-                            : null,
-                        blogDescription: options.blogDescription,
-                        blogTitle: options.blogTitle,
-                    },
-                    items: blogPosts
-                        .slice(page * postsPerPage, (page + 1) * postsPerPage)
-                        .map((item) => item.id),
-                });
-            }
-            const blogTags = {};
-            const tagsPath = utils_1.normalizeUrl([basePageUrl, 'tags']);
-            blogPosts.forEach((blogPost) => {
-                const { tags } = blogPost.metadata;
-                if (!tags || tags.length === 0) {
-                    // TODO: Extract tags out into a separate plugin.
-                    // eslint-disable-next-line no-param-reassign
-                    blogPost.metadata.tags = [];
-                    return;
-                }
-                // eslint-disable-next-line no-param-reassign
-                blogPost.metadata.tags = tags.map((tag) => {
-                    if (typeof tag === 'string') {
-                        const normalizedTag = lodash_1.kebabCase(tag);
-                        const permalink = utils_1.normalizeUrl([tagsPath, normalizedTag]);
-                        if (!blogTags[normalizedTag]) {
-                            blogTags[normalizedTag] = {
-                                // Will only use the name of the first occurrence of the tag.
-                                name: tag.toLowerCase(),
-                                items: [],
-                                permalink,
-                            };
-                        }
-                        blogTags[normalizedTag].items.push(blogPost.id);
-                        return {
-                            label: tag,
-                            permalink,
-                        };
-                    }
-                    return tag;
-                });
+            const blogListPaginated = (0, blogUtils_1.paginateBlogPosts)({
+                blogPosts,
+                blogTitle,
+                blogDescription,
+                postsPerPageOption,
+                basePageUrl: baseBlogUrl,
+            });
+            const blogTags = (0, blogUtils_1.getBlogTags)({
+                blogPosts,
+                postsPerPageOption,
+                blogDescription,
+                blogTitle,
             });
-            const blogTagsListPath = Object.keys(blogTags).length > 0 ? tagsPath : null;
             return {
+                blogSidebarTitle,
                 blogPosts,
                 blogListPaginated,
                 blogTags,
@@ -150,40 +99,68 @@ function pluginContentBlog(context, options) {
             };
         },
         async contentLoaded({ content: blogContents, actions }) {
-            if (!blogContents) {
-                return;
-            }
-            const { blogListComponent, blogPostComponent, blogTagsListComponent, blogTagsPostsComponent, } = options;
+            const { blogListComponent, blogPostComponent, blogTagsListComponent, blogTagsPostsComponent, blogArchiveComponent, routeBasePath, archiveBasePath, } = options;
             const { addRoute, createData } = actions;
-            const { blogPosts: loadedBlogPosts, blogListPaginated, blogTags, blogTagsListPath, } = blogContents;
+            const { blogSidebarTitle, blogPosts, blogListPaginated, blogTags, blogTagsListPath, } = blogContents;
             const blogItemsToMetadata = {};
             const sidebarBlogPosts = options.blogSidebarCount === 'ALL'
                 ? blogPosts
-                : lodash_1.take(blogPosts, options.blogSidebarCount);
+                : blogPosts.slice(0, options.blogSidebarCount);
+            function blogPostItemsModule(items) {
+                return items.map((postId) => {
+                    const blogPostMetadata = blogItemsToMetadata[postId];
+                    return {
+                        content: {
+                            __import: true,
+                            path: blogPostMetadata.source,
+                            query: {
+                                truncated: true,
+                            },
+                        },
+                    };
+                });
+            }
+            if (archiveBasePath && blogPosts.length) {
+                const archiveUrl = (0, utils_1.normalizeUrl)([
+                    baseUrl,
+                    routeBasePath,
+                    archiveBasePath,
+                ]);
+                // Create a blog archive route
+                const archiveProp = await createData(`${(0, utils_1.docuHash)(archiveUrl)}.json`, JSON.stringify({ blogPosts }, null, 2));
+                addRoute({
+                    path: archiveUrl,
+                    component: blogArchiveComponent,
+                    exact: true,
+                    modules: {
+                        archive: aliasedSource(archiveProp),
+                    },
+                });
+            }
             // This prop is useful to provide the blog list sidebar
             const sidebarProp = await createData(
             // Note that this created data path must be in sync with
             // metadataPath provided to mdx-loader.
             `blog-post-list-prop-${pluginId}.json`, JSON.stringify({
-                title: options.blogSidebarTitle,
+                title: blogSidebarTitle,
                 items: sidebarBlogPosts.map((blogPost) => ({
                     title: blogPost.metadata.title,
                     permalink: blogPost.metadata.permalink,
                 })),
             }, null, 2));
             // Create routes for blog entries.
-            await Promise.all(loadedBlogPosts.map(async (blogPost) => {
+            await Promise.all(blogPosts.map(async (blogPost) => {
                 const { id, metadata } = blogPost;
                 await createData(
                 // Note that this created data path must be in sync with
                 // metadataPath provided to mdx-loader.
-                `${utils_1.docuHash(metadata.source)}.json`, JSON.stringify(metadata, null, 2));
+                `${(0, utils_1.docuHash)(metadata.source)}.json`, JSON.stringify(metadata, null, 2));
                 addRoute({
                     path: metadata.permalink,
                     component: blogPostComponent,
                     exact: true,
                     modules: {
-                        sidebar: sidebarProp,
+                        sidebar: aliasedSource(sidebarProp),
                         content: metadata.source,
                     },
                 });
@@ -193,94 +170,84 @@ function pluginContentBlog(context, options) {
             await Promise.all(blogListPaginated.map(async (listPage) => {
                 const { metadata, items } = listPage;
                 const { permalink } = metadata;
-                const pageMetadataPath = await createData(`${utils_1.docuHash(permalink)}.json`, JSON.stringify(metadata, null, 2));
+                const pageMetadataPath = await createData(`${(0, utils_1.docuHash)(permalink)}.json`, JSON.stringify(metadata, null, 2));
                 addRoute({
                     path: permalink,
                     component: blogListComponent,
                     exact: true,
                     modules: {
-                        sidebar: sidebarProp,
-                        items: items.map((postID) => {
-                            // To tell routes.js this is an import and not a nested object to recurse.
-                            return {
-                                content: {
-                                    __import: true,
-                                    path: blogItemsToMetadata[postID].source,
-                                    query: {
-                                        truncated: true,
-                                    },
-                                },
-                            };
-                        }),
+                        sidebar: aliasedSource(sidebarProp),
+                        items: blogPostItemsModule(items),
                         metadata: aliasedSource(pageMetadataPath),
                     },
                 });
             }));
-            // Tags.
-            if (blogTagsListPath === null) {
+            // Tags. This is the last part so we early-return if there are no tags.
+            if (Object.keys(blogTags).length === 0) {
                 return;
             }
-            const tagsModule = {};
-            await Promise.all(Object.keys(blogTags).map(async (tag) => {
-                const { name, items, permalink } = blogTags[tag];
-                tagsModule[tag] = {
-                    allTagsPath: blogTagsListPath,
-                    slug: tag,
-                    name,
-                    count: items.length,
-                    permalink,
-                };
-                const tagsMetadataPath = await createData(`${utils_1.docuHash(permalink)}.json`, JSON.stringify(tagsModule[tag], null, 2));
-                addRoute({
-                    path: permalink,
-                    component: blogTagsPostsComponent,
-                    exact: true,
-                    modules: {
-                        sidebar: sidebarProp,
-                        items: items.map((postID) => {
-                            const metadata = blogItemsToMetadata[postID];
-                            return {
-                                content: {
-                                    __import: true,
-                                    path: metadata.source,
-                                    query: {
-                                        truncated: true,
-                                    },
-                                },
-                            };
-                        }),
-                        metadata: aliasedSource(tagsMetadataPath),
-                    },
-                });
-            }));
-            // Only create /tags page if there are tags.
-            if (Object.keys(blogTags).length > 0) {
-                const tagsListPath = await createData(`${utils_1.docuHash(`${blogTagsListPath}-tags`)}.json`, JSON.stringify(tagsModule, null, 2));
+            async function createTagsListPage() {
+                const tagsProp = Object.values(blogTags).map((tag) => ({
+                    label: tag.label,
+                    permalink: tag.permalink,
+                    count: tag.items.length,
+                }));
+                const tagsPropPath = await createData(`${(0, utils_1.docuHash)(`${blogTagsListPath}-tags`)}.json`, JSON.stringify(tagsProp, null, 2));
                 addRoute({
                     path: blogTagsListPath,
                     component: blogTagsListComponent,
                     exact: true,
                     modules: {
-                        sidebar: sidebarProp,
-                        tags: aliasedSource(tagsListPath),
+                        sidebar: aliasedSource(sidebarProp),
+                        tags: aliasedSource(tagsPropPath),
                     },
                 });
             }
+            async function createTagPostsListPage(tag) {
+                await Promise.all(tag.pages.map(async (blogPaginated) => {
+                    const { metadata, items } = blogPaginated;
+                    const tagProp = {
+                        label: tag.label,
+                        permalink: tag.permalink,
+                        allTagsPath: blogTagsListPath,
+                        count: tag.items.length,
+                    };
+                    const tagPropPath = await createData(`${(0, utils_1.docuHash)(metadata.permalink)}.json`, JSON.stringify(tagProp, null, 2));
+                    const listMetadataPath = await createData(`${(0, utils_1.docuHash)(metadata.permalink)}-list.json`, JSON.stringify(metadata, null, 2));
+                    addRoute({
+                        path: metadata.permalink,
+                        component: blogTagsPostsComponent,
+                        exact: true,
+                        modules: {
+                            sidebar: aliasedSource(sidebarProp),
+                            items: blogPostItemsModule(items),
+                            tag: aliasedSource(tagPropPath),
+                            listMetadata: aliasedSource(listMetadataPath),
+                        },
+                    });
+                }));
+            }
+            await createTagsListPage();
+            await Promise.all(Object.values(blogTags).map(createTagPostsListPage));
+        },
+        translateContent({ content, translationFiles }) {
+            return (0, translations_1.translateContent)(content, translationFiles);
         },
-        configureWebpack(_config, isServer, { getJSLoader }) {
-            const { rehypePlugins, remarkPlugins, truncateMarker, beforeDefaultRemarkPlugins, beforeDefaultRehypePlugins, } = options;
+        configureWebpack(_config, isServer, { getJSLoader }, content) {
+            const { admonitions, rehypePlugins, remarkPlugins, truncateMarker, beforeDefaultRemarkPlugins, beforeDefaultRehypePlugins, } = options;
             const markdownLoaderOptions = {
                 siteDir,
                 contentPaths,
                 truncateMarker,
-                sourceToPermalink: blogUtils_1.getSourceToPermalink(blogPosts),
+                sourceToPermalink: (0, blogUtils_1.getSourceToPermalink)(content.blogPosts),
                 onBrokenMarkdownLink: (brokenMarkdownLink) => {
                     if (onBrokenMarkdownLinks === 'ignore') {
                         return;
                     }
-                    utils_1.reportMessage(`Blog markdown link couldn't be resolved: (${brokenMarkdownLink.link}) in ${brokenMarkdownLink.filePath}`, onBrokenMarkdownLinks);
+                    logger_1.default.report(onBrokenMarkdownLinks) `Blog markdown link couldn't be resolved: (url=${brokenMarkdownLink.link}) in path=${brokenMarkdownLink.filePath}`;
                 },
             };
+            const contentDirs = (0, utils_1.getContentPathList)(contentPaths);
             return {
                 resolve: {
                     alias: {
@@ -290,8 +257,8 @@ function pluginContentBlog(context, options) {
                 module: {
                     rules: [
                         {
-                            test: /(\.mdx?)$/,
-                            include: blogUtils_1.getContentPathList(contentPaths)
+                            test: /\.mdx?$/i,
+                            include: contentDirs
                                 // Trailing slash is important, see https://github.com/facebook/docusaurus/pull/3970
                                 .map(utils_1.addTrailingPathSeparator),
                             use: [
@@ -299,17 +266,32 @@ function pluginContentBlog(context, options) {
                                 {
                                     loader: require.resolve('@docusaurus/mdx-loader'),
                                     options: {
+                                        admonitions,
                                         remarkPlugins,
                                         rehypePlugins,
-                                        beforeDefaultRemarkPlugins,
+                                        beforeDefaultRemarkPlugins: [
+                                            footnoteIDFixer_1.default,
+                                            ...beforeDefaultRemarkPlugins,
+                                        ],
                                         beforeDefaultRehypePlugins,
-                                        staticDir: path_1.default.join(siteDir, constants_1.STATIC_DIR_NAME),
-                                        // Note that metadataPath must be the same/in-sync as
-                                        // the path from createData for each MDX.
+                                        staticDirs: siteConfig.staticDirectories.map((dir) => path_1.default.resolve(siteDir, dir)),
+                                        siteDir,
+                                        isMDXPartial: (0, utils_1.createAbsoluteFilePathMatcher)(options.exclude, contentDirs),
                                         metadataPath: (mdxPath) => {
-                                            const aliasedPath = utils_1.aliasedSitePath(mdxPath, siteDir);
-                                            return path_1.default.join(dataDir, `${utils_1.docuHash(aliasedPath)}.json`);
+                                            // Note that metadataPath must be the same/in-sync as
+                                            // the path from createData for each MDX.
+                                            const aliasedPath = (0, utils_1.aliasedSitePath)(mdxPath, siteDir);
+                                            return path_1.default.join(dataDir, `${(0, utils_1.docuHash)(aliasedPath)}.json`);
                                         },
+                                        // For blog posts a title in markdown is always removed
+                                        // Blog posts title are rendered separately
+                                        removeContentTitle: true,
+                                        // Assets allow to convert some relative images paths to
+                                        // require() calls
+                                        createAssets: ({ frontMatter, metadata, }) => ({
+                                            image: frontMatter.image,
+                                            authorsImageUrls: metadata.authors.map((author) => author.imageURL),
+                                        }),
                                     },
                                 },
                                 {
@@ -322,59 +304,54 @@ function pluginContentBlog(context, options) {
                 },
             };
         },
-        async postBuild({ outDir }) {
-            var _a;
-            if (!((_a = options.feedOptions) === null || _a === void 0 ? void 0 : _a.type)) {
+        async postBuild({ outDir, content }) {
+            if (!options.feedOptions.type) {
                 return;
             }
-            const feed = await blogUtils_1.generateBlogFeed(contentPaths, context, options);
-            if (!feed) {
+            const { blogPosts } = content;
+            if (!blogPosts.length) {
                 return;
             }
-            const feedTypes = options.feedOptions.type;
-            await Promise.all(feedTypes.map(async (feedType) => {
-                const feedPath = path_1.default.join(outDir, options.routeBasePath, `${feedType}.xml`);
-                const feedContent = feedType === 'rss' ? feed.rss2() : feed.atom1();
-                try {
-                    await fs_extra_1.default.outputFile(feedPath, feedContent);
-                }
-                catch (err) {
-                    throw new Error(`Generating ${feedType} feed failed: ${err}`);
-                }
-            }));
+            await (0, feed_1.createBlogFeedFiles)({
+                blogPosts,
+                options,
+                outDir,
+                siteConfig,
+                locale: currentLocale,
+            });
         },
-        injectHtmlTags() {
-            var _a;
-            if (!((_a = options.feedOptions) === null || _a === void 0 ? void 0 : _a.type)) {
+        injectHtmlTags({ content }) {
+            if (!content.blogPosts.length || !options.feedOptions.type) {
                 return {};
             }
             const feedTypes = options.feedOptions.type;
-            const { siteConfig: { title }, baseUrl, } = context;
+            const feedTitle = options.feedOptions.title ?? context.siteConfig.title;
             const feedsConfig = {
                 rss: {
                     type: 'application/rss+xml',
                     path: 'rss.xml',
-                    title: `${title} Blog RSS Feed`,
+                    title: `${feedTitle} RSS Feed`,
                 },
                 atom: {
                     type: 'application/atom+xml',
                     path: 'atom.xml',
-                    title: `${title} Blog Atom Feed`,
+                    title: `${feedTitle} Atom Feed`,
+                },
+                json: {
+                    type: 'application/json',
+                    path: 'feed.json',
+                    title: `${feedTitle} JSON Feed`,
                 },
             };
             const headTags = [];
             feedTypes.forEach((feedType) => {
-                const feedConfig = feedsConfig[feedType] || {};
-                if (!feedsConfig) {
-                    return;
-                }
-                const { type, path: feedConfigPath, title: feedConfigTitle } = feedConfig;
+                const { type, path: feedConfigPath, title: feedConfigTitle, } = feedsConfig[feedType];
                 headTags.push({
                     tagName: 'link',
                     attributes: {
                         rel: 'alternate',
                         type,
-                        href: utils_1.normalizeUrl([
+                        href: (0, utils_1.normalizeUrl)([
                             baseUrl,
                             options.routeBasePath,
                             feedConfigPath,
@@ -390,8 +367,5 @@ function pluginContentBlog(context, options) {
     };
 }
 exports.default = pluginContentBlog;
-function validateOptions({ validate, options, }) {
-    const validatedOptions = validate(pluginOptionSchema_1.PluginOptionSchema, options);
-    return validatedOptions;
-}
-exports.validateOptions = validateOptions;
+var options_1 = require("./options");
+Object.defineProperty(exports, "validateOptions", { enumerable: true, get: function () { return options_1.validateOptions; } });

package/lib/markdownLoader.d.ts

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

package/lib/markdownLoader.js

@@ -7,25 +7,24 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const blogUtils_1 = require("./blogUtils");
-const loader_utils_1 = require("loader-utils");
-const markdownLoader = function (source) {
+function markdownLoader(source) {
     const filePath = this.resourcePath;
     const fileString = source;
     const callback = this.async();
     const markdownLoaderOptions = this.getOptions();
     // Linkify blog posts
-    let finalContent = blogUtils_1.linkify({
+    let finalContent = (0, blogUtils_1.linkify)({
         fileString,
         filePath,
         ...markdownLoaderOptions,
     });
     // Truncate content if requested (e.g: file.md?truncated=true).
     const truncated = this.resourceQuery
-        ? !!loader_utils_1.parseQuery(this.resourceQuery).truncated
+        ? !!new URLSearchParams(this.resourceQuery.slice(1)).get('truncated')
         : undefined;
     if (truncated) {
-        finalContent = blogUtils_1.truncate(finalContent, markdownLoaderOptions.truncateMarker);
+        finalContent = (0, blogUtils_1.truncate)(finalContent, markdownLoaderOptions.truncateMarker);
     }
-    return callback && callback(null, finalContent);
-};
+    return callback(null, finalContent);
+}
 exports.default = markdownLoader;

package/lib/options.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { PluginOptions, Options } from '@docusaurus/plugin-content-blog';
+import type { OptionValidationContext } from '@docusaurus/types';
+export declare const DEFAULT_OPTIONS: PluginOptions;
+export declare function validateOptions({ validate, options, }: OptionValidationContext<Options | undefined, PluginOptions>): PluginOptions;