@wbc-ui/core2 1.0.0-r01

package/logo/wb-core.svg

@@ -0,0 +1,32 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 140" width="400" height="140">
+  <defs>
+    <linearGradient id="g" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#1976D2"/>
+      <stop offset="100%" style="stop-color:#42A5F5"/>
+    </linearGradient>
+    <linearGradient id="g2" x1="0%" y1="0%" x2="100%" y2="0%">
+      <stop offset="0%" style="stop-color:#0D47A1"/>
+      <stop offset="100%" style="stop-color:#1976D2"/>
+    </linearGradient>
+  </defs>
+
+  <!-- WBC hex icon -->
+  <polygon points="70,20 120,45 120,95 70,120 20,95 20,45" fill="url(#g)" stroke="#0D47A1" stroke-width="2"/>
+  <text x="70" y="82" text-anchor="middle" font-family="monospace" font-weight="bold" font-size="32" fill="white">WBC</text>
+
+  <!-- subtag -->
+  <rect x="50" y="88" width="40" height="14" rx="3" fill="#0D47A1" opacity="0.85"/>
+  <text x="70" y="99" text-anchor="middle" font-family="monospace" font-size="8" fill="white">CORE</text>
+
+  <!-- Type label -->
+  <text x="150" y="50" font-family="Arial, sans-serif" font-weight="900" font-size="36" fill="url(#g2)">@wbc-ui</text>
+  <text x="150" y="72" font-family="Arial, sans-serif" font-weight="700" font-size="24" fill="#1565C0">/ core2</text>
+
+  <!-- Tagline -->
+  <text x="150" y="100" font-family="Arial, sans-serif" font-size="13" fill="#546E7A">UI as Data · Vue 2 Engine · JSON → VNodes</text>
+
+  <!-- Decorative dots -->
+  <circle cx="155" cy="112" r="2.5" fill="#1976D2" opacity="0.5"/>
+  <circle cx="165" cy="112" r="2.5" fill="#42A5F5" opacity="0.5"/>
+  <circle cx="175" cy="112" r="2.5" fill="#90CAF9" opacity="0.5"/>
+</svg>

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@wbc-ui/core2",
+  "version": "1.0.0-r01",
+  "description": "Advanced Dynamic UI Engine for Vue 2 — Part of the @wbc-ui ecosystem",
+  "author": "Wissem Boughamoura <wissemb11@gmail.com> (https://www.wi-bg.com)",
+  "homepage": "https://wbc-ui.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wbc-ui/core2.git",
+    "directory": "frontEnd/wbc-ui/core2/packages/wb-core"
+  },
+  "bugs": {
+    "url": "https://github.com/wbc-ui/core2/issues"
+  },
+  "main": "dist-free/core2.umd.js",
+  "module": "dist-free/core2.es.js",
+  "exports": {
+    ".": {
+      "import": "./dist-free/core2.es.js",
+      "require": "./dist-free/core2.umd.js"
+    },
+    "./vite-plugin": "./vite-plugin.mjs",
+    "./vite-plugin.js": "./vite-plugin.mjs",
+    "./vite-plugin.mjs": "./vite-plugin.mjs",
+    "./wbc.webpack.js": "./wbc.webpack.js",
+    "./dist-free/*": "./dist-free/*"
+  },
+  "files": [
+    "dist-free",
+    "README.md",
+    "LICENSE",
+    "logo/",
+    "vite-plugin.mjs",
+    "wbc.webpack.js"
+  ],
+  "dependencies": {
+    "acorn": "^8.16.0",
+    "acorn-walk": "^8.3.5",
+    "bootstrap": "^4.6.2",
+    "dompurify": "^3.3.3",
+    "jsep": "^1.4.0",
+    "lz-string": "^1.5.0",
+    "markdown-it": "^14.1.0",
+    "markdown-it-anchor": "^9.2.0",
+    "markdown-it-code-copy": "^0.2.2",
+    "turndown": "^7.2.0"
+  },
+  "peerDependencies": {
+    "vue": "^2.7.16",
+    "vue-router": "^3.0.0",
+    "vuetify": "^2.7.2",
+    "vuex": "^3.6.2",
+    "bootstrap-vue": "^2.22.0",
+    "vue-json-viewer": "^2.2.22",
+    "vue-cookies": "^1.8.3",
+    "vue-cryptojs": "^2.3.1",
+    "vue-dayjs": "^1.0.2"
+  },
+  "peerDependenciesMeta": {
+    "echarts": {
+      "optional": true
+    },
+    "mermaid": {
+      "optional": true
+    },
+    "codemirror": {
+      "optional": true
+    },
+    "vue-codemirror": {
+      "optional": true
+    },
+    "vue-cryptojs": {
+      "optional": true
+    },
+    "vue-dayjs": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "vue",
+    "vue2",
+    "ui-engine",
+    "dynamic-ui",
+    "wbc-ui",
+    "dynamic-components",
+    "no-code",
+    "low-code",
+    "json-driven",
+    "vuetify"
+  ],
+  "sideEffects": false
+}

