@rspress-theme-anatole/core 0.0.1

package/dist/loader.d.ts

@@ -0,0 +1,86 @@
+import { AdditionalPage } from '@rspress-theme-anatole/shared';
+import { DefaultThemeConfig } from '@rspress-theme-anatole/shared';
+import type { FrontMatterMeta } from '@rspress-theme-anatole/shared';
+import type { PageIndexInfo } from '@rspress-theme-anatole/shared';
+import type { RouteMeta } from '@rspress-theme-anatole/shared';
+import type { Rspack as Rspack_2 } from '@rsbuild/core';
+import type { RspressPlugin } from '@rspress-theme-anatole/shared';
+import type { UserConfig } from '@rspress-theme-anatole/shared';
+
+export declare function createCheckPageMetaUpdateFn(): (modulePath: string, pageMeta: PageMeta) => void;
+
+declare interface LoaderOptions {
+    config: UserConfig;
+    docDirectory: string;
+    checkDeadLinks: boolean;
+    routeService: RouteService;
+    pluginDriver: PluginDriver;
+}
+
+declare function mdxLoader(this: Rspack_2.LoaderContext<LoaderOptions>, source: string): Promise<void>;
+export default mdxLoader;
+
+export declare interface PageMeta {
+    toc: TocItem[];
+    title: string;
+    headingTitle: string;
+    frontmatter?: FrontMatterMeta;
+}
+
+declare class PluginDriver {
+    #private;
+    constructor(config: UserConfig, isProd: boolean);
+    init(): Promise<void>;
+    addPlugin(plugin: RspressPlugin): void;
+    getPlugins(): RspressPlugin[];
+    clearPlugins(): void;
+    removePlugin(pluginName: string): void;
+    modifyConfig(): Promise<UserConfig<DefaultThemeConfig>>;
+    beforeBuild(): Promise<void[]>;
+    afterBuild(): Promise<void[]>;
+    modifySearchIndexData(pages: PageIndexInfo[]): Promise<void[]>;
+    extendPageData(pageData: PageIndexInfo): Promise<void[]>;
+    addPages(): Promise<AdditionalPage[]>;
+    routeGenerated(routes: RouteMeta[]): Promise<void[]>;
+    addRuntimeModules(): Promise<Record<string, string>>;
+    addSSGRoutes(): Promise<({
+        path: string;
+    } | {
+        path: string;
+    })[]>;
+    globalUIComponents(): (string | [string, object])[];
+    globalStyles(): string[];
+    _runParallelAsyncHook<H extends RspressPluginHookKeys>(hookName: H, ...args: Parameters<Required<RspressPlugin>[H]>): Promise<Awaited<ReturnType<Required<RspressPlugin>[H]>>[]>;
+    _runSerialAsyncHook<H extends RspressPluginHookKeys>(hookName: H, ...args: Parameters<Required<RspressPlugin>[H]>): RspressPlugin;
+}
+
+declare class RouteService {
+    #private;
+    routeData: Map<string, RouteMeta>;
+    constructor(scanDir: string, userConfig: UserConfig, tempDir: string, pluginDriver: PluginDriver);
+    init(): Promise<void>;
+    addRoute(routeInfo: RouteMeta): void;
+    removeRoute(filePath: string): void;
+    getRoutes(): RouteMeta[];
+    isExistRoute(routePath: string): boolean;
+    isEmpty(): boolean;
+    generateRoutesCode(isStaticImport?: boolean): string;
+    generateRoutesCodeByRouteMeta(routeMeta: RouteMeta[], isStaticImport: boolean): string;
+    normalizeRoutePath(routePath: string): {
+        routePath: string;
+        lang: string;
+        version: string;
+    };
+}
+
+declare type RspressPluginHookKeys = 'beforeBuild' | 'afterBuild' | 'addPages' | 'addRuntimeModules' | 'routeGenerated' | 'addSSGRoutes' | 'extendPageData' | 'modifySearchIndexData';
+
+declare interface TocItem {
+    id: string;
+    text: string;
+    depth: number;
+}
+
+export declare function updateSiteDataRuntimeModule(modulePath: string, pageMeta: PageMeta): Promise<void>;
+
+export { }

package/dist/loader.js

@@ -0,0 +1,582 @@
+import __rslib_shim_module__ from 'module';
+/*#__PURE__*/ import.meta.url;
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
+import * as __WEBPACK_EXTERNAL_MODULE__mdx_js_mdx_b904bd09__ from "@mdx-js/mdx";
+import * as __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__ from "@rspress-theme-anatole/shared";
+import * as __WEBPACK_EXTERNAL_MODULE__rspress_shared_logger_4374e44a__ from "@rspress-theme-anatole/shared/logger";
+import * as __WEBPACK_EXTERNAL_MODULE__rspress_shared_node_utils_78947ce6__ from "@rspress-theme-anatole/shared/node-utils";
+import "rspack-plugin-virtual-module";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_enhanced_resolve_bf4706da__ from "enhanced-resolve";
+import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
+import * as __WEBPACK_EXTERNAL_MODULE_rehype_external_links_09bed11a__ from "rehype-external-links";
+import * as __WEBPACK_EXTERNAL_MODULE_remark_gfm_073acf21__ from "remark-gfm";
+import * as __WEBPACK_EXTERNAL_MODULE_unist_util_visit_555e002a__ from "unist-util-visit";
+import * as __WEBPACK_EXTERNAL_MODULE_github_slugger_8e9a17cb__ from "github-slugger";
+import * as __WEBPACK_EXTERNAL_MODULE_hast_util_heading_rank_cff646ba__ from "hast-util-heading-rank";
+import * as __WEBPACK_EXTERNAL_MODULE_unist_util_visit_children_71921007__ from "unist-util-visit-children";
+const importStatementRegex = /import\s+(.*?)\s+from\s+(['"])(.*?)(?:"|');?/gm;
+`{
+  const saved = localStorage.getItem('${__WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.APPEARANCE_KEY}')
+  const preferDark = window.matchMedia('(prefers-color-scheme: dark)').matches
+  const isDark = !saved || saved === 'auto' ? preferDark : saved === 'dark'
+  document.documentElement.classList.toggle('dark', isDark)
+  document.documentElement.style.colorScheme = isDark ? 'dark' : 'light'
+}`.replace(/\n/g, ';').replace(/\s{2,}/g, '');
+const dirname = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname((0, __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__.fileURLToPath)(new URL(import.meta.url)));
+const PACKAGE_ROOT = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(dirname, '..');
+__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(PACKAGE_ROOT, 'dist', 'runtime', 'clientEntry.js');
+__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(PACKAGE_ROOT, 'dist', 'runtime', 'ssrEntry.js');
+const TEMP_DIR = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(process.cwd(), 'node_modules', __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.RSPRESS_TEMP_DIR);
+var runtimeModule_RuntimeModuleID = /*#__PURE__*/ function(RuntimeModuleID) {
+    RuntimeModuleID["GlobalStyles"] = "virtual-global-styles";
+    RuntimeModuleID["GlobalComponents"] = "virtual-global-components";
+    RuntimeModuleID["RouteForClient"] = "virtual-routes";
+    RuntimeModuleID["RouteForSSR"] = "virtual-routes-ssr";
+    RuntimeModuleID["SiteData"] = "virtual-site-data";
+    RuntimeModuleID["SearchIndexHash"] = "virtual-search-index-hash";
+    RuntimeModuleID["I18nText"] = "virtual-i18n-text";
+    RuntimeModuleID["SearchHooks"] = "virtual-search-hooks";
+    RuntimeModuleID["PrismLanguages"] = "virtual-prism-languages";
+    return RuntimeModuleID;
+}({});
+let resolver;
+let startFlatten = false;
+const processor = (0, __WEBPACK_EXTERNAL_MODULE__mdx_js_mdx_b904bd09__.createProcessor)();
+const { CachedInputFileSystem, ResolverFactory } = __WEBPACK_EXTERNAL_MODULE_enhanced_resolve_bf4706da__["default"];
+const fileSystem = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"];
+async function resolveDepPath(importPath, importer, alias) {
+    if (!resolver) resolver = ResolverFactory.createResolver({
+        fileSystem: new CachedInputFileSystem(fileSystem, 0),
+        extensions: [
+            '.mdx',
+            '.md'
+        ],
+        alias
+    });
+    const resolveResult = await new Promise((resolve, reject)=>{
+        resolver.resolve({
+            importer
+        }, importer, importPath, {}, (err, filePath)=>{
+            if (err) return reject(err);
+            if (!filePath) return reject(new Error(`Empty result when resolving ${importPath} from ${importer}`));
+            return resolve(filePath);
+        });
+    });
+    return resolveResult;
+}
+async function flattenMdxContent(content, basePath, alias) {
+    const deps = [];
+    const regex = new RegExp(importStatementRegex);
+    if (!regex.test(content)) return {
+        flattenContent: content,
+        deps
+    };
+    if (!startFlatten) {
+        resolver = ResolverFactory.createResolver({
+            fileSystem: new CachedInputFileSystem(fileSystem, 0),
+            extensions: [
+                '.mdx',
+                '.md',
+                '.js'
+            ],
+            alias
+        });
+        startFlatten = true;
+    }
+    let ast;
+    let result = content;
+    try {
+        ast = processor.parse(content);
+    } catch (e) {
+        __WEBPACK_EXTERNAL_MODULE__rspress_shared_logger_4374e44a__.logger.debug('flattenMdxContent parse failed: \n', e);
+        return {
+            flattenContent: content,
+            deps
+        };
+    }
+    const importNodes = ast.children.filter((node)=>'mdxjsEsm' === node.type).flatMap((node)=>{
+        var _node_data_estree, _node_data;
+        return (null === (_node_data = node.data) || void 0 === _node_data ? void 0 : null === (_node_data_estree = _node_data.estree) || void 0 === _node_data_estree ? void 0 : _node_data_estree.body) || [];
+    }).filter((node)=>'ImportDeclaration' === node.type);
+    for (const importNode of importNodes){
+        const id = importNode.specifiers[0].local.name;
+        const importPath = importNode.source.value;
+        let absoluteImportPath;
+        try {
+            absoluteImportPath = await resolveDepPath(importPath, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(basePath), alias);
+        } catch (_e) {
+            continue;
+        }
+        if (__WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.MDX_OR_MD_REGEXP.test(absoluteImportPath)) {
+            const importedContent = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(absoluteImportPath, 'utf-8');
+            const { flattenContent: replacedValue, deps: subDeps } = await flattenMdxContent(importedContent, absoluteImportPath, alias);
+            result = result.replace(new RegExp(`import\\s+${id}\\s+from\\s+['"](${importPath})['"];?`), '').replace(new RegExp(`<${id}\\s*/>`, 'g'), ()=>replacedValue);
+            deps.push(...subDeps, absoluteImportPath);
+        }
+    }
+    return {
+        flattenContent: result,
+        deps
+    };
+}
+function applyReplaceRules(code = '', replaceRules = []) {
+    let result = code;
+    for (const rule of replaceRules)result = result.replace(rule.search, rule.replace);
+    return result;
+}
+function escapeMarkdownHeadingIds(content) {
+    const markdownHeadingRegexp = /(?:^|\n)#{1,6}(?!#).*/g;
+    return content.replace(markdownHeadingRegexp, (substring)=>substring.replace('{#', '\\{#').replace('\\\\{#', '\\{#'));
+}
+const isWindows = 'win32' === __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__["default"].platform();
+function slash(p) {
+    return p.replace(/\\/g, '/');
+}
+function normalizePath(id) {
+    return __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].posix.normalize(isWindows ? slash(id) : id);
+}
+const rehypePluginCodeMeta = ()=>(tree)=>{
+        (0, __WEBPACK_EXTERNAL_MODULE_unist_util_visit_555e002a__.visit)(tree, 'element', (node)=>{
+            var _node_children_;
+            if ('pre' === node.tagName && (null === (_node_children_ = node.children[0]) || void 0 === _node_children_ ? void 0 : _node_children_.type) === 'element' && 'code' === node.children[0].tagName) {
+                var _codeNode_data;
+                const codeNode = node.children[0];
+                codeNode.properties ??= {};
+                codeNode.properties.meta = null === (_codeNode_data = codeNode.data) || void 0 === _codeNode_data ? void 0 : _codeNode_data.meta;
+            }
+        });
+    };
+const rehypeHeaderAnchor = ()=>{
+    const slugger = new __WEBPACK_EXTERNAL_MODULE_github_slugger_8e9a17cb__["default"]();
+    return (tree)=>{
+        (0, __WEBPACK_EXTERNAL_MODULE_unist_util_visit_555e002a__.visit)(tree, 'element', (node)=>{
+            var _node_properties;
+            if (!(0, __WEBPACK_EXTERNAL_MODULE_hast_util_heading_rank_cff646ba__.headingRank)(node)) return;
+            if (!(null === (_node_properties = node.properties) || void 0 === _node_properties ? void 0 : _node_properties.id)) {
+                const [text, customId] = collectHeaderText(node);
+                node.properties ??= {};
+                node.properties.id = customId || slugger.slug(text);
+            }
+            node.children.unshift(create(node));
+        });
+    };
+};
+const collectHeaderText = (node)=>{
+    let text = '';
+    let id = '';
+    node.children.forEach((child)=>{
+        if ('text' === child.type) {
+            const [textPart, idPart] = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_node_utils_78947ce6__.extractTextAndId)(child.value);
+            child.value = textPart;
+            text += textPart;
+            id = idPart;
+        }
+        if ('element' === child.type) child.children.forEach((c)=>{
+            if ('text' === c.type) text += c.value;
+        });
+    });
+    return [
+        text,
+        id
+    ];
+};
+function create(node) {
+    return {
+        type: 'element',
+        tagName: 'a',
+        properties: {
+            class: 'header-anchor',
+            ariaHidden: 'true',
+            href: `#${node.properties.id}`
+        },
+        children: [
+            {
+                type: 'text',
+                value: '#'
+            }
+        ]
+    };
+}
+const getASTNodeImport = (name, from)=>({
+        type: 'mdxjsEsm',
+        value: `import ${name} from ${JSON.stringify(from)}`,
+        data: {
+            estree: {
+                type: 'Program',
+                sourceType: 'module',
+                body: [
+                    {
+                        type: 'ImportDeclaration',
+                        specifiers: [
+                            {
+                                type: 'ImportDefaultSpecifier',
+                                local: {
+                                    type: 'Identifier',
+                                    name
+                                }
+                            }
+                        ],
+                        source: {
+                            type: 'Literal',
+                            value: from,
+                            raw: `${JSON.stringify(from)}`
+                        }
+                    }
+                ]
+            }
+        }
+    });
+const remarkBuiltin = ({ globalComponents })=>(tree)=>{
+        const demos = globalComponents.map((componentPath)=>{
+            const filename = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].parse(componentPath).name;
+            const componentName = filename[0].toUpperCase() + filename.slice(1);
+            return getASTNodeImport(componentName, componentPath);
+        });
+        tree.children.unshift(...demos);
+    };
+const IGNORE_REGEXP = /^(https?|mailto|tel|#)/;
+function checkLinks(links, filepath, root, routeService) {
+    const errorInfos = [];
+    links.filter((link)=>!IGNORE_REGEXP.test(link)).map((link)=>normalizePath(link)).forEach((link)=>{
+        const relativePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(root, filepath);
+        if (!routeService.isExistRoute((0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.cleanUrl)(link))) errorInfos.push(`Internal link to "${link}" is dead, check it in "${relativePath}"`);
+    });
+    if (errorInfos.length > 0) {
+        null == errorInfos || errorInfos.forEach((err)=>{
+            __WEBPACK_EXTERNAL_MODULE__rspress_shared_logger_4374e44a__.logger.error(err);
+        });
+        if ((0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.isProduction)()) throw new Error('Dead link found');
+    }
+}
+const remarkCheckDeadLinks = (checkLink)=>{
+    const { root, routeService } = checkLink;
+    return (tree, vfile)=>{
+        const internalLinks = new Set();
+        (0, __WEBPACK_EXTERNAL_MODULE_unist_util_visit_555e002a__.visit)(tree, 'link', ({ url })=>{
+            if (!url) return;
+            if (internalLinks.has(url)) return;
+            if (!url.startsWith('http') && !url.startsWith('https')) {
+                var _url_split_join;
+                const { routePath: normalizeUrl } = routeService.normalizeRoutePath(null === (_url_split_join = url.split(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].sep).join('/')) || void 0 === _url_split_join ? void 0 : _url_split_join.split('#')[0]);
+                internalLinks.add(normalizeUrl);
+            }
+        });
+        checkLinks(Array.from(internalLinks), vfile.path, root, routeService);
+    };
+};
+const remarkPluginNormalizeLink = ({ root, cleanUrls })=>(tree, file)=>{
+        const images = [];
+        (0, __WEBPACK_EXTERNAL_MODULE_unist_util_visit_555e002a__.visit)(tree, 'link', (node)=>{
+            if (!node.url) return;
+            if (node.url.startsWith('#')) {
+                node.url = `#${node.url.slice(1)}`;
+                return;
+            }
+            let { url, hash } = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.parseUrl)(node.url);
+            if ((0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.isExternalUrl)(url)) {
+                node.url = url + (hash ? `#${hash}` : '');
+                return;
+            }
+            const extname = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].extname(url);
+            if ('.md' === extname || '.mdx' === extname) url = url.replace(extname, '');
+            const relativePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(root, file.path);
+            if (url.startsWith('.')) url = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].posix.join((0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.slash)(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(relativePath)), url);
+            url = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.normalizeHref)(url, cleanUrls);
+            if (hash) url += `#${hash}`;
+            node.url = url;
+        });
+        const normalizeImageUrl = (imageUrl)=>{
+            if ((0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.isExternalUrl)(imageUrl) || imageUrl.startsWith('/')) return '';
+            return imageUrl;
+        };
+        const getMdxSrcAttribute = (tempVar)=>({
+                type: 'mdxJsxAttribute',
+                name: 'src',
+                value: {
+                    type: 'mdxJsxAttributeValueExpression',
+                    value: tempVar,
+                    data: {
+                        estree: {
+                            type: 'Program',
+                            sourceType: 'module',
+                            body: [
+                                {
+                                    type: 'ExpressionStatement',
+                                    expression: {
+                                        type: 'Identifier',
+                                        name: tempVar
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            });
+        (0, __WEBPACK_EXTERNAL_MODULE_unist_util_visit_555e002a__.visit)(tree, 'image', (node)=>{
+            const { alt, url } = node;
+            if (!url) return;
+            const imagePath = normalizeImageUrl(url);
+            if (!imagePath) return;
+            const tempVariableName = `image${images.length}`;
+            Object.assign(node, {
+                type: 'mdxJsxFlowElement',
+                name: 'img',
+                children: [],
+                attributes: [
+                    alt && {
+                        type: 'mdxJsxAttribute',
+                        name: 'alt',
+                        value: alt
+                    },
+                    getMdxSrcAttribute(tempVariableName)
+                ].filter(Boolean)
+            });
+            images.push(getASTNodeImport(tempVariableName, imagePath));
+        });
+        (0, __WEBPACK_EXTERNAL_MODULE_unist_util_visit_555e002a__.visit)(tree, (node)=>{
+            if ('mdxJsxFlowElement' !== node.type && 'mdxJsxTextElement' !== node.type || 'img' !== node.name) return;
+            const srcAttr = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_node_utils_78947ce6__.getNodeAttribute)(node, 'src', true);
+            if ('string' != typeof (null == srcAttr ? void 0 : srcAttr.value)) return;
+            const imagePath = normalizeImageUrl(srcAttr.value);
+            if (!imagePath) return;
+            const tempVariableName = `image${images.length}`;
+            Object.assign(srcAttr, getMdxSrcAttribute(tempVariableName));
+            images.push(getASTNodeImport(tempVariableName, imagePath));
+        });
+        tree.children.unshift(...images);
+    };
+const parseToc = (tree)=>{
+    let title = '';
+    const toc = [];
+    const slugger = new __WEBPACK_EXTERNAL_MODULE_github_slugger_8e9a17cb__["default"]();
+    (0, __WEBPACK_EXTERNAL_MODULE_unist_util_visit_children_71921007__.visitChildren)((node)=>{
+        if ('heading' !== node.type || !node.depth || !node.children) return;
+        if (node.depth >= 1 && node.depth < 5) {
+            let customId = '';
+            const text = node.children.map((child)=>{
+                if ('link' === child.type) {
+                    var _child_children;
+                    return null === (_child_children = child.children) || void 0 === _child_children ? void 0 : _child_children.map((item)=>item.value).join('');
+                }
+                if ('strong' === child.type) {
+                    var _child_children1;
+                    return `**${null === (_child_children1 = child.children) || void 0 === _child_children1 ? void 0 : _child_children1.map((item)=>item.value).join('')}**`;
+                }
+                if ('emphasis' === child.type) {
+                    var _child_children2;
+                    return `*${null === (_child_children2 = child.children) || void 0 === _child_children2 ? void 0 : _child_children2.map((item)=>item.value).join('')}*`;
+                }
+                if ('delete' === child.type) {
+                    var _child_children3;
+                    return `~~${null === (_child_children3 = child.children) || void 0 === _child_children3 ? void 0 : _child_children3.map((item)=>item.value).join('')}~~`;
+                }
+                if ('text' === child.type) {
+                    const [textPart, idPart] = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_node_utils_78947ce6__.extractTextAndId)(child.value);
+                    customId = idPart;
+                    return textPart;
+                }
+                if ('inlineCode' === child.type) return `\`${child.value}\``;
+                return '';
+            }).join('');
+            if (1 === node.depth) {
+                if (!title) title = text;
+            } else {
+                const id = customId ? customId : slugger.slug(text);
+                const { depth } = node;
+                toc.push({
+                    id,
+                    text,
+                    depth
+                });
+            }
+        }
+    })(tree);
+    return {
+        title,
+        toc
+    };
+};
+const remarkPluginToc = function() {
+    const data = this.data();
+    return (tree)=>{
+        const { toc, title } = parseToc(tree);
+        data.pageMeta.toc = toc;
+        if (title) data.pageMeta.title = title;
+    };
+};
+async function createMDXOptions(docDirectory, config, checkDeadLinks, routeService, filepath, pluginDriver) {
+    var _config_route;
+    const cleanUrls = (null == config ? void 0 : null === (_config_route = config.route) || void 0 === _config_route ? void 0 : _config_route.cleanUrls) ?? false;
+    const { remarkPlugins: remarkPluginsFromConfig = [], rehypePlugins: rehypePluginsFromConfig = [], globalComponents: globalComponentsFromConfig = [] } = (null == config ? void 0 : config.markdown) || {};
+    const rspressPlugins = pluginDriver.getPlugins();
+    const remarkPluginsFromPlugins = rspressPlugins.flatMap((plugin)=>{
+        var _plugin_markdown;
+        return (null === (_plugin_markdown = plugin.markdown) || void 0 === _plugin_markdown ? void 0 : _plugin_markdown.remarkPlugins) || [];
+    });
+    const rehypePluginsFromPlugins = rspressPlugins.flatMap((plugin)=>{
+        var _plugin_markdown;
+        return (null === (_plugin_markdown = plugin.markdown) || void 0 === _plugin_markdown ? void 0 : _plugin_markdown.rehypePlugins) || [];
+    });
+    const globalComponents = [
+        ...rspressPlugins.flatMap((plugin)=>{
+            var _plugin_markdown;
+            return (null === (_plugin_markdown = plugin.markdown) || void 0 === _plugin_markdown ? void 0 : _plugin_markdown.globalComponents) || [];
+        }),
+        ...globalComponentsFromConfig
+    ];
+    return {
+        providerImportSource: '@mdx-js/react',
+        format: __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].extname(filepath).slice(1),
+        remarkPlugins: [
+            __WEBPACK_EXTERNAL_MODULE_remark_gfm_073acf21__["default"],
+            remarkPluginToc,
+            [
+                remarkPluginNormalizeLink,
+                {
+                    cleanUrls,
+                    root: docDirectory
+                }
+            ],
+            checkDeadLinks && [
+                remarkCheckDeadLinks,
+                {
+                    root: docDirectory,
+                    base: (null == config ? void 0 : config.base) || '',
+                    routeService
+                }
+            ],
+            globalComponents.length && [
+                remarkBuiltin,
+                {
+                    globalComponents
+                }
+            ],
+            ...remarkPluginsFromConfig,
+            ...remarkPluginsFromPlugins
+        ].filter(Boolean),
+        rehypePlugins: [
+            rehypeHeaderAnchor,
+            rehypePluginCodeMeta,
+            [
+                __WEBPACK_EXTERNAL_MODULE_rehype_external_links_09bed11a__["default"],
+                {
+                    target: '_blank',
+                    rel: 'noopener noreferrer'
+                }
+            ],
+            ...rehypePluginsFromConfig,
+            ...rehypePluginsFromPlugins
+        ]
+    };
+}
+async function updateSiteDataRuntimeModule(modulePath, pageMeta) {
+    const siteDataModulePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(TEMP_DIR, 'runtime', `${runtimeModule_RuntimeModuleID.SiteData}.mjs`);
+    const { default: siteData } = await import((0, __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__.pathToFileURL)(siteDataModulePath).href);
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(siteDataModulePath, `export default ${JSON.stringify({
+        ...siteData,
+        timestamp: Date.now().toString(),
+        pages: siteData.pages.map((page)=>page._filepath === modulePath ? {
+                ...page,
+                ...pageMeta
+            } : page)
+    }, null, 2)}`);
+}
+function createCheckPageMetaUpdateFn() {
+    const pageMetaMap = new Map();
+    return (modulePath, pageMeta)=>{
+        const prevMeta = pageMetaMap.get(modulePath);
+        const deserializedMeta = JSON.stringify(pageMeta);
+        pageMetaMap.set(modulePath, deserializedMeta);
+        if (!prevMeta) return;
+        if (prevMeta !== deserializedMeta) setTimeout(async ()=>{
+            __WEBPACK_EXTERNAL_MODULE__rspress_shared_logger_4374e44a__.logger.info('Page metadata changed, page reloading...');
+            await updateSiteDataRuntimeModule(modulePath, pageMeta);
+        });
+    };
+}
+const checkPageMetaUpdate = createCheckPageMetaUpdateFn();
+async function mdxLoader(source) {
+    var _config_markdown;
+    this.cacheable(true);
+    const callback = this.async();
+    const options = this.getOptions();
+    const filepath = this.resourcePath;
+    const { alias } = this._compiler.options.resolve;
+    const { config, docDirectory, checkDeadLinks, routeService, pluginDriver } = options;
+    const { frontmatter, content } = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_node_utils_78947ce6__.loadFrontMatter)(source, filepath, docDirectory, true);
+    const { flattenContent, deps } = await flattenMdxContent(content, filepath, alias);
+    deps.forEach((dep)=>this.addDependency(dep));
+    const replacedContent = applyReplaceRules(flattenContent, config.replaceRules);
+    const preprocessedContent = escapeMarkdownHeadingIds(replacedContent);
+    let enableMdxRs;
+    const mdxRs = (null == config ? void 0 : null === (_config_markdown = config.markdown) || void 0 === _config_markdown ? void 0 : _config_markdown.mdxRs) ?? true;
+    enableMdxRs = 'object' == typeof mdxRs ? 'function' == typeof (null == mdxRs ? void 0 : mdxRs.include) ? mdxRs.include(filepath) : true : mdxRs;
+    try {
+        let compileResult;
+        let pageMeta = {
+            title: '',
+            toc: [],
+            headingTitle: ''
+        };
+        const frontmatterTitle = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_node_utils_78947ce6__.extractTextAndId)(frontmatter.title)[0];
+        if (enableMdxRs) {
+            const { compile } = await import("@rspress/mdx-rs");
+            const { toc, links, title, code } = await compile({
+                value: preprocessedContent,
+                filepath,
+                root: docDirectory,
+                development: 'production' !== process.env.NODE_ENV
+            });
+            compileResult = code;
+            const headingTitle = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_node_utils_78947ce6__.extractTextAndId)(title)[0];
+            pageMeta = {
+                toc,
+                title: frontmatterTitle || headingTitle,
+                headingTitle,
+                frontmatter
+            };
+            if (checkDeadLinks) checkLinks(links, filepath, docDirectory, routeService);
+        } else {
+            const mdxOptions = await createMDXOptions(docDirectory, config, checkDeadLinks, routeService, filepath, pluginDriver);
+            const compiler = (0, __WEBPACK_EXTERNAL_MODULE__mdx_js_mdx_b904bd09__.createProcessor)(mdxOptions);
+            compiler.data('pageMeta', {
+                toc: [],
+                title: ''
+            });
+            const vFile = await compiler.process({
+                value: preprocessedContent,
+                path: filepath
+            });
+            compileResult = String(vFile);
+            const compilationMeta = compiler.data('pageMeta');
+            const headingTitle = (0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_node_utils_78947ce6__.extractTextAndId)(compilationMeta.title)[0];
+            pageMeta = {
+                ...compilationMeta,
+                title: frontmatterTitle || headingTitle,
+                headingTitle,
+                frontmatter
+            };
+        }
+        if (!(0, __WEBPACK_EXTERNAL_MODULE__rspress_shared_baa012d0__.isProduction)()) checkPageMetaUpdate(filepath, pageMeta);
+        const result = `const frontmatter = ${JSON.stringify(frontmatter)};
+${compileResult}
+MDXContent.__RSPRESS_PAGE_META = {};
+
+MDXContent.__RSPRESS_PAGE_META["${encodeURIComponent(normalizePath(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(docDirectory, filepath)))}"] = ${JSON.stringify(pageMeta)};
+`;
+        callback(null, result);
+    } catch (e) {
+        if (e instanceof Error) {
+            __WEBPACK_EXTERNAL_MODULE__rspress_shared_logger_4374e44a__.logger.error(`MDX compile error: ${e.message} in ${filepath}`);
+            __WEBPACK_EXTERNAL_MODULE__rspress_shared_logger_4374e44a__.logger.debug(e);
+            callback({
+                message: e.message,
+                name: `${filepath} compile error`
+            });
+        }
+    }
+}
+export { createCheckPageMetaUpdateFn, mdxLoader as default, updateSiteDataRuntimeModule };

package/dist/runtime/App.d.ts

@@ -0,0 +1,10 @@
+import { type PageData } from '@rspress-theme-anatole/shared';
+import 'virtual-global-styles';
+export declare enum QueryStatus {
+    Show = "1",
+    Hide = "0"
+}
+export declare function initPageData(routePath: string): Promise<PageData>;
+export declare function App({ helmetContext }: {
+    helmetContext?: object;
+}): import("react/jsx-runtime").JSX.Element;