balm-core 5.2.0 → 6.0.0-alpha.0

package/tslib/bundler/webpack/config/common.js

@@ -1,130 +0,0 @@
-import HtmlWebpackPlugin from 'html-webpack-plugin';
-import getLoaders from '../loaders.js';
-import { CHUNK } from '../../../config/constants.js';
-import getClientEnvironment from './env.js';
-function getDefaultPlugins(webpack, scripts) {
-    const env = getClientEnvironment(BalmJS.file.publicUrlOrPath.slice(0, -1));
-    const plugins = [
-        new webpack.DefinePlugin(env.stringified),
-        new webpack.IgnorePlugin({
-            resourceRegExp: /^\.\/locale$/,
-            contextRegExp: /moment$/
-        })
-    ];
-    if (scripts.injectHtml) {
-        const isSPA = BalmJS.entries.length < 2;
-        const titles = scripts.htmlPluginOptions.title || ['BalmJS App'];
-        if (!BalmJS.entries.length) {
-            BalmJS.entries.push({
-                key: 'main',
-                value: `./${BalmJS.file.defaultEntry}`
-            });
-        }
-        BalmJS.entries.forEach((entry, index) => {
-            const entryName = isSPA ? 'index' : entry.key;
-            const chunks = isSPA ? 'all' : [entryName];
-            const title = titles[index];
-            const options = Object.assign({
-                filename: BalmJS.file.absPath(`${BalmJS.config.src.base}/${entryName}.html`),
-                chunks
-            }, scripts.htmlPluginOptions, {
-                title
-            });
-            plugins.push(new HtmlWebpackPlugin(options));
-        });
-    }
-    return plugins;
-}
-function getSplitChunks() {
-    const scripts = BalmJS.config.scripts;
-    const jsFolder = BalmJS.config.paths.target.js;
-    let cacheGroups = {};
-    if (scripts.extractAllVendors) {
-        const vendorsFilename = scripts.useCache
-            ? `${scripts.vendorName}.${CHUNK.hash}.js`
-            : `${scripts.vendorName}.js`;
-        cacheGroups = {
-            allVendors: {
-                name: 'vendors',
-                chunks: 'initial',
-                test: /[\\/](node_modules|bower_components)[\\/]/,
-                filename: BalmJS.file.assetsPath(`${jsFolder}/${vendorsFilename}`)
-            }
-        };
-    }
-    else if (BalmJS.vendors.length) {
-        cacheGroups = {};
-        for (const vendor of BalmJS.vendors) {
-            const name = vendor.key;
-            const cacheGroupModules = vendor.value.join('|');
-            const vendorFilename = scripts.useCache
-                ? `${name}.${CHUNK.hash}.js`
-                : `${name}.js`;
-            cacheGroups[`${name}Scripts`] = {
-                name,
-                chunks: 'initial',
-                test: new RegExp(`[\\\\/](${cacheGroupModules})[\\\\/].*(?<!\\.css)$`),
-                filename: BalmJS.file.assetsPath(`${jsFolder}/${scripts.vendorName}/${vendorFilename}`),
-                enforce: true
-            };
-        }
-    }
-    if (BalmJS.config.env.isProd && BalmJS.config.scripts.extractCss) {
-        for (const entry of BalmJS.entries) {
-            const name = entry.key;
-            cacheGroups[`${name}Styles`] = {
-                type: 'css/mini-extract',
-                name,
-                chunks: (chunk) => chunk.name === name,
-                enforce: true
-            };
-        }
-    }
-    return Object.keys(cacheGroups).length ? { cacheGroups } : false;
-}
-function getCommonConfig(webpack, scripts) {
-    const splitChunks = getSplitChunks();
-    const optimization = splitChunks
-        ? BalmJS.utils.deepMerge({
-            splitChunks: splitChunks
-        }, scripts.optimization)
-        : scripts.optimization;
-    return {
-        context: BalmJS.config.workspace,
-        mode: 'none',
-        bail: BalmJS.config.env.isProd,
-        module: {
-            strictExportPresence: true,
-            rules: getLoaders(scripts.loaders)
-        },
-        resolve: {
-            modules: [
-                'node_modules',
-                'bower_components',
-                BalmJS.file.absPath(BalmJS.config.src.base)
-            ],
-            extensions: [
-                '.wasm',
-                '.mjs',
-                '.js',
-                '.json',
-                '.jsx',
-                '.ts',
-                '.tsx',
-                '.vue',
-                ...scripts.extensions
-            ],
-            alias: scripts.alias,
-            descriptionFiles: ['package.json', 'bower.json'],
-            mainFields: ['browser', 'module', 'main']
-        },
-        optimization,
-        plugins: [
-            ...getDefaultPlugins(webpack, scripts),
-            ...scripts.plugins
-        ],
-        target: scripts.target,
-        stats: scripts.stats
-    };
-}
-export default getCommonConfig;