package/vite-plugin.mjs

@@ -0,0 +1,354 @@
+/**
+ * wbc-ui2 — Vite Plugins
+ *
+ * Provides Vite plugins that replicate the Webpack features
+ * required by wbc-ui2 (WBC) to resolve local files.
+ *
+ * Usage in your vite.config.js:
+ *
+ *   import { wbcVitePlugin } from '@wbc-ui/core2/vite-plugin';
+ *
+ *   export default defineConfig({
+ *       plugins: [
+ *           vue(),
+ *           ...wbcVitePlugin(),   // ← spread! returns an array of plugins
+ *       ],
+ *   });
+ */
+// ─── Extension Lists ───
+
+// Standard modules (handled by Vite's normal pipeline)
+// NOTE: JS/TS are NOT here — they go through raw + lazy to avoid side-effect execution
+const STANDARD_EXTENSIONS =
+    '{jpeg,jpg,png,gif,svg,webp,avif,bmp,ico,' +
+    'mp4,webm,mov,avi,mp3,wav,flac,ogg,' +
+    'json,pdf,' +
+    'vue}';
+
+// Raw files (handled as strings via ?raw)
+// JS/TS are included here — loaded as raw text (no execution, no side effects)
+const RAW_EXTENSIONS = '{md,txt,py,rs,php,sh,tex,html,mmd,css,scss,sass,less,styl,stylus,js,jsx,ts,tsx}';
+
+// Directories to exclude from context scanning
+const EXCLUDED_DIRS = [
+    '!**/node_modules/**',
+    '!**/dist/**',
+    '!**/dist-vite/**',
+    '!**/dist-rollup/**',
+    '!**/public/**',
+    '!**/.vite/**',
+    '!**/.git/**',
+];
+
+// ─── Extensions loaded as raw strings (not parsed as modules) ───
+// Used by rawFileLoaderPlugin for direct imports
+const RAW_EXTENSIONS_RE = /\.(md|txt|py|rs|sh|tex|php|html|mmd)$/;
+const DOUBLE_UNDERSCORE_RE = /__[^/]+\.(vue|js|ts|md|php|sh|html|tex|txt|py|rs|css|scss|sass)$/;
+
+/**
+ * Plugin 1: require.context() → import.meta.glob()
+ */
+function requireContextPlugin() {
+    return {
+        name: 'wbc-ui2:require-context',
+        enforce: 'pre',
+        transform(code, id) {
+            // Only process JS/TS source files
+            if (!id.endsWith('.js') && !id.endsWith('.ts')) return null;
+            if (id.includes('node_modules')) return null;
+            if (!code.includes('require.context')) return null;
+
+            const transformed = code.replace(
+                /require\.context\(\s*["']([^"']+)["']\s*,\s*true\s*\)/g,
+                (_match, dir) => {
+                    const glob = dir.endsWith('/') ? dir : dir + '/';
+
+                    const mainPattern = `${glob}**/*.${STANDARD_EXTENSIONS}`;
+                    const excludeUnderscore = `${glob}**/__*.*`;
+
+                    const rawPattern1 = `${glob}**/*.${RAW_EXTENSIONS}`;
+                    const rawPattern2 = `${glob}**/__*.*`;
+
+                    const jsLazyPattern = `${glob}**/*.{js,jsx,ts,tsx}`;
+
+                    const mainGlobArray = JSON.stringify([
+                        mainPattern,
+                        '!' + excludeUnderscore,
+                        ...EXCLUDED_DIRS
+                    ]);
+
+                    const rawGlobArray = JSON.stringify([
+                        rawPattern1,
+                        rawPattern2,
+                        ...EXCLUDED_DIRS
+                    ]);
+
+                    const jsLazyGlobArray = JSON.stringify([
+                        jsLazyPattern,
+                        ...EXCLUDED_DIRS
+                    ]);
+
+                    return `(function(){` +
+                        // 1. Standard modules (images, vue, json — NOT js)
+                        `var _std=import.meta.glob(${mainGlobArray},{eager:true});` +
+                        // 2. Raw text (md, html, css, js — everything as text)
+                        `var _r=import.meta.glob(${rawGlobArray},{eager:true,query:"?raw",import:"default"});` +
+                        // 3. Lazy JS modules (for on-demand Vue component loading)
+                        `var _lazy=import.meta.glob(${jsLazyGlobArray},{eager:false});` +
+                        // Build merged map + separate lazy map
+                        `var _prefix=${JSON.stringify(glob)};` +
+                        `var _m={};` +
+                        `var _lazyMap={};` +
+                        // First: add all standard entries
+                        `Object.keys(_std).forEach(function(k){` +
+                        `var nk=k.indexOf(_prefix)===0?"./"+k.slice(_prefix.length):k;` +
+                        `_m[nk]=_std[k]` +
+                        `});` +
+                        // Then: add raw entries (wrap as {default: text}), don't overwrite standard
+                        `Object.keys(_r).forEach(function(k){` +
+                        `var nk=k.indexOf(_prefix)===0?"./"+k.slice(_prefix.length):k;` +
+                        `if(!_m[nk]){_m[nk]={default:_r[nk]||_r[k]}}` +
+                        `});` +
+                        // Store lazy importers in separate map (avoids frozen object issue)
+                        `Object.keys(_lazy).forEach(function(k){` +
+                        `var nk=k.indexOf(_prefix)===0?"./"+k.slice(_prefix.length):k;` +
+                        `_lazyMap[nk]=_lazy[k]` +
+                        `});` +
+                        // Build context function
+                        `function _c(k){if(!(k in _m)){throw new Error(\"Cannot find module '\"+k+\"'\")}return _m[k]}` +
+                        `_c.keys=function(){return Object.keys(_m)};` +
+                        // rawSource: returns raw text for code display
+                        `_c.rawSource=function(k){` +
+                        `var nk=k;` +
+                        `var rk=k.indexOf("./")===0?_prefix+k.slice(2):k;` +
+                        `return _r[rk]||_r[nk]||_r[k]||null` +
+                        `};` +
+                        // lazyImport: returns Promise resolving to JS module (for Vue components)
+                        `_c.lazyImport=function(k){` +
+                        `var norm=function(p){return p.replace(/\\/\\//g,'/').replace(/^\\.\\//,'')};` +
+                        `var nk=norm(k);` +
+                        `var fn=_lazyMap[k]||_lazyMap["./"+nk]||_lazyMap[nk]||_lazyMap[_prefix+nk]||_lazyMap["./"+_prefix+nk];` +
+                        `if(!fn){` +
+                        `  Object.keys(_lazyMap).forEach(function(lk){ if(norm(lk)===nk) fn=_lazyMap[lk] });` +
+                        `}` +
+                        `if(!fn && k.indexOf(_prefix)===0) fn=_lazyMap["./"+k.slice(_prefix.length)];` +
+                        `if(!fn) console.warn("WBC lazyImport: could not find '"+k+"' in", Object.keys(_lazyMap));` +
+                        `return fn?fn():null` +
+                        `};` +
+                        `return _c` +
+                        `})()`;
+                }
+            );
+
+            if (transformed !== code) {
+                return { code: transformed, map: null };
+            }
+        }
+    };
+}
+
+/**
+ * Plugin 2: Raw file loader
+ * Handles direct imports of raw files (not via require.context)
+ */
+function rawFileLoaderPlugin() {
+    return {
+        name: 'wbc-ui2:raw-file-loader',
+        enforce: 'pre',
+        transform(code, id) {
+            // Skip files already loaded with ?raw query
+            if (id.includes('?raw')) return null;
+
+            // Exclude index.html (Vite entry point) from raw transformation
+            if (id.endsWith('index.html')) return null;
+
+            // Exclude public directory files so they are served verbatim by Vite's static file server
+            if (id.includes('/public/')) return null;
+
+            const isRawExt = RAW_EXTENSIONS_RE.test(id);
+            const isDoubleUnderscore = DOUBLE_UNDERSCORE_RE.test(id);
+            if (isRawExt || isDoubleUnderscore) {
+                const json = JSON.stringify(code);
+                return {
+                    code: `export default ${json}`,
+                    map: null
+                };
+            }
+        }
+    };
+}
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+function monorepoDevConfigPlugin() {
+    return {
+        name: 'wbc-ui2:monorepo-dev-config',
+        config(config, env) {
+            let pluginDir;
+            try {
+                pluginDir = path.dirname(fileURLToPath(import.meta.url));
+            } catch (e) {
+                pluginDir = __dirname;
+            }
+
+            const coreSrcPath = path.resolve(pluginDir, './src');
+            if (!fs.existsSync(coreSrcPath)) return null;
+
+            // Dependencies are resolved from the common monorepo root or root node_modules.
+            // Plugin lives at packages/wb-core/core/, so monoRoot = packages/
+            const monoRoot = path.resolve(pluginDir, '../../');
+            const rootNodeModules = path.resolve(monoRoot, '../node_modules');
+
+            const DEPS = [
+                'echarts', 'mermaid', 'leaflet',
+                'highlight.js', '@guolao/vue-monaco-editor', 'html2pdf.js',
+                'pdfjs-dist', 'vuetify', 'lz-string', 'markdown-it',
+                'vue-doc-preview', '@vue-office/excel',
+                '@vue-office/docx',
+                'prettier',
+                'vue2-leaflet'
+            ];
+
+            const depAliases = {};
+            DEPS.forEach(d => {
+                try {
+                    depAliases[d] = path.dirname(require.resolve(`${d}/package.json`));
+                } catch (e) {
+                    depAliases[d] = path.resolve(rootNodeModules, d);
+                }
+            });
+
+            // ── Build the alias list ──
+            // Each package needs TWO aliases:
+            //   1. Exact match (RegExp):  import X from '@wbc-ui2/table'     → wb-table/src/index.js
+            //   2. Prefix match (string): import Y from '@wbc-ui2/table/src/WBTable.js' → wb-table/src/WBTable.js
+            const WBC_PACKAGES = {
+                '@wbc-ui/core2':       'wb-core',
+                '@wbc-ui/code2':       'wb-code',
+                '@wbc-ui/js2':         'wb-js',
+                '@wbc-ui/gis2':        'wb-gis',
+                '@wbc-ui/chart2':      'wb-chart',
+                '@wbc-ui/mermaid2':    'wb-mermaid',
+                '@wbc-ui/latex2':      'wb-latex',
+                '@wbc-ui/dataviewer2': 'wb-dataviewer',
+                '@wbc-ui/alert2':      'wb-alert',
+                '@wbc-ui/wiki-obj2':   'wbc-wiki-obj',
+                '@wbc-ui/office2':     'wb-office',
+            };
+
+            const wbcAliases = [];
+            for (const [pkg, dir] of Object.entries(WBC_PACKAGES)) {
+                const escaped = pkg.replace(/[/]/g, '\\/');
+                // 1. Exact match → core/src/index.js (for: import X from '@wbc-ui/code2')
+                wbcAliases.push({ find: new RegExp(`^${escaped}$`), replacement: path.resolve(monoRoot, `${dir}/core/src/index.js`) });
+                // 2. Prefix match → package's core dir (for: import Y from '@wbc-ui/code2/src/WBCode.js')
+                wbcAliases.push({ find: pkg, replacement: path.resolve(monoRoot, `${dir}/core`) });
+            }
+
+            // Add external dependency aliases + specific subpath overrides
+            wbcAliases.push(
+                ...Object.keys(depAliases).map(k => ({ find: k, replacement: depAliases[k] })),
+                { find: 'vuetify/lib', replacement: path.resolve(rootNodeModules, 'vuetify/lib') },
+                { find: 'lodash/debounce', replacement: path.resolve(rootNodeModules, 'lodash/debounce') },
+            );
+
+
+            // ── MUTATE config in-place to avoid merge conflicts ──
+            // Vite's mergeConfig can overwrite resolve.alias if the app also defines it.
+            // By mutating directly, we guarantee the aliases are applied.
+            config.resolve = config.resolve || {};
+            
+            // Convert existing alias object to array format if needed
+            const existingAliases = config.resolve.alias || {};
+            let aliasArray = [];
+            if (Array.isArray(existingAliases)) {
+                aliasArray = existingAliases;
+            } else if (typeof existingAliases === 'object') {
+                aliasArray = Object.keys(existingAliases).map(k => ({
+                    find: k,
+                    replacement: existingAliases[k]
+                }));
+            }
+            // Prepend our aliases (higher priority) before existing ones
+            config.resolve.alias = [...wbcAliases, ...aliasArray];
+            config.resolve.dedupe = ['vue', 'vuetify', 'vuex', 'vue-router'];
+
+            // ── Prettier v3 subpath aliases ──
+            // Prettier v3 renamed parser-* to plugins/*. Add aliases for legacy imports.
+            let prettierDir;
+            try {
+                prettierDir = path.dirname(require.resolve('prettier/package.json'));
+            } catch (e) {
+                prettierDir = path.resolve(rootNodeModules, 'prettier');
+            }
+            const prettierSubpathAliases = [
+                { find: 'prettier/parser-html', replacement: path.resolve(prettierDir, 'plugins/html.mjs') },
+                { find: 'prettier/parser-babel', replacement: path.resolve(prettierDir, 'plugins/babel.mjs') },
+                { find: 'prettier/parser-postcss', replacement: path.resolve(prettierDir, 'plugins/postcss.mjs') },
+                { find: 'prettier/parser-yaml', replacement: path.resolve(prettierDir, 'plugins/yaml.mjs') },
+                { find: 'prettier/parser-typescript', replacement: path.resolve(prettierDir, 'plugins/typescript.mjs') },
+                { find: 'prettier/standalone', replacement: path.resolve(prettierDir, 'standalone.mjs') },
+            ];
+
+            // Prepend prettier subpath aliases (before the generic 'prettier' alias)
+            config.resolve.alias = [...prettierSubpathAliases, ...config.resolve.alias];
+
+            // Return remaining config to be merged normally
+            return {
+                define: {
+                    'process.env.NODE_ENV': JSON.stringify('development'),
+                    'process.env.VUE_APP_BUILD_MODE': JSON.stringify('local'),
+                    'process.env.IS_ROLLUP': JSON.stringify('false'),
+                    'process.env.BASE_URL': JSON.stringify('/'),
+                    'global': 'globalThis',
+                    '__WBC_PRO__': JSON.stringify(process.env.WBC_PRO === 'true'),
+                    '__WBC_DEV__': JSON.stringify(process.env.WBC_PRO === undefined),
+                },
+                assetsInclude: ['**/*.xlsx', '**/*.xls', '**/*.doc', '**/*.docx', '**/*.ppt', '**/*.pptx', '**/*.zip', '**/*.pdf'],
+                optimizeDeps: {
+                    entries: ['index.html'],
+                    include: [...DEPS.filter(d => !['vuetify', 'prettier'].includes(d)), 'vuetify/lib', 'lodash/debounce']
+                },
+                css: {
+                    preprocessorOptions: {
+                        sass: {
+                            api: 'legacy',
+                            quietDeps: true,
+                            silenceDeprecations: ['slash-div']
+                        },
+                        scss: {
+                            api: 'legacy',
+                            quietDeps: true,
+                            silenceDeprecations: ['slash-div']
+                        }
+                    }
+                },
+                server: {
+                    fs: {
+                        allow: [
+                            path.resolve(pluginDir, './'),
+                            path.resolve(monoRoot),
+                            path.resolve(monoRoot, '../../'),
+                        ]
+                    },
+                    watch: {
+                        ignored: ['**/dist-cli/**', '**/dist-vite/**', '**/dist-webpack/**', '**/node_modules/**']
+                    }
+                }
+            };
+        }
+    }
+}
+
+export function wbcVitePlugin() {
+    return [
+        requireContextPlugin(),
+        rawFileLoaderPlugin(),
+        monorepoDevConfigPlugin(),
+    ];
+}
+
+export { requireContextPlugin, rawFileLoaderPlugin };
+export default wbcVitePlugin;

