@rspress/plugin-preview 0.0.0-canary-20250521

package/dist/index.js

@@ -0,0 +1,626 @@
+"use strict";
+var __webpack_modules__ = {
+    "@rsbuild/plugin-less": function(module) {
+        module.exports = import("@rsbuild/plugin-less").then(function(module) {
+            return module;
+        });
+    },
+    "@rsbuild/plugin-sass": function(module) {
+        module.exports = import("@rsbuild/plugin-sass").then(function(module) {
+            return module;
+        });
+    }
+};
+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__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        pluginPreview: ()=>pluginPreview
+    });
+    const external_node_net_namespaceObject = require("node:net");
+    var external_node_net_default = /*#__PURE__*/ __webpack_require__.n(external_node_net_namespaceObject);
+    const external_node_path_namespaceObject = require("node:path");
+    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+    const core_namespaceObject = require("@rsbuild/core");
+    const plugin_babel_namespaceObject = require("@rsbuild/plugin-babel");
+    const plugin_react_namespaceObject = require("@rsbuild/plugin-react");
+    const plugin_solid_namespaceObject = require("@rsbuild/plugin-solid");
+    const shared_namespaceObject = require("@rspress/shared");
+    const external_lodash_namespaceObject = require("lodash");
+    const staticPath = external_node_path_default().join(__dirname, '..', 'static');
+    const demoBlockComponentPath = external_node_path_default().join(staticPath, 'global-components', 'DemoBlock.tsx');
+    const virtualDir = external_node_path_default().join(process.cwd(), 'node_modules', shared_namespaceObject.RSPRESS_TEMP_DIR, 'virtual-demo');
+    const external_node_fs_namespaceObject = require("node:fs");
+    var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+    const toValidVarName = (str)=>{
+        if (/^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(str)) return str;
+        return str.replace(/[^0-9a-zA-Z_$]/g, '_').replace(/^([0-9])/, '_$1');
+    };
+    const generateId = (pageName, index)=>`_${toValidVarName(pageName)}_${index}`;
+    const injectDemoBlockImport = (str, path)=>`
+    import DemoBlock from ${JSON.stringify(path)};
+    ${str}
+  `;
+    function generateEntryForPerComponent(demos, entryCssPath, framework) {
+        const sourceEntry = {};
+        Object.values(demos).forEach((routes)=>{
+            routes.forEach((route)=>{
+                const { id, path: demoPath } = route;
+                const entry = (0, external_node_path_namespaceObject.join)(virtualDir, `${id}.entry.tsx`);
+                const solidEntry = `
+      import { render } from 'solid-js/web';
+      import ${JSON.stringify(entryCssPath)};
+      import Demo from ${JSON.stringify(demoPath)};
+      render(() => <Demo />, document.getElementById('root'));
+      `;
+                const reactEntry = `
+      import { render } from 'react-dom';
+      import ${JSON.stringify(entryCssPath)};
+      import Demo from ${JSON.stringify(demoPath)};
+      render(<Demo />, document.getElementById('root'));
+      `;
+                const entryContent = 'react' === framework ? reactEntry : solidEntry;
+                (0, external_node_fs_namespaceObject.writeFileSync)(entry, entryContent);
+                sourceEntry[id] = entry;
+            });
+        });
+        return sourceEntry;
+    }
+    function generateEntryForPage(demos, entryCssPath, framework) {
+        const sourceEntry = {};
+        Object.entries(demos).forEach(([key, routes])=>{
+            if (0 === routes.length) return;
+            const reactContent = `
+      import { render } from 'react-dom';
+      import ${JSON.stringify(entryCssPath)};
+      ${routes.map((demo, index)=>`import Demo_${index} from ${JSON.stringify(demo.path)}`).join('\n')}
+      function App() {
+        return (
+          <div className="preview-container">
+            <div className="preview-nav">{"${routes[0].title}"}</div>
+            ${routes.map((_demo, index)=>`<Demo_${index} />`).join('\n')}
+          </div>
+        )
+      }
+      render(<App /> , document.getElementById('root'));
+    `;
+            const solidContent = `
+      import { render } from 'solid-js/web';
+      import ${JSON.stringify(entryCssPath)};
+      ${routes.map((demo, index)=>`import Demo_${index} from ${JSON.stringify(demo.path)}`).join('\n')}
+      function App() {
+        return (
+          <div class="preview-container">
+            <div class="preview-nav">{"${routes[0].title}"}</div>
+            ${routes.map((_, index)=>`<Demo_${index} />`).join('\n')}
+          </div>
+        )
+      }
+      render(() => <App /> , document.getElementById('root'));
+    `;
+            const renderContent = 'solid' === framework ? solidContent : reactContent;
+            const id = `_${toValidVarName(key)}`;
+            const entry = (0, external_node_path_namespaceObject.join)(virtualDir, `${id}.entry.tsx`);
+            (0, external_node_fs_namespaceObject.writeFileSync)(entry, renderContent);
+            sourceEntry[id] = entry;
+        });
+        return sourceEntry;
+    }
+    function generateEntry(demos, framework, position) {
+        const sourceEntry = {};
+        const entryCssPath = (0, external_node_path_namespaceObject.join)(staticPath, 'global-styles', 'entry.css');
+        if ('follow' === position) {
+            const entries = generateEntryForPerComponent(demos, entryCssPath, framework);
+            Object.assign(sourceEntry, entries);
+        } else if ('fixed' === position) {
+            const entries = generateEntryForPage(demos, entryCssPath, framework);
+            Object.assign(sourceEntry, entries);
+        } else if ('fixed-with-per-comp' === position) {
+            const entries = generateEntryForPerComponent(demos, entryCssPath, framework);
+            Object.assign(sourceEntry, entries);
+            const perPageEntries = generateEntryForPage(demos, entryCssPath, framework);
+            Object.assign(sourceEntry, perPageEntries);
+        }
+        return sourceEntry;
+    }
+    const node_utils_namespaceObject = require("@rspress/shared/node-utils");
+    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);
+        }
+    };
+    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 getExternalDemoContent = (tempVar)=>({
+            type: 'mdxJsxFlowElement',
+            name: '',
+            attributes: [],
+            children: [
+                {
+                    type: 'mdxJsxFlowElement',
+                    name: 'pre',
+                    attributes: [],
+                    children: [
+                        {
+                            type: 'mdxJsxFlowElement',
+                            name: 'code',
+                            attributes: [
+                                {
+                                    type: 'mdxJsxAttribute',
+                                    name: 'className',
+                                    value: 'language-tsx'
+                                },
+                                {
+                                    type: 'mdxJsxAttribute',
+                                    name: 'children',
+                                    value: {
+                                        type: 'mdxJsxExpressionAttribute',
+                                        value: tempVar,
+                                        data: {
+                                            estree: {
+                                                type: 'Program',
+                                                body: [
+                                                    {
+                                                        type: 'ExpressionStatement',
+                                                        expression: {
+                                                            type: 'Identifier',
+                                                            name: tempVar
+                                                        }
+                                                    }
+                                                ]
+                                            }
+                                        }
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        });
+    const remarkPlugin_demos = {};
+    const remarkCodeToDemo = function({ getRouteMeta, previewMode, defaultRenderMode, position, previewLanguages, previewCodeTransform }) {
+        const routeMeta = getRouteMeta();
+        external_node_fs_default().mkdirSync(virtualDir, {
+            recursive: true
+        });
+        const data = this.data();
+        return (tree, vfile)=>{
+            const demoMdx = [];
+            const route = routeMeta.find((meta)=>(0, shared_namespaceObject.normalizePosixPath)(meta.absolutePath) === (0, shared_namespaceObject.normalizePosixPath)(vfile.path || vfile.history[0]));
+            if (!route) return;
+            const { pageName } = route;
+            remarkPlugin_demos[pageName] = [];
+            let title = pageName;
+            let index = 1;
+            let externalDemoIndex = 0;
+            function constructDemoNode(demoId, demoPath, currentNode, isMobileMode, externalDemoIndex) {
+                if (isMobileMode) {
+                    const relativePathReg = new RegExp(/^\.\.?\/.*$/);
+                    remarkPlugin_demos[pageName].push({
+                        title,
+                        id: demoId,
+                        path: relativePathReg.test(demoPath) ? (0, external_node_path_namespaceObject.resolve)(vfile.dirname || (0, external_node_path_namespaceObject.dirname)(vfile.path), demoPath) : demoPath
+                    });
+                } else demoMdx.push(getASTNodeImport(`Demo${demoId}`, demoPath));
+                const tempVar = `externalDemoContent${externalDemoIndex}`;
+                if (void 0 !== externalDemoIndex) demoMdx.push(getASTNodeImport(tempVar, `!!${demoPath}?raw`));
+                if (isMobileMode && 'fixed' === position) void 0 !== externalDemoIndex && Object.assign(currentNode, getExternalDemoContent(tempVar));
+                else Object.assign(currentNode, {
+                    type: 'mdxJsxFlowElement',
+                    name: 'fixed-with-per-comp' === position ? 'ContainerFixedPerComp' : 'Container',
+                    attributes: [
+                        {
+                            type: 'mdxJsxAttribute',
+                            name: 'isMobile',
+                            value: isMobileMode
+                        },
+                        {
+                            type: 'mdxJsxAttribute',
+                            name: 'demoId',
+                            value: demoId
+                        }
+                    ],
+                    children: [
+                        void 0 === externalDemoIndex ? {
+                            ...currentNode,
+                            hasVisited: true
+                        } : getExternalDemoContent(tempVar),
+                        isMobileMode ? {
+                            type: 'mdxJsxFlowElement',
+                            name: null
+                        } : {
+                            type: 'mdxJsxFlowElement',
+                            name: `Demo${demoId}`
+                        }
+                    ]
+                });
+            }
+            lib_visit(tree, 'heading', (node)=>{
+                if (1 === node.depth) {
+                    const firstChild = node.children[0];
+                    title = firstChild && 'value' in firstChild && firstChild.value || title;
+                }
+            });
+            lib_visit(tree, 'mdxJsxFlowElement', (node)=>{
+                if ('code' === node.name) {
+                    const src = (0, node_utils_namespaceObject.getNodeAttribute)(node, 'src');
+                    if ('string' != typeof src) return;
+                    const currentMode = (0, node_utils_namespaceObject.getNodeAttribute)(node, 'previewMode') ?? previewMode;
+                    const isMobileAttr = (0, node_utils_namespaceObject.getNodeAttribute)(node, 'isMobile');
+                    let isMobileMode = false;
+                    isMobileMode = void 0 === isMobileAttr ? 'iframe' === currentMode : null === isMobileAttr ? true : 'object' == typeof isMobileAttr ? 'false' !== isMobileAttr.value : 'false' !== isMobileAttr;
+                    const id = generateId(pageName, index++);
+                    constructDemoNode(id, src, node, isMobileMode, externalDemoIndex++);
+                }
+            });
+            lib_visit(tree, 'code', (node)=>{
+                if ('hasVisited' in node) return;
+                if (node.lang && previewLanguages.includes(node.lang)) {
+                    var _node_meta, _node_meta1, _node_meta2, _node_meta3, _node_meta4, _node_meta5;
+                    if ((null == (_node_meta = node.meta) ? void 0 : _node_meta.includes('pure')) || !(null == (_node_meta1 = node.meta) ? void 0 : _node_meta1.includes('preview')) && 'pure' === defaultRenderMode) return;
+                    const value = injectDemoBlockImport(previewCodeTransform({
+                        language: node.lang,
+                        code: node.value
+                    }), demoBlockComponentPath);
+                    const isMobileMode = (null == (_node_meta2 = node.meta) ? void 0 : _node_meta2.includes('mobile')) || (null == (_node_meta3 = node.meta) ? void 0 : _node_meta3.includes('iframe')) || !(null == (_node_meta4 = node.meta) ? void 0 : _node_meta4.includes('web')) && !(null == (_node_meta5 = node.meta) ? void 0 : _node_meta5.includes('internal')) && 'iframe' === previewMode;
+                    const id = generateId(pageName, index++);
+                    const virtualModulePath = (0, external_node_path_namespaceObject.join)(virtualDir, `${id}.tsx`);
+                    constructDemoNode(id, virtualModulePath, node, isMobileMode);
+                    if (external_node_fs_default().existsSync(virtualModulePath)) {
+                        const content = external_node_fs_default().readFileSync(virtualModulePath, 'utf-8');
+                        if (content === value) return;
+                    }
+                    external_node_fs_default().writeFileSync(virtualModulePath, value);
+                }
+            });
+            tree.children.unshift(...demoMdx);
+            if (remarkPlugin_demos[pageName].length > 0) data.pageMeta.haveDemos = true;
+        };
+    };
+    let src_routeMeta;
+    const DEFAULT_PREVIEW_LANGUAGES = [
+        'jsx',
+        'tsx'
+    ];
+    function pluginPreview(options) {
+        const { isMobile = false, iframeOptions = {}, iframePosition = 'follow', defaultRenderMode = 'preview', previewLanguages = DEFAULT_PREVIEW_LANGUAGES, previewCodeTransform = ({ code })=>code } = options ?? {};
+        const previewMode = (null == options ? void 0 : options.previewMode) ?? (isMobile ? 'iframe' : 'internal');
+        const { devPort = 7890, framework = 'react', position = iframePosition, builderConfig = {} } = iframeOptions;
+        const getRouteMeta = ()=>src_routeMeta;
+        let lastDemos;
+        let devServer;
+        let clientConfig;
+        const port = devPort;
+        return {
+            name: '@rspress/plugin-preview',
+            config (config) {
+                config.markdown = config.markdown || {};
+                config.markdown.mdxRs = false;
+                return config;
+            },
+            routeGenerated (routes) {
+                src_routeMeta = routes;
+            },
+            async beforeBuild (_, isProd) {
+                if (!isProd) try {
+                    await new Promise((resolve, reject)=>{
+                        const server = external_node_net_default().createServer();
+                        server.unref();
+                        server.on('error', reject);
+                        server.listen({
+                            port,
+                            host: '0.0.0.0'
+                        }, ()=>{
+                            server.close(resolve);
+                        });
+                    });
+                } catch (e) {
+                    if (!!e && 'object' == typeof e && 'code' in e && 'EADDRINUSE' !== e.code) throw e;
+                    throw new Error(`Port "${port}" is occupied, please choose another one.`);
+                }
+            },
+            async afterBuild (config, isProd) {
+                var _devServer_server;
+                if ((0, external_lodash_namespaceObject.isEqual)(remarkPlugin_demos, lastDemos)) return;
+                lastDemos = (0, external_lodash_namespaceObject.cloneDeep)(remarkPlugin_demos);
+                await (null == devServer ? void 0 : null == (_devServer_server = devServer.server) ? void 0 : _devServer_server.close());
+                devServer = void 0;
+                const sourceEntry = generateEntry(remarkPlugin_demos, framework, position);
+                const outDir = (0, external_node_path_namespaceObject.join)(config.outDir ?? 'doc_build', '~demo');
+                if (0 === Object.keys(sourceEntry).length) return;
+                const { html, source, output, performance } = clientConfig ?? {};
+                const rsbuildConfig = (0, core_namespaceObject.mergeRsbuildConfig)({
+                    dev: {
+                        progressBar: false
+                    },
+                    server: {
+                        port: devPort,
+                        printUrls: ()=>void 0,
+                        strictPort: true
+                    },
+                    performance: {
+                        ...performance,
+                        printFileSize: false
+                    },
+                    html,
+                    source: {
+                        ...source,
+                        entry: sourceEntry
+                    },
+                    output: {
+                        ...output,
+                        assetPrefix: (null == output ? void 0 : output.assetPrefix) ? `${(0, shared_namespaceObject.removeTrailingSlash)(output.assetPrefix)}/~demo` : '/~demo',
+                        distPath: {
+                            root: outDir
+                        },
+                        copy: void 0
+                    },
+                    plugins: null == config ? void 0 : config.builderPlugins
+                }, builderConfig);
+                const rsbuildInstance = await (0, core_namespaceObject.createRsbuild)({
+                    callerName: 'rspress',
+                    rsbuildConfig
+                });
+                const { pluginSass } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@rsbuild/plugin-sass"));
+                const { pluginLess } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@rsbuild/plugin-less"));
+                rsbuildInstance.addPlugins([
+                    pluginSass(),
+                    pluginLess()
+                ]);
+                if ('solid' === framework) rsbuildInstance.addPlugins([
+                    (0, plugin_babel_namespaceObject.pluginBabel)({
+                        include: /\.(?:jsx|tsx)$/
+                    }),
+                    (0, plugin_solid_namespaceObject.pluginSolid)()
+                ]);
+                if ('react' === framework) rsbuildInstance.addPlugins([
+                    (0, plugin_react_namespaceObject.pluginReact)()
+                ]);
+                if (isProd) rsbuildInstance.build();
+                else devServer = await rsbuildInstance.startDevServer();
+            },
+            builderConfig: {
+                source: {
+                    include: [
+                        (0, external_node_path_namespaceObject.join)(__dirname, '..')
+                    ]
+                },
+                tools: {
+                    bundlerChain (chain) {
+                        chain.module.rule('Raw').resourceQuery(/raw/).type('asset/source').end();
+                        chain.resolve.extensions.prepend('.md').prepend('.mdx');
+                    },
+                    rspack: {
+                        watchOptions: {
+                            ignored: /\.git/
+                        }
+                    }
+                },
+                plugins: [
+                    {
+                        name: 'close-demo-server',
+                        setup: (api)=>{
+                            api.modifyRsbuildConfig((config)=>{
+                                var _config_output;
+                                if ((null == (_config_output = config.output) ? void 0 : _config_output.target) === 'web') clientConfig = config;
+                            });
+                            api.onCloseDevServer(async ()=>{
+                                var _devServer_server;
+                                await (null == devServer ? void 0 : null == (_devServer_server = devServer.server) ? void 0 : _devServer_server.close());
+                                devServer = void 0;
+                            });
+                        }
+                    }
+                ]
+            },
+            extendPageData (pageData, isProd) {
+                if (!isProd) pageData.devPort = port;
+                pageData.extraHighlightLanguages = previewLanguages;
+            },
+            markdown: {
+                remarkPlugins: [
+                    [
+                        remarkCodeToDemo,
+                        {
+                            getRouteMeta,
+                            position,
+                            previewMode,
+                            defaultRenderMode,
+                            previewLanguages,
+                            previewCodeTransform
+                        }
+                    ]
+                ],
+                globalComponents: [
+                    (0, external_node_path_namespaceObject.join)(staticPath, 'global-components', 'Container.tsx'),
+                    (0, external_node_path_namespaceObject.join)(staticPath, 'global-components', 'ContainerFixedPerComp.tsx')
+                ]
+            },
+            globalUIComponents: 'fixed-with-per-comp' === position ? [
+                (0, external_node_path_namespaceObject.join)(staticPath, 'global-components', 'DeviceFixedPerComp.tsx')
+            ] : 'fixed' === position ? [
+                (0, external_node_path_namespaceObject.join)(staticPath, 'global-components', 'Device.tsx')
+            ] : [],
+            globalStyles: (0, external_node_path_namespaceObject.join)(staticPath, 'global-styles', `${previewMode}.css`)
+        };
+    }
+})();
+exports.pluginPreview = __webpack_exports__.pluginPreview;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "pluginPreview"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils.d.ts

@@ -0,0 +1,19 @@
+export declare const generateId: (pageName: string, index: number) => string;
+
+export declare const injectDemoBlockImport: (str: string, path: string) => string;
+
+/**
+ * remove .html extension and validate
+ * @param routePath id from pathname
+ * @returns normalized id
+ */
+export declare const normalizeId: (routePath: string) => string;
+
+/**
+ * Converts a string to a valid variable name. If the string is already a valid variable name, returns the original string.
+ * @param str - The string to convert.
+ * @returns The converted string.
+ */
+export declare const toValidVarName: (str: string) => string;
+
+export { }