@rspress/plugin-playground 1.40.2 → 1.41.0

package/dist/cli/esm/301.mjs

@@ -0,0 +1,11 @@
+export const ids = [
+    '301'
+];
+export const modules = {
+    "../../node_modules/.pnpm/unist-util-visit@4.1.2/node_modules/unist-util-visit/index.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            visit: ()=>_lib_index_js__WEBPACK_IMPORTED_MODULE_0__.Vn
+        });
+        var _lib_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../node_modules/.pnpm/unist-util-visit@4.1.2/node_modules/unist-util-visit/lib/index.js");
+    }
+};

package/dist/cli/esm/index.d.ts

@@ -1,24 +1,28 @@
-import { loader, EditorProps } from '@monaco-editor/react';
-import { RouteMeta, RspressPlugin } from '@rspress/shared';
-
-interface PlaygroundOptions {
-    render: string;
-    include: Array<string | [string, string]>;
-    defaultDirection: 'horizontal' | 'vertical';
-    editorPosition: 'left' | 'right';
-    babelUrl: string;
-    monacoLoader: Parameters<typeof loader.config>[0];
-    monacoOptions: EditorProps['options'];
-    /**
-     * determine how to handle a internal code block without meta
-     * @default 'playground'
-     */
-    defaultRenderMode?: 'pure' | 'playground';
-}
-declare let routeMeta: RouteMeta[];
-/**
- * The plugin is used to preview component.
- */
-declare function pluginPlayground(options?: Partial<PlaygroundOptions>): RspressPlugin;
-
-export { pluginPlayground, routeMeta };
+import type { EditorProps } from '@monaco-editor/react';
+import type { loader } from '@monaco-editor/react';
+import type { RouteMeta } from '@rspress/shared';
+import type { RspressPlugin } from '@rspress/shared';
+
+declare interface PlaygroundOptions {
+    render: string;
+    include: Array<string | [string, string]>;
+    defaultDirection: 'horizontal' | 'vertical';
+    editorPosition: 'left' | 'right';
+    babelUrl: string;
+    monacoLoader: Parameters<typeof loader.config>[0];
+    monacoOptions: EditorProps['options'];
+    /**
+     * determine how to handle a internal code block without meta
+     * @default 'playground'
+     */
+    defaultRenderMode?: 'pure' | 'playground';
+}
+
+/**
+ * The plugin is used to preview component.
+ */
+export declare function pluginPlayground(options?: Partial<PlaygroundOptions>): RspressPlugin;
+
+export declare let routeMeta: RouteMeta[];
+
+export { }

package/dist/cli/esm/index.mjs

@@ -0,0 +1,470 @@
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_rspack_plugin_virtual_module_609978fd__ from "rspack-plugin-virtual-module";
+import * as __WEBPACK_EXTERNAL_MODULE__oxidation_compiler_napi_5e24345a__ from "@oxidation-compiler/napi";
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/unist-util-visit@4.1.2/node_modules/unist-util-visit/lib/index.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Vn: ()=>lib_visit
+        });
+        const convert = function(test) {
+            if (null == test) return ok;
+            if ('string' == typeof test) return typeFactory(test);
+            if ('object' == typeof test) return Array.isArray(test) ? anyFactory(test) : propsFactory(test);
+            if ('function' == typeof test) return castFactory(test);
+            throw new Error('Expected function, string, or object as test');
+        };
+        function anyFactory(tests) {
+            const checks = [];
+            let index = -1;
+            while(++index < tests.length)checks[index] = convert(tests[index]);
+            return castFactory(any);
+            function any(...parameters) {
+                let index = -1;
+                while(++index < checks.length)if (checks[index].call(this, ...parameters)) return true;
+                return false;
+            }
+        }
+        function propsFactory(check) {
+            return castFactory(all);
+            function all(node) {
+                let key;
+                for(key in check)if (node[key] !== check[key]) return false;
+                return true;
+            }
+        }
+        function typeFactory(check) {
+            return castFactory(type);
+            function type(node) {
+                return node && node.type === check;
+            }
+        }
+        function castFactory(check) {
+            return assertion;
+            function assertion(node, ...parameters) {
+                return Boolean(node && 'object' == typeof node && 'type' in node && Boolean(check.call(this, node, ...parameters)));
+            }
+        }
+        function ok() {
+            return true;
+        }
+        function color(d) {
+            return '\u001B[33m' + d + '\u001B[39m';
+        }
+        const CONTINUE = true;
+        const EXIT = false;
+        const SKIP = 'skip';
+        const visitParents = function(tree, test, visitor, reverse) {
+            if ('function' == typeof test && 'function' != typeof visitor) {
+                reverse = visitor;
+                visitor = test;
+                test = null;
+            }
+            const is = convert(test);
+            const step = reverse ? -1 : 1;
+            factory(tree, void 0, [])();
+            function factory(node, index, parents) {
+                const value = node && 'object' == typeof node ? node : {};
+                if ('string' == typeof value.type) {
+                    const name = 'string' == typeof value.tagName ? value.tagName : 'string' == typeof value.name ? value.name : void 0;
+                    Object.defineProperty(visit, 'name', {
+                        value: 'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'
+                    });
+                }
+                return visit;
+                function visit() {
+                    let result = [];
+                    let subresult;
+                    let offset;
+                    let grandparents;
+                    if (!test || is(node, index, parents[parents.length - 1] || null)) {
+                        result = toResult(visitor(node, parents));
+                        if (result[0] === EXIT) return result;
+                    }
+                    if (node.children && result[0] !== SKIP) {
+                        offset = (reverse ? node.children.length : -1) + step;
+                        grandparents = parents.concat(node);
+                        while(offset > -1 && offset < node.children.length){
+                            subresult = factory(node.children[offset], offset, grandparents)();
+                            if (subresult[0] === EXIT) return subresult;
+                            offset = 'number' == typeof subresult[1] ? subresult[1] : offset + step;
+                        }
+                    }
+                    return result;
+                }
+            }
+        };
+        function toResult(value) {
+            if (Array.isArray(value)) return value;
+            if ('number' == typeof value) return [
+                CONTINUE,
+                value
+            ];
+            return [
+                value
+            ];
+        }
+        const lib_visit = function(tree, test, visitor, reverse) {
+            if ('function' == typeof test && 'function' != typeof visitor) {
+                reverse = visitor;
+                visitor = test;
+                test = null;
+            }
+            visitParents(tree, test, overload, reverse);
+            function overload(node, parents) {
+                const parent = parents[parents.length - 1];
+                return visitor(node, parent ? parent.children.indexOf(node) : null, parent);
+            }
+        };
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.d = function(exports, definition) {
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.f = {};
+    __webpack_require__.e = function(chunkId) {
+        return Promise.all(Object.keys(__webpack_require__.f).reduce(function(promises, key) {
+            __webpack_require__.f[key](chunkId, promises);
+            return promises;
+        }, []));
+    };
+})();
+(()=>{
+    __webpack_require__.u = function(chunkId) {
+        return "" + chunkId + ".mjs";
+    };
+})();
+(()=>{
+    __webpack_require__.o = function(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+    };
+})();
+(()=>{
+    var installedChunks = {
+        980: 0
+    };
+    var installChunk = function(data) {
+        var ids = data.ids;
+        var modules = data.modules;
+        var runtime = data.runtime;
+        var moduleId, chunkId, i = 0;
+        for(moduleId in modules)if (__webpack_require__.o(modules, moduleId)) __webpack_require__.m[moduleId] = modules[moduleId];
+        if (runtime) runtime(__webpack_require__);
+        for(; i < ids.length; i++){
+            chunkId = ids[i];
+            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
+            installedChunks[ids[i]] = 0;
+        }
+    };
+    __webpack_require__.f.j = function(chunkId, promises) {
+        var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : void 0;
+        if (0 !== installedChunkData) {
+            if (installedChunkData) promises.push(installedChunkData[1]);
+            else {
+                var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, function(e) {
+                    if (0 !== installedChunks[chunkId]) installedChunks[chunkId] = void 0;
+                    throw e;
+                });
+                var promise = Promise.race([
+                    promise,
+                    new Promise(function(resolve) {
+                        installedChunkData = installedChunks[chunkId] = [
+                            resolve
+                        ];
+                    })
+                ]);
+                promises.push(installedChunkData[1] = promise);
+            }
+        }
+    };
+})();
+const DEFAULT_BABEL_URL = 'https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/7.22.20/babel.min.js';
+const DEFAULT_MONACO_URL = 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.43.0/min/vs';
+function normalizeUrl(u) {
+    return u.replace(/\/\//g, '/');
+}
+const staticPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(__dirname, '../../../static');
+var lib = __webpack_require__("../../node_modules/.pnpm/unist-util-visit@4.1.2/node_modules/unist-util-visit/lib/index.js");
+const parseImports = (code, sourceExt)=>{
+    const parsed = __WEBPACK_EXTERNAL_MODULE__oxidation_compiler_napi_5e24345a__["default"].parseSync(code, {
+        sourceType: 'module',
+        sourceFilename: `index.${sourceExt}`
+    });
+    const ast = JSON.parse(parsed.program);
+    const result = [];
+    ast.body.forEach((statement)=>{
+        if ('ImportDeclaration' === statement.type) result.push(statement.source.value);
+    });
+    return result;
+};
+const getNodeAttribute = (node, attrName)=>{
+    var _node_attributes_find;
+    return null === (_node_attributes_find = node.attributes.find((attr)=>attr.name === attrName)) || void 0 === _node_attributes_find ? void 0 : _node_attributes_find.value;
+};
+const getNodeMeta = (node, metaName)=>{
+    if (!node.meta) return;
+    const meta = node.meta.split(' ');
+    const item = meta.find((x)=>x.startsWith(metaName));
+    if (null == item ? void 0 : item.startsWith(`${metaName}=`)) return item.substring(metaName.length + 1);
+    return item;
+};
+function createPlaygroundNode(currentNode, attrs) {
+    Object.assign(currentNode, {
+        type: 'mdxJsxFlowElement',
+        name: 'Playground',
+        attributes: attrs.map((it)=>({
+                type: 'mdxJsxAttribute',
+                name: it[0],
+                value: it[1]
+            }))
+    });
+}
+const remarkPlugin = ({ getRouteMeta, editorPosition, defaultRenderMode })=>{
+    const routeMeta = getRouteMeta();
+    return (tree, vfile)=>{
+        const route = routeMeta.find((meta)=>(0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.resolve)(meta.absolutePath) === (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.resolve)(vfile.path || vfile.history[0]));
+        if (!route) return;
+        (0, lib.Vn)(tree, 'mdxJsxFlowElement', (node)=>{
+            if ('code' === node.name) {
+                const src = getNodeAttribute(node, 'src');
+                if (!src) return;
+                const demoPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)((0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.dirname)(route.absolutePath), src);
+                if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(demoPath)) return;
+                const direction = getNodeAttribute(node, 'direction') || '';
+                const code = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(demoPath, {
+                    encoding: 'utf8'
+                });
+                const language = src.substr(src.lastIndexOf('.') + 1);
+                createPlaygroundNode(node, [
+                    [
+                        'code',
+                        code
+                    ],
+                    [
+                        'language',
+                        language
+                    ],
+                    [
+                        'direction',
+                        direction
+                    ],
+                    [
+                        'editorPosition',
+                        editorPosition
+                    ]
+                ]);
+            }
+        });
+        (0, lib.Vn)(tree, 'code', (node)=>{
+            if ('jsx' === node.lang || 'tsx' === node.lang) {
+                var _node_meta, _node_meta1;
+                const hasPureMeta = null == node ? void 0 : null === (_node_meta = node.meta) || void 0 === _node_meta ? void 0 : _node_meta.includes('pure');
+                const hasPlaygroundMeta = null == node ? void 0 : null === (_node_meta1 = node.meta) || void 0 === _node_meta1 ? void 0 : _node_meta1.includes('playground');
+                let noTransform;
+                switch(defaultRenderMode){
+                    case 'pure':
+                        noTransform = !hasPlaygroundMeta;
+                        break;
+                    case 'playground':
+                        noTransform = hasPureMeta;
+                        break;
+                    default:
+                        break;
+                }
+                if (noTransform) return;
+                const direction = getNodeMeta(node, 'direction') || '';
+                createPlaygroundNode(node, [
+                    [
+                        'code',
+                        node.value
+                    ],
+                    [
+                        'language',
+                        node.lang
+                    ],
+                    [
+                        'direction',
+                        direction
+                    ],
+                    [
+                        'editorPosition',
+                        editorPosition
+                    ]
+                ]);
+            }
+        });
+    };
+};
+let cli_rslib_entry_routeMeta;
+function pluginPlayground(options) {
+    var _monacoLoader_paths;
+    const { render = '', include, defaultDirection = 'horizontal', editorPosition = 'left', babelUrl = DEFAULT_BABEL_URL, monacoLoader = {}, monacoOptions = {}, defaultRenderMode = 'playground' } = options || {};
+    const playgroundVirtualModule = new __WEBPACK_EXTERNAL_MODULE_rspack_plugin_virtual_module_609978fd__.RspackVirtualModulePlugin({});
+    const getRouteMeta = ()=>cli_rslib_entry_routeMeta;
+    if (render && !/Playground\.(jsx?|tsx?)$/.test(render)) throw new Error('[Playground]: render should ends with Playground.(jsx?|tsx?)');
+    const preloads = [];
+    const monacoPrefix = (null === (_monacoLoader_paths = monacoLoader.paths) || void 0 === _monacoLoader_paths ? void 0 : _monacoLoader_paths.vs) || DEFAULT_MONACO_URL;
+    preloads.push(normalizeUrl(`${monacoPrefix}/loader.js`));
+    preloads.push(normalizeUrl(`${monacoPrefix}/editor/editor.main.js`));
+    return {
+        name: '@rspress/plugin-playground',
+        config (config, { removePlugin }) {
+            config.markdown = config.markdown || {};
+            config.markdown.mdxRs = false;
+            removePlugin('@rspress/plugin-preview');
+            return config;
+        },
+        async routeGenerated (routes) {
+            cli_rslib_entry_routeMeta = routes;
+            const files = routes.map((route)=>route.absolutePath);
+            const imports = {};
+            await Promise.all(files.map(async (filepath, _index)=>{
+                const isMdxFile = /\.mdx?$/.test(filepath);
+                if (!isMdxFile) return;
+                const { createProcessor } = await import("@mdx-js/mdx");
+                const { visit } = await __webpack_require__.e("301").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/unist-util-visit@4.1.2/node_modules/unist-util-visit/index.js"));
+                const { default: remarkGFM } = await import("remark-gfm");
+                try {
+                    const processor = createProcessor({
+                        format: __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].extname(filepath).slice(1),
+                        remarkPlugins: [
+                            remarkGFM
+                        ]
+                    });
+                    const source = await __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].promises.readFile(filepath, 'utf-8');
+                    const ast = processor.parse(source);
+                    visit(ast, 'mdxJsxFlowElement', (node)=>{
+                        if ('code' === node.name) {
+                            const src = getNodeAttribute(node, 'src');
+                            if (!src) return;
+                            const demoPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(filepath), src);
+                            if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(demoPath)) return;
+                            const code = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(demoPath, {
+                                encoding: 'utf8'
+                            });
+                            const thisImports = parseImports(code, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].extname(demoPath));
+                            thisImports.forEach((x)=>{
+                                if (void 0 === imports[x]) imports[x] = x;
+                            });
+                        }
+                    });
+                    visit(ast, 'code', (node)=>{
+                        if ('jsx' === node.lang || 'tsx' === node.lang) {
+                            const { value, meta } = node;
+                            const hasPureMeta = null == meta ? void 0 : meta.includes('pure');
+                            const hasPlaygroundMeta = null == meta ? void 0 : meta.includes('playground');
+                            let noTransform;
+                            switch(defaultRenderMode){
+                                case 'pure':
+                                    noTransform = !hasPlaygroundMeta;
+                                    break;
+                                case 'playground':
+                                    noTransform = hasPureMeta;
+                                    break;
+                                default:
+                                    break;
+                            }
+                            if (noTransform) return;
+                            const thisImports = parseImports(value, node.lang);
+                            thisImports.forEach((x)=>{
+                                if (void 0 === imports[x]) imports[x] = x;
+                            });
+                        }
+                    });
+                } catch (e) {
+                    console.error(e);
+                    throw e;
+                }
+            }));
+            if (include) include.forEach((item)=>{
+                if ('string' == typeof item) imports[item] = item;
+                else imports[item[0]] = item[1];
+            });
+            if (!('react' in imports)) imports.react = 'react';
+            const importKeys = Object.keys(imports);
+            const code = [
+                ...importKeys.map((x, index)=>`import * as i_${index} from '${imports[x]}';`),
+                'const imports = new Map();',
+                ...importKeys.map((x, index)=>`imports.set('${x}', i_${index});`),
+                'function getImport(name, getDefault) {',
+                '  if (!imports.has(name)) {',
+                '    throw new Error("Module " + name + " not found");',
+                '  }',
+                '  const result = imports.get(name);',
+                '  if (getDefault && typeof result === "object") {',
+                '    return result.default || result;',
+                '  }',
+                '  return result;',
+                '}',
+                'export { imports };',
+                'export default getImport;'
+            ].join('\n');
+            playgroundVirtualModule.writeModule('_rspress_playground_imports', code);
+        },
+        builderConfig: {
+            source: {
+                define: {
+                    __PLAYGROUND_DIRECTION__: JSON.stringify(defaultDirection),
+                    __PLAYGROUND_MONACO_LOADER__: JSON.stringify(monacoLoader),
+                    __PLAYGROUND_MONACO_OPTIONS__: JSON.stringify(monacoOptions),
+                    __PLAYGROUND_BABEL_URL__: JSON.stringify(babelUrl)
+                },
+                include: [
+                    (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(__dirname, '..', '..', '..')
+                ]
+            },
+            html: {
+                tags: preloads.map((url)=>({
+                        tag: 'link',
+                        head: true,
+                        attrs: {
+                            rel: 'preload',
+                            href: url,
+                            as: "script"
+                        }
+                    }))
+            },
+            tools: {
+                rspack: {
+                    plugins: [
+                        playgroundVirtualModule
+                    ]
+                }
+            }
+        },
+        markdown: {
+            remarkPlugins: [
+                [
+                    remarkPlugin,
+                    {
+                        getRouteMeta,
+                        editorPosition,
+                        defaultRenderMode
+                    }
+                ]
+            ],
+            globalComponents: [
+                render ? render : __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(staticPath, 'global-components', 'Playground.tsx')
+            ]
+        },
+        globalStyles: __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(staticPath, 'global-styles', 'web.css')
+    };
+}
+export { pluginPlayground, cli_rslib_entry_routeMeta as routeMeta };