@moneko/core 3.0.0-beta.103 → 3.0.0-beta.104

package/lib/swcrc.js

@@ -1 +1,105 @@
-import{merge as e}from"webpack-merge";import{CONFIG as o}from"./common.js";import{isReact as r,isSolid as s,jsxImportSource as t}from"./process-env.js";let n={env:{targets:["last 2 version","> 0.5%","ie 11","not dead"],mode:"entry",coreJs:"3"}};export const swcMinifyOption={compress:{top_retain:[],keep_infinity:!0,global_defs:{"@alert":"console.log"},pure_funcs:["console.log","console.warn","console.error","console.info"],toplevel:!1,drop_console:!0,drop_debugger:!0,module:!1,ecma:2015,ie8:!1,keep_classnames:void 0,keep_fnames:!1},mangle:!0};export default((a=!1)=>{let c={module:{type:"es6",ignoreDynamic:!0,strict:!0,strictMode:!0,lazy:!0,noInterop:!0},jsc:{parser:{syntax:"typescript",decorators:!0,dynamicImport:!0,tsx:!0},loose:!0,target:"es2022",externalHelpers:!0,transform:{legacyDecorator:!0,decoratorMetadata:!0,react:{runtime:"automatic",throwIfNamespace:!0,useBuiltins:!0,refresh:r&&a,development:a,importSource:t},optimizer:{simplify:!1}},experimental:{plugins:[["swc-plugin-another-transform-imports",function(e){for(let o=0,r=Object.keys(e),s=r.length;o<s;o++)e[r[o]].transform=`${r[o]}/${e[r[o]].transform}`,e[r[o]].style&&(e[r[o]].style=`${r[o]}/${e[r[o]].style}`);return e}(o.importOnDemand||{})],s&&["@moneko/jsx-dom-expressions",o.jsxDomExpressions||{}]].filter(Boolean)}},sourceMaps:!0,parseMap:!0},i=Object.assign(c,!a&&n);return o.swcrc&&(i=e(i,"function"==typeof o.swcrc?o.swcrc(a):o.swcrc)),i});
+import { merge } from 'webpack-merge';
+import { CONFIG } from './common.js';
+import { isReact, isSolid, jsxImportSource } from './process-env.js';
+const swcPolyfill = {
+    env: {
+        targets: [
+            'last 2 version',
+            '> 0.5%',
+            'ie 11',
+            'not dead'
+        ],
+        mode: 'entry',
+        coreJs: '3'
+    }
+};
+export const swcMinifyOption = {
+    compress: {
+        top_retain: [],
+        keep_infinity: true,
+        global_defs: {
+            '@alert': 'console.log'
+        },
+        pure_funcs: [
+            'console.log',
+            'console.warn',
+            'console.error',
+            'console.info'
+        ],
+        toplevel: false,
+        drop_console: true,
+        drop_debugger: true,
+        module: false,
+        ecma: 2015,
+        ie8: false,
+        keep_classnames: undefined,
+        keep_fnames: false
+    },
+    mangle: true
+};
+function transformConfigs(config) {
+    for(let i = 0, ks = Object.keys(config), l = ks.length; i < l; i++){
+        config[ks[i]].transform = `${ks[i]}/${config[ks[i]].transform}`;
+        if (config[ks[i]].style) {
+            config[ks[i]].style = `${ks[i]}/${config[ks[i]].style}`;
+        }
+    }
+    return config;
+}
+export default ((isDev = false)=>{
+    const swcOption = {
+        module: {
+            type: 'es6',
+            ignoreDynamic: true,
+            strict: true,
+            strictMode: true,
+            lazy: true,
+            noInterop: true
+        },
+        jsc: {
+            parser: {
+                syntax: 'typescript',
+                decorators: true,
+                dynamicImport: true,
+                tsx: true
+            },
+            loose: true,
+            target: 'es2022',
+            externalHelpers: true,
+            transform: {
+                legacyDecorator: true,
+                decoratorMetadata: true,
+                react: {
+                    runtime: 'automatic',
+                    throwIfNamespace: true,
+                    useBuiltins: true,
+                    refresh: isReact && isDev,
+                    development: isDev,
+                    importSource: jsxImportSource
+                },
+                optimizer: {
+                    simplify: false
+                }
+            },
+            experimental: {
+                plugins: [
+                    [
+                        'swc-plugin-another-transform-imports',
+                        transformConfigs(CONFIG.importOnDemand || {})
+                    ],
+                    isSolid && [
+                        '@moneko/jsx-dom-expressions',
+                        CONFIG.jsxDomExpressions || {}
+                    ]
+                ].filter(Boolean)
+            }
+        },
+        sourceMaps: true,
+        parseMap: true
+    };
+    let swcrc = Object.assign(swcOption, !isDev && swcPolyfill);
+    if (CONFIG.swcrc) {
+        swcrc = merge(swcrc, typeof CONFIG.swcrc === 'function' ? CONFIG.swcrc(isDev) : CONFIG.swcrc);
+    }
+    return swcrc;
+});