package/tslib/bundler/webpack/config/dev.js

@@ -1,14 +0,0 @@
-import { merge } from 'webpack-merge';
-import getCommonConfig from './common.js';
-function getDevConfig(webpack, scripts) {
-    return merge(getCommonConfig(webpack, scripts), {
-        mode: 'development',
-        plugins: [
-            new webpack.HotModuleReplacementPlugin()
-        ],
-        devtool: scripts.sourceMap
-            ? scripts.sourceMap
-            : 'eval-cheap-module-source-map'
-    });
-}
-export default getDevConfig;

package/tslib/bundler/webpack/config/env.js

@@ -1,44 +0,0 @@
-import dotenv from 'dotenv';
-import dotenvExpand from 'dotenv-expand';
-const NODE_ENV = process.env.NODE_ENV;
-if (!NODE_ENV) {
-    throw new Error('The NODE_ENV environment variable is required but was not specified.');
-}
-const dotenvFile = BalmJS.file.resolveApp('.env');
-const dotenvFiles = [
-    `${dotenvFile}.${NODE_ENV}.local`,
-    NODE_ENV !== 'test' && `${dotenvFile}.local`,
-    `${dotenvFile}.${NODE_ENV}`,
-    dotenvFile
-].filter(Boolean);
-dotenvFiles.forEach((dotenvFile) => {
-    if (node.fs.existsSync(dotenvFile)) {
-        dotenvExpand.expand(dotenv.config({
-            path: dotenvFile
-        }));
-    }
-});
-const BALM_APP = /^BALM_APP_/i;
-function getClientEnvironment(publicUrl) {
-    const raw = Object.keys(process.env)
-        .filter((key) => BALM_APP.test(key))
-        .reduce((env, key) => {
-        env[key] = process.env[key];
-        return env;
-    }, {
-        NODE_ENV: process.env.NODE_ENV || 'development',
-        PUBLIC_URL: publicUrl,
-        ...BalmJS.config.scripts.nodeEnv
-    });
-    const stringified = {
-        'process.env': Object.keys(raw).reduce((env, key) => {
-            env[key] = JSON.stringify(raw[key]);
-            return env;
-        }, {})
-    };
-    BalmJS.logger.debug('webpack .env', stringified, {
-        pre: true
-    });
-    return { raw, stringified };
-}
-export default getClientEnvironment;

package/tslib/bundler/webpack/config/index.js

@@ -1,8 +0,0 @@
-import getDevConfig from './dev.js';
-import getProdConfig from './prod.js';
-function getDefaultConfig(webpack, scripts) {
-    return BalmJS.config.env.isProd || scripts.minify || scripts.ie8
-        ? getProdConfig(webpack, scripts)
-        : getDevConfig(webpack, scripts);
-}
-export default getDefaultConfig;

package/tslib/bundler/webpack/config/prod.js

