@flatjs/evolve 2.1.0-next.3 → 2.1.0-next.5

package/dist/helpers/split-to-multi-compiler.js

@@ -1 +1,32 @@
-import{join}from"path";import{mergeOptions}from"@flatjs/common";import{devReactFastRefresh}from"../constants.js";import{normalizeEvolveEntryName}from"./normalize-entry-map.js";export function splitToMultiCompilerConfigs(e,t,r,o=!1){const n=[];for(const[t,o]of Object.entries(e)){const e=normalizeEvolveEntryName(t,r.projectVirtualPath);n.push({[e]:o.entry})}return n.map((e=>{const r=Object.keys(e)[0];if(o){e[join(r,devReactFastRefresh.reactRefreshSetup)]=["@pmmmwh/react-refresh-webpack-plugin/client/ReactRefreshEntry.js"]}return mergeOptions(t,{name:r,entry:e})}))}
+import { join } from 'path';
+import { mergeOptions } from '@flatjs/common';
+import { devReactFastRefresh } from '../constants.js';
+import { normalizeEvolveEntryName } from './normalize-entry-map.js';
+/**
+ * Split the `webpack` to make sure that we have separated compiler process for each module
+ * @param webpackConfig `Omit<Configuration, 'entry'>` webpack final configuration
+ */
+export function splitToMultiCompilerConfigs(servedEntries, webpackConfig, evolveOptions, enabledHmr = false) {
+    const result = [];
+    for (const [entryName, entryItem] of Object.entries(servedEntries)) {
+        // Make sure that we have correct `virtualPath` for each webpack `entry`
+        const normalizedEntryName = normalizeEvolveEntryName(entryName, evolveOptions.projectVirtualPath);
+        result.push({
+            [normalizedEntryName]: entryItem.entry,
+        });
+    }
+    return result.map((newEntry) => {
+        const entryName = Object.keys(newEntry)[0];
+        if (enabledHmr) {
+            // `${virtualPath}/module/reactRefreshSetup`
+            const fastRefreshEntryName = join(entryName, devReactFastRefresh.reactRefreshSetup);
+            newEntry[fastRefreshEntryName] = [
+                '@pmmmwh/react-refresh-webpack-plugin/client/ReactRefreshEntry.js',
+            ];
+        }
+        return mergeOptions(webpackConfig, {
+            name: entryName,
+            entry: newEntry,
+        });
+    });
+}

package/dist/index.js

@@ -1 +1,5 @@
-export*from"./define-config/index.js";export*from"./load-config/index.js";export*from"./main/index.js";export*from"./types/types-options.js";export*from"./types/types-entry-map.js";
+export * from './define-config/index.js';
+export * from './load-config/index.js';
+export * from './main/index.js';
+export * from './types/types-options.js';
+export * from './types/types-entry-map.js';

package/dist/load-config/index.js

@@ -1 +1 @@
-export*from"./load-evolve-config.js";
+export * from './load-evolve-config.js';

package/dist/load-config/load-evolve-config.js

@@ -1 +1,41 @@
-import{searchConfig}from"@armit/config-loader";import{mergeOptions,logger}from"@flatjs/common";import{configFileName,moduleName}from"../constants.js";import{defaultEvolveOptions}from"../default-options.js";import{normalizeResolveAlias}from"../helpers/normalize-resolve-alias.js";import{refreshEvolveMockOptions}from"../helpers/refresh-evolve-mock-options.js";export const loadEvolveConfig=async(o,e,i={},s={configFile:configFileName,esmLoaderOptions:{externals:[/^@flatjs\/.*/]}})=>{const{configFile:r,esmLoaderOptions:l}=s,a=await searchConfig(r,e,{esm:{...l,projectCwd:e}});let n={};n="function"==typeof a?.config?await(a?.config(o)):a?.config||{};const t=mergeOptions(defaultEvolveOptions,n),m=mergeOptions(t,i),f=mergeOptions(m,{projectCwd:e}),c="build"===o.command?f:await refreshEvolveMockOptions(e,f,s);return logger.debug(`Load evolve config:\n${JSON.stringify(c,null,2)}`,moduleName),c.webpack?.resolve?.alias&&(c.webpack.resolve.alias=normalizeResolveAlias(e,c.webpack?.resolve?.alias)),c};
+import { searchConfig } from '@armit/config-loader';
+import { mergeOptions, logger } from '@flatjs/common';
+import { configFileName, moduleName } from '../constants.js';
+import { defaultEvolveOptions } from '../default-options.js';
+import { normalizeResolveAlias } from '../helpers/normalize-resolve-alias.js';
+import { refreshEvolveMockOptions } from '../helpers/refresh-evolve-mock-options.js';
+export const loadEvolveConfig = async (configEnv, projectCwd, overrideOptions = {}, configLoaderOptions = {
+    configFile: configFileName,
+    esmLoaderOptions: {
+        externals: [/^@flatjs\/.*/],
+    },
+}) => {
+    const { configFile, esmLoaderOptions } = configLoaderOptions;
+    const data = await searchConfig(configFile, projectCwd, {
+        esm: {
+            ...esmLoaderOptions,
+            projectCwd,
+        },
+    });
+    let localData = {};
+    if (typeof data?.config === 'function') {
+        localData = await data?.config(configEnv);
+    }
+    else {
+        localData = data?.config || {};
+    }
+    // Merge user local config with default configure options.
+    const localConfigOptions = mergeOptions(defaultEvolveOptions, localData);
+    const mergedConfigOptions = mergeOptions(localConfigOptions, overrideOptions);
+    const finalData = mergeOptions(mergedConfigOptions, { projectCwd });
+    // We don't need to load mocks configuration from `flatjs-mock.config.js` while `build` phase.
+    const latestEvolveOptions = configEnv.command === 'build'
+        ? finalData
+        : await refreshEvolveMockOptions(projectCwd, finalData, configLoaderOptions);
+    logger.debug(`Load evolve config:\n${JSON.stringify(latestEvolveOptions, null, 2)}`, moduleName);
+    // Normalize webpack.resolve.alias to make sure convert `alias` to absolute path.
+    if (latestEvolveOptions.webpack?.resolve?.alias) {
+        latestEvolveOptions.webpack.resolve.alias = normalizeResolveAlias(projectCwd, latestEvolveOptions.webpack?.resolve?.alias);
+    }
+    return latestEvolveOptions;
+};

