@flatjs/evolve 2.1.0-next.11 → 2.1.0-next.12

package/dist/main/start-serve.js

@@ -1 +1,34 @@
-import{logger,requireResolve}from"@flatjs/common";import{filterActivedEntriesByModule}from"../helpers/filter-actived-entries.js";import{normalizeEvolveEntryMap}from"../helpers/normalize-entry-map.js";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{prepareServe}from"./prepare-serve.js";export const startServe=async(e,r,o={},t)=>{const i={projectCwd:e,command:"serve",resolve:requireResolve},n=await loadEvolveConfig(i,e,o,t),l=filterActivedEntriesByModule(n.entryMap,r),s=Object.keys(l);if(!s.length)return logger.warn("No served entries providered!"),[];logger.info({servedEntries:s});const v=normalizeEvolveEntryMap(l,n.entryMap);return prepareServe(e,v,n)};
+import { logger, requireResolve } from '@flatjs/common';
+import { filterActivedEntriesByModule } from '../helpers/filter-actived-entries.js';
+import { normalizeEvolveEntryMap } from '../helpers/normalize-entry-map.js';
+import { loadEvolveConfig } from '../load-config/load-evolve-config.js';
+import { prepareServe } from './prepare-serve.js';
+/**
+ * The main entry to start evolve serve
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param serveModules The filter pattern to detect modules we want to serve.
+ * @param overrideEvolveOptions The overrided evolve options
+ * @param configLoaderOptions Evolve config loader options
+ */
+export const startServe = async (projectCwd, serveModules, overrideEvolveOptions = {}, configLoaderOptions) => {
+    const command = {
+        projectCwd,
+        command: 'serve',
+        resolve: requireResolve,
+    };
+    // Try to load evolve configuration from `flatjs-evolve.config.ts`
+    const evolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    const servedEntries = filterActivedEntriesByModule(evolveOptions.entryMap, serveModules);
+    const servedEntryKeys = Object.keys(servedEntries);
+    // Make sure that we have at least one serve entry module.
+    if (!servedEntryKeys.length) {
+        logger.warn(`No served entries providered!`);
+        return [];
+    }
+    logger.info({
+        servedEntries: servedEntryKeys,
+    });
+    // Normalized served entries to make sure we have latested entry options.
+    const normalizedServedEntries = normalizeEvolveEntryMap(servedEntries, evolveOptions.entryMap);
+    return prepareServe(projectCwd, normalizedServedEntries, evolveOptions);
+};

package/dist/main/start-static.js

@@ -1 +1,19 @@
-import{requireResolve}from"@flatjs/common";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{prepareStatic}from"./prepare-static.js";export const startStatic=async(o,e={},r)=>{const t={projectCwd:o,command:"static",resolve:requireResolve},a=await loadEvolveConfig(t,o,e,r);return prepareStatic(o,a)};
+import { requireResolve } from '@flatjs/common';
+import { loadEvolveConfig } from '../load-config/load-evolve-config.js';
+import { prepareStatic } from './prepare-static.js';
+/**
+ * The main entry to start evolve static server to proxy all modules of `production` build
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param overrideEvolveOptions The overrided evolve options
+ * @param configLoaderOptions Evolve config loader options
+ */
+export const startStatic = async (projectCwd, overrideEvolveOptions = {}, configLoaderOptions) => {
+    const command = {
+        projectCwd,
+        command: 'static',
+        resolve: requireResolve,
+    };
+    // Try to load evolve configuration from `flatjs-evolve.config.ts`
+    const evolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    return prepareStatic(projectCwd, evolveOptions);
+};

package/dist/minimizer/create-minimizers.js