@@ -1,43 +0,0 @@
-import TerserPlugin from 'terser-webpack-plugin';
-import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
-import MiniCssExtractPlugin from 'mini-css-extract-plugin';
-import webpackBundleAnalyzer from 'webpack-bundle-analyzer';
-import { merge } from 'webpack-merge';
-import getCommonConfig from './common.js';
-import { CHUNK } from '../../../config/constants.js';
-const bundleAnalyzerReport = process.env.npm_config_report || false;
-const getCssFilename = () => `${BalmJS.config.paths.target.css}/${CHUNK.dir}/[name].${CHUNK.hash}.css`;
-function getProdConfig(webpack, scripts) {
-    const shouldUseSourceMap = scripts.sourceMap;
-    const terserOptions = scripts.minifyOptions;
-    if (scripts.ie8) {
-        terserOptions.ie8 = true;
-    }
-    return merge(getCommonConfig(webpack, scripts), {
-        mode: 'production',
-        optimization: {
-            minimizer: [
-                new TerserPlugin({
-                    terserOptions,
-                    extractComments: false
-                }),
-                new CssMinimizerPlugin()
-            ]
-        },
-        plugins: [
-            ...(scripts.extractCss
-                ? [
-                    new MiniCssExtractPlugin({
-                        filename: BalmJS.file.assetsPath(getCssFilename()),
-                        chunkFilename: BalmJS.file.assetsPath(getCssFilename())
-                    })
-                ]
-                : []),
-            ...(bundleAnalyzerReport
-                ? [new webpackBundleAnalyzer.BundleAnalyzerPlugin()]
-                : [])
-        ],
-        devtool: shouldUseSourceMap ? 'source-map' : false
-    });
-}
-export default getProdConfig;

package/tslib/bundler/webpack/config/regex.js

@@ -1,10 +0,0 @@
-const htmlRegex = /\.html$/;
-const cssRegex = /\.css$/;
-const cssModuleRegex = /\.module\.css$/;
-const sassRegex = /\.(scss|sass)$/;
-const sassModuleRegex = /\.module\.(scss|sass)$/;
-const jsRegex = /\.(js|mjs|jsx|ts|tsx)$/;
-const imgRegex = /\.(bmp|gif|jpe?g|png|svg|webp)(\?.*)?$/;
-const fontRegex = /\.(woff2?|eot|ttf|otf)(\?.*)?$/;
-const mediaRegex = /\.(mp4|webm|ogg|mp3|wav|flac|aac)(\?.*)?$/;
-export { htmlRegex, cssRegex, cssModuleRegex, sassRegex, sassModuleRegex, jsRegex, imgRegex, fontRegex, mediaRegex };

package/tslib/bundler/webpack/entry.js

@@ -1,68 +0,0 @@
-import { HMR_PATH } from '../../config/constants.js';
-const FILENAME_REGEX = new RegExp('[^/]+$', 'i');
-const HOT_CLIENT = 'webpack-hot-middleware/client';
-function initVendors(entries) {
-    const jsVendors = [];
-    const jsEntries = [];
-    for (const [key, value] of Object.entries(entries)) {
-        if (BalmJS.utils.isArray(value)) {
-            jsVendors.push({
-                key,
-                value: value
-            });
-        }
-        else {
-            jsEntries.push({
-                key,
-                value: value
-            });
-        }
-    }
-    BalmJS.vendors = jsVendors;
-    BalmJS.entries = jsEntries;
-}
-function getEntry(input, scripts) {
-    let webpackEntries = {};
-    const hotOptions = Object.assign({}, BalmJS.config.server.hotOptions, {
-        path: HMR_PATH
-    });
-    const HMR = `${HOT_CLIENT}?` +
-        Object.entries(hotOptions)
-            .map((option) => option.join('='))
-            .join('&');
-    const useHMR = BalmJS.config.server.useHMR;
-    if (BalmJS.utils.isObject(input)) {
-        initVendors(input);
-        for (const [key, value] of Object.entries(input)) {
-            const isVendor = BalmJS.utils.isArray(value);
-            const entryKey = isVendor
-                ? node.path.join(scripts.vendorName, key)
-                : node.path.join(key);
-            const hotValue = BalmJS.utils.isString(value)
-                ? [value, HMR]
-                : [...value, HMR];
-            const entryValue = useHMR ? hotValue : value;
-            if (!isVendor) {
-                webpackEntries[entryKey] = entryValue;
-            }
-        }
-    }
-    else if (BalmJS.utils.isArray(input) && input.length) {
-        for (const value of input) {
-            const matchResult = FILENAME_REGEX.exec(value)[0];
-            const key = matchResult.split('.')[0];
-            webpackEntries[key] = useHMR ? [value, HMR] : value;
-        }
-    }
-    else if (BalmJS.utils.isString(input) && input.trim().length) {
-        webpackEntries = useHMR ? [input, HMR] : input;
-    }
-    else {
-        BalmJS.logger.warn('webpack entry', '`scripts.entry` must be `string | array | object`');
-    }
-    BalmJS.logger.debug('webpack entry', webpackEntries, {
-        pre: true
-    });
-    return webpackEntries;
-}
-export default getEntry;

