@moneko/core 3.0.0-beta.30 → 3.0.0-beta.32

package/lib/utils.js

@@ -1 +1,64 @@
-import{writeFileSync as e}from"fs";import{networkInterfaces as t}from"os";import r from"path";import{transformFileSync as o}from"@swc/core";import{cacheDir as n}from"./process-env.js";import s from"./resolver-sync.js";let c={inputSourceMap:!1,sourceMaps:!1,module:{type:"es6"},jsc:{parser:{syntax:"typescript"},loose:!1}};export function tfc(e){return o(e,c).code||"{}"}export function readConf(t,o){let s=r.join(n,`${o}.mjs`);return e(s,tfc(t),"utf-8"),import(s)}export function toUpperCaseString(e){return e?.replace(/\b\w/g,e=>e.toUpperCase()).replace(/\./g," ")}export function getIPAdress(){let e=t();for(let t in e)if(Object.prototype.hasOwnProperty.call(e,t)){let r=e[t];for(let e=0;e<r.length;e++){let t=r[e];if("IPv4"===t.family&&"127.0.0.1"!==t.address&&!t.address.startsWith("169.254")&&!t.internal)return t.address}}}export function resolveProgramPath(e){return r.resolve(process.cwd(),"./"+e)}export const resolveNodeModulesPath=e=>resolveProgramPath(`node_modules/${e}`);export const resolve=e=>s.resolveSync({},process.cwd(),e)||e;export function isObject(e){let t=typeof e;return null!==e&&("object"==t||"function"==t)}export function isFunction(e){if(!isObject(e))return!1;let t=Object.prototype.toString.call(e);return"[object Function]"==t||"[object AsyncFunction]"==t||"[object GeneratorFunction]"==t||"[object Proxy]"==t}
+import { writeFileSync } from 'fs';
+import { networkInterfaces } from 'os';
+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 getIPAdress() {
+    const interfaces = networkInterfaces();
+    for(const devName in interfaces){
+        if (Object.prototype.hasOwnProperty.call(interfaces, devName)) {
+            const iface = interfaces[devName];
+            for(let i = 0; i < iface.length; i++){
+                const alias = iface[i];
+                if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.address.startsWith('169.254') && !alias.internal) {
+                    return alias.address;
+                }
+            }
+        }
+    }
+}
+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/webpack.common.d.ts

@@ -1,3 +1,4 @@
+import './routes.js';
 import type { WebpackConfiguration } from 'webpack-dev-server';
 export declare const outputConfig: WebpackConfiguration['output'];
 declare const config: WebpackConfiguration;

package/lib/webpack.common.js