@@ -1 +1,25 @@
-import{logger}from"@flatjs/common";import{moduleName}from"../constants.js";import{printInfo}from"../helpers/print-log.js";import{imageMinimizer}from"./image-minimizer.js";import{terserMinimizer}from"./terser-minimizer.js";export const createMinimizers=(i,r)=>{const e=[];if(i)return logger.debug("Ignore minimizer plugin for `serve` mode",moduleName),e;if(!1===r?.minimizer)return printInfo("Note `minimizer` has been disabled for now"),e;if(r?.minimizer?.imageMin){const i=imageMinimizer();i&&e.push(i)}const m=terserMinimizer(r?.minimizer?.terserOptions||{});return e.push(m),e};
+import { logger } from '@flatjs/common';
+import { moduleName } from '../constants.js';
+import { printInfo } from '../helpers/print-log.js';
+import { imageMinimizer } from './image-minimizer.js';
+import { terserMinimizer } from './terser-minimizer.js';
+export const createMinimizers = (serveMode, webpackOptions) => {
+    const minimizers = [];
+    if (serveMode) {
+        logger.debug('Ignore minimizer plugin for `serve` mode', moduleName);
+        return minimizers;
+    }
+    if (webpackOptions?.minimizer === false) {
+        printInfo('Note `minimizer` has been disabled for now');
+        return minimizers;
+    }
+    if (webpackOptions?.minimizer?.imageMin) {
+        const imageMinPlugin = imageMinimizer();
+        if (imageMinPlugin) {
+            minimizers.push(imageMinPlugin);
+        }
+    }
+    const terserPlugin = terserMinimizer(webpackOptions?.minimizer?.terserOptions || {});
+    minimizers.push(terserPlugin);
+    return minimizers;
+};

package/dist/minimizer/default-options.js

@@ -1 +1,14 @@
-export const defaultTerserOptions={ecma:void 0,parse:{},compress:{},mangle:!0,module:!1,output:void 0,toplevel:!1,ie8:!1,keep_classnames:void 0,keep_fnames:!1,safari10:!1};
+export const defaultTerserOptions = {
+    ecma: undefined,
+    parse: {},
+    compress: {},
+    // Note `mangle.properties` is `false` by default.
+    mangle: true,
+    module: false,
+    output: undefined,
+    toplevel: false,
+    ie8: false,
+    keep_classnames: undefined,
+    keep_fnames: false,
+    safari10: false,
+};

package/dist/minimizer/image-minimizer.js

@@ -1 +1,65 @@
-import{projectHasYarn}from"@armit/package";import{chalk,logger,requireResolve}from"@flatjs/common";import ImageMinimizerPlugin from"image-minimizer-webpack-plugin";import{moduleName}from"../constants.js";const logs=new Map;export const imageMinimizer=()=>{const e=[],i=[["svgo",{}],["gifsicle",{}],["jpegtran",{}],["pngquant",{}]].map((i=>{const n=i[0];try{return requireResolve(import.meta.url,`imagemin-${n}`),i}catch(i){if(!logs.get(n)){logs.set(n,!0);const i=chalk(["magenta"])(`"${projectHasYarn()?"yarn add":"npm install"} imagemin-${n} -D"`);e.push(`Execute ${i} for assets optimization`)}return null}})).filter(Boolean);if(e.length)for(const i of e)logger.warn(i,moduleName);return i.length?new ImageMinimizerPlugin({minimizer:{implementation:ImageMinimizerPlugin.imageminMinify,options:{plugins:i}}}):null};
+import { projectHasYarn } from '@armit/package';
+import { chalk, logger, requireResolve } from '@flatjs/common';
+import ImageMinimizerPlugin from 'image-minimizer-webpack-plugin';
+import { moduleName } from '../constants.js';
+const logs = new Map();
+/**
+ * Install libpng library & gifsicle tool
+ * macos
+ * =====================
+ * brew install libpng
+ * brew install gifsicle
+ *
+ * centos
+ * =====================
+ * sudo yum install libpng
+ * sudo yum install epel-release
+ * sudo yum install gifsicle
+ * @returns
+ */
+export const imageMinimizer = () => {
+    const suggestedPlugins = [
+        // Svgo configuration here https://github.com/svg/svgo#configuration
+        ['svgo', {}],
+        ['gifsicle', {}],
+        ['jpegtran', {}],
+        ['pngquant', {}],
+    ];
+    const logMessage = [];
+    const availabledPlugins = suggestedPlugins
+        .map((item) => {
+        const moduleId = item[0];
+        try {
+            requireResolve(import.meta.url, `imagemin-${moduleId}`);
+            return item;
+        }
+        catch (err) {
+            if (!logs.get(moduleId)) {
+                logs.set(moduleId, true);
+                const command = chalk(['magenta'])(`"${projectHasYarn() ? 'yarn add' : 'npm install'} imagemin-${moduleId} -D"`);
+                logMessage.push(`Execute ${command} for assets optimization`);
+            }
+            return null;
+        }
+    })
+        .filter(Boolean);
+    if (logMessage.length) {
+        for (const msg of logMessage) {
+            logger.warn(msg, moduleName);
+        }
+    }
+    if (availabledPlugins.length) {
+        return new ImageMinimizerPlugin({
+            minimizer: {
+                // Recommended squoosh options for lossless optimization
+                implementation: ImageMinimizerPlugin.imageminMinify,
+                options: {
+                    // Lossless optimization with custom option
+                    // Feel free to experiment with options for better result for you
+                    plugins: availabledPlugins,
+                },
+            },
+        });
+    }
+    return null;
+};