package/wbc.webpack.js

@@ -0,0 +1,95 @@
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+    chainWebpack: (config) => {
+        // 1. Basic Rules
+        if (!config.module.rules.has('vue')) {
+            config.module.rule('vue').test(/\.vue$/).use('vue-loader').loader('vue-loader').end();
+        }
+        if (!config.module.rules.has('js')) {
+            config.module.rule('js')
+                .test(/\.(js|jsx)$/)
+                .exclude.add(/node_modules/).end()
+                .use('babel-loader')
+                .loader(require.resolve('babel-loader'))
+                .options({ 
+                    presets: [
+                        [require.resolve('@babel/preset-env'), { modules: false }],
+                        require.resolve('@babel/preset-react')
+                    ]
+                });
+        }
+        config.module.rule('mjs-interop').test(/\.m?js/).merge({ resolve: { fullySpecified: false } });
+
+        // 2. Asset Rules (REPAIRED: Support for images/videos/fonts) 🛡️🚀
+        config.module.rule('assets')
+            .test(/\.(png|jpe?g|gif|svg|webp|avif|mp4|webm|ogg|mp3|wav|flac|aac|woff2?|eot|ttf|otf)$/i)
+            .type('asset/resource')
+            .set('generator', { filename: 'assets/[name].[hash:8][ext]' });
+
+        // 3. Style Rules
+        const styleRules = [
+            { name: 'css', test: /\.css$/ },
+            { name: 'scss', test: /\.scss$/, loader: 'sass-loader', options: {} },
+            { name: 'sass', test: /\.sass$/, loader: 'sass-loader', options: { sassOptions: { indentedSyntax: true } } }
+        ];
+
+        styleRules.forEach(r => {
+            if (!config.module.rules.has(r.name)) {
+                const rule = config.module.rule(r.name).test(r.test);
+                rule.use('style-loader').loader(require.resolve('style-loader')).end();
+                rule.use('css-loader').loader(require.resolve('css-loader')).end();
+                rule.use('postcss-loader').loader(require.resolve('postcss-loader')).end();
+                if (r.loader) {
+                    rule.use(r.name + '-loader').loader(require.resolve(r.loader)).options({
+                        ...r.options,
+                        sassOptions: {
+                           ...(r.options.sassOptions || {}),
+                           api: 'modern-compiler',
+                           silenceDeprecations: ['slash-div']
+                        }
+                    }).end();
+                }
+            }
+        });
+
+        // 4. Raw loaders
+        config.module.rule('wbc-raw').test(/\.(txt|py|php|sh|rs|md|tex|html|xml|yaml|yml)$/).exclude.add(/index\.html/).end().use('raw-loader').loader(require.resolve('raw-loader')).end();
+        config.module.rule('wbc-html-snippets').test(/sampleHtml\.js$/).use('raw-loader').loader(require.resolve('raw-loader')).end();
+
+        // 5. Aliases ⚓️
+        const projectRoot = process.cwd();
+        const localR = (p) => path.resolve(projectRoot, p);
+        const libDir = __dirname;
+        const monoRoot = path.dirname(libDir);
+
+        const resolveSafe = (m) => {
+           try { return path.dirname(require.resolve(`${m}/package.json`)); } catch(e) { return localR(`node_modules/${m}`); }
+        };
+
+        config.resolve.alias
+          .set('@', projectRoot)
+          .set('@src', localR('src'))
+          .set('vue$', require.resolve('vue/dist/vue.esm.js'))
+          .set('vue', resolveSafe('vue'))
+          .set('vuetify$', resolveSafe('vuetify'))
+          .set('wbc-ui2', libDir)
+          .set('@wbc-ui/code2', path.join(monoRoot, 'wb-code'))
+          .set('@wbc-ui/chart2', path.join(monoRoot, 'wb-chart'))
+          .set('@wbc-ui/latex2', path.join(monoRoot, 'wb-latex'))
+          .set('@wbc-ui/mermaid2', path.join(monoRoot, 'wb-mermaid'))
+          .set('@wbc-ui/wiki-obj2', path.join(monoRoot, 'wbc-wiki-obj'));
+
+        config.resolve.modules
+          .add(localR('node_modules'))
+          .add(path.join(monoRoot, 'node_modules'))
+          .add('node_modules');
+          
+        // Avoid HMR conflicts in monorepo if explicitly requested
+        if (config.devServer.has('hot')) {
+           // If HMR is still causing browser crashes, we force liveReload instead
+           // config.devServer.hot(false).liveReload(true);
+        }
+    }
+};