up n_m

node_modules/@docusaurus/plugin-content-pages/lib/index.js

@@ -0,0 +1,188 @@
+"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 = exports.getContentPathList = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const utils_1 = require("@docusaurus/utils");
+const frontMatter_1 = require("./frontMatter");
+function getContentPathList(contentPaths) {
+    return [contentPaths.contentPathLocalized, contentPaths.contentPath];
+}
+exports.getContentPathList = getContentPathList;
+const isMarkdownSource = (source) => source.endsWith('.md') || source.endsWith('.mdx');
+function pluginContentPages(context, options) {
+    const { siteConfig, siteDir, generatedFilesDir, localizationDir } = context;
+    const contentPaths = {
+        contentPath: path_1.default.resolve(siteDir, options.path),
+        contentPathLocalized: (0, utils_1.getPluginI18nPath)({
+            localizationDir,
+            pluginName: 'docusaurus-plugin-content-pages',
+            pluginId: options.id,
+        }),
+    };
+    const pluginDataDirRoot = path_1.default.join(generatedFilesDir, 'docusaurus-plugin-content-pages');
+    const dataDir = path_1.default.join(pluginDataDirRoot, options.id ?? utils_1.DEFAULT_PLUGIN_ID);
+    return {
+        name: 'docusaurus-plugin-content-pages',
+        getPathsToWatch() {
+            const { include } = options;
+            return getContentPathList(contentPaths).flatMap((contentPath) => include.map((pattern) => `${contentPath}/${pattern}`));
+        },
+        async loadContent() {
+            const { include } = options;
+            if (!(await fs_extra_1.default.pathExists(contentPaths.contentPath))) {
+                return null;
+            }
+            const { baseUrl } = siteConfig;
+            const pagesFiles = await (0, utils_1.Globby)(include, {
+                cwd: contentPaths.contentPath,
+                ignore: options.exclude,
+            });
+            async function processPageSourceFile(relativeSource) {
+                // Lookup in localized folder in priority
+                const contentPath = await (0, utils_1.getFolderContainingFile)(getContentPathList(contentPaths), relativeSource);
+                const source = path_1.default.join(contentPath, relativeSource);
+                const aliasedSourcePath = (0, utils_1.aliasedSitePath)(source, siteDir);
+                const permalink = (0, utils_1.normalizeUrl)([
+                    baseUrl,
+                    options.routeBasePath,
+                    (0, utils_1.encodePath)((0, utils_1.fileToPath)(relativeSource)),
+                ]);
+                if (!isMarkdownSource(relativeSource)) {
+                    return {
+                        type: 'jsx',
+                        permalink,
+                        source: aliasedSourcePath,
+                    };
+                }
+                const content = await fs_extra_1.default.readFile(source, 'utf-8');
+                const { frontMatter: unsafeFrontMatter, contentTitle, excerpt, } = await (0, utils_1.parseMarkdownFile)({
+                    filePath: source,
+                    fileContent: content,
+                    parseFrontMatter: siteConfig.markdown.parseFrontMatter,
+                });
+                const frontMatter = (0, frontMatter_1.validatePageFrontMatter)(unsafeFrontMatter);
+                if ((0, utils_1.isDraft)({ frontMatter })) {
+                    return undefined;
+                }
+                const unlisted = (0, utils_1.isUnlisted)({ frontMatter });
+                return {
+                    type: 'mdx',
+                    permalink,
+                    source: aliasedSourcePath,
+                    title: frontMatter.title ?? contentTitle,
+                    description: frontMatter.description ?? excerpt,
+                    frontMatter,
+                    unlisted,
+                };
+            }
+            async function doProcessPageSourceFile(relativeSource) {
+                try {
+                    return await processPageSourceFile(relativeSource);
+                }
+                catch (err) {
+                    throw new Error(`Processing of page source file path=${relativeSource} failed.`, { cause: err });
+                }
+            }
+            return (await Promise.all(pagesFiles.map(doProcessPageSourceFile))).filter(Boolean);
+        },
+        async contentLoaded({ content, actions }) {
+            if (!content) {
+                return;
+            }
+            const { addRoute, createData } = actions;
+            await Promise.all(content.map(async (metadata) => {
+                const { permalink, source } = metadata;
+                if (metadata.type === 'mdx') {
+                    await createData(
+                    // Note that this created data path must be in sync with
+                    // metadataPath provided to mdx-loader.
+                    `${(0, utils_1.docuHash)(metadata.source)}.json`, JSON.stringify(metadata, null, 2));
+                    addRoute({
+                        path: permalink,
+                        component: options.mdxPageComponent,
+                        exact: true,
+                        modules: {
+                            content: source,
+                        },
+                    });
+                }
+                else {
+                    addRoute({
+                        path: permalink,
+                        component: source,
+                        exact: true,
+                        modules: {
+                            config: `@generated/docusaurus.config`,
+                        },
+                    });
+                }
+            }));
+        },
+        configureWebpack() {
+            const { admonitions, rehypePlugins, remarkPlugins, beforeDefaultRehypePlugins, beforeDefaultRemarkPlugins, } = options;
+            const contentDirs = getContentPathList(contentPaths);
+            return {
+                resolve: {
+                    alias: {
+                        '~pages': 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,
+                                        beforeDefaultRehypePlugins,
+                                        beforeDefaultRemarkPlugins,
+                                        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 aliasedSource = (0, utils_1.aliasedSitePath)(mdxPath, siteDir);
+                                            return path_1.default.join(dataDir, `${(0, utils_1.docuHash)(aliasedSource)}.json`);
+                                        },
+                                        // Assets allow to convert some relative images paths to
+                                        // require(...) calls
+                                        createAssets: ({ frontMatter, }) => ({
+                                            image: frontMatter.image,
+                                        }),
+                                        markdownConfig: siteConfig.markdown,
+                                    },
+                                },
+                                {
+                                    loader: path_1.default.resolve(__dirname, './markdownLoader.js'),
+                                    options: {
+                                    // siteDir,
+                                    // contentPath,
+                                    },
+                                },
+                            ].filter(Boolean),
+                        },
+                    ],
+                },
+            };
+        },
+    };
+}
+exports.default = pluginContentPages;
+var options_1 = require("./options");
+Object.defineProperty(exports, "validateOptions", { enumerable: true, get: function () { return options_1.validateOptions; } });