package/dist/minimizer/index.js

@@ -1 +1 @@
-export*from"./create-minimizers.js";
+export * from './create-minimizers.js';

package/dist/minimizer/terser-minimizer.js

@@ -1,3 +1,15 @@
-import{mergeOptions}from"@flatjs/common";import TerserPlugin from"terser-webpack-plugin";import{defaultTerserOptions}from"./default-options.js";export const terserMinimizer=e=>new TerserPlugin({parallel:!0,
-// Disable Extract all or some (use /^\**!|@preserve|@license|@cc_on/i RegExp) comments.
-extractComments:!1,terserOptions:mergeOptions(defaultTerserOptions,e)});
+import { mergeOptions } from '@flatjs/common';
+import TerserPlugin from 'terser-webpack-plugin';
+import { defaultTerserOptions } from './default-options.js';
+/**
+ * https://github.com/webpack-contrib/terser-webpack-plugin#terseroptions
+ */
+export const terserMinimizer = (terserOptions) => {
+    return new TerserPlugin({
+        parallel: true,
+        // Disable Extract all or some (use /^\**!|@preserve|@license|@cc_on/i RegExp) comments.
+        extractComments: false,
+        // Terser minify options.
+        terserOptions: mergeOptions(defaultTerserOptions, terserOptions),
+    });
+};

package/dist/minimizer/types.js

@@ -1 +1 @@
-export{};
+export {};

package/dist/plugins/circular-dependency/circular-dependency-plugin.js