package/lib/tsloader.config.js

@@ -1 +1,25 @@
-import t from"fs";import r from"ts-import-plugin";import o from"webpack-merge";import{CONFIG as e}from"./common.js";import{isFunction as m,readConf as s,resolveProgramPath as a}from"./utils.js";let i=[];Array.isArray(e.importOnDemand)&&Object.assign(i,e.importOnDemand.map(t=>r(t)));let n=[...i],p={transpileOnly:!0,getCustomTransformers:()=>({before:n})};try{let r=a("tsloader.config.ts");t.accessSync(r,t.constants.R_OK);let e=(await s(r,"tsloader.config")).default;p=o(p,m(e)?e(process):e)}catch(t){}export default p;
+import fs from 'fs';
+import transformerFactory from 'ts-import-plugin';
+import merge from 'webpack-merge';
+import { CONFIG } from './common.js';
+import { isFunction, readConf, resolveProgramPath } from './utils.js';
+const importOnDemand = [];
+if (Array.isArray(CONFIG.importOnDemand)) {
+    Object.assign(importOnDemand, CONFIG.importOnDemand.map((item)=>transformerFactory(item)));
+}
+const beforeTransformers = [
+    ...importOnDemand
+];
+let tsLoaderConfig = {
+    transpileOnly: true,
+    getCustomTransformers: ()=>({
+            before: beforeTransformers
+        })
+};
+try {
+    const customTsloaderConfigPath = resolveProgramPath('tsloader.config.ts');
+    fs.accessSync(customTsloaderConfigPath, fs.constants.R_OK);
+    const customTsloaderConfig = (await readConf(customTsloaderConfigPath, 'tsloader.config')).default;
+    tsLoaderConfig = merge(tsLoaderConfig, isFunction(customTsloaderConfig) ? customTsloaderConfig(process) : customTsloaderConfig);
+} catch (error) {}
+export default tsLoaderConfig;

package/lib/utils.js

@@ -1 +1,49 @@
-import{writeFileSync as e}from"fs";import o from"path";import{transformFileSync as t}from"@swc/core";import{cacheDir as r}from"./process-env.js";import n from"./resolver-sync.js";let c={inputSourceMap:!1,sourceMaps:!1,module:{type:"es6"},jsc:{parser:{syntax:"typescript"},loose:!1}};export function tfc(e){return t(e,c).code||"{}"}export function readConf(t,n){let c=o.join(r,`${n}.mjs`);return e(c,tfc(t),"utf-8"),import(c)}export function toUpperCaseString(e){return e?.replace(/\b\w/g,e=>e.toUpperCase()).replace(/\./g," ")}export function resolveProgramPath(e){return o.resolve(process.cwd(),`./${e}`)}export const resolveNodeModulesPath=e=>resolveProgramPath(`node_modules/${e}`);export const resolve=e=>n.resolveSync({},process.cwd(),e)||e;export function isObject(e){let o=typeof e;return null!==e&&("object"==o||"function"==o)}export function isFunction(e){if(!isObject(e))return!1;let o=Object.prototype.toString.call(e);return"[object Function]"==o||"[object AsyncFunction]"==o||"[object GeneratorFunction]"==o||"[object Proxy]"==o}
+import { writeFileSync } from 'fs';
+import path from 'path';
+import { transformFileSync } from '@swc/core';
+import { cacheDir } from './process-env.js';
+import resolverSync from './resolver-sync.js';
+const swcOption = {
+    inputSourceMap: false,
+    sourceMaps: false,
+    module: {
+        type: 'es6'
+    },
+    jsc: {
+        parser: {
+            syntax: 'typescript'
+        },
+        loose: false
+    }
+};
+export function tfc(filepath) {
+    return transformFileSync(filepath, swcOption).code || '{}';
+}
+export function readConf(src, name) {
+    const cacheFile = path.join(cacheDir, `${name}.mjs`);
+    writeFileSync(cacheFile, tfc(src), 'utf-8');
+    return import(cacheFile);
+}
+export function toUpperCaseString(string) {
+    return string?.replace(/\b\w/g, (th)=>th.toUpperCase()).replace(/\./g, ' ');
+}
+export function resolveProgramPath(src) {
+    return path.resolve(process.cwd(), `./${src}`);
+}
+export const resolveNodeModulesPath = (src)=>{
+    return resolveProgramPath(`node_modules/${src}`);
+};
+export const resolve = (url)=>resolverSync.resolveSync({}, process.cwd(), url) || url;
+const funcTag = '[object Function]';
+const asyncTag = '[object AsyncFunction]';
+const genTag = '[object GeneratorFunction]';
+const proxyTag = '[object Proxy]';
+export function isObject(target) {
+    const type = typeof target;
+    return target !== null && (type == 'object' || type == 'function');
+}
+export function isFunction(target) {
+    if (!isObject(target)) return false;
+    const tagType = Object.prototype.toString.call(target);
+    return tagType == funcTag || tagType == asyncTag || tagType == genTag || tagType == proxyTag;
+}

package/lib/virtual-module-plugin.js

@@ -1 +1,54 @@
-import t from"webpack-virtual-modules";import{docs as o}from"./docs.js";import{example as e,route as r}from"./routes.js";import{resolveNodeModulesPath as a}from"./utils.js";export default class{constructor(t){this.options=t}apply(i){let l=new t({[a(r.data.name)]:r.data.data,[a(e.data.name)]:"export default []"});r.listener(t=>{t.data&&l.writeModule(a(t.name),t.data)}),e.listener(t=>{let o=t.data;for(let t in o)Object.prototype.hasOwnProperty.call(o,t)&&o[t]&&l.writeModule(a(t),o[t])}),o.listener(t=>{for(let o in t)Object.prototype.hasOwnProperty.call(t,o)&&t[o]&&l.writeModule(a(o),t[o])}),l.apply(i),i.hooks.compilation.tap("VirtualModulePlugin",()=>{for(let t in this.options)if(Object.prototype.hasOwnProperty.call(this.options,t)){let o=this.options[t];"string"==typeof o?l.writeModule(a(t),o):l.writeModule(a(t),`export default ${JSON.stringify(o)}`)}})}};
+import VirtualModulesPlugin from 'webpack-virtual-modules';
+import { docs } from './docs.js';
+import { example, route } from './routes.js';
+import { resolveNodeModulesPath } from './utils.js';
+class VirtualModulePlugin {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    apply(compiler) {
+        const vm = new VirtualModulesPlugin({
+            [resolveNodeModulesPath(route.data.name)]: route.data.data,
+            [resolveNodeModulesPath(example.data.name)]: 'export default []'
+        });
+        route.listener((next)=>{
+            if (next.data) {
+                vm.writeModule(resolveNodeModulesPath(next.name), next.data);
+            }
+        });
+        example.listener((next)=>{
+            const obj = next.data;
+            for(const key in obj){
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    if (obj[key]) {
+                        vm.writeModule(resolveNodeModulesPath(key), obj[key]);
+                    }
+                }
+            }
+        });
+        docs.listener((obj)=>{
+            for(const key in obj){
+                if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    if (obj[key]) {
+                        vm.writeModule(resolveNodeModulesPath(key), obj[key]);
+                    }
+                }
+            }
+        });
+        vm.apply(compiler);
+        compiler.hooks.compilation.tap('VirtualModulePlugin', ()=>{
+            for(const key in this.options){
+                if (Object.prototype.hasOwnProperty.call(this.options, key)) {
+                    const data = this.options[key];
+                    if (typeof data === 'string') {
+                        vm.writeModule(resolveNodeModulesPath(key), data);
+                    } else {
+                        vm.writeModule(resolveNodeModulesPath(key), `export default ${JSON.stringify(data)}`);
+                    }
+                }
+            }
+        });
+    }
+}
+export default VirtualModulePlugin;

package/lib/virtual-modules.js

@@ -1,3 +1,34 @@
-import{accessSync as o,constants as p}from"fs";import{join as m}from"path";import r from"./app.js";import t from"./common/rem.js";import{CONFIG as a}from"./common.js";import{coverage as e}from"./coverage.js";import{FRAMEWORK as l}from"./process-env.js";import{resolveProgramPath as s}from"./utils.js";let i={...a.virtualModule,"@app":r,"@app/fallback":"export default null","@app/coverage":e,"@app/entry":`${a.normalizeCss?`import "@moneko/${l}/lib/normalize.css";`:""}
-  ${a.rem?.designSize?t:""}
-  await import('@moneko/${l}/lib/entry.js');`};a.fallbackCompPath&&Object.assign(i,{"@app/fallback":`import Fallback from "${a.fallbackCompPath}";export default Fallback;`});let c={};try{let r=m(s("site"),"./mdx-scope.ts");o(r,p.R_OK),c='import scope from "@/mdx-scope";export default scope;'}catch(o){c={}}Object.assign(i,{"@app/mdx-scope":c});export default i;
+import { accessSync, constants } from 'fs';
+import { join } from 'path';
+import app from './app.js';
+import rem from './common/rem.js';
+import { CONFIG } from './common.js';
+import { coverage } from './coverage.js';
+import { FRAMEWORK } from './process-env.js';
+import { resolveProgramPath } from './utils.js';
+const virtualModules = {
+    ...CONFIG.virtualModule,
+    '@app': app,
+    '@app/fallback': 'export default null',
+    '@app/coverage': coverage,
+    '@app/entry': `${CONFIG.normalizeCss ? `import "@moneko/${FRAMEWORK}/lib/normalize.css";` : ''}
+  ${CONFIG.rem?.designSize ? rem : ''}
+  await import('@moneko/${FRAMEWORK}/lib/entry.js');`
+};
+if (CONFIG.fallbackCompPath) {
+    Object.assign(virtualModules, {
+        '@app/fallback': `import Fallback from "${CONFIG.fallbackCompPath}";export default Fallback;`
+    });
+}
+let mdxScope = {};
+try {
+    const appEntryPath = join(resolveProgramPath('site'), './mdx-scope.ts');
+    accessSync(appEntryPath, constants.R_OK);
+    mdxScope = 'import scope from "@/mdx-scope";export default scope;';
+} catch (error) {
+    mdxScope = {};
+}
+Object.assign(virtualModules, {
+    '@app/mdx-scope': mdxScope
+});
+export default virtualModules;

package/lib/webpack.common.d.ts

@@ -1,6 +1,5 @@
 import './cleanup.js';
 import type { WebpackConfiguration } from 'webpack-dev-server';
-export declare const alias: Record<string, string>;
 export declare const outputConfig: WebpackConfiguration['output'];
 declare const config: WebpackConfiguration;
 export default config;

package/lib/webpack.common.js

@@ -1 +1,216 @@
-import e from"fs";import t from"add-asset-html-webpack-plugin";import s from"html-webpack-plugin";import n from"webpack";import o from"webpackbar";import"./cleanup.js";import{CONFIG as l,PUBLICPATH as i}from"./common.js";import a from"./define.js";import r from"./done.js";import p from"./html-add-entry-attr.js";import m from"./html-plugin-option.js";import{moduleFederation as c}from"./module-federation.js";import u from"./module.config.js";import{APPTYPE as d,DEV as f,PACKAGENAME as j,PROGRAMPATH as g,hasEslintConfig as h,hasStylelintConfig as b}from"./process-env.js";import{seo as y}from"./seo.js";import{resolveNodeModulesPath as w,resolveProgramPath as x}from"./utils.js";import k from"./virtual-module-plugin.js";import v from"./virtual-modules.js";let{AutomaticPrefetchPlugin:O,DefinePlugin:C,SourceMapDevToolPlugin:$,WatchIgnorePlugin:B}=n,A=[".eslintrc.js",".eslintrc.json",".eslintrc.yaml",".eslintrc.json"],S=[".stylelintrc",".stylelintrc.json",".stylelintrc.yaml",".stylelintrc.yml",".stylelintrc.js","stylelint.config.js","stylelint.config.cjs"],T=e.readdirSync(g),K=!1,L=!1;for(let e=0,t=T.length;e<t;e++)S.includes(T[e])&&(L=!0),A.includes(T[e])&&(K=!0);K||(K=h),L||(L=b);let M=L?(await import("stylelint-webpack-plugin")).default:null,P=K?(await import("eslint-webpack-plugin")).default:null;export const alias={"@":x("src")};Object.assign(alias,l.alias),"library"===d&&Object.assign(alias,{"@":x("site"),"@pkg":x("components"),[j]:x("components")});let F=l.assetHtml.map(e=>({publicPath:"",...e}));export const outputConfig={path:x("library"===d?"docs":"dist"),filename:"js/[name].bundle.js",chunkFilename:"js/[name].chunk.js",assetModuleFilename:"assets/[name][hash][ext][query]",library:{name:j,type:"window"},globalObject:"window",chunkLoadingGlobal:`webpackJsonp_${j}`,pathinfo:f,clean:!0,publicPath:i};let N=w("@app/entry");"single-component"===d&&(Object.assign(alias,{[j]:x("umd")}),N=x(f?"example/index.ts":"src/index.ts"),outputConfig.path=x(f?"dist":"umd"),outputConfig.filename="index.js",outputConfig.globalObject="this",outputConfig.library={export:"default",name:j,type:"umd",umdNamedDefine:!0});let R={main:N};l.entry&&("string"==typeof l.entry?R=l.entry:Object.keys(l.entry)&&Object.assign(R,l.entry)),l.output&&("string"==typeof l.output?outputConfig.path=l.output:Object.keys(l.output)&&Object.assign(outputConfig,l.output));let W=l.routeBaseName.split("/").filter(Boolean).length,_=`${Array(W).fill("..").join("/")+(W?"/":"")}404.html`,{pathSegmentsToKeep:q=W,path:D=_}=l.fixBrowserRouter||{},G={entry:R,stats:"errors-only",infrastructureLogging:{level:"none"},target:"web",plugins:[new O,...c,P&&new P({fix:!0,threads:!0,extensions:["js","md","mdx","cjs","ejs","mjs","jsx","ts","tsx","json","html","coffee","vue"]}),M&&new M({fix:!0,threads:!0,extensions:["css","scss","sass","less","ts","tsx","js","jsx"],exclude:["node_modules/","es/","lib/","docs/","coverage/","dist/"]}),l.htmlPluginOption&&new s(m),l.fixBrowserRouter&&new s({filename:D,inject:!1,templateContent:()=>`<html html><head><title>${m.title}</title><script>var pathSegmentsToKeep = ${q||W};var l = window.location;l.replace(l.protocol + '//' + l.hostname + (l.port ? ':' + l.port : '') + l.pathname.split('/').slice(0, 1 + pathSegmentsToKeep).join('/') + '/?/' + l.pathname.slice(1).split('/').slice(pathSegmentsToKeep).join('/').replace(/&/g, '~and~') + (l.search ? '&' + l.search.slice(1).replace(/&/g, '~and~') : '') + l.hash);</script></head><body></body></html>`}),new t(F),"single-spa"===d&&new p(e=>!!(e.match(/main\.(.*)\.bundle.js$/)||e.match("main.bundle.js"))),new C(a),new B({paths:[/\.d\.ts$/]}),l.sourceMap&&new $(l.sourceMap),l.bar&&new o(l.bar),new r({done:()=>{!f&&l.seo&&y(),l.done?.(),f||setTimeout(()=>{process.exit(0)},2e3)}}),new k(v),...l.plugins].filter(Boolean),experiments:{topLevelAwait:!0,syncWebAssembly:!0,asyncWebAssembly:!0},resolve:{extensions:[".tsx",".ts",".js",".jsx"],alias:alias,fallback:{path:!1,fs:!1,crypto:!1,assert:!1}},module:u,externals:l.externals,output:outputConfig};export default G;
+import fs from 'fs';
+import AddAssetHtmlPlugin from 'add-asset-html-webpack-plugin';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import webpack from 'webpack';
+import WebpackBar from 'webpackbar';
+import './cleanup.js';
+import { CONFIG, PUBLICPATH } from './common.js';
+import define from './define.js';
+import DoneWebpackPlugin from './done.js';
+import AddEntryAttributeWebpackPlugin from './html-add-entry-attr.js';
+import htmlPluginOption from './html-plugin-option.js';
+import { moduleFederation } from './module-federation.js';
+import moduleConfig from './module.config.js';
+import { APPTYPE, DEV, PACKAGENAME, PROGRAMPATH, hasEslintConfig, hasStylelintConfig } from './process-env.js';
+import { seo } from './seo.js';
+import { resolveNodeModulesPath, resolveProgramPath } from './utils.js';
+import VirtualModulePlugin from './virtual-module-plugin.js';
+import virtualModules from './virtual-modules.js';
+const { AutomaticPrefetchPlugin , DefinePlugin , SourceMapDevToolPlugin , WatchIgnorePlugin  } = webpack;
+const eslintrc = [
+    '.eslintrc.js',
+    '.eslintrc.json',
+    '.eslintrc.yaml',
+    '.eslintrc.json'
+];
+const stylelintrc = [
+    '.stylelintrc',
+    '.stylelintrc.json',
+    '.stylelintrc.yaml',
+    '.stylelintrc.yml',
+    '.stylelintrc.js',
+    'stylelint.config.js',
+    'stylelint.config.cjs'
+];
+const rootFiles = fs.readdirSync(PROGRAMPATH);
+let hasEslint = false, hasStylelint = false;
+for(let i = 0, len = rootFiles.length; i < len; i++){
+    if (stylelintrc.includes(rootFiles[i])) {
+        hasStylelint = true;
+    }
+    if (eslintrc.includes(rootFiles[i])) {
+        hasEslint = true;
+    }
+}
+if (!hasEslint) {
+    hasEslint = hasEslintConfig;
+}
+if (!hasStylelint) {
+    hasStylelint = hasStylelintConfig;
+}
+const StylelintPlugin = hasStylelint ? (await import('stylelint-webpack-plugin')).default : null;
+const ESLintPlugin = hasEslint ? (await import('eslint-webpack-plugin')).default : null;
+const assetHtmlOption = CONFIG.assetHtml.map((item)=>{
+    return {
+        publicPath: '',
+        ...item
+    };
+});
+export const outputConfig = {
+    path: resolveProgramPath(APPTYPE === 'library' ? 'docs' : 'dist'),
+    filename: 'js/[name].bundle.js',
+    chunkFilename: 'js/[name].chunk.js',
+    assetModuleFilename: 'assets/[name][hash][ext][query]',
+    library: {
+        name: PACKAGENAME,
+        type: 'window'
+    },
+    globalObject: 'window',
+    chunkLoadingGlobal: `webpackJsonp_${PACKAGENAME}`,
+    pathinfo: DEV,
+    clean: true,
+    publicPath: PUBLICPATH
+};
+let mainEntry = resolveNodeModulesPath('@app/entry');
+if (APPTYPE === 'single-component') {
+    mainEntry = resolveProgramPath(DEV ? 'example/index.ts' : 'src/index.ts');
+    outputConfig.path = resolveProgramPath(DEV ? 'dist' : 'umd');
+    outputConfig.filename = 'index.js';
+    outputConfig.globalObject = 'this';
+    outputConfig.library = {
+        export: 'default',
+        name: PACKAGENAME,
+        type: 'umd',
+        umdNamedDefine: true
+    };
+}
+let entryMap = {
+    main: mainEntry
+};
+if (CONFIG.entry) {
+    if (typeof CONFIG.entry === 'string') {
+        entryMap = CONFIG.entry;
+    } else if (Object.keys(CONFIG.entry)) {
+        Object.assign(entryMap, CONFIG.entry);
+    }
+}
+if (CONFIG.output) {
+    if (typeof CONFIG.output === 'string') {
+        outputConfig.path = CONFIG.output;
+    } else if (Object.keys(CONFIG.output)) {
+        Object.assign(outputConfig, CONFIG.output);
+    }
+}
+const dirDeep = CONFIG.routeBaseName.split('/').filter(Boolean).length;
+const page404 = `${Array(dirDeep).fill('..').join('/') + (dirDeep ? '/' : '')}404.html`;
+const { pathSegmentsToKeep =dirDeep , path =page404  } = CONFIG.fixBrowserRouter || {};
+const config = {
+    entry: entryMap,
+    stats: 'errors-only',
+    infrastructureLogging: {
+        level: 'none'
+    },
+    target: 'web',
+    plugins: [
+        new AutomaticPrefetchPlugin(),
+        ...moduleFederation,
+        ESLintPlugin && new ESLintPlugin({
+            fix: true,
+            threads: true,
+            extensions: [
+                'js',
+                'md',
+                'mdx',
+                'cjs',
+                'ejs',
+                'mjs',
+                'jsx',
+                'ts',
+                'tsx',
+                'json',
+                'html',
+                'coffee',
+                'vue'
+            ]
+        }),
+        StylelintPlugin && new StylelintPlugin({
+            fix: true,
+            threads: true,
+            extensions: [
+                'css',
+                'scss',
+                'sass',
+                'less',
+                'ts',
+                'tsx',
+                'js',
+                'jsx'
+            ],
+            exclude: [
+                'node_modules/',
+                'es/',
+                'lib/',
+                'docs/',
+                'coverage/',
+                'dist/'
+            ]
+        }),
+        CONFIG.htmlPluginOption && new HtmlWebpackPlugin(htmlPluginOption),
+        CONFIG.fixBrowserRouter && new HtmlWebpackPlugin({
+            filename: path,
+            inject: false,
+            templateContent: ()=>`<html html><head><title>${htmlPluginOption.title}</title><script>var pathSegmentsToKeep = ${pathSegmentsToKeep || dirDeep};var l = window.location;l.replace(l.protocol + '//' + l.hostname + (l.port ? ':' + l.port : '') + l.pathname.split('/').slice(0, 1 + pathSegmentsToKeep).join('/') + '/?/' + l.pathname.slice(1).split('/').slice(pathSegmentsToKeep).join('/').replace(/&/g, '~and~') + (l.search ? '&' + l.search.slice(1).replace(/&/g, '~and~') : '') + l.hash);</script></head><body></body></html>`
+        }),
+        new AddAssetHtmlPlugin(assetHtmlOption),
+        APPTYPE === 'single-spa' && new AddEntryAttributeWebpackPlugin((src)=>{
+            return !!(src.match(/main\.(.*)\.bundle.js$/) || src.match('main.bundle.js'));
+        }),
+        new DefinePlugin(define),
+        new WatchIgnorePlugin({
+            paths: [
+                /\.d\.ts$/
+            ]
+        }),
+        CONFIG.sourceMap && new SourceMapDevToolPlugin(CONFIG.sourceMap),
+        CONFIG.bar && new WebpackBar(CONFIG.bar),
+        new DoneWebpackPlugin({
+            done: ()=>{
+                if (!DEV && CONFIG.seo) {
+                    seo();
+                }
+                CONFIG.done?.();
+                if (!DEV) {
+                    setTimeout(()=>{
+                        process.exit(0);
+                    }, 2000);
+                }
+            }
+        }),
+        new VirtualModulePlugin(virtualModules),
+        ...CONFIG.plugins
+    ].filter(Boolean),
+    experiments: {
+        topLevelAwait: true,
+        syncWebAssembly: true,
+        asyncWebAssembly: true
+    },
+    resolve: {
+        extensions: [
+            '.tsx',
+            '.ts',
+            '.js',
+            '.jsx'
+        ],
+        alias: CONFIG.alias,
+        fallback: {
+            path: false,
+            fs: false,
+            crypto: false,
+            assert: false
+        }
+    },
+    module: moduleConfig,
+    externals: CONFIG.externals,
+    output: outputConfig
+};
+export default config;

package/lib/webpack.dev.js

@@ -1,4 +1,94 @@
-import e from"@soda/friendly-errors-webpack-plugin";import o from"chalk";import r from"webpack";import{merge as t}from"webpack-merge";import{CONFIG as s}from"./common.js";import{hasPkg as a}from"./has-pkg.js";import{getIPv4 as p,getPort as i}from"./net.js";import{CUSTOMCONFIG as m,isReact as l}from"./process-env.js";import{isFunction as n,resolveProgramPath as c}from"./utils.js";import d from"./webpack.common.js";let{HotModuleReplacementPlugin:v}=r,{yellow:h,green:f}=o,w=p(),u=s.devServer.port||3e3,g=await i(u,65535,s.devServer.host),k=s.devServer.port!==g,y=a("@moneko/mock"),$=y&&await import("@moneko/mock"),S=l&&(await import("@pmmmwh/react-refresh-webpack-plugin")).default,b=!1;s.cacheDirectory&&(b={type:"filesystem",allowCollectingMemory:!0,cacheDirectory:s.cacheDirectory,name:`${m||"default"}-development`});let j=!1===s.devtool||s.devtool?s.devtool:"eval-cheap-module-source-map";s.devServer.port=g;let x="/"===s.routeBaseName,D=s.devServer.https?"https:":"http:",A=x?"":s.routeBaseName;export default t(d,{devtool:j,mode:"development",cache:b,devServer:{headers:{"Access-Control-Allow-Origin":"*"},compress:s.devServer.compress,host:"0.0.0.0",port:g,historyApiFallback:x||{index:A.endsWith("/")?A:`${A}/`,disableDotRule:!0},https:s.devServer.https,proxy:s.proxy,allowedHosts:s.devServer.allowedHosts,client:{progress:!1,logging:"info",overlay:!1},static:{watch:{ignored:e=>e.endsWith(".d.ts")||/\/node_modules\//.test(e)}},setupMiddlewares:(e,o)=>{if(!o)throw Error("webpack-dev-server is not defined");return o.app&&n($)&&$(o.app,c("mock/")),e},open:!1,hot:!0},plugins:[new v,S&&new S,new e({compilationSuccessInfo:{messages:[`You application is running here:
+import FriendlyErrorsWebpackPlugin from '@soda/friendly-errors-webpack-plugin';
+import chalk from 'chalk';
+import webpack from 'webpack';
+import { merge } from 'webpack-merge';
+import { CONFIG } from './common.js';
+import { hasPkg } from './has-pkg.js';
+import { getIPv4, getPort } from './net.js';
+import { CUSTOMCONFIG, isReact } from './process-env.js';
+import { isFunction, resolveProgramPath } from './utils.js';
+import common from './webpack.common.js';
+const { HotModuleReplacementPlugin  } = webpack;
+const { yellow , green  } = chalk;
+const ip = getIPv4();
+const oldPord = CONFIG.devServer.port || 3000;
+const port = await getPort(oldPord, 65535, CONFIG.devServer.host);
+const skipPort = CONFIG.devServer.port !== port;
+const hasMockMiddlewares = hasPkg('@moneko/mock');
+const mockMiddlewares = hasMockMiddlewares && await import('@moneko/mock');
+const ReactRefresh = isReact && (await import('@pmmmwh/react-refresh-webpack-plugin')).default;
+let cacheConfig = false;
+if (CONFIG.cacheDirectory) {
+    cacheConfig = {
+        type: 'filesystem',
+        allowCollectingMemory: true,
+        cacheDirectory: CONFIG.cacheDirectory,
+        name: `${CUSTOMCONFIG || 'default'}-development`
+    };
+}
+const devtool = CONFIG.devtool === false || CONFIG.devtool ? CONFIG.devtool : 'eval-cheap-module-source-map';
+CONFIG.devServer.port = port;
+const initRouteBase = CONFIG.routeBaseName === '/';
+const protocol = CONFIG.devServer.https ? 'https:' : 'http:';
+const routeBase = initRouteBase ? '' : CONFIG.routeBaseName;
+export default merge(common, {
+    devtool: devtool,
+    mode: 'development',
+    cache: cacheConfig,
+    devServer: {
+        headers: {
+            'Access-Control-Allow-Origin': '*'
+        },
+        compress: CONFIG.devServer.compress,
+        host: '0.0.0.0',
+        port: port,
+        historyApiFallback: initRouteBase || {
+            index: routeBase.endsWith('/') ? routeBase : `${routeBase}/`,
+            disableDotRule: true
+        },
+        https: CONFIG.devServer.https,
+        proxy: CONFIG.proxy,
+        allowedHosts: CONFIG.devServer.allowedHosts,
+        client: {
+            progress: false,
+            logging: 'info',
+            overlay: false
+        },
+        static: {
+            watch: {
+                ignored: (f)=>{
+                    return f.endsWith('.d.ts') || /\/node_modules\//.test(f);
+                }
+            }
+        },
+        setupMiddlewares: (middlewares, devServer)=>{
+            if (!devServer) {
+                throw new Error('webpack-dev-server is not defined');
+            }
+            if (devServer.app && isFunction(mockMiddlewares)) {
+                mockMiddlewares(devServer.app, resolveProgramPath('mock/'));
+            }
+            return middlewares;
+        },
+        open: false,
+        hot: true
+    },
+    plugins: [
+        new HotModuleReplacementPlugin(),
+        ReactRefresh && new ReactRefresh(),
+        new FriendlyErrorsWebpackPlugin({
+            compilationSuccessInfo: {
+                messages: [
+                    `You application is running here:
 
-    Local:   ${o.cyan(`${D}//${s.devServer.host}:${g}${A}`)}
-    Network: ${o.cyan(`${D}//${w}:${g}${A}`)}`],notes:k?[`Port ${h(u)} is in use, trying ${f(g)} instead`]:[]},clearConsole:!0})].filter(Boolean)});
+    Local:   ${chalk.cyan(`${protocol}//${CONFIG.devServer.host}:${port}${routeBase}`)}
+    Network: ${chalk.cyan(`${protocol}//${ip}:${port}${routeBase}`)}`
+                ],
+                notes: skipPort ? [
+                    `Port ${yellow(oldPord)} is in use, trying ${green(port)} instead`
+                ] : []
+            },
+            clearConsole: true
+        })
+    ].filter(Boolean)
+});