mirror of
https://github.com/Snigdha-OS/documentation.git
synced 2025-09-10 19:54:57 +02:00
367 lines
17 KiB
JavaScript
367 lines
17 KiB
JavaScript
"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.validateOptions = void 0;
|
|
const tslib_1 = require("tslib");
|
|
const path_1 = tslib_1.__importDefault(require("path"));
|
|
const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
|
|
const utils_1 = require("@docusaurus/utils");
|
|
const blogUtils_1 = require("./blogUtils");
|
|
const footnoteIDFixer_1 = tslib_1.__importDefault(require("./remark/footnoteIDFixer"));
|
|
const translations_1 = require("./translations");
|
|
const feed_1 = require("./feed");
|
|
const props_1 = require("./props");
|
|
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: (0, utils_1.getPluginI18nPath)({
|
|
localizationDir,
|
|
pluginName: 'docusaurus-plugin-content-blog',
|
|
pluginId: options.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/${(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;
|
|
const contentMarkdownGlobs = (0, utils_1.getContentPathList)(contentPaths).flatMap((contentPath) => include.map((pattern) => `${contentPath}/${pattern}`));
|
|
return [authorsMapFilePath, ...contentMarkdownGlobs].filter(Boolean);
|
|
},
|
|
getTranslationFiles() {
|
|
return (0, translations_1.getTranslationFiles)(options);
|
|
},
|
|
// Fetches blog contents and returns metadata for the necessary routes.
|
|
async loadContent() {
|
|
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);
|
|
const listedBlogPosts = blogPosts.filter(blogUtils_1.shouldBeListed);
|
|
if (!blogPosts.length) {
|
|
return {
|
|
blogSidebarTitle,
|
|
blogPosts: [],
|
|
blogListPaginated: [],
|
|
blogTags: {},
|
|
blogTagsListPath,
|
|
blogTagsPaginated: [],
|
|
};
|
|
}
|
|
// Colocate next and prev metadata.
|
|
listedBlogPosts.forEach((blogPost, index) => {
|
|
const prevItem = index > 0 ? listedBlogPosts[index - 1] : null;
|
|
if (prevItem) {
|
|
blogPost.metadata.prevItem = {
|
|
title: prevItem.metadata.title,
|
|
permalink: prevItem.metadata.permalink,
|
|
};
|
|
}
|
|
const nextItem = index < listedBlogPosts.length - 1
|
|
? listedBlogPosts[index + 1]
|
|
: null;
|
|
if (nextItem) {
|
|
blogPost.metadata.nextItem = {
|
|
title: nextItem.metadata.title,
|
|
permalink: nextItem.metadata.permalink,
|
|
};
|
|
}
|
|
});
|
|
const blogListPaginated = (0, blogUtils_1.paginateBlogPosts)({
|
|
blogPosts: listedBlogPosts,
|
|
blogTitle,
|
|
blogDescription,
|
|
postsPerPageOption,
|
|
basePageUrl: baseBlogUrl,
|
|
});
|
|
const blogTags = (0, blogUtils_1.getBlogTags)({
|
|
blogPosts,
|
|
postsPerPageOption,
|
|
blogDescription,
|
|
blogTitle,
|
|
});
|
|
return {
|
|
blogSidebarTitle,
|
|
blogPosts,
|
|
blogListPaginated,
|
|
blogTags,
|
|
blogTagsListPath,
|
|
};
|
|
},
|
|
async contentLoaded({ content: blogContents, actions }) {
|
|
const { blogListComponent, blogPostComponent, blogTagsListComponent, blogTagsPostsComponent, blogArchiveComponent, routeBasePath, archiveBasePath, } = options;
|
|
const { addRoute, createData } = actions;
|
|
const { blogSidebarTitle, blogPosts, blogListPaginated, blogTags, blogTagsListPath, } = blogContents;
|
|
const listedBlogPosts = blogPosts.filter(blogUtils_1.shouldBeListed);
|
|
const blogItemsToMetadata = {};
|
|
const sidebarBlogPosts = options.blogSidebarCount === 'ALL'
|
|
? blogPosts
|
|
: 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 && listedBlogPosts.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: listedBlogPosts }, 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: blogSidebarTitle,
|
|
items: sidebarBlogPosts.map((blogPost) => ({
|
|
title: blogPost.metadata.title,
|
|
permalink: blogPost.metadata.permalink,
|
|
unlisted: blogPost.metadata.unlisted,
|
|
})),
|
|
}, null, 2));
|
|
// Create routes for blog entries.
|
|
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.
|
|
`${(0, utils_1.docuHash)(metadata.source)}.json`, JSON.stringify(metadata, null, 2));
|
|
addRoute({
|
|
path: metadata.permalink,
|
|
component: blogPostComponent,
|
|
exact: true,
|
|
modules: {
|
|
sidebar: aliasedSource(sidebarProp),
|
|
content: metadata.source,
|
|
},
|
|
});
|
|
blogItemsToMetadata[id] = metadata;
|
|
}));
|
|
// Create routes for blog's paginated list entries.
|
|
await Promise.all(blogListPaginated.map(async (listPage) => {
|
|
const { metadata, items } = listPage;
|
|
const { permalink } = metadata;
|
|
const pageMetadataPath = await createData(`${(0, utils_1.docuHash)(permalink)}.json`, JSON.stringify(metadata, null, 2));
|
|
addRoute({
|
|
path: permalink,
|
|
component: blogListComponent,
|
|
exact: true,
|
|
modules: {
|
|
sidebar: aliasedSource(sidebarProp),
|
|
items: blogPostItemsModule(items),
|
|
metadata: aliasedSource(pageMetadataPath),
|
|
},
|
|
});
|
|
}));
|
|
// Tags. This is the last part so we early-return if there are no tags.
|
|
if (Object.keys(blogTags).length === 0) {
|
|
return;
|
|
}
|
|
async function createTagsListPage() {
|
|
const tagsPropPath = await createData(`${(0, utils_1.docuHash)(`${blogTagsListPath}-tags`)}.json`, JSON.stringify((0, props_1.toTagsProp)({ blogTags }), null, 2));
|
|
addRoute({
|
|
path: blogTagsListPath,
|
|
component: blogTagsListComponent,
|
|
exact: true,
|
|
modules: {
|
|
sidebar: aliasedSource(sidebarProp),
|
|
tags: aliasedSource(tagsPropPath),
|
|
},
|
|
});
|
|
}
|
|
async function createTagPostsListPage(tag) {
|
|
await Promise.all(tag.pages.map(async (blogPaginated) => {
|
|
const { metadata, items } = blogPaginated;
|
|
const tagPropPath = await createData(`${(0, utils_1.docuHash)(metadata.permalink)}.json`, JSON.stringify((0, props_1.toTagProp)({ tag, blogTagsListPath }), 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, utils, content) {
|
|
const { admonitions, rehypePlugins, remarkPlugins, truncateMarker, beforeDefaultRemarkPlugins, beforeDefaultRehypePlugins, } = options;
|
|
const markdownLoaderOptions = {
|
|
siteDir,
|
|
contentPaths,
|
|
truncateMarker,
|
|
sourceToPermalink: (0, blogUtils_1.getSourceToPermalink)(content.blogPosts),
|
|
onBrokenMarkdownLink: (brokenMarkdownLink) => {
|
|
if (onBrokenMarkdownLinks === 'ignore') {
|
|
return;
|
|
}
|
|
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: {
|
|
'~blog': pluginDataDirRoot,
|
|
},
|
|
},
|
|
module: {
|
|
rules: [
|
|
{
|
|
test: /\.mdx?$/i,
|
|
include: contentDirs
|
|
// Trailing slash is important, see https://github.com/facebook/docusaurus/pull/3970
|
|
.map(utils_1.addTrailingPathSeparator),
|
|
use: [
|
|
{
|
|
loader: require.resolve('@docusaurus/mdx-loader'),
|
|
options: {
|
|
admonitions,
|
|
remarkPlugins,
|
|
rehypePlugins,
|
|
beforeDefaultRemarkPlugins: [
|
|
footnoteIDFixer_1.default,
|
|
...beforeDefaultRemarkPlugins,
|
|
],
|
|
beforeDefaultRehypePlugins,
|
|
staticDirs: siteConfig.staticDirectories.map((dir) => path_1.default.resolve(siteDir, dir)),
|
|
siteDir,
|
|
isMDXPartial: (0, utils_1.createAbsoluteFilePathMatcher)(options.exclude, contentDirs),
|
|
metadataPath: (mdxPath) => {
|
|
// 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),
|
|
}),
|
|
markdownConfig: siteConfig.markdown,
|
|
},
|
|
},
|
|
{
|
|
loader: path_1.default.resolve(__dirname, './markdownLoader.js'),
|
|
options: markdownLoaderOptions,
|
|
},
|
|
].filter(Boolean),
|
|
},
|
|
],
|
|
},
|
|
};
|
|
},
|
|
async postBuild({ outDir, content }) {
|
|
if (!options.feedOptions.type) {
|
|
return;
|
|
}
|
|
const { blogPosts } = content;
|
|
if (!blogPosts.length) {
|
|
return;
|
|
}
|
|
await (0, feed_1.createBlogFeedFiles)({
|
|
blogPosts,
|
|
options,
|
|
outDir,
|
|
siteConfig,
|
|
locale: currentLocale,
|
|
});
|
|
},
|
|
injectHtmlTags({ content }) {
|
|
if (!content.blogPosts.length || !options.feedOptions.type) {
|
|
return {};
|
|
}
|
|
const feedTypes = options.feedOptions.type;
|
|
const feedTitle = options.feedOptions.title ?? context.siteConfig.title;
|
|
const feedsConfig = {
|
|
rss: {
|
|
type: 'application/rss+xml',
|
|
path: 'rss.xml',
|
|
title: `${feedTitle} RSS Feed`,
|
|
},
|
|
atom: {
|
|
type: 'application/atom+xml',
|
|
path: 'atom.xml',
|
|
title: `${feedTitle} Atom Feed`,
|
|
},
|
|
json: {
|
|
type: 'application/json',
|
|
path: 'feed.json',
|
|
title: `${feedTitle} JSON Feed`,
|
|
},
|
|
};
|
|
const headTags = [];
|
|
feedTypes.forEach((feedType) => {
|
|
const { type, path: feedConfigPath, title: feedConfigTitle, } = feedsConfig[feedType];
|
|
headTags.push({
|
|
tagName: 'link',
|
|
attributes: {
|
|
rel: 'alternate',
|
|
type,
|
|
href: (0, utils_1.normalizeUrl)([
|
|
baseUrl,
|
|
options.routeBasePath,
|
|
feedConfigPath,
|
|
]),
|
|
title: feedConfigTitle,
|
|
},
|
|
});
|
|
});
|
|
return {
|
|
headTags,
|
|
};
|
|
},
|
|
};
|
|
}
|
|
exports.default = pluginContentBlog;
|
|
var options_1 = require("./options");
|
|
Object.defineProperty(exports, "validateOptions", { enumerable: true, get: function () { return options_1.validateOptions; } });
|