@@ -1 +1,119 @@
-import{relative}from"node:path";import{mergeOptions}from"@flatjs/common";import Graph from"tarjan-graph";import webpack from"webpack";const BASE_ERROR="Circular dependency detected:\r\n",PLUGIN_TITLE="CircularDependencyPlugin";export class CircularDependencyPlugin{constructor(o={}){this.options=mergeOptions({exclude:/node_modules/,include:/.*/,failOnError:!1,allowAsyncCycles:!1,projectCwd:process.cwd()},o)}apply(o){const e=this.options.projectCwd;o.hooks.compilation.tap(PLUGIN_TITLE,(o=>{o.hooks.optimizeModules.tap(PLUGIN_TITLE,(t=>{this.options.onStart&&this.options.onStart({compilation:o});const n=new(Graph.default||Graph);for(const e of t){const t=[];for(const n of e.dependencies){if(n.constructor&&"CommonJsSelfReferenceDependency"===n.constructor.name)continue;let r=null;r=o.moduleGraph?o.moduleGraph.getModule(n):n.module,r&&(r instanceof webpack.NormalModule&&r.resource&&(this.options.allowAsyncCycles&&n.weak||e!==r&&t.push(r.identifier())))}n.add(e.identifier(),t)}const r=n.getCycles();this.isCyclic(r,o,e),this.options.onEnd&&this.options.onEnd({compilation:o})}))}))}isCyclic(o,e,t){o.forEach((o=>{const n=o.slice().reverse().map((o=>{const t=e.findModule(o.name);return t instanceof webpack.NormalModule&&t.resource||null}));if(n.every((o=>!o||this.options.exclude.test(o)||!this.options.include.test(o))))return;const r=n.map((o=>relative(t,o)));if(this.options.onDetected){try{this.options.onDetected({paths:r.concat([r[0]]),compilation:e})}catch(o){e.errors.push(o)}return}const s=new Error(BASE_ERROR.concat(r.concat([r[0]]).join(" -> ")));this.options.failOnError?e.errors.push(s):e.warnings.push(s)}))}}
+import { relative } from 'node:path';
+import { mergeOptions } from '@flatjs/common';
+import Graph from 'tarjan-graph';
+import webpack from 'webpack';
+const BASE_ERROR = 'Circular dependency detected:\r\n';
+const PLUGIN_TITLE = `CircularDependencyPlugin`;
+export class CircularDependencyPlugin {
+    constructor(options = {}) {
+        this.options = mergeOptions({
+            exclude: /node_modules/,
+            include: /.*/,
+            failOnError: false,
+            allowAsyncCycles: false,
+            projectCwd: process.cwd(),
+        }, options);
+    }
+    apply(compiler) {
+        const cwd = this.options.projectCwd;
+        // eslint-disable-next-line sonarjs/cognitive-complexity
+        compiler.hooks.compilation.tap(PLUGIN_TITLE, (compilation) => {
+            // eslint-disable-next-line sonarjs/cognitive-complexity
+            compilation.hooks.optimizeModules.tap(PLUGIN_TITLE, (modules) => {
+                if (this.options.onStart) {
+                    this.options.onStart({ compilation });
+                }
+                const dependencyGraph = new (Graph.default || Graph)();
+                for (const module of modules) {
+                    // Iterate over the current modules dependencies
+                    const dependedModuleIds = [];
+                    for (const dependency of module.dependencies) {
+                        if (dependency.constructor &&
+                            dependency.constructor.name === 'CommonJsSelfReferenceDependency') {
+                            continue;
+                        }
+                        let depModule = null;
+                        if (compilation.moduleGraph) {
+                            // handle getting a module for webpack 5
+                            depModule = compilation.moduleGraph.getModule(dependency);
+                        }
+                        else {
+                            // handle getting a module for webpack 4
+                            depModule = dependency.module;
+                        }
+                        if (!depModule) {
+                            continue;
+                        }
+                        // ignore dependencies that don't have an associated resource
+                        if (!(depModule instanceof webpack.NormalModule) ||
+                            !depModule.resource) {
+                            continue;
+                        }
+                        // optionally ignore dependencies that are resolved asynchronously
+                        if (this.options.allowAsyncCycles && dependency.weak) {
+                            continue;
+                        }
+                        // the dependency was resolved to the current module due to how webpack internals
+                        // setup dependencies like CommonJsSelfReferenceDependency and ModuleDecoratorDependency
+                        if (module === depModule) {
+                            continue;
+                        }
+                        dependedModuleIds.push(depModule.identifier());
+                    }
+                    dependencyGraph.add(module.identifier(), dependedModuleIds);
+                }
+                const cycles = dependencyGraph.getCycles();
+                this.isCyclic(cycles, compilation, cwd);
+                if (this.options.onEnd) {
+                    this.options.onEnd({ compilation });
+                }
+            });
+        });
+    }
+    isCyclic(cycles, compilation, cwd) {
+        cycles.forEach((vertices) => {
+            // Convert the array of vertices into an array of module paths
+            const cyclicAbsolutePaths = vertices
+                .slice()
+                .reverse()
+                .map((vertex) => {
+                const module = compilation.findModule(vertex.name);
+                if (!(module instanceof webpack.NormalModule)) {
+                    return null;
+                }
+                return module.resource || null;
+            });
+            if (cyclicAbsolutePaths.every((resource) => !resource ||
+                this.options.exclude.test(resource) ||
+                !this.options.include.test(resource))) {
+                // If all modules in the cycle are excluded by the config, don't report an error
+                return;
+            }
+            const cyclicPaths = cyclicAbsolutePaths.map((resource) => relative(cwd, resource));
+            // allow consumers to override all behavior with onDetected
+            if (this.options.onDetected) {
+                try {
+                    this.options.onDetected({
+                        paths: cyclicPaths.concat([cyclicPaths[0]]),
+                        compilation: compilation,
+                    });
+                }
+                catch (err) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    compilation.errors.push(err);
+                }
+                return;
+            }
+            // mark warnings or errors on webpack compilation
+            const error = new Error(BASE_ERROR.concat(cyclicPaths.concat([cyclicPaths[0]]).join(' -> ')));
+            if (this.options.failOnError) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                compilation.errors.push(error);
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                compilation.warnings.push(error);
+            }
+        });
+    }
+}