package/dist/load-config/types.js

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

package/dist/main/create-thread-worker.js

@@ -1 +1,42 @@
-import EventEmitter from"events";import{createThreadPool}from"@armit/worker-threads";import{getWorkerPath}from"./get-worker-path.js";import{startBuildWorker}from"./start-build-worker.js";class ThreadPoolForUnittest{constructor(r){this.workerSize=r}startBuildWorker(...r){return startBuildWorker(...r)}get pool(){const r=new EventEmitter,e={terminate(){console.warn('[WARNING] Using fake "terminate" for unittest!')},refill(){console.warn('[WARNING] Using fake "refill" for unittest!')},async drain(){console.warn('[WARNING] Using fake "drain" for unittest!')},size:this.workerSize,isTerminated:!1,threads:new Map};return Object.assign(r,e)}}export const createThreadWorker=async r=>{const e=getWorkerPath();return"test"===process.env.NODE_ENV?(console.warn("[WARNING] Using fake thread pool worker for unittest!"),new ThreadPoolForUnittest(r)):await createThreadPool(e,{size:r})};
+import EventEmitter from 'events';
+import { createThreadPool, } from '@armit/worker-threads';
+import { getWorkerPath } from './get-worker-path.js';
+import { startBuildWorker } from './start-build-worker.js';
+class ThreadPoolForUnittest {
+    constructor(workerSize) {
+        this.workerSize = workerSize;
+    }
+    startBuildWorker(...args) {
+        return startBuildWorker(...args);
+    }
+    get pool() {
+        const puddleInterface = new EventEmitter();
+        const pool = {
+            terminate() {
+                console.warn(`[WARNING] Using fake "terminate" for unittest!`);
+            },
+            refill() {
+                console.warn(`[WARNING] Using fake "refill" for unittest!`);
+            },
+            async drain() {
+                console.warn(`[WARNING] Using fake "drain" for unittest!`);
+            },
+            size: this.workerSize,
+            isTerminated: false,
+            threads: new Map(),
+        };
+        return Object.assign(puddleInterface, pool);
+    }
+}
+export const createThreadWorker = async (workerSize) => {
+    const workerPath = getWorkerPath();
+    // FIXME: Is safe to remove `worker thread` while `test` environment, cause of we need to run UT using `source code`
+    const isTestEnv = process.env.NODE_ENV === 'test';
+    if (isTestEnv) {
+        console.warn(`[WARNING] Using fake thread pool worker for unittest!`);
+        return new ThreadPoolForUnittest(workerSize);
+    }
+    return await createThreadPool(workerPath, {
+        size: workerSize,
+    });
+};

package/dist/main/env-verify.js

@@ -1 +1,21 @@
-import{illegalPackageChecker,keepPackageDepsUpToDateForNonMonoRepo}from"@armit/package";export const envVerify=async(e,a)=>{const{packageInstallChecker:o,needVerifyPackages:r}=a;!1!==o&&o?.enabled&&await illegalPackageChecker({cwd:e,modules:o?.detectModules,throwError:o?.throwError,showAllInstalledGraph:o?.showAllInstalledGraph}),!1!==r&&await keepPackageDepsUpToDateForNonMonoRepo({cwd:e,autoUpgrade:!0,needVerifyPackages:r||{}})};
+import { illegalPackageChecker, keepPackageDepsUpToDateForNonMonoRepo, } from '@armit/package';
+export const envVerify = async (projectCwd, evolveOptions) => {
+    const { packageInstallChecker, needVerifyPackages } = evolveOptions;
+    if (packageInstallChecker !== false && packageInstallChecker?.enabled) {
+        // Verify local install node modules
+        await illegalPackageChecker({
+            cwd: projectCwd,
+            modules: packageInstallChecker?.detectModules,
+            throwError: packageInstallChecker?.throwError,
+            showAllInstalledGraph: packageInstallChecker?.showAllInstalledGraph,
+        });
+    }
+    if (needVerifyPackages !== false) {
+        // Keep package deps up to date for non-monorepo
+        await keepPackageDepsUpToDateForNonMonoRepo({
+            cwd: projectCwd,
+            autoUpgrade: true,
+            needVerifyPackages: needVerifyPackages || {},
+        });
+    }
+};

package/dist/main/get-worker-path.js

@@ -1 +1,5 @@
-import{pathToFileURL}from"node:url";import{getDirname}from"@armit/file-utility";export const getWorkerPath=()=>pathToFileURL(getDirname(import.meta.url,"./start-build-worker.js")).toString();
+import { pathToFileURL } from 'node:url';
+import { getDirname } from '@armit/file-utility';
+export const getWorkerPath = () => {
+    return pathToFileURL(getDirname(import.meta.url, './start-build-worker.js')).toString();
+};

package/dist/main/index.js

@@ -1 +1,4 @@
-export*from"./start-build.js";export*from"./start-serve.js";export*from"./start-static.js";export*from"./start-build-dynamic.js";
+export * from './start-build.js';
+export * from './start-serve.js';
+export * from './start-static.js';
+export * from './start-build-dynamic.js';

package/dist/main/prepare-build.js

@@ -1 +1,38 @@
-import{ensureSlash,mergeOptions}from"@flatjs/common";import{EvolveBuildError}from"../errors/evolve-build-error.js";import{printCompilerError}from"../helpers/print-log.js";import{startOneEntryBuild}from"./start-one-entry-build.js";export const prepareBuild=async(r,o)=>{const[t,e]=r,n=o.multiHtmlCdn?.prod||[];if(!n.length)throw new Error(`No CDN config for env:"prod", moduleName: ${t}`);const i=ensureSlash(n[Math.floor(Math.random()*n.length)],!0),l={[t]:e};try{const r=e.options?.useRelativeAssetPath,t=mergeOptions(o,{webpack:{publicPath:r?"auto":i}});return await startOneEntryBuild(l,t)}catch(r){const o=printCompilerError(r);throw new EvolveBuildError("BUILD_ERROR",o)}};
+import { ensureSlash, mergeOptions } from '@flatjs/common';
+import { EvolveBuildError } from '../errors/evolve-build-error.js';
+import { printCompilerError } from '../helpers/print-log.js';
+import { startOneEntryBuild, } from './start-one-entry-build.js';
+/**
+ * The main entry to start an evolve `build`
+ * @param entryMapItem The `entryMapItem` for one entry build task
+ * @param evolveOptions FlatEvolveOptions
+ */
+export const prepareBuild = async (entryMapItem, evolveOptions) => {
+    const [entryKey, entryConfig] = entryMapItem;
+    // Fetch all configuration cdn
+    const cdnPath = evolveOptions.multiHtmlCdn?.prod || [];
+    if (!cdnPath.length) {
+        throw new Error(`No CDN config for env:"prod", moduleName: ${entryKey}`);
+    }
+    // Random choose one to publicPath
+    const cdnPublicPath = ensureSlash(cdnPath[Math.floor(Math.random() * cdnPath.length)], true);
+    // Construct single entry map item to build.
+    const toBuildEntryMapItem = {
+        [entryKey]: entryConfig,
+    };
+    try {
+        const useRelativeAssetPath = entryConfig.options?.useRelativeAssetPath;
+        const buildEvolveOptions = mergeOptions(evolveOptions, {
+            webpack: {
+                // Only for `assets` used at styling files (e.g.`xxx.less`)
+                publicPath: useRelativeAssetPath ? 'auto' : cdnPublicPath,
+            },
+        });
+        return await startOneEntryBuild(toBuildEntryMapItem, buildEvolveOptions);
+    }
+    catch (err) {
+        const formattedErrors = printCompilerError(err);
+        // Need re-throw error, in order to third API can capture this error.
+        throw new EvolveBuildError(`BUILD_ERROR`, formattedErrors);
+    }
+};

package/dist/main/prepare-serve.js

@@ -1 +1,45 @@
-import{arrayUnique,urlJoin}from"@flatjs/common";import{attachMockMiddlewares}from"@flatjs/mock";import{createAppPageRoute,createDevServer,createDevServerCompilerTasks,createDevServerEntries}from"../dev-server/index.js";import{openPage}from"../helpers/index.js";import{normalizePageProxy}from"../helpers/normalize-page-proxy.js";import{envVerify}from"./env-verify.js";export const prepareServe=async(e,r,o)=>{await envVerify(e,o);const{app:t,devPort:a,devHostUri:i,publicIp:s}=await createDevServer(o),p=o.devServer?.mockOptions?.mockFilters||[];for(const[,e]of Object.entries(r))p.push(...e.options?.mockFilters||[]);await attachMockMiddlewares(t,{...o.devServer?.mockOptions,mockFilters:arrayUnique(p),projectCwd:e});const n=await createDevServerEntries(a,r,o);createAppPageRoute(e,t,i,n,o);const c=normalizePageProxy(o.devServer?.pageProxy||"/pages"),v=urlJoin(i,[c]);o.devServer?.autoOpen&&openPage(v);const m=await createDevServerCompilerTasks(e,v,s,n,o);return Promise.all(m).then((()=>t))};
+import { arrayUnique, urlJoin } from '@flatjs/common';
+import { attachMockMiddlewares } from '@flatjs/mock';
+import { createAppPageRoute, createDevServer, createDevServerCompilerTasks, createDevServerEntries, } from '../dev-server/index.js';
+import { openPage } from '../helpers/index.js';
+import { normalizePageProxy } from '../helpers/normalize-page-proxy.js';
+import { envVerify } from './env-verify.js';
+/**
+ * The main entry to start evolve serve
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param servedEntries All normalized webpack entries we have served.
+ * @param evolveOptions FlatEvolveOptions
+ */
+export const prepareServe = async (projectCwd, servedEntries, evolveOptions) => {
+    // Verify if we have an correct project local environment.
+    await envVerify(projectCwd, evolveOptions);
+    // Create pure dev server.
+    const { app, devPort, devHostUri, publicIp } = await createDevServer(evolveOptions);
+    // Extract all the mock filters of served entries.
+    const mockFilters = evolveOptions.devServer?.mockOptions?.mockFilters || [];
+    // Loop all entries gather all mock files definition from each entry item.
+    for (const [, value] of Object.entries(servedEntries)) {
+        mockFilters.push(...(value.options?.mockFilters || []));
+    }
+    // Attach core handlers for mock
+    await attachMockMiddlewares(app, {
+        ...evolveOptions.devServer?.mockOptions,
+        mockFilters: arrayUnique(mockFilters),
+        projectCwd,
+    });
+    // Create dev-server configurationn for all servedEntries.
+    const servedDevServerEntries = await createDevServerEntries(devPort, servedEntries, evolveOptions);
+    // Create new route `/pages*`,`*` to pure dev server
+    createAppPageRoute(projectCwd, app, devHostUri, servedDevServerEntries, evolveOptions);
+    const pageProxy = normalizePageProxy(evolveOptions.devServer?.pageProxy || '/pages');
+    const mainPage = urlJoin(devHostUri, [pageProxy]);
+    // Open page via browser
+    if (evolveOptions.devServer?.autoOpen) {
+        openPage(mainPage);
+    }
+    // Create dev-server compiler tasks
+    const serveTasks = await createDevServerCompilerTasks(projectCwd, mainPage, publicIp, servedDevServerEntries, evolveOptions);
+    return Promise.all(serveTasks).then(() => {
+        return app;
+    });
+};

package/dist/main/prepare-static.js

@@ -1 +1,30 @@
-import{chalk,logger,urlJoin}from"@flatjs/common";import{attachMockMiddlewares}from"@flatjs/mock";import{createAppPageRoute}from"../dev-server/create-app-page-route.js";import{createDevServer}from"../dev-server/create-dev-server.js";import{normalizePageProxy}from"../helpers/normalize-page-proxy.js";import{openPage}from"../helpers/open-page.js";export const prepareStatic=async(e,r)=>{const{app:a,devHostUri:o}=await createDevServer(r);await attachMockMiddlewares(a,{...r.devServer?.mockOptions,projectCwd:e}),createAppPageRoute(e,a,o,{},r);const t=normalizePageProxy(r.devServer?.pageProxy||"/pages"),p=urlJoin(o,[t]);r.devServer?.autoOpen&&openPage(p),logger.info(`${"static page".padEnd(12," ")} ➩ ${chalk(["cyan"])(p)}`)};
+import { chalk, logger, urlJoin } from '@flatjs/common';
+import { attachMockMiddlewares } from '@flatjs/mock';
+import { createAppPageRoute } from '../dev-server/create-app-page-route.js';
+import { createDevServer } from '../dev-server/create-dev-server.js';
+import { normalizePageProxy } from '../helpers/normalize-page-proxy.js';
+import { openPage } from '../helpers/open-page.js';
+/**
+ * The main entry to start evolve serve
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param evolveOptions FlatEvolveOptions
+ */
+export const prepareStatic = async (projectCwd, evolveOptions) => {
+    // Create pure dev server.
+    const { app, devHostUri } = await createDevServer(evolveOptions);
+    // Attach core handlers for mock
+    await attachMockMiddlewares(app, {
+        ...evolveOptions.devServer?.mockOptions,
+        projectCwd,
+    });
+    // Create new route `/pages*`,`*` to pure dev server
+    createAppPageRoute(projectCwd, app, devHostUri, {}, evolveOptions);
+    const pageProxy = normalizePageProxy(evolveOptions.devServer?.pageProxy || '/pages');
+    const mainPage = urlJoin(devHostUri, [pageProxy]);
+    // Open page via browser
+    if (evolveOptions.devServer?.autoOpen) {
+        openPage(mainPage);
+    }
+    logger.info(`${'static page'.padEnd(12, ' ')} ➩ ${chalk(['cyan'])(mainPage)}`);
+};
+// Start up main page proxy server.

package/dist/main/start-build-dynamic.js

@@ -1 +1,157 @@
-import{isAbsolute,join}from"node:path";import{getDiffFiles,getCommitIdOfBranch}from"@armit/git";import{arraysIntersect,chalk,logger,requireResolve}from"@flatjs/common";import{traverseGraph}from"@flatjs/graph";import Listr from"listr";import{moduleName}from"../constants.js";import{filterActivedEntriesByEntryInputs,filterActivedEntriesByModule}from"../helpers/filter-actived-entries.js";import{getGitRoot}from"../helpers/get-git-root.js";import{getMaxProcessTasks}from"../helpers/get-max-process-tasks.js";import{jsonSerializer}from"../helpers/json-serializer.js";import{resolveEntryMapInputFiles}from"../helpers/resolve-entry-map-input-files.js";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{createThreadWorker}from"./create-thread-worker.js";import{envVerify}from"./env-verify.js";export async function getBuildEntryFiles(e,r,t,i,o){const n=[],s=[];for(const e of t)r.includes(e)?n.push(e):s.push(e);if(o&&logger.info("Use custom graph traverse filter",moduleName),s.length){const t=await traverseGraph({input:s,projectCwd:e,treeNodeFilter:o||(()=>!0),lessImportOptions:{projectCwd:e,aliases:i}});if(!t)return n;logger.debug(`DependencyGraph:\n${JSON.stringify(t,null,2)}`);for(const e of s){const i=t[e]||[];arraysIntersect(i,r)&&n.push(e)}}return n}export async function dynamicCheckBuildEntryMap(e,r,t,i,o){const n={projectCwd:e,command:"build",resolve:requireResolve},s=await loadEvolveConfig(n,e,i,o);if(s.ci?.fixedBuildModules&&s.ci?.fixedBuildModules.length){logger.info("Use `fixedBuildModules` configuration to build...");return{buildEntries:filterActivedEntriesByModule(s.entryMap,s.ci?.fixedBuildModules),newEvolveOptions:s}}if(logger.info("Dynamicly checking code changed modules ..."),!r){const e=s.ci?.basedBranch||"origin/master";r=await getCommitIdOfBranch(e),logger.info(`Resolving base branch "${e}" commit hash "${r}" ...`)}let a=r?await getDiffFiles(r,t):[];const l=getGitRoot(e);if(!l)throw new Error(`No .git root (${e}) found`);if(a=a.map((e=>isAbsolute(e)?e:join(l,e))),logger.debug(`Diff files: \n${JSON.stringify(a,null,2)}`),!a.length)return logger.warn("It seems that there are no code files changed."),{buildEntries:{},newEvolveOptions:s};const c=await resolveEntryMapInputFiles(e,s.entryMap),d=await getBuildEntryFiles(e,a,c,s.webpack?.resolve?.alias,s.ci?.graphTreeNodeFilter);logger.debug(`To build entry files: \n${JSON.stringify(d,null,2)}`);return{buildEntries:await filterActivedEntriesByEntryInputs(e,s.entryMap,d),newEvolveOptions:s}}export const startDynamicBuild=async(e,r,t,i={},o)=>{const{buildEntries:n,newEvolveOptions:s}=await dynamicCheckBuildEntryMap(e,r,t,i,o);await envVerify(e,s);const a=Object.keys(n);if(!a.length)return logger.warn("No build entries providered!"),[];const l=getMaxProcessTasks(a.length,s.maxProcesses);logger.info(`Start dynamic build with (${chalk(["magenta"])(String(l))}) workers:\n${JSON.stringify({buildEntries:a},null,2)}`);const c=await createThreadWorker(l),d=new Listr([],{concurrent:l,exitOnError:!0}),f=[];for(const[r]of Object.entries(n))d.add({title:`Build module ${chalk(["magenta"])(r)} ...`,task:async()=>{const t=await c.startBuildWorker(e,r,jsonSerializer.stringify(i),o);f.push(t)}});return d.tasks.length&&await d.run(),c.pool.terminate(),f};
+import { isAbsolute, join } from 'node:path';
+import { getDiffFiles, getCommitIdOfBranch } from '@armit/git';
+import { arraysIntersect, chalk, logger, requireResolve } from '@flatjs/common';
+import { traverseGraph } from '@flatjs/graph';
+import Listr from 'listr';
+import { moduleName } from '../constants.js';
+import { filterActivedEntriesByEntryInputs, filterActivedEntriesByModule, } from '../helpers/filter-actived-entries.js';
+import { getGitRoot } from '../helpers/get-git-root.js';
+import { getMaxProcessTasks } from '../helpers/get-max-process-tasks.js';
+import { jsonSerializer } from '../helpers/json-serializer.js';
+import { resolveEntryMapInputFiles } from '../helpers/resolve-entry-map-input-files.js';
+import { loadEvolveConfig } from '../load-config/load-evolve-config.js';
+import { createThreadWorker } from './create-thread-worker.js';
+import { envVerify } from './env-verify.js';
+export async function getBuildEntryFiles(projectCwd, diffFiles, allEntryInputs, resolveAlias, graphTreeNodeFilter) {
+    const toBuildEntryFiles = [];
+    const entryInputsPendingToCheck = [];
+    for (const entryInput of allEntryInputs) {
+        // If entry have been existed in diff files, need to rebuild.
+        if (diffFiles.includes(entryInput)) {
+            toBuildEntryFiles.push(entryInput);
+        }
+        else {
+            entryInputsPendingToCheck.push(entryInput);
+        }
+    }
+    if (graphTreeNodeFilter) {
+        logger.info(`Use custom graph traverse filter`, moduleName);
+    }
+    // If there has pedding entry inputs to check.
+    if (entryInputsPendingToCheck.length) {
+        const graphDeps = await traverseGraph({
+            input: entryInputsPendingToCheck,
+            projectCwd,
+            treeNodeFilter: graphTreeNodeFilter || (() => true),
+            lessImportOptions: {
+                projectCwd,
+                aliases: resolveAlias,
+            },
+        });
+        if (!graphDeps) {
+            return toBuildEntryFiles;
+        }
+        logger.debug(`DependencyGraph:\n${JSON.stringify(graphDeps, null, 2)}`);
+        for (const entryInputToCheck of entryInputsPendingToCheck) {
+            const dependsFiles = graphDeps[entryInputToCheck] || [];
+            if (arraysIntersect(dependsFiles, diffFiles)) {
+                toBuildEntryFiles.push(entryInputToCheck);
+            }
+        }
+    }
+    return toBuildEntryFiles;
+}
+/**
+ * Dynamic check which entry modules need to build.
+ * @returns
+ */
+export async function dynamicCheckBuildEntryMap(projectCwd, earlyCommit, lastCommit, overrideEvolveOptions, configLoaderOptions) {
+    const command = {
+        projectCwd,
+        command: 'build',
+        resolve: requireResolve,
+    };
+    // 1. Try to load evolve configuration from `flatjs-evolve.config.ts`
+    const newEvolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    // 2. Check if we have fixed build modules.
+    if (newEvolveOptions.ci?.fixedBuildModules &&
+        newEvolveOptions.ci?.fixedBuildModules.length) {
+        logger.info('Use `fixedBuildModules` configuration to build...');
+        const buildEntries = filterActivedEntriesByModule(newEvolveOptions.entryMap, newEvolveOptions.ci?.fixedBuildModules);
+        return { buildEntries, newEvolveOptions };
+    }
+    logger.info('Dynamicly checking code changed modules ...');
+    // 3. Resolve diff files based on specificed branch.
+    // Check if we have fixed `early commit` if no resolve based on `Branch` from evolve config file.
+    if (!earlyCommit) {
+        const basedBranch = newEvolveOptions.ci?.basedBranch || 'origin/master';
+        earlyCommit = await getCommitIdOfBranch(basedBranch);
+        // Try resolve based branch commit hash.
+        logger.info(`Resolving base branch "${basedBranch}" commit hash "${earlyCommit}" ...`);
+    }
+    // `packages/evolve/tests/main/fixtures/src/home/index.ts` without repo cwd.
+    let diffFiles = earlyCommit
+        ? await getDiffFiles(earlyCommit, lastCommit)
+        : [];
+    const gitRoot = getGitRoot(projectCwd);
+    if (!gitRoot) {
+        throw new Error(`No .git root (${projectCwd}) found`);
+    }
+    // Hack diff files with git repo root dir.
+    diffFiles = diffFiles.map((diffFile) => {
+        return isAbsolute(diffFile) ? diffFile : join(gitRoot, diffFile);
+    });
+    logger.debug(`Diff files: \n${JSON.stringify(diffFiles, null, 2)}`);
+    // No code changed here.
+    if (!diffFiles.length) {
+        logger.warn('It seems that there are no code files changed.');
+        return {
+            buildEntries: {},
+            newEvolveOptions,
+        };
+    }
+    // 4. Resolve entry input files.
+    const allEntryInputs = await resolveEntryMapInputFiles(projectCwd, newEvolveOptions.entryMap);
+    // 5. Flag changed entries (with absolute filepath)
+    const toBuildEntryFiles = await getBuildEntryFiles(projectCwd, diffFiles, allEntryInputs, newEvolveOptions.webpack?.resolve?.alias, newEvolveOptions.ci?.graphTreeNodeFilter);
+    logger.debug(`To build entry files: \n${JSON.stringify(toBuildEntryFiles, null, 2)}`);
+    // 6. Filter entry map items which need to build.
+    const buildEntries = await filterActivedEntriesByEntryInputs(projectCwd, newEvolveOptions.entryMap, toBuildEntryFiles);
+    return { buildEntries, newEvolveOptions };
+}
+/**
+ * The main entry to start an evolve `build` with automatically detect modules which have been changed between two commits.
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param earlyCommit The diff based earlier commit hash
+ * @param lastCommit If is omitted, it will have the same effect as using HEAD instead.
+ */
+export const startDynamicBuild = async (projectCwd, earlyCommit, lastCommit, overrideEvolveOptions = {}, configLoaderOptions) => {
+    // 1. Fetch all changed files betwwen two `commit`
+    const { buildEntries, newEvolveOptions } = await dynamicCheckBuildEntryMap(projectCwd, earlyCommit, lastCommit, overrideEvolveOptions, configLoaderOptions);
+    await envVerify(projectCwd, newEvolveOptions);
+    const buildEntryKeys = Object.keys(buildEntries);
+    // Make sure that we have at least one build entry module.
+    if (!buildEntryKeys.length) {
+        logger.warn(`No build entries providered!`);
+        return [];
+    }
+    const workerSize = getMaxProcessTasks(buildEntryKeys.length, newEvolveOptions.maxProcesses);
+    logger.info(`Start dynamic build with (${chalk(['magenta'])(String(workerSize))}) workers:\n${JSON.stringify({ buildEntries: buildEntryKeys }, null, 2)}`);
+    const worker = await createThreadWorker(workerSize);
+    const buildTasks = new Listr([], {
+        concurrent: workerSize,
+        exitOnError: true,
+    });
+    const buildResults = [];
+    for (const [entryKey] of Object.entries(buildEntries)) {
+        buildTasks.add({
+            title: `Build module ${chalk(['magenta'])(entryKey)} ...`,
+            task: async () => {
+                const buildResult = await worker.startBuildWorker(projectCwd, entryKey, jsonSerializer.stringify(overrideEvolveOptions), configLoaderOptions);
+                buildResults.push(buildResult);
+            },
+        });
+    }
+    if (buildTasks.tasks.length) {
+        try {
+            await buildTasks.run();
+        }
+        catch (err) {
+            worker.pool.terminate();
+            // we need to catch the error here, makesure the `worker` can be terminated.
+            throw err;
+        }
+    }
+    worker.pool.terminate();
+    return buildResults;
+};

package/dist/main/start-build-worker.js

@@ -1 +1,46 @@
-import{requireResolve}from"@flatjs/common";import{filterActivedEntriesByModule}from"../helpers/filter-actived-entries.js";import{jsonSerializer}from"../helpers/json-serializer.js";import{normalizeEvolveEntryMap}from"../helpers/normalize-entry-map.js";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{prepareBuild}from"./prepare-build.js";export const startBuildWorker=async(e,r,o,i)=>{const l={projectCwd:e,command:"build",resolve:requireResolve},t=jsonSerializer.parse(o)||{},n=await loadEvolveConfig(l,e,t,i),a=filterActivedEntriesByModule(n.entryMap,[new RegExp(`^${r}$`)]);if(!Object.keys(a).length)throw new Error(`No build entry resolved via "${r}" on "startBuildWorker"!`);const s=normalizeEvolveEntryMap(a,n.entryMap)[r];return prepareBuild([r,s],n)};
+import { requireResolve } from '@flatjs/common';
+import { filterActivedEntriesByModule } from '../helpers/filter-actived-entries.js';
+import { jsonSerializer } from '../helpers/json-serializer.js';
+import { normalizeEvolveEntryMap } from '../helpers/normalize-entry-map.js';
+import { loadEvolveConfig } from '../load-config/load-evolve-config.js';
+import { prepareBuild } from './prepare-build.js';
+/**
+ * FIXME: The main entry to start an evolve `build`, NOTE: avoid pass configuration with `function` here.
+ * If you need to call build api avoid `worker` you can directly call `prepareBuild`
+ * @internal
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param entryKey The `entryKey` for one entry build task
+ * @param serializedEvolveOptions The overrided evolve options, NOTE: we will serialize `function` property here first
+ * @param configLoaderOptions Evolve config loader options, NOTE: avoid pass configuration with `function` here.
+ */
+export const startBuildWorker = async (projectCwd, entryKey, serializedEvolveOptions, configLoaderOptions) => {
+    const command = {
+        projectCwd,
+        command: 'build',
+        resolve: requireResolve,
+    };
+    const overrideEvolveOptions = jsonSerializer.parse(serializedEvolveOptions) || {};
+    // Try to load evolve configuration from `flatjs-evolve.config.ts`
+    // FIXME: Cause of `worker-theads` do not support pass configuration with `function` reference.
+    const newEvolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    // FIXME: Cause of `worker threads` we need avoid pass entryItem config directly
+    // because we have some config node item with `function`
+    // It will break `worker threads` comunication, e.g below shown.
+    // DataCloneError: function (url) {
+    //   if (url.indexOf('dev.flatjs.com') > 0) return 'me';
+    //   if (url.indexOf('.qa.') > 0) retur...<omitted>... } could not be cloned.
+    //   at new DOMException (node:internal/per_context/domexception:53:5)
+    // So we need to re cacalculate the build entry via `entryKey`
+    const buildOneEntry = filterActivedEntriesByModule(newEvolveOptions.entryMap, [
+        // Make sure that the entryKey is correct match.
+        new RegExp(`^${entryKey}$`),
+    ]);
+    const buildEntryKeys = Object.keys(buildOneEntry);
+    // Make sure that we have at least one build entry module.
+    if (!buildEntryKeys.length) {
+        throw new Error(`No build entry resolved via "${entryKey}" on "startBuildWorker"!`);
+    }
+    const normalizedBuildOneEntry = normalizeEvolveEntryMap(buildOneEntry, newEvolveOptions.entryMap);
+    const buildEntryConfig = normalizedBuildOneEntry[entryKey];
+    return prepareBuild([entryKey, buildEntryConfig], newEvolveOptions);
+};

package/dist/main/start-build.js

@@ -1 +1,53 @@
-import{chalk,logger,requireResolve}from"@flatjs/common";import Listr from"listr";import{filterActivedEntriesByModule}from"../helpers/filter-actived-entries.js";import{getMaxProcessTasks}from"../helpers/get-max-process-tasks.js";import{jsonSerializer}from"../helpers/json-serializer.js";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{createThreadWorker}from"./create-thread-worker.js";import{envVerify}from"./env-verify.js";export const startBuild=async(e,r,t={},o)=>{const i={projectCwd:e,command:"build",resolve:requireResolve},s=await loadEvolveConfig(i,e,t,o);await envVerify(e,s);const a=filterActivedEntriesByModule(s.entryMap,r),n=Object.keys(a);if(!n.length)return logger.warn("No build entries providered!"),[];const l=getMaxProcessTasks(n.length,s.maxProcesses);logger.info(`Start standard build with (${chalk(["magenta"])(String(l))}) workers:\n${JSON.stringify({buildEntries:n},null,2)}`);const c=await createThreadWorker(l),d=new Listr([],{concurrent:l,exitOnError:!0}),m=[];for(const[r]of Object.entries(a))d.add({title:`Build module ${chalk(["magenta"])(r)} ...`,task:async()=>{const i=await c.startBuildWorker(e,r,jsonSerializer.stringify(t),o);m.push(i)}});return d.tasks.length&&await d.run(),c.pool.terminate(),m};
+import { chalk, logger, requireResolve } from '@flatjs/common';
+import Listr from 'listr';
+import { filterActivedEntriesByModule } from '../helpers/filter-actived-entries.js';
+import { getMaxProcessTasks } from '../helpers/get-max-process-tasks.js';
+import { jsonSerializer } from '../helpers/json-serializer.js';
+import { loadEvolveConfig } from '../load-config/load-evolve-config.js';
+import { createThreadWorker } from './create-thread-worker.js';
+import { envVerify } from './env-verify.js';
+export const startBuild = async (projectCwd, buildModules, overrideEvolveOptions = {}, configLoaderOptions) => {
+    const command = {
+        projectCwd,
+        command: 'build',
+        resolve: requireResolve,
+    };
+    // Try to load evolve configuration from `flatjs-evolve.config.ts`
+    const newEvolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    await envVerify(projectCwd, newEvolveOptions);
+    const buildEntries = filterActivedEntriesByModule(newEvolveOptions.entryMap, buildModules);
+    const buildEntryKeys = Object.keys(buildEntries);
+    // Make sure that we have at least one build entry module.
+    if (!buildEntryKeys.length) {
+        logger.warn(`No build entries providered!`);
+        return [];
+    }
+    const workerSize = getMaxProcessTasks(buildEntryKeys.length, newEvolveOptions.maxProcesses);
+    logger.info(`Start standard build with (${chalk(['magenta'])(String(workerSize))}) workers:\n${JSON.stringify({ buildEntries: buildEntryKeys }, null, 2)}`);
+    const worker = await createThreadWorker(workerSize);
+    const buildTasks = new Listr([], {
+        concurrent: workerSize,
+        exitOnError: true,
+    });
+    const buildResults = [];
+    for (const [entryKey] of Object.entries(buildEntries)) {
+        buildTasks.add({
+            title: `Build module ${chalk(['magenta'])(entryKey)} ...`,
+            task: async () => {
+                const buildResult = await worker.startBuildWorker(projectCwd, entryKey, jsonSerializer.stringify(overrideEvolveOptions), configLoaderOptions);
+                buildResults.push(buildResult);
+            },
+        });
+    }
+    if (buildTasks.tasks.length) {
+        try {
+            await buildTasks.run();
+        }
+        catch (err) {
+            worker.pool.terminate();
+            // we need to catch the error here, makesure the `worker` can be terminated.
+            throw err;
+        }
+    }
+    return buildResults;
+};

package/dist/main/start-one-entry-build.js

@@ -1 +1,35 @@
-import webpack from"webpack";import{loadWebpackConfig}from"../create-webpack/load-webpack-config.js";import{splitToMultiCompilerConfigs}from"../helpers/split-to-multi-compiler.js";export const startOneEntryBuild=async(r,o)=>{const t=await loadWebpackConfig("production",r,o),n=splitToMultiCompilerConfigs(r,t,o,!1);if(n.length>1)throw new Error("startOneEntryBuild() only support `compiler` at a time");const e=n[0];return new Promise(((r,t)=>{webpack(e,((n,i)=>{if(n)return t(n);const a=i?.toJson();return a?.errors?.length?t(a.errors):o.rejectWarnings&&a?.warnings?.length?t(a.warnings):void r({name:e.name,warningStats:a?.warnings})}))}))};
+import webpack from 'webpack';
+import { loadWebpackConfig } from '../create-webpack/load-webpack-config.js';
+import { splitToMultiCompilerConfigs } from '../helpers/split-to-multi-compiler.js';
+/**
+ * The helpers to build one entry at a time
+ * @param singleBuildEntry The single entry
+ * @param buildPublicPath
+ * @param evolveOptions
+ */
+export const startOneEntryBuild = async (singleBuildEntry, evolveOptions) => {
+    // Try to load webpack configuration
+    const webpackConfig = await loadWebpackConfig('production', singleBuildEntry, evolveOptions);
+    const compilerConfigs = splitToMultiCompilerConfigs(singleBuildEntry, webpackConfig, evolveOptions, false);
+    if (compilerConfigs.length > 1) {
+        throw new Error('startOneEntryBuild() only support `compiler` at a time');
+    }
+    const currCompiler = compilerConfigs[0];
+    // Run the single build.
+    return new Promise((resolve, reject) => {
+        webpack(currCompiler, (err, stats) => {
+            if (err) {
+                // Handle errors here
+                return reject(err);
+            }
+            const statsJson = stats?.toJson();
+            if (statsJson?.errors?.length) {
+                return reject(statsJson.errors);
+            }
+            if (evolveOptions.rejectWarnings && statsJson?.warnings?.length) {
+                return reject(statsJson.warnings);
+            }
+            resolve({ name: currCompiler.name, warningStats: statsJson?.warnings });
+        });
+    });
+};