package/tslib/bundler/webpack/index.js

@@ -1,30 +0,0 @@
-import { merge } from 'webpack-merge';
-import getEntry from './entry.js';
-import getOutput from './output.js';
-import getDefaultConfig from './config/index.js';
-const webpackModule = process.env.WEBPACK || requireModule.resolve('webpack');
-const webpack = requireModule(webpackModule);
-function webpackConfig(input, output, customWebpackOptions = {}, isHook = false) {
-    const scripts = BalmJS.config.scripts;
-    const defaultEntry = `./${BalmJS.file.defaultEntry}`;
-    const baseConfig = {
-        entry: input ? getEntry(input, scripts) : defaultEntry,
-        output: getOutput(output, scripts, isHook)
-    };
-    BalmJS.logger.debug('webpack bundler', {
-        input: baseConfig.entry,
-        output: baseConfig.output.path
-    }, {
-        pre: true
-    });
-    if (scripts.externals) {
-        baseConfig.externals = scripts.externals;
-    }
-    const defaultConfig = getDefaultConfig(webpack, scripts);
-    const configuration = merge(baseConfig, defaultConfig, scripts.webpackOptions, customWebpackOptions);
-    BalmJS.logger.success('webpack configuration', configuration, {
-        pre: true
-    });
-    return configuration;
-}
-export { webpack, webpackConfig };

package/tslib/bundler/webpack/loaders.js

@@ -1,51 +0,0 @@
-import { mergeWithRules, CustomizeRule } from 'webpack-merge';
-import LOADERS from './rules/index.js';
-function getLoaders(customLoaders) {
-    const enableDefaultLoaders = Object.assign({
-        js: true,
-        css: true,
-        html: true,
-        asset: true
-    }, BalmJS.config.scripts.defaultLoaders);
-    const useDefaultLoaders = Object.values(enableDefaultLoaders).some((value) => value);
-    let defaultLoaders = [];
-    if (useDefaultLoaders) {
-        Object.values(LOADERS).forEach((Loader) => {
-            const key = Loader.name.replace('Loader', '');
-            if (enableDefaultLoaders[key]) {
-                const loader = Loader();
-                if (BalmJS.utils.isArray(loader)) {
-                    defaultLoaders = defaultLoaders.concat(loader);
-                }
-                else {
-                    defaultLoaders.push(loader);
-                }
-            }
-        });
-    }
-    const result = mergeWithRules({
-        module: {
-            rules: {
-                test: CustomizeRule.Match,
-                use: {
-                    loader: CustomizeRule.Match,
-                    options: CustomizeRule.Replace
-                }
-            }
-        }
-    })({
-        module: {
-            rules: defaultLoaders
-        }
-    }, {
-        module: {
-            rules: customLoaders
-        }
-    });
-    const defaultModule = result.module;
-    BalmJS.logger.debug('webpack loaders', defaultModule.rules, {
-        pre: true
-    });
-    return defaultModule.rules;
-}
-export default getLoaders;

package/tslib/bundler/webpack/output.js

@@ -1,41 +0,0 @@
-import { CHUNK, ASSET } from '../../config/constants.js';
-function getJsFilename(scripts, isChunk = false) {
-    let filename;
-    if (isChunk) {
-        filename = BalmJS.config.env.isProd ? `[name].${CHUNK.hash}` : '[name]';
-    }
-    else {
-        filename = scripts.useCache ? `[name].${CHUNK.hash}` : '[name]';
-    }
-    return `${filename}.js`;
-}
-function getOutput(output, scripts, isHook = false) {
-    const outputDirectory = output || BalmJS.config.dest.base;
-    const jsFolder = BalmJS.config.paths.target.js;
-    const bundleFilename = getJsFilename(scripts);
-    const chunkFilename = getJsFilename(scripts, true);
-    const customLibraryConfig = scripts.library
-        ? { library: scripts.library }
-        : {};
-    const miniprogramConfig = BalmJS.config.env.isMP
-        ? {
-            path: BalmJS.file.absPath(node.path.join(BalmJS.config.dest.base, ASSET.mpDir)),
-            library: {
-                name: 'createApp',
-                type: 'window',
-                export: 'default'
-            }
-        }
-        : {};
-    return Object.assign({
-        path: BalmJS.file.absPath(outputDirectory),
-        filename: isHook
-            ? bundleFilename
-            : BalmJS.file.assetsPath(`${jsFolder}/${bundleFilename}`),
-        chunkFilename: isHook
-            ? chunkFilename
-            : BalmJS.file.assetsPath(`${jsFolder}/${CHUNK.dir}/${chunkFilename}`),
-        publicPath: BalmJS.file.publicUrlOrPath
-    }, customLibraryConfig, miniprogramConfig);
-}
-export default getOutput;

package/tslib/bundler/webpack/rules/asset.js

@@ -1,33 +0,0 @@
-import { imgRegex, fontRegex, mediaRegex } from '../config/regex.js';
-import { ASSET } from '../../../config/constants.js';
-function assetLoader() {
-    return [
-        {
-            test: imgRegex,
-            type: BalmJS.config.scripts.imageAssetType,
-            parser: {
-                dataUrlCondition: {
-                    maxSize: BalmJS.config.scripts.imageInlineSizeLimit
-                }
-            },
-            generator: {
-                filename: BalmJS.file.assetsPath(`${ASSET.dir}/${BalmJS.config.paths.target.img}/[name].${ASSET.hash}[ext]`)
-            }
-        },
-        {
-            test: fontRegex,
-            type: 'asset/resource',
-            generator: {
-                filename: BalmJS.file.assetsPath(`${ASSET.dir}/${BalmJS.config.paths.target.font}/[name].${ASSET.hash}[ext]`)
-            }
-        },
-        {
-            test: mediaRegex,
-            type: 'asset/resource',
-            generator: {
-                filename: BalmJS.file.assetsPath(`${ASSET.dir}/${BalmJS.config.paths.target.media}/[name].${ASSET.hash}[ext]`)
-            }
-        }
-    ];
-}
-export default assetLoader;

package/tslib/bundler/webpack/rules/babel.js

@@ -1,16 +0,0 @@
-import { jsRegex } from '../config/regex.js';
-function jsLoader() {
-    const options = Object.assign({
-        cacheDirectory: true
-    }, BalmJS.config.scripts.babelLoaderOptions);
-    return {
-        test: jsRegex,
-        include: [
-            BalmJS.file.absPaths(BalmJS.config.src.js),
-            ...BalmJS.config.scripts.includeJsResource
-        ],
-        loader: requireModule.resolve('babel-loader'),
-        options
-    };
-}
-export default jsLoader;

package/tslib/bundler/webpack/rules/css.js

@@ -1,95 +0,0 @@
-import fs from 'node:fs';
-import MiniCssExtractPlugin from 'mini-css-extract-plugin';
-import { cssRegex, cssModuleRegex, sassRegex, sassModuleRegex } from '../config/regex.js';
-const useTailwind = fs.existsSync(node.path.join(BalmJS.config.workspace, 'tailwind.config.js'));
-function getStyleLoaders(styleLoader, cssOptions, preProcessor = '', sassOptions = {}) {
-    const { sourceMap } = cssOptions;
-    const loaders = [
-        BalmJS.config.env.isProd && BalmJS.config.scripts.extractCss
-            ? {
-                loader: MiniCssExtractPlugin.loader,
-                options: {
-                    esModule: BalmJS.config.scripts.useEsModule
-                }
-            }
-            : styleLoader,
-        {
-            loader: requireModule.resolve('css-loader'),
-            options: cssOptions
-        },
-        {
-            loader: requireModule.resolve('postcss-loader'),
-            options: Object.assign({
-                postcssOptions: {
-                    plugins: BalmJS.plugins.postcssPlugins(true, useTailwind)
-                },
-                sourceMap
-            }, BalmJS.config.scripts.postcssLoaderOptions)
-        }
-    ].filter(Boolean);
-    if (preProcessor) {
-        loaders.push({
-            loader: requireModule.resolve(preProcessor),
-            options: Object.assign({
-                sourceMap: true
-            }, sassOptions)
-        });
-    }
-    return loaders;
-}
-function cssLoader() {
-    let styleLoader = {
-        loader: requireModule.resolve('style-loader'),
-        options: {
-            esModule: BalmJS.config.scripts.useEsModule
-        }
-    };
-    if (BalmJS.config.env.inSSR) {
-        const loadersCount = BalmJS.config.scripts.loaders.length;
-        for (let i = 0; i < loadersCount; i++) {
-            if (BalmJS.config.scripts.loaders[i].loader ===
-                'vue-loader') {
-                styleLoader = 'vue-style-loader';
-                break;
-            }
-        }
-    }
-    const sourceMap = BalmJS.config.env.isProd
-        ? BalmJS.config.scripts.sourceMap
-        : BalmJS.config.env.isDev;
-    return [
-        {
-            test: cssRegex,
-            exclude: cssModuleRegex,
-            use: getStyleLoaders(styleLoader, {
-                importLoaders: 1,
-                sourceMap,
-                modules: {
-                    mode: 'icss'
-                },
-                esModule: BalmJS.config.scripts.useEsModule
-            }),
-            sideEffects: true
-        },
-        {
-            test: sassRegex,
-            exclude: sassModuleRegex,
-            use: getStyleLoaders(styleLoader, {
-                importLoaders: 3,
-                sourceMap,
-                modules: {
-                    mode: 'icss'
-                }
-            }, 'sass-loader', {
-                implementation: requireModule.resolve('sass'),
-                sassOptions: Object.assign({
-                    loadPaths: BalmJS.file.stylePaths,
-                    sourceMap: true,
-                    quietDeps: BalmJS.config.logs.level < BalmJS.LogLevel.Warn
-                }, BalmJS.config.styles.sassOptions)
-            }),
-            sideEffects: true
-        }
-    ];
-}
-export default cssLoader;

package/tslib/bundler/webpack/rules/html.js

@@ -1,15 +0,0 @@
-import { htmlRegex } from '../config/regex.js';
-function htmlLoader() {
-    const options = Object.assign({
-        minimize: {
-            removeAttributeQuotes: false
-        },
-        esModule: BalmJS.config.scripts.useEsModule
-    }, BalmJS.config.scripts.htmlLoaderOptions);
-    return {
-        test: `${htmlRegex}i`,
-        loader: requireModule.resolve('html-loader'),
-        options
-    };
-}
-export default htmlLoader;

package/tslib/bundler/webpack/rules/index.js

@@ -1,10 +0,0 @@
-import jsLoader from './babel.js';
-import cssLoader from './css.js';
-import htmlLoader from './html.js';
-import assetLoader from './asset.js';
-export default {
-    assetLoader,
-    htmlLoader,
-    jsLoader,
-    cssLoader
-};

package/tslib/config/assets.js

@@ -1,24 +0,0 @@
-const root = 'assets';
-const mainDir = 'public';
-const subDir = '';
-const buildDir = 'build';
-const virtualDir = '';
-const cache = false;
-const options = {
-    fileNameManifest: 'rev-manifest.json',
-    dontRenameFile: ['.html'],
-    dontUpdateReference: ['.html']
-};
-const includes = [];
-const excludes = [];
-export default {
-    root,
-    mainDir,
-    subDir,
-    buildDir,
-    virtualDir,
-    cache,
-    options,
-    includes,
-    excludes
-};

package/tslib/config/constants.js

@@ -1,14 +0,0 @@
-const DOMAIN = 'https://balm.js.org';
-const HMR_PATH = '/__balm_hmr';
-const PUBLIC_URL = '%PUBLIC_URL%';
-const ASSETS_TYPES = ['css', 'js', 'img', 'font', 'media'];
-const CHUNK = {
-    dir: 'chunk',
-    hash: '[contenthash:8]'
-};
-const ASSET = {
-    dir: 'asset',
-    hash: '[hash:8]',
-    mpDir: 'common'
-};
-export { DOMAIN, HMR_PATH, PUBLIC_URL, ASSETS_TYPES, CHUNK, ASSET };