package/dist/plugins/circular-dependency/index.js

@@ -1 +1,15 @@
-import{CircularDependencyPlugin}from"./circular-dependency-plugin.js";export const createCircularDependencyPlugin=(e,n)=>e?[new CircularDependencyPlugin({projectCwd:n.projectCwd})]:[];
+import { CircularDependencyPlugin } from './circular-dependency-plugin.js';
+/**
+ * Detect modules with circular dependencies when bundling with webpack for `development` mode.
+ * @returns
+ */
+export const createCircularDependencyPlugin = (serveMode, evolveOptions) => {
+    if (!serveMode) {
+        return [];
+    }
+    return [
+        new CircularDependencyPlugin({
+            projectCwd: evolveOptions.projectCwd,
+        }),
+    ];
+};

package/dist/plugins/clean-webpack/clean-webpack-plugin.js

@@ -1 +1,173 @@
-import{rmSync}from"node:fs";import{relative}from"node:path";import{fileWalkSync}from"@armit/file-utility";import{logger}from"@flatjs/common";import{moduleName}from"../../constants.js";export class CleanWebpackPlugin{constructor(e={}){this.verbose=!0===e.verbose||!1,this.projectCwd=e.projectCwd||process.cwd(),this.cleanStaleWebpackAssets=!0!==e.cleanStaleWebpackAssets&&!1!==e.cleanStaleWebpackAssets||e.cleanStaleWebpackAssets,this.protectWebpackAssets=!0!==e.protectWebpackAssets&&!1!==e.protectWebpackAssets||e.protectWebpackAssets,this.cleanAfterEveryBuildPatterns=Array.isArray(e.cleanAfterEveryBuildPatterns)?e.cleanAfterEveryBuildPatterns:[],this.cleanOnceBeforeBuildPatterns=Array.isArray(e.cleanOnceBeforeBuildPatterns)?e.cleanOnceBeforeBuildPatterns:["**/*"],this.currentAssets=[],this.initialClean=!1,this.outputPath="",this.apply=this.apply.bind(this),this.handleInitial=this.handleInitial.bind(this),this.handleDone=this.handleDone.bind(this),this.removeFiles=this.removeFiles.bind(this)}apply(e){if(!e.options.output||!e.options.output.path)return void logger.warn("clean-webpack-plugin: options.output.path not defined. Plugin disabled...",moduleName);this.outputPath=e.options.output.path;const t=e.hooks;0!==this.cleanOnceBeforeBuildPatterns.length&&t.emit.tap("clean-webpack-plugin",(e=>{this.handleInitial(e)})),t.done.tap("clean-webpack-plugin",(e=>{this.handleDone(e)}))}handleInitial(e){if(this.initialClean)return;e.getStats().hasErrors()||(this.initialClean=!0,this.removeFiles(this.cleanOnceBeforeBuildPatterns))}handleDone(e){if(e.hasErrors())return void(this.verbose&&logger.warn("clean-webpack-plugin: pausing due to webpack errors",moduleName));const t=(e.toJson({assets:!0}).assets||[]).map((e=>e.name)),s=this.currentAssets.filter((e=>!1===t.includes(e)));this.currentAssets=t.sort();const i=[];!0===this.cleanStaleWebpackAssets&&0!==s.length&&i.push(...s),0!==this.cleanAfterEveryBuildPatterns.length&&i.push(...this.cleanAfterEveryBuildPatterns),0!==i.length&&this.removeFiles(i)}removeFiles(e){try{const t=fileWalkSync(e,{absolute:!0,unique:!0,cwd:this.outputPath,dot:!0,ignore:this.protectWebpackAssets?this.currentAssets:[]});for(const e of t)rmSync(e,{force:!0,recursive:!0});this.verbose&&t.forEach((e=>{const t=relative(this.projectCwd,e);logger.debug(`clean-webpack-plugin: removed ${t}`,moduleName)}))}catch(e){if(/Cannot delete files\/folders outside the current working directory\./.test(e.message)){throw new Error("clean-webpack-plugin: Cannot delete files/folders outside the current working directory. Can be overridden with the `dangerouslyAllowCleanPatternsOutsideProject` option.")}throw e}}}
+import { rmSync } from 'node:fs';
+import { relative } from 'node:path';
+import { fileWalkSync } from '@armit/file-utility';
+import { logger } from '@flatjs/common';
+import { moduleName } from '../../constants.js';
+export class CleanWebpackPlugin {
+    constructor(options = {}) {
+        this.verbose = options.verbose === true || false;
+        this.projectCwd = options.projectCwd || process.cwd();
+        this.cleanStaleWebpackAssets =
+            options.cleanStaleWebpackAssets === true ||
+                options.cleanStaleWebpackAssets === false
+                ? options.cleanStaleWebpackAssets
+                : true;
+        this.protectWebpackAssets =
+            options.protectWebpackAssets === true ||
+                options.protectWebpackAssets === false
+                ? options.protectWebpackAssets
+                : true;
+        this.cleanAfterEveryBuildPatterns = Array.isArray(options.cleanAfterEveryBuildPatterns)
+            ? options.cleanAfterEveryBuildPatterns
+            : [];
+        this.cleanOnceBeforeBuildPatterns = Array.isArray(options.cleanOnceBeforeBuildPatterns)
+            ? options.cleanOnceBeforeBuildPatterns
+            : ['**/*'];
+        /**
+         * Store webpack build assets
+         */
+        this.currentAssets = [];
+        /**
+         * Only used with cleanOnceBeforeBuildPatterns
+         */
+        this.initialClean = false;
+        this.outputPath = '';
+        this.apply = this.apply.bind(this);
+        this.handleInitial = this.handleInitial.bind(this);
+        this.handleDone = this.handleDone.bind(this);
+        this.removeFiles = this.removeFiles.bind(this);
+    }
+    apply(compiler) {
+        if (!compiler.options.output || !compiler.options.output.path) {
+            logger.warn('clean-webpack-plugin: options.output.path not defined. Plugin disabled...', moduleName);
+            return;
+        }
+        this.outputPath = compiler.options.output.path;
+        /**
+         * webpack 4+ comes with a new plugin system.
+         *
+         * Check for hooks in-order to support old plugin system
+         */
+        const hooks = compiler.hooks;
+        if (this.cleanOnceBeforeBuildPatterns.length !== 0) {
+            hooks.emit.tap('clean-webpack-plugin', (compilation) => {
+                this.handleInitial(compilation);
+            });
+        }
+        hooks.done.tap('clean-webpack-plugin', (stats) => {
+            this.handleDone(stats);
+        });
+    }
+    /**
+     * Initially remove files from output directory prior to build.
+     *
+     * Only happens once.
+     *
+     * Warning: It is recommended to initially clean your build directory outside of webpack to minimize unexpected behavior.
+     */
+    handleInitial(compilation) {
+        if (this.initialClean) {
+            return;
+        }
+        /**
+         * Do not remove files if there are compilation errors
+         *
+         * Handle logging inside this.handleDone
+         */
+        const stats = compilation.getStats();
+        if (stats.hasErrors()) {
+            return;
+        }
+        this.initialClean = true;
+        this.removeFiles(this.cleanOnceBeforeBuildPatterns);
+    }
+    handleDone(stats) {
+        /**
+         * Do nothing if there is a webpack error
+         */
+        if (stats.hasErrors()) {
+            if (this.verbose) {
+                logger.warn('clean-webpack-plugin: pausing due to webpack errors', moduleName);
+            }
+            return;
+        }
+        /**
+         * Fetch Webpack's output asset files
+         */
+        const assets = stats.toJson({
+            assets: true,
+        }).assets || [];
+        const assetList = assets.map((asset) => {
+            return asset.name;
+        });
+        /**
+         * Get all files that were in the previous build but not the current
+         *
+         * (relies on del's cwd: outputPath option)
+         */
+        const staleFiles = this.currentAssets.filter((previousAsset) => {
+            return assetList.includes(previousAsset) === false;
+        });
+        /**
+         * Save assets for next compilation
+         */
+        this.currentAssets = assetList.sort();
+        const removePatterns = [];
+        /**
+         * Remove unused webpack assets
+         */
+        if (this.cleanStaleWebpackAssets === true && staleFiles.length !== 0) {
+            removePatterns.push(...staleFiles);
+        }
+        /**
+         * Remove cleanAfterEveryBuildPatterns
+         */
+        if (this.cleanAfterEveryBuildPatterns.length !== 0) {
+            removePatterns.push(...this.cleanAfterEveryBuildPatterns);
+        }
+        if (removePatterns.length !== 0) {
+            this.removeFiles(removePatterns);
+        }
+    }
+    removeFiles(patterns) {
+        try {
+            const deleted = fileWalkSync(patterns, {
+                absolute: true,
+                unique: true,
+                // Change context to build directory
+                cwd: this.outputPath,
+                dot: true,
+                ignore: this.protectWebpackAssets ? this.currentAssets : [],
+            });
+            for (const filepath of deleted) {
+                rmSync(filepath, {
+                    force: true,
+                    recursive: true,
+                });
+            }
+            /**
+             * Log if verbose is enabled
+             */
+            if (this.verbose) {
+                deleted.forEach((file) => {
+                    const filename = relative(this.projectCwd, file);
+                    const message = 'removed';
+                    /**
+                     * Use console.warn over .log
+                     * https://github.com/webpack/webpack/issues/1904
+                     * https://github.com/johnagan/clean-webpack-plugin/issues/11
+                     */
+                    logger.debug(`clean-webpack-plugin: ${message} ${filename}`, moduleName);
+                });
+            }
+        }
+        catch (error) {
+            const needsForce = /Cannot delete files\/folders outside the current working directory\./.test(error.message);
+            if (needsForce) {
+                const message = 'clean-webpack-plugin: Cannot delete files/folders outside the current working directory. Can be overridden with the `dangerouslyAllowCleanPatternsOutsideProject` option.';
+                throw new Error(message);
+            }
+            throw error;
+        }
+    }
+}