@@ -1 +1,218 @@
-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{CONFIG as l,ENTRYPATH as i,PUBLICPATH as a}from"./common.js";import r from"./done.js";import p from"./envFlags.js";import m from"./html-add-entry-attr.js";import c from"./html-plugin-option.js";import{moduleFederation as u}from"./module-federation.js";import f from"./module.config.js";import{APPTYPE as d,DEV as g,hasEslintConfig as j,hasStylelintConfig as h,PACKAGENAME as b,PROGRAMPATH as y,FRAMEWORK as w}from"./process-env.js";import{seo as x}from"./seo.js";import{resolveNodeModulesPath as k,resolveProgramPath as v}from"./utils.js";let C=[".eslintrc.js",".eslintrc.json",".eslintrc.yaml",".eslintrc.json"],O=[".stylelintrc",".stylelintrc.json",".stylelintrc.yaml",".stylelintrc.yml",".stylelintrc.js","stylelint.config.js","stylelint.config.cjs"],P=e.readdirSync(y),$=!1,T=!1;for(let e=0,t=P.length;e<t;e++)O.includes(P[e])&&(T=!0),C.includes(P[e])&&($=!0);$||($=j),T||(T=h);let A=T?(await import("stylelint-webpack-plugin")).default:null,B=$?(await import("eslint-webpack-plugin")).default:null,S={"@":v("src")};Object.assign(S,l.alias),"library"===d&&Object.assign(S,{"@":v("site"),"@pkg":v("components"),[b]:v("components")});let M=l.assetHtml.map(e=>({publicPath:"",...e}));export const outputConfig={path:v("library"===d?"docs":"dist"),filename:"js/[name].bundle.js",chunkFilename:"js/[name].chunk.js",assetModuleFilename:"assets/[name].[hash][ext]",library:b,libraryTarget:"window",globalObject:"window",chunkLoadingGlobal:`webpackJsonp_${b}`,pathinfo:!1,clean:!0,publicPath:a};let F=k(`@moneko/${w}/lib/packages/${i[d]}/index.js`);"single-component"===d&&(Object.assign(S,{[b]:v("umd")}),F=v(g?"example/index.ts":"src/index.ts"),outputConfig.path=v(g?"dist":"umd"),outputConfig.filename="index.js",outputConfig.library=b,outputConfig.libraryTarget="umd",outputConfig.libraryExport="default");let K={main:F};l.entry&&("string"==typeof l.entry?K=l.entry:Object.keys(l.entry)&&Object.assign(K,l.entry)),l.output&&("string"==typeof l.output?outputConfig.path=l.output:Object.keys(l.output)&&Object.assign(outputConfig,l.output));let L=l.routeBaseName.split("/").filter(Boolean).length,W=Array(L).fill("..").join("/")+(L?"/":"")+"404.html",{pathSegmentsToKeep:D=L,path:R=W}=l.fixBrowserRouter||{},_={entry:K,stats:"errors-only",infrastructureLogging:{level:"none"},target:"web",plugins:[new n.AutomaticPrefetchPlugin,...u,B&&new B({fix:!0,threads:!0,extensions:["js","md","mdx","cjs","ejs","mjs","jsx","ts","tsx","json","html","coffee","vue"]}),A&&new A({fix:!0,threads:!0,extensions:["css","scss","sass","less","ts","tsx","js","jsx"],exclude:["node_modules/","es/","lib/","docs/","coverage/","dist/"]}),new s(c),l.fixBrowserRouter&&new s({filename:R,inject:!1,templateContent:()=>`<html html><head><title>${c.title}</title><script>var pathSegmentsToKeep = ${D||L};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(M),"single-spa"===d&&new m(e=>!!(e.match(/main\.(.*)\.bundle.js$/)||e.match("main.bundle.js"))),new n.DefinePlugin(p),new n.WatchIgnorePlugin({paths:[/\.d\.ts$/]}),l.sourceMap&&new n.SourceMapDevToolPlugin(l.sourceMap),new o({name:"编译中",color:"#6f42c1"}),new r({done:()=>{!g&&l.seo&&x(),l.done?.()}}),...l.plugins].filter(Boolean),experiments:{topLevelAwait:!0,syncWebAssembly:!0,asyncWebAssembly:!0},resolve:{extensions:[".tsx",".ts",".js",".jsx"],alias:S,fallback:{path:!1,fs:!1,crypto:!1,assert:!1}},module:f,externals:l.externals,output:outputConfig};export default _;
+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 { CONFIG, ENTRYPATH, PUBLICPATH } from './common.js';
+import DoneWebpackPlugin from './done.js';
+import envFlags from './envFlags.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, hasEslintConfig, hasStylelintConfig, PACKAGENAME, PROGRAMPATH, FRAMEWORK } from './process-env.js';
+import './routes.js';
+import { seo } from './seo.js';
+import { resolveNodeModulesPath, resolveProgramPath } from './utils.js';
+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 alias = {
+    '@': resolveProgramPath('src')
+};
+Object.assign(alias, CONFIG.alias);
+if (APPTYPE === 'library') {
+    Object.assign(alias, {
+        '@': resolveProgramPath('site'),
+        '@pkg': resolveProgramPath('components'),
+        [PACKAGENAME]: resolveProgramPath('components')
+    });
+}
+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]`,
+    library: PACKAGENAME,
+    libraryTarget: 'window',
+    globalObject: 'window',
+    chunkLoadingGlobal: `webpackJsonp_${PACKAGENAME}`,
+    pathinfo: false,
+    clean: true,
+    publicPath: PUBLICPATH
+};
+let mainEntry = resolveNodeModulesPath(`@moneko/${FRAMEWORK}/lib/packages/${ENTRYPATH[APPTYPE]}/index.js`);
+if (APPTYPE === 'single-component') {
+    Object.assign(alias, {
+        [PACKAGENAME]: resolveProgramPath('umd')
+    });
+    mainEntry = resolveProgramPath(DEV ? 'example/index.ts' : 'src/index.ts');
+    outputConfig.path = resolveProgramPath(DEV ? 'dist' : 'umd');
+    outputConfig.filename = 'index.js';
+    outputConfig.library = PACKAGENAME;
+    outputConfig.libraryTarget = 'umd';
+    outputConfig.libraryExport = 'default';
+}
+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 webpack.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/'
+            ]
+        }),
+        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 webpack.DefinePlugin(envFlags),
+        new webpack.WatchIgnorePlugin({
+            paths: [
+                /\.d\.ts$/
+            ]
+        }),
+        CONFIG.sourceMap && new webpack.SourceMapDevToolPlugin(CONFIG.sourceMap),
+        new WebpackBar({
+            name: '编译中',
+            color: '#6f42c1'
+        }),
+        new DoneWebpackPlugin({
+            done: ()=>{
+                if (!DEV && CONFIG.seo) {
+                    seo();
+                }
+                CONFIG.done?.();
+            }
+        }),
+        ...CONFIG.plugins
+    ].filter(Boolean),
+    experiments: {
+        topLevelAwait: true,
+        syncWebAssembly: true,
+        asyncWebAssembly: true
+    },
+    resolve: {
+        extensions: [
+            '.tsx',
+            '.ts',
+            '.js',
+            '.jsx'
+        ],
+        alias: 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,98 @@
-import e from"@soda/friendly-errors-webpack-plugin";import o from"chalk";import{getPort as r}from"portfinder";import t from"webpack";import{merge as s}from"webpack-merge";import{CONFIG as p}from"./common.js";import{hasPkg as i}from"./has-pkg.js";import{FRAMEWORK as a}from"./process-env.js";import{getIPAdress as l,isFunction as m,resolveProgramPath as c}from"./utils.js";import n from"./webpack.common.js";let d=i("@moneko/mock"),v=d&&await import("@moneko/mock"),h="react"===a&&(await import("@pmmmwh/react-refresh-webpack-plugin")).default,w=!1;p.cacheDirectory&&(w={type:"filesystem",allowCollectingMemory:!0,cacheDirectory:p.cacheDirectory});let f=!1===p.devtool||p.devtool?p.devtool:"eval-cheap-module-source-map",u=new Promise(i=>{r({port:p.devServer.port,stopPort:9999},(r,a)=>{let d=[];p.devServer.port!==a&&d.push(`Port ${o.yellow(p.devServer.port)} is in use, trying ${o.green(a)} instead`),p.devServer.port=a;let u="/"===p.routeBaseName,g=p.devServer.https?"https:":"http:",k=u?"":p.routeBaseName,y=s(n,{devtool:f,mode:"development",cache:w,devServer:{headers:{"Access-Control-Allow-Origin":"*"},compress:p.devServer.compress,host:"0.0.0.0",port:a,historyApiFallback:u||{index:k,disableDotRule:!0},https:p.devServer.https,proxy:p.proxy,allowedHosts:p.devServer.allowedHosts,client:{progress:!1,logging:"info",overlay:!1},static:{watch:{ignored:e=>e.endsWith(".d.ts")}},setupMiddlewares:(e,o)=>{if(!o)throw Error("webpack-dev-server is not defined");return o.app&&m(v)&&v(o.app,c("mock/")),e},open:!1,hot:!0},plugins:[new t.HotModuleReplacementPlugin,h&&new h,new e({compilationSuccessInfo:{messages:[`You application is running here:
+import FriendlyErrorsWebpackPlugin from '@soda/friendly-errors-webpack-plugin';
+import chalk from 'chalk';
+import { getPort } from 'portfinder';
+import webpack from 'webpack';
+import { merge } from 'webpack-merge';
+import { CONFIG } from './common.js';
+import { hasPkg } from './has-pkg.js';
+import { FRAMEWORK } from './process-env.js';
+import { getIPAdress, isFunction, resolveProgramPath } from './utils.js';
+import common from './webpack.common.js';
+const hasMockMiddlewares = hasPkg('@moneko/mock');
+const mockMiddlewares = hasMockMiddlewares && await import('@moneko/mock');
+const ReactRefresh = FRAMEWORK === 'react' && (await import('@pmmmwh/react-refresh-webpack-plugin')).default;
+let cacheConfig = false;
+if (CONFIG.cacheDirectory) {
+    cacheConfig = {
+        type: 'filesystem',
+        allowCollectingMemory: true,
+        cacheDirectory: CONFIG.cacheDirectory
+    };
+}
+const devtool = CONFIG.devtool === false || CONFIG.devtool ? CONFIG.devtool : 'eval-cheap-module-source-map';
+const webpackConfig = new Promise((resolve)=>{
+    getPort({
+        port: CONFIG.devServer.port,
+        stopPort: 9999
+    }, (_err, port)=>{
+        const notes = [];
+        if (CONFIG.devServer.port !== port) {
+            notes.push(`Port ${chalk.yellow(CONFIG.devServer.port)} is in use, trying ${chalk.green(port)} instead`);
+        }
+        CONFIG.devServer.port = port;
+        const initRouteBase = CONFIG.routeBaseName === '/';
+        const protocol = CONFIG.devServer.https ? 'https:' : 'http:';
+        const routeBase = initRouteBase ? '' : CONFIG.routeBaseName;
+        const conf = 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,
+                    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 webpack.HotModuleReplacementPlugin(),
+                ReactRefresh && new ReactRefresh(),
+                new FriendlyErrorsWebpackPlugin({
+                    compilationSuccessInfo: {
+                        messages: [
+                            `You application is running here:
 
-    local:   ${o.cyan(`${g}//${p.devServer.host}:${a}${k}`)}
-    network: ${o.cyan(`${g}//${l()}:${a}${k}`)}`],notes:d},clearConsole:!0})].filter(Boolean)});i(y)})});export default u;
+    local:   ${chalk.cyan(`${protocol}//${CONFIG.devServer.host}:${port}${routeBase}`)}
+    network: ${chalk.cyan(`${protocol}//${getIPAdress()}:${port}${routeBase}`)}`
+                        ],
+                        notes: notes
+                    },
+                    clearConsole: true
+                })
+            ].filter(Boolean)
+        });
+        resolve(conf);
+    });
+});
+export default webpackConfig;

package/lib/webpack.prod.js

@@ -1 +1,64 @@
-import e from"css-minimizer-webpack-plugin";import i from"mini-css-extract-plugin";import n from"terser-webpack-plugin";import m from"webpack";import{BundleAnalyzerPlugin as o}from"webpack-bundle-analyzer";import{merge as r}from"webpack-merge";import{CONFIG as s}from"./common.js";import{getMinifyOption as t}from"./minify.js";import c from"./webpack.common.js";let{cssnanoMinify:l,swcMinify:p}=e,a="swc"===s.compiler?"swc":"terser",u="swc"===s.compiler?"swc":"cssnano",f=[];s.minifier&&(s.minifier.js&&f.push(new n(t(s.minifier.js?.type||a,s.minifier.js?.options))),s.minifier.css&&f.push(new e({minify:{swc:p,cssnano:l}[s.minifier.css?.type||u],minimizerOptions:s.minifier.css?.options})));let d={splitChunks:s.splitChunk,runtimeChunk:s.runtimeChunk,chunkIds:"named",moduleIds:"named",removeAvailableModules:!0,removeEmptyChunks:!0,mergeDuplicateChunks:!0,minimize:!0,minimizer:f},h=!1;s.cacheDirectory&&(h={type:"filesystem",allowCollectingMemory:!0,cacheDirectory:s.cacheDirectory});export default r(c,{devtool:!1===s.devtool||s.devtool?s.devtool:"cheap-module-source-map",mode:"production",cache:h,optimization:d,plugins:[new i({filename:"style/[name].bundle.css",chunkFilename:"style/[name].chunk.css",experimentalUseImportModule:!0}),s.bundleAnalyzer&&new o(s.bundleAnalyzer),s.splitChunk&&new m.optimize.MinChunkSizePlugin({minChunkSize:1e4})].filter(Boolean)});
+import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
+import MiniCssExtractPlugin from 'mini-css-extract-plugin';
+import TerserPlugin from 'terser-webpack-plugin';
+import webpack from 'webpack';
+import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
+import { merge } from 'webpack-merge';
+import { CONFIG } from './common.js';
+import { getMinifyOption } from './minify.js';
+import common from './webpack.common.js';
+const { cssnanoMinify , swcMinify  } = CssMinimizerPlugin;
+const defaultJsMiniify = CONFIG.compiler === 'swc' ? 'swc' : 'terser';
+const defaultCssMiniify = CONFIG.compiler === 'swc' ? 'swc' : 'cssnano';
+const cssMinify = {
+    swc: swcMinify,
+    cssnano: cssnanoMinify
+};
+const minimizer = [];
+if (CONFIG.minifier) {
+    if (CONFIG.minifier.js) {
+        minimizer.push(new TerserPlugin(getMinifyOption(CONFIG.minifier.js?.type || defaultJsMiniify, CONFIG.minifier.js?.options)));
+    }
+    if (CONFIG.minifier.css) {
+        minimizer.push(new CssMinimizerPlugin({
+            minify: cssMinify[CONFIG.minifier.css?.type || defaultCssMiniify],
+            minimizerOptions: CONFIG.minifier.css?.options
+        }));
+    }
+}
+const optimization = {
+    splitChunks: CONFIG.splitChunk,
+    runtimeChunk: CONFIG.runtimeChunk,
+    chunkIds: 'named',
+    moduleIds: 'named',
+    removeAvailableModules: true,
+    removeEmptyChunks: true,
+    mergeDuplicateChunks: true,
+    minimize: true,
+    minimizer: minimizer
+};
+let cacheConfig = false;
+if (CONFIG.cacheDirectory) {
+    cacheConfig = {
+        type: 'filesystem',
+        allowCollectingMemory: true,
+        cacheDirectory: CONFIG.cacheDirectory
+    };
+}
+export default merge(common, {
+    devtool: CONFIG.devtool === false || CONFIG.devtool ? CONFIG.devtool : 'cheap-module-source-map',
+    mode: 'production',
+    cache: cacheConfig,
+    optimization: optimization,
+    plugins: [
+        new MiniCssExtractPlugin({
+            filename: 'style/[name].bundle.css',
+            chunkFilename: 'style/[name].chunk.css',
+            experimentalUseImportModule: true
+        }),
+        CONFIG.bundleAnalyzer && new BundleAnalyzerPlugin(CONFIG.bundleAnalyzer),
+        CONFIG.splitChunk && new webpack.optimize.MinChunkSizePlugin({
+            minChunkSize: 10000
+        })
+    ].filter(Boolean)
+});

package/lib/yarn-argv.js

@@ -1 +1,9 @@
-let e=JSON.parse(process.env.npm_config_argv||"{}")?.original,a={};e?.forEach(e=>{let r=e.split("=");Object.assign(a,{[r[0]]:r[1]||!0})});export default a;
+const original = JSON.parse(process.env.npm_config_argv || '{}')?.original;
+const yarnArgv = {};
+original?.forEach((o)=>{
+    const m = o.split('=');
+    Object.assign(yarnArgv, {
+        [m[0]]: m[1] || true
+    });
+});
+export default yarnArgv;

package/package.json

@@ -1,18 +1,17 @@
 {
   "name": "@moneko/core",
-  "version": "3.0.0-beta.30",
+  "version": "3.0.0-beta.32",
   "description": "core",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
-    "build": "swc src -d lib -C module.type=nodenext -C jsc.target=esnext -C jsc.loose=true -C jsc.minify.mangle=true -C jsc.minify.compress=true -C minify=true -D",
+    "build": "swc src -d lib -C module.type=nodenext -C jsc.target=esnext -C jsc.loose=true -C jsc.minify.mangle=false -C jsc.minify.compress=false -C minify=false -D",
     "prebuild": "rm -rf ./lib && tsc"
   },
   "keywords": [],
   "author": "moneko",
   "license": "MIT",
   "dependencies": {
-    "@emotion/css": "11.11.0",
     "@mdx-js/loader": "2.3.0",
     "@soda/friendly-errors-webpack-plugin": "1.8.1",
     "@swc/core": "1.3.56",
@@ -51,6 +50,7 @@
     "@moneko/mock": "^1.0.9",
     "@moneko/postcss": "^1.0.30",
     "@swc/cli": "0.1.62",
+    "@types/js-yaml": "^4.0.5",
     "@types/mini-css-extract-plugin": "^2.5.1",
     "@types/shelljs": "^0.8.12",
     "@types/webpack-bundle-analyzer": "^4.6.0",