@module-federation/rspress-plugin 0.0.0-docs-remove-invalid-lark-link-20251205062649

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 ScriptedAlchemy LLC (Zack Jackson) Zhou Shaw (zhouxiao)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# @examples/mf-react-component
+
+This example demonstrates how to use Rslib to build a simple Module Federation React component.
+
+### Command
+
+Build package
+
+```
+nx build rslib-module
+```
+
+Serve package
+
+```
+nx serve rslib-module
+```
+
+Dev package
+
+1. 
+
+```
+nx dev rslib-module
+```
+
+2.
+
+```
+nx storybook rslib-module
+```
+
+visit http://localhost:6006

package/dist/esm/index.js

@@ -0,0 +1,296 @@
+import external_path_default from "path";
+import external_fs_extra_default from "fs-extra";
+import { pluginModuleFederation } from "@module-federation/rsbuild-plugin";
+import { BUILD_002, buildDescMap, getShortErrorMsg } from "@module-federation/error-codes";
+import { createLogger, createModuleFederationConfig } from "@module-federation/sdk";
+import promises_default from "node:fs/promises";
+import external_node_path_default from "node:path";
+import { load } from "cheerio";
+import { htmlToText } from "html-to-text";
+import { groupBy } from "lodash-es";
+import external_fs_default from "fs";
+const logger = createLogger('[ Module Federation Rspress Plugin ]');
+const src_logger = logger;
+const SEARCH_INDEX_NAME = 'search_index';
+function findSearchIndexPaths(outputDir) {
+    const staticDir = external_path_default.join(outputDir, 'static');
+    if (!external_fs_default.existsSync(staticDir)) return;
+    const files = external_fs_default.readdirSync(staticDir);
+    const searchIndexFiles = files.filter((file)=>file.startsWith(SEARCH_INDEX_NAME) && file.endsWith('.json') && external_fs_default.statSync(external_path_default.join(staticDir, file)).isFile());
+    if (searchIndexFiles) return searchIndexFiles.map((searchIndexFile)=>external_path_default.join(staticDir, searchIndexFile));
+}
+function generateTocFromHtml(html) {
+    const $ = load(html);
+    const headings = $('h1, h2, h3, h4, h5, h6');
+    const toc = [];
+    let title = '';
+    headings.each((index, heading)=>{
+        const $heading = $(heading);
+        const text = $heading.text();
+        const id = $heading.attr('id');
+        const depth = parseInt(heading.tagName.replace('h', ''), 10);
+        if (id) toc.push({
+            text,
+            id,
+            depth
+        });
+        if (1 === depth) title = text;
+    });
+    return {
+        toc,
+        title
+    };
+}
+const replaceHtmlExt = (filepath)=>filepath.replace(external_node_path_default.extname(filepath), '.html');
+async function extractPageDataFromHtml(routes, options) {
+    return Promise.all(routes.map(async (route)=>{
+        const { domain, searchCodeBlocks, outputDir, defaultLang } = options;
+        const defaultIndexInfo = {
+            title: '',
+            content: '',
+            _html: '',
+            _flattenContent: '',
+            routePath: route.routePath,
+            lang: route.lang,
+            toc: [],
+            domain,
+            frontmatter: {},
+            version: route.version,
+            _filepath: route.absolutePath,
+            _relativePath: ''
+        };
+        const htmlPath = replaceHtmlExt(external_node_path_default.join(outputDir, route.lang === defaultLang ? route.relativePath.replace(route.lang, '') : route.relativePath));
+        const html = await promises_default.readFile(htmlPath, 'utf-8');
+        let { toc: rawToc, title } = generateTocFromHtml(html);
+        let content = html;
+        content = htmlToText(html, {
+            wordwrap: 80,
+            selectors: [
+                {
+                    selector: 'a',
+                    options: {
+                        ignoreHref: true
+                    }
+                },
+                {
+                    selector: 'img',
+                    format: 'skip'
+                },
+                {
+                    selector: 'pre > code',
+                    format: searchCodeBlocks ? 'block' : 'skip'
+                },
+                ...[
+                    'h1',
+                    'h2',
+                    'h3',
+                    'h4',
+                    'h5',
+                    'h6'
+                ].map((tag)=>({
+                        selector: tag,
+                        options: {
+                            uppercase: false
+                        }
+                    }))
+            ],
+            tables: true,
+            longWordSplit: {
+                forceWrapOnLimit: true
+            }
+        });
+        if (content.startsWith(title)) content = content.slice(title.length);
+        const toc = rawToc.map((item)=>{
+            const match = item.id.match(/-(\d+)$/);
+            let position = -1;
+            if (match) for(let i = 0; i < Number(match[1]); i++){
+                position = content.indexOf(`\n${item.text}#\n\n`, position + 1);
+                if (-1 === position) break;
+            }
+            return {
+                ...item,
+                charIndex: content.indexOf(`\n${item.text}#\n\n`, position + 1)
+            };
+        });
+        return {
+            ...defaultIndexInfo,
+            title,
+            toc,
+            content,
+            _html: html
+        };
+    }));
+}
+function deletePrivateField(obj) {
+    if ('object' != typeof obj || null === obj) return obj;
+    const newObj = {
+        ...obj
+    };
+    for(const key in newObj)if (key.startsWith('_')) delete newObj[key];
+    return newObj;
+}
+async function rebuildSearchIndexByHtml(routes, options) {
+    const { versioned, outputDir } = options;
+    const searchFilePaths = findSearchIndexPaths(outputDir);
+    if (!searchFilePaths) {
+        src_logger.error('Cannot find search index files!');
+        process.exit(1);
+    }
+    const pages = await extractPageDataFromHtml(routes, options);
+    const groupedPages = groupBy(pages, (page)=>{
+        if (page.frontmatter?.pageType === 'home') return 'noindex';
+        const version = versioned ? page.version : '';
+        const lang = page.lang || '';
+        return `${version}###${lang}`;
+    });
+    delete groupedPages.noindex;
+    await Promise.all(Object.keys(groupedPages).map(async (group)=>{
+        const stringifiedIndex = JSON.stringify(groupedPages[group].map(deletePrivateField));
+        const [version, lang] = group.split('###');
+        const indexVersion = version ? `.${version.replace('.', '_')}` : '';
+        const indexLang = lang ? `.${lang}` : '';
+        const searchFilePath = searchFilePaths.find((filePath)=>filePath.replace(`${external_node_path_default.dirname(filePath)}/`, '').startsWith(`${SEARCH_INDEX_NAME}${indexVersion}${indexLang}`));
+        if (!searchFilePath) {
+            src_logger.error(`Cannot find search index file for version ${version} and lang ${lang}!`);
+            process.exit(1);
+        }
+        await promises_default.writeFile(searchFilePath, stringifiedIndex);
+    }));
+}
+const isDev = ()=>'development' === process.env.NODE_ENV;
+function replaceEntryWithBootstrapEntry(bundlerConfig) {
+    const { entry } = bundlerConfig;
+    if (!entry) {
+        src_logger.error('No entry found!');
+        process.exit(1);
+    }
+    if ('function' == typeof entry) {
+        src_logger.error('Not support entry function!');
+        process.exit(1);
+    }
+    const replaceWithAsyncEntry = (entries, entryName)=>{
+        const entryPath = external_path_default.resolve(process.cwd(), `node_modules/.federation/${entryName}-bootstrap.js`);
+        external_fs_extra_default.ensureDirSync(external_path_default.dirname(entryPath));
+        if ('string' == typeof entries) {
+            external_fs_extra_default.writeFileSync(entryPath, `const entry = import ('${entries}');
+      const render = entry.then(({render})=>(render));
+      const routes = entry.then(({routes})=>(routes));
+      export {
+          render,
+          routes
+        };`);
+            return entryPath;
+        }
+        external_fs_extra_default.writeFileSync(entryPath, `const entry = import ('${entries.slice(-1)[0]}');
+         const render = entry.then(({render})=>(render));
+      const routes = entry.then(({routes})=>(routes));
+      export {
+          render,
+          routes
+        };`);
+        return entries.slice(0, -1).concat(entryPath);
+    };
+    if ('object' == typeof entry && !Array.isArray(entry)) return void Object.keys(entry).forEach((entryName)=>{
+        const entryValue = entry[entryName];
+        if (!Array.isArray(entryValue)) {
+            src_logger.error(`Not support entry ${typeof entryValue}!`);
+            process.exit(1);
+        }
+        entry[entryName] = replaceWithAsyncEntry(entryValue, `${entryName}${bundlerConfig.name ? `-${bundlerConfig.name}` : ''}`);
+    });
+    bundlerConfig.entry = replaceWithAsyncEntry(entry, bundlerConfig.name || 'index');
+}
+function plugin_pluginModuleFederation(mfConfig, rspressOptions) {
+    const { autoShared = true, rebuildSearchIndex = true } = rspressOptions || {};
+    if (autoShared) mfConfig.shared = {
+        react: {
+            singleton: true,
+            requiredVersion: false
+        },
+        'react-dom': {
+            singleton: true,
+            requiredVersion: false
+        },
+        'react/': {
+            singleton: true,
+            requiredVersion: false
+        },
+        'react-dom/': {
+            singleton: true,
+            requiredVersion: false
+        },
+        '@mdx-js/react': {
+            singleton: true,
+            requiredVersion: false
+        },
+        '@rspress/runtime': {
+            singleton: true,
+            requiredVersion: false
+        },
+        ...mfConfig.shared
+    };
+    let enableSSG = false;
+    let outputDir = '';
+    let routes = [];
+    return {
+        name: 'plugin-module-federation',
+        async config (config) {
+            if (!isDev() && false !== config.ssg) enableSSG = true;
+            config.builderConfig ||= {};
+            config.builderConfig.dev ||= {};
+            if (isDev() && void 0 === config.builderConfig.dev.lazyCompilation) {
+                src_logger.warn('lazyCompilation is not fully supported for module federation, set lazyCompilation to false');
+                config.builderConfig.dev.lazyCompilation = false;
+            }
+            config.builderConfig.plugins ||= [];
+            config.builderConfig.plugins.push(pluginModuleFederation(mfConfig, {
+                ssr: enableSSG,
+                environment: 'node',
+                ssrDir: 'mf-ssg'
+            }));
+            return config;
+        },
+        builderConfig: {
+            plugins: [],
+            tools: {
+                rspack (config) {
+                    replaceEntryWithBootstrapEntry(config);
+                    if ('node' === config.name) {
+                        if (('/' === config.output.publicPath || 'auto' === config.output.publicPath) && mfConfig.exposes) {
+                            src_logger.error(getShortErrorMsg(BUILD_002, buildDescMap, {
+                                publicPath: config.output.publicPath
+                            }));
+                            process.exit(1);
+                        }
+                        outputDir = config.output.path;
+                    }
+                }
+            }
+        },
+        routeGenerated (routeMetaArr) {
+            routes = routeMetaArr;
+        },
+        async afterBuild (config) {
+            if (!mfConfig.remotes || isDev() || !rebuildSearchIndex) return;
+            if (!enableSSG) {
+                src_logger.error('rebuildSearchIndex is only supported for ssg');
+                process.exit(1);
+            }
+            const searchConfig = config?.search || {};
+            const replaceRules = config?.replaceRules || [];
+            const domain = searchConfig?.mode === 'remote' ? searchConfig.domain ?? '' : '';
+            const versioned = searchConfig && 'remote' !== searchConfig.mode && searchConfig.versioned;
+            const searchCodeBlocks = 'codeBlocks' in searchConfig ? Boolean(searchConfig.codeBlocks) : true;
+            await rebuildSearchIndexByHtml(routes, {
+                outputDir,
+                versioned,
+                replaceRules,
+                domain,
+                searchCodeBlocks,
+                defaultLang: config.lang || 'en'
+            });
+            src_logger.info('rebuildSearchIndex success!');
+        }
+    };
+}
+export { createModuleFederationConfig, plugin_pluginModuleFederation as pluginModuleFederation };

package/dist/esm/packages/rspress-plugin/src/findSearchIndexPath.d.ts

@@ -0,0 +1 @@
+export declare function findSearchIndexPaths(outputDir: string): string[] | undefined;

package/dist/esm/packages/rspress-plugin/src/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: import("@module-federation/sdk").Logger;
+export default logger;

package/dist/esm/packages/rspress-plugin/src/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { moduleFederationPlugin } from '@module-federation/sdk';
+import type { RspressPlugin } from '@rspress/shared';
+type RspressPluginOptions = {
+    autoShared?: boolean;
+    rebuildSearchIndex?: boolean;
+};
+export declare function pluginModuleFederation(mfConfig: moduleFederationPlugin.ModuleFederationPluginOptions, rspressOptions?: RspressPluginOptions): RspressPlugin;
+export { createModuleFederationConfig } from '@module-federation/sdk';

package/dist/esm/packages/rspress-plugin/src/rebuildSearchIndexByHtml.d.ts

@@ -0,0 +1,10 @@
+import type { RouteMeta, ReplaceRule } from '@rspress/shared';
+export type RebuildSearchIndexByHtmlOptions = {
+    domain: string;
+    searchCodeBlocks: boolean;
+    replaceRules: ReplaceRule[];
+    versioned?: boolean;
+    outputDir: string;
+    defaultLang: string;
+};
+export declare function rebuildSearchIndexByHtml(routes: RouteMeta[], options: RebuildSearchIndexByHtmlOptions): Promise<void>;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@module-federation/rspress-plugin",
+  "version": "0.0.0-docs-remove-invalid-lark-link-20251205062649",
+  "type": "module",
+  "description": "Module Federation plugin for Rspress",
+  "keywords": [
+    "Module Federation",
+    "Rspress"
+  ],
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/rspress-plugin"
+  },
+  "license": "MIT",
+  "author": "hanric <hanric.zhang@gmail.com>",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/packages/rspress-plugin/src/plugin.d.ts",
+      "import": "./dist/esm/index.js"
+    }
+  },
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/packages/rspress-plugin/src/plugin.d.ts",
+  "devDependencies": {
+    "@rslib/core": "^0.9.2",
+    "@rspress/shared": "2.0.0-beta.16",
+    "@types/html-to-text": "^9.0.4",
+    "@types/lodash-es": "^4.17.12",
+    "@types/react": "^18.3.11"
+  },
+  "dependencies": {
+    "cheerio": "1.0.0-rc.12",
+    "fs-extra": "11.3.0",
+    "html-to-text": "^9.0.5",
+    "lodash-es": "^4.17.21",
+    "@module-federation/sdk": "0.0.0-docs-remove-invalid-lark-link-20251205062649",
+    "@module-federation/rsbuild-plugin": "0.0.0-docs-remove-invalid-lark-link-20251205062649",
+    "@module-federation/enhanced": "0.0.0-docs-remove-invalid-lark-link-20251205062649",
+    "@module-federation/error-codes": "0.0.0-docs-remove-invalid-lark-link-20251205062649"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib mf-dev",
+    "build:watch": "rslib build --watch"
+  }
+}