package/dist/plugins/clean-webpack/index.js

@@ -1 +1,22 @@
-import{join}from"node:path";import{ensureSlash}from"@flatjs/common";import{CleanWebpackPlugin}from"./clean-webpack-plugin.js";export const createCleanWebpackPlugin=(e,n,o)=>e?[]:[new CleanWebpackPlugin({verbose:!0,projectCwd:o.projectCwd,cleanOnceBeforeBuildPatterns:n.map((e=>`${join(ensureSlash(e[0],!0),"**/*")}`))})];
+import { join } from 'node:path';
+import { ensureSlash } from '@flatjs/common';
+import { CleanWebpackPlugin } from './clean-webpack-plugin.js';
+/**
+ * Cleaning up the /dist folder for `production` build
+ * @param singleEntryItem
+ * @returns
+ */
+export const createCleanWebpackPlugin = (serveMode, entryMapItemList, evolveOptions) => {
+    if (serveMode) {
+        return [];
+    }
+    return [
+        new CleanWebpackPlugin({
+            verbose: true,
+            projectCwd: evolveOptions.projectCwd,
+            cleanOnceBeforeBuildPatterns: entryMapItemList.map((entryMapItem) => {
+                return `${join(ensureSlash(entryMapItem[0], true), '**/*')}`;
+            }),
+        }),
+    ];
+};

package/dist/plugins/define-variable/define-variable-plugin.js

@@ -1 +1,28 @@
-import{getLastCommitHash,gitBranchName}from"@armit/git";import webpack from"webpack";export const createBuiltinDefineVariables=async(e,i)=>{const t=await getLastCommitHash(),n=await gitBranchName();return[new webpack.DefinePlugin({__SENTRY_DEBUG__:e,"process.env.FLAT_BUILD_DATE":JSON.stringify((new Date).toISOString()),"process.env.FLAT_COMMIT_HASH":JSON.stringify(t),"process.env.FLAT_BRANCH_NAME":JSON.stringify(n),"process.env.FLAT_RELEASE_VERSION":JSON.stringify(i.ci?.releaseVersion||t),...i.pluginOptions.definePlugin})]};
+/* eslint-disable @typescript-eslint/naming-convention */
+import { getLastCommitHash, gitBranchName } from '@armit/git';
+import webpack from 'webpack';
+/**
+ * The DefinePlugin replaces variables in your code with other values or expressions at compile time.
+ * ```ts
+ * `__SENTRY_DEBUG__`
+ * `process.env.FLAT_BUILD_DATE`
+ * `process.env.FLAT_COMMIT_HASH`
+ * `process.env.FLAT_BRANCH_NAME`
+ * `process.env.FLAT_RELEASE_VERSION`
+ * ```
+ * @returns
+ */
+export const createBuiltinDefineVariables = async (serveMode, evolveOptions) => {
+    const commitHash = await getLastCommitHash();
+    const branchName = await gitBranchName();
+    return [
+        new webpack.DefinePlugin({
+            __SENTRY_DEBUG__: serveMode,
+            'process.env.FLAT_BUILD_DATE': JSON.stringify(new Date().toISOString()),
+            'process.env.FLAT_COMMIT_HASH': JSON.stringify(commitHash),
+            'process.env.FLAT_BRANCH_NAME': JSON.stringify(branchName),
+            'process.env.FLAT_RELEASE_VERSION': JSON.stringify(evolveOptions.ci?.releaseVersion || commitHash),
+            ...evolveOptions.pluginOptions.definePlugin,
+        }),
+    ];
+};

package/dist/plugins/define-variable/index.js

@@ -1 +1 @@
-export*from"./define-variable-plugin.js";
+export * from './define-variable-plugin.js';

package/dist/plugins/html-inject-scripts/plugin-html-inject-script.js

@@ -1 +1,27 @@
-import htmlWebpackPlugin from"html-webpack-plugin";const PLUGIN_PREFIX="HtmlInjectScriptPlugin";export class HtmlInjectScriptPlugin{constructor(t){this.scripts=t||[]}processScripts(){return this.scripts.filter(Boolean).map((t=>({tagName:"script",innerHTML:t,voidTag:!1,attributes:{},meta:{plugin:"html-inject-script-webpack-plugin"}})))}apply(t){t.hooks.compilation.tap(`${PLUGIN_PREFIX}_compilation`,(t=>{htmlWebpackPlugin.getHooks(t).alterAssetTags.tap(`${PLUGIN_PREFIX}_alterAssetTags`,(t=>(t.assetTags.scripts.unshift(...this.processScripts()),t)))}))}}
+import htmlWebpackPlugin from 'html-webpack-plugin';
+const PLUGIN_PREFIX = `HtmlInjectScriptPlugin`;
+export class HtmlInjectScriptPlugin {
+    constructor(scripts) {
+        this.scripts = scripts || [];
+    }
+    processScripts() {
+        return this.scripts.filter(Boolean).map((asset) => {
+            return {
+                tagName: 'script',
+                innerHTML: asset,
+                voidTag: false,
+                attributes: {},
+                meta: { plugin: 'html-inject-script-webpack-plugin' },
+            };
+        });
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(`${PLUGIN_PREFIX}_compilation`, (compilation) => {
+            const hooks = htmlWebpackPlugin.getHooks(compilation);
+            hooks.alterAssetTags.tap(`${PLUGIN_PREFIX}_alterAssetTags`, (data) => {
+                data.assetTags.scripts.unshift(...this.processScripts());
+                return data;
+            });
+        });
+    }
+}