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

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,51 @@
-import Tinypool from"tinypool";import{getWorkerPath}from"./get-worker-path.js";import startBuildWorker from"./start-build-worker.js";class ThreadPoolForUnittest{startBuildWorker(r){return startBuildWorker(r)}terminate(){console.warn('[WARNING] Using fake "terminate" for unittest!')}}class ThreadPoolForTinyPool{constructor(r,o){const{runtime:e="worker_threads",idleTimeout:t=6e4,minThreads:n=1,maxThreads:s}=o||{};this.pool=new Tinypool({filename:r,minThreads:n,maxThreads:s,runtime:e,idleTimeout:t})}startBuildWorker(r){return this.pool.run(r)}terminate(){this.pool.destroy()}}export const createThreadWorker=r=>{const o=getWorkerPath();return"test"===process.env.NODE_ENV?(console.warn("[WARNING] Using fake thread pool worker for unittest!"),new ThreadPoolForUnittest):new ThreadPoolForTinyPool(o,r)};
+import Tinypool from 'tinypool';
+import { getWorkerPath } from './get-worker-path.js';
+import startBuildWorker from './start-build-worker.js';
+/**
+ * Represents a thread pool for unit testing.
+ */
+class ThreadPoolForUnittest {
+    startBuildWorker(options) {
+        return startBuildWorker(options);
+    }
+    terminate() {
+        console.warn(`[WARNING] Using fake "terminate" for unittest!`);
+    }
+}
+/**
+ * Represents a thread pool for executing tasks using the TinyPool library.
+ */
+class ThreadPoolForTinyPool {
+    /**
+     * Creates a new instance of the `ThreadPoolForTinyPool` class.
+     * @param workerPath The path to the worker file.
+     * @param workerSize The number of worker threads to create.
+     * @param options Optional configuration options for the worker pool.
+     */
+    constructor(workerPath, options) {
+        const { runtime = 'worker_threads', idleTimeout = 60000, minThreads = 1, maxThreads, } = options || {};
+        this.pool = new Tinypool({
+            filename: workerPath,
+            minThreads,
+            maxThreads,
+            runtime,
+            idleTimeout,
+        });
+    }
+    startBuildWorker(options) {
+        return this.pool.run(options);
+    }
+    terminate() {
+        this.pool.destroy();
+    }
+}
+export const createThreadWorker = (options) => {
+    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();
+    }
+    return new ThreadPoolForTinyPool(workerPath, options);
+};

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,39 @@
-import{ensureSlash,mergeOptions}from"@flatjs/common";import{ignoreEntryOptionKeys}from"../constants.js";import{EvolveBuildError}from"../errors/evolve-build-error.js";import{printCompilerError}from"../helpers/print-log.js";import{verifyGroupEntryOptions}from"../helpers/verify-group-entry-options.js";import{startGroupEntryBuild}from"./start-group-entry-build.js";export const prepareBuild=async(r,o)=>{const t=Object.values(r)[0];if(!verifyGroupEntryOptions(r,ignoreEntryOptionKeys,!0))throw new Error("The entry options in a group must be the same.");const e=o.multiHtmlCdn?.prod||[];if(!e.length)throw new Error(`No CDN config for env:"prod", groupName: ${t.groupName}`);const n=ensureSlash(e[Math.floor(Math.random()*e.length)],!0);try{const e=t.options?.useRelativeAssetPath,i=mergeOptions(o,{webpack:{publicPath:e?"auto":n}});return await startGroupEntryBuild(r,i)}catch(r){const o=printCompilerError(r);throw new EvolveBuildError("BUILD_ERROR",o)}};
+import { ensureSlash, mergeOptions } from '@flatjs/common';
+import { ignoreEntryOptionKeys } from '../constants.js';
+import { EvolveBuildError } from '../errors/evolve-build-error.js';
+import { printCompilerError } from '../helpers/print-log.js';
+import { verifyGroupEntryOptions } from '../helpers/verify-group-entry-options.js';
+import { startGroupEntryBuild, } from './start-group-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 (groupEntries, evolveOptions) => {
+    const firstGroupEntryItem = Object.values(groupEntries)[0];
+    if (!verifyGroupEntryOptions(groupEntries, ignoreEntryOptionKeys, true)) {
+        throw new Error('The entry options in a group must be the same.');
+    }
+    // Fetch all configuration cdn
+    const cdnPath = evolveOptions.multiHtmlCdn?.prod || [];
+    if (!cdnPath.length) {
+        throw new Error(`No CDN config for env:"prod", groupName: ${firstGroupEntryItem.groupName}`);
+    }
+    // Random choose one to publicPath
+    const cdnPublicPath = ensureSlash(cdnPath[Math.floor(Math.random() * cdnPath.length)], true);
+    try {
+        const useRelativeAssetPath = firstGroupEntryItem.options?.useRelativeAssetPath;
+        const buildEvolveOptions = mergeOptions(evolveOptions, {
+            webpack: {
+                // Only for `assets` used at styling files (e.g.`xxx.less`)
+                publicPath: useRelativeAssetPath ? 'auto' : cdnPublicPath,
+            },
+        });
+        return await startGroupEntryBuild(groupEntries, 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,69 @@
-import{arrayUnique,logger,urlJoin}from"@flatjs/common";import{attachMockMiddlewares}from"@flatjs/mock";import{ignoreEntryOptionKeys}from"../constants.js";import{createAppPageRoute,createDevServer,createDevServerCompilerTask,createDevServerEntries}from"../dev-server/index.js";import{flatEntryMap,openPage}from"../helpers/index.js";import{normalizePageProxy}from"../helpers/normalize-page-proxy.js";import{splitToEntryGroup}from"../helpers/split-to-entry-group.js";import{verifyGroupEntryOptions}from"../helpers/verify-group-entry-options.js";import{envVerify}from"./env-verify.js";export const prepareServe=async(e,r,o)=>{await envVerify(e,o);const t=splitToEntryGroup(r,o,ignoreEntryOptionKeys,!0);if(!t.length)return void logger.warn("No served entries provided!");const n=[],{app:i,devPort:s,devHostUri:p,publicIp:a}=await createDevServer(o),c=o.devServer?.mockOptions?.mockFilters||[];for(const[,e]of Object.entries(r))c.push(...e.options?.mockFilters||[]);await attachMockMiddlewares(i,{...o.devServer?.mockOptions,mockFilters:arrayUnique(c),projectCwd:e});let v=s;const m=[];for(const e of t){if(!verifyGroupEntryOptions(e,ignoreEntryOptionKeys,!0))throw new Error("The entry options in a group must be the same.");v++;const r=await createDevServerEntries(v,e,o);m.push(r)}const l=flatEntryMap(m);createAppPageRoute(e,i,p,l,o);const y=normalizePageProxy(o.devServer?.pageProxy||"/pages"),f=urlJoin(p,[y]);o.devServer?.autoOpen&&openPage(f);for(const r of m){const t=createDevServerCompilerTask(e,f,a,r,m,o);n.push(t)}return Promise.all(n).then((()=>i))};
+import { arrayUnique, logger, urlJoin } from '@flatjs/common';
+import { attachMockMiddlewares } from '@flatjs/mock';
+import { ignoreEntryOptionKeys } from '../constants.js';
+import { createAppPageRoute, createDevServer, createDevServerCompilerTask, createDevServerEntries, } from '../dev-server/index.js';
+import { flatEntryMap, openPage } from '../helpers/index.js';
+import { normalizePageProxy } from '../helpers/normalize-page-proxy.js';
+import { splitToEntryGroup } from '../helpers/split-to-entry-group.js';
+import { verifyGroupEntryOptions } from '../helpers/verify-group-entry-options.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);
+    // Group by entry group name
+    const entryMapGroupList = splitToEntryGroup(servedEntries, evolveOptions, ignoreEntryOptionKeys, true);
+    if (!entryMapGroupList.length) {
+        logger.warn(`No served entries provided!`);
+        return;
+    }
+    const serveTasks = [];
+    // 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,
+    });
+    let lastPort = devPort;
+    const servedDevServerEntryList = [];
+    for (const entryMapGroup of entryMapGroupList) {
+        // Verify that each entry option is the same in a group
+        if (!verifyGroupEntryOptions(entryMapGroup, ignoreEntryOptionKeys, true)) {
+            throw new Error('The entry options in a group must be the same.');
+        }
+        // Create dev-server configuration for all servedEntries.
+        lastPort++;
+        const servedDevServerEntries = await createDevServerEntries(lastPort, entryMapGroup, evolveOptions);
+        servedDevServerEntryList.push(servedDevServerEntries);
+    }
+    // Create new route `/pages*`,`*` to pure dev server
+    const flatServedDevServerEntries = flatEntryMap(servedDevServerEntryList);
+    createAppPageRoute(projectCwd, app, devHostUri, flatServedDevServerEntries, evolveOptions);
+    const pageProxy = normalizePageProxy(evolveOptions.devServer?.pageProxy || '/pages');
+    const mainPage = urlJoin(devHostUri, [pageProxy]);
+    // Open page via browser
+    if (evolveOptions.devServer?.autoOpen) {
+        openPage(mainPage);
+    }
+    for (const servedDevServerEntryItem of servedDevServerEntryList) {
+        // Create dev-server compiler tasks
+        const task = createDevServerCompilerTask(projectCwd, mainPage, publicIp, servedDevServerEntryItem, servedDevServerEntryList, evolveOptions);
+        serveTasks.push(task);
+    }
+    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,171 @@
-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{ignoreEntryOptionKeys,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{normalizeEvolveEntryMap}from"../helpers/normalize-entry-map.js";import{resolveEntryMapInputFiles}from"../helpers/resolve-entry-map-input-files.js";import{splitToEntryGroup}from"../helpers/split-to-entry-group.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 p=await resolveEntryMapInputFiles(e,s.entryMap),c=await getBuildEntryFiles(e,a,p,s.webpack?.resolve?.alias,s.ci?.graphTreeNodeFilter);logger.debug(`To build entry files: \n${JSON.stringify(c,null,2)}`);return{buildEntries:await filterActivedEntriesByEntryInputs(e,s.entryMap,c),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=normalizeEvolveEntryMap(n,s.entryMap),l=splitToEntryGroup(a,s,ignoreEntryOptionKeys,!1);if(!l.length)return logger.warn("No build entries provided!"),[];const p=l.map((e=>Object.values(e)?.[0]?.groupName)),{threads:c={}}=s,d=getMaxProcessTasks(l.length,c?.maxThreads);logger.info(`Start dynamic build with (${chalk(["magenta"])(String(d))}) workers:\n${JSON.stringify({buildEntriesGroup:p},null,2)}`);const f=createThreadWorker({...c,maxThreads:d}),u=new Listr([],{concurrent:d,exitOnError:!0}),g=[];for(const r of l){const t=Object.values(r)?.[0]?.groupName||"",n=Object.keys(r);u.add({title:`Build group ${t}: ${chalk(["magenta"])(`${JSON.stringify(n,null,2)}`)} ...`,task:async()=>{const r=await f.startBuildWorker({projectCwd:e,entryKeys:n,serializedEvolveOptions:jsonSerializer.stringify(i),configLoaderOptions:o});g.push(r)}})}if(u.tasks.length)try{await u.run()}catch(e){throw f.terminate(),e}return f.terminate(),g};
+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 { ignoreEntryOptionKeys, 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 { normalizeEvolveEntryMap } from '../helpers/normalize-entry-map.js';
+import { resolveEntryMapInputFiles } from '../helpers/resolve-entry-map-input-files.js';
+import { splitToEntryGroup } from '../helpers/split-to-entry-group.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 between two `commit`
+    const { buildEntries, newEvolveOptions } = await dynamicCheckBuildEntryMap(projectCwd, earlyCommit, lastCommit, overrideEvolveOptions, configLoaderOptions);
+    await envVerify(projectCwd, newEvolveOptions);
+    // Make sure that each entry option includes the groupName
+    const normalizedBuildOneEntry = normalizeEvolveEntryMap(buildEntries, newEvolveOptions.entryMap);
+    const entryMapGroupList = splitToEntryGroup(normalizedBuildOneEntry, newEvolveOptions, ignoreEntryOptionKeys, false);
+    if (!entryMapGroupList.length) {
+        logger.warn(`No build entries provided!`);
+        return [];
+    }
+    const buildEntryGroupNames = entryMapGroupList.map((group) => {
+        return Object.values(group)?.[0]?.groupName;
+    });
+    const { threads = {} } = newEvolveOptions;
+    const maxThreads = getMaxProcessTasks(entryMapGroupList.length, threads?.maxThreads);
+    logger.info(`Start dynamic build with (${chalk(['magenta'])(String(maxThreads))}) workers:\n${JSON.stringify({ buildEntriesGroup: buildEntryGroupNames }, null, 2)}`);
+    const worker = createThreadWorker({ ...threads, maxThreads });
+    const buildTasks = new Listr([], {
+        concurrent: maxThreads,
+        exitOnError: true,
+    });
+    const buildResults = [];
+    for (const entryMapGroupItem of entryMapGroupList) {
+        const groupName = Object.values(entryMapGroupItem)?.[0]?.groupName || '';
+        const entryKeys = Object.keys(entryMapGroupItem);
+        buildTasks.add({
+            title: `Build group ${groupName}: ${chalk(['magenta'])(`${JSON.stringify(entryKeys, null, 2)}`)} ...`,
+            task: async () => {
+                const buildResult = await worker.startBuildWorker({
+                    projectCwd: projectCwd,
+                    entryKeys: entryKeys,
+                    serializedEvolveOptions: jsonSerializer.stringify(overrideEvolveOptions),
+                    configLoaderOptions: configLoaderOptions,
+                });
+                buildResults.push(buildResult);
+            },
+        });
+    }
+    if (buildTasks.tasks.length) {
+        try {
+            await buildTasks.run();
+        }
+        catch (err) {
+            worker.terminate();
+            // we need to catch the error here, make sure the `worker` can be terminated.
+            throw err;
+        }
+    }
+    worker.terminate();
+    return buildResults;
+};

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

@@ -1 +1,44 @@
-import{requireResolve}from"@flatjs/common";import{ignoreEntryOptionKeys}from"../constants.js";import{filterActivedEntriesByModule}from"../helpers/filter-actived-entries.js";import{jsonSerializer}from"../helpers/json-serializer.js";import{normalizeEvolveEntryMap}from"../helpers/normalize-entry-map.js";import{splitToEntryGroup}from"../helpers/split-to-entry-group.js";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{prepareBuild}from"./prepare-build.js";export default async e=>{const{projectCwd:r,entryKeys:o,serializedEvolveOptions:i,configLoaderOptions:t}=e,n={projectCwd:r,command:"build",resolve:requireResolve},p=jsonSerializer.parse(i)||{},l=await loadEvolveConfig(n,r,p,t),s=o.map((e=>new RegExp(`^${e}$`))),a=filterActivedEntriesByModule(l.entryMap,s),m=normalizeEvolveEntryMap(a,l.entryMap),d=splitToEntryGroup(m,l,ignoreEntryOptionKeys,!1);return prepareBuild(d[0],l)};
+import { requireResolve } from '@flatjs/common';
+import { ignoreEntryOptionKeys } from '../constants.js';
+import { filterActivedEntriesByModule } from '../helpers/filter-actived-entries.js';
+import { jsonSerializer } from '../helpers/json-serializer.js';
+import { normalizeEvolveEntryMap } from '../helpers/normalize-entry-map.js';
+import { splitToEntryGroup } from '../helpers/split-to-entry-group.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 options.projectCwd The Root directory (workspace) of this project.
+ * @param options.entryKey The `entryKey` for one entry build task
+ * @param options.serializedEvolveOptions The overrided evolve options, NOTE: we will serialize `function` property here first
+ * @param options.configLoaderOptions Evolve config loader options, NOTE: avoid pass configuration with `function` here.
+ */
+export default async (options) => {
+    const { projectCwd, entryKeys, serializedEvolveOptions, configLoaderOptions, } = options;
+    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 modulesRegList = entryKeys.map((key) => new RegExp(`^${key}$`));
+    const buildGroupEntry = filterActivedEntriesByModule(newEvolveOptions.entryMap, 
+    // Make sure that the entryKey is correct match.
+    modulesRegList);
+    const normalizedBuildGroupEntry = normalizeEvolveEntryMap(buildGroupEntry, newEvolveOptions.entryMap);
+    const entryMapGroupList = splitToEntryGroup(normalizedBuildGroupEntry, newEvolveOptions, ignoreEntryOptionKeys, false);
+    return prepareBuild(entryMapGroupList[0], newEvolveOptions);
+};

package/dist/main/start-build.js

@@ -1 +1,69 @@
-import{chalk,logger,requireResolve}from"@flatjs/common";import Listr from"listr";import{ignoreEntryOptionKeys}from"../constants.js";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{normalizeEvolveEntryMap}from"../helpers/normalize-entry-map.js";import{splitToEntryGroup}from"../helpers/split-to-entry-group.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(r,e,t={},o)=>{const i={projectCwd:r,command:"build",resolve:requireResolve},s=await loadEvolveConfig(i,r,t,o);await envVerify(r,s);const n=filterActivedEntriesByModule(s.entryMap,e),a=normalizeEvolveEntryMap(n,s.entryMap),l=splitToEntryGroup(a,s,ignoreEntryOptionKeys,!1);if(!l.length)return logger.warn("No build entries provided!"),[];const p=l.map((r=>Object.values(r)?.[0]?.groupName)),{threads:m={}}=s,c=getMaxProcessTasks(l.length,m?.maxThreads);logger.info(`Start standard build with (${chalk(["magenta"])(String(c))}) workers:\n${JSON.stringify({buildEntriesGroup:p},null,2)}`);const d=createThreadWorker({...m,maxThreads:c}),f=new Listr([],{concurrent:c,exitOnError:!0}),g=[];for(const e of l){const i=Object.values(e)?.[0]?.groupName||"",s=Object.keys(e);f.add({title:`Build group ${i}: ${chalk(["magenta"])(`${JSON.stringify(s,null,2)}`)} ...`,task:async()=>{const e=await d.startBuildWorker({projectCwd:r,entryKeys:s,serializedEvolveOptions:jsonSerializer.stringify(t),configLoaderOptions:o});g.push(e)}})}if(f.tasks.length)try{await f.run()}catch(r){throw d.terminate(),r}return d.terminate(),g};
+import { chalk, logger, requireResolve } from '@flatjs/common';
+import Listr from 'listr';
+import { ignoreEntryOptionKeys } from '../constants.js';
+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 { normalizeEvolveEntryMap } from '../helpers/normalize-entry-map.js';
+import { splitToEntryGroup } from '../helpers/split-to-entry-group.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);
+    // Make sure that each entry option includes the groupName
+    const normalizedBuildOneEntry = normalizeEvolveEntryMap(buildEntries, newEvolveOptions.entryMap);
+    const entryMapGroupList = splitToEntryGroup(normalizedBuildOneEntry, newEvolveOptions, ignoreEntryOptionKeys, false);
+    if (!entryMapGroupList.length) {
+        logger.warn(`No build entries provided!`);
+        return [];
+    }
+    const buildEntryGroupNames = entryMapGroupList.map((group) => {
+        return Object.values(group)?.[0]?.groupName;
+    });
+    const { threads = {} } = newEvolveOptions;
+    const maxThreads = getMaxProcessTasks(entryMapGroupList.length, threads?.maxThreads);
+    logger.info(`Start standard build with (${chalk(['magenta'])(String(maxThreads))}) workers:\n${JSON.stringify({ buildEntriesGroup: buildEntryGroupNames }, null, 2)}`);
+    const worker = createThreadWorker({ ...threads, maxThreads });
+    const buildTasks = new Listr([], {
+        concurrent: maxThreads,
+        exitOnError: true,
+    });
+    const buildResults = [];
+    for (const entryMapGroupItem of entryMapGroupList) {
+        const groupName = Object.values(entryMapGroupItem)?.[0]?.groupName || '';
+        const entryKeys = Object.keys(entryMapGroupItem);
+        buildTasks.add({
+            title: `Build group ${groupName}: ${chalk(['magenta'])(`${JSON.stringify(entryKeys, null, 2)}`)} ...`,
+            task: async () => {
+                const buildResult = await worker.startBuildWorker({
+                    projectCwd: projectCwd,
+                    entryKeys: entryKeys,
+                    serializedEvolveOptions: jsonSerializer.stringify(overrideEvolveOptions),
+                    configLoaderOptions: configLoaderOptions,
+                });
+                buildResults.push(buildResult);
+            },
+        });
+    }
+    if (buildTasks.tasks.length) {
+        try {
+            await buildTasks.run();
+        }
+        catch (err) {
+            worker.terminate();
+            // we need to catch the error here, make sure the `worker` can be terminated.
+            throw err;
+        }
+    }
+    worker.terminate();
+    return buildResults;
+};

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

@@ -1 +1,32 @@
-import webpack from"webpack";import{loadWebpackConfig}from"../create-webpack/load-webpack-config.js";import{assertSingleCompiler}from"../helpers/assert-single-compiler.js";export const startGroupEntryBuild=async(r,e)=>{const n=await loadWebpackConfig("production",r,e),o=assertSingleCompiler(r,n,e,!1);return new Promise(((r,n)=>{webpack(o,((a,t)=>{if(a)return n(a);const s=t?.toJson();return s?.errors?.length?n(s.errors):e.rejectWarnings&&s?.warnings?.length?n(s.warnings):void r({name:o.name,warningStats:s?.warnings})}))}))};
+import webpack from 'webpack';
+import { loadWebpackConfig } from '../create-webpack/load-webpack-config.js';
+import { assertSingleCompiler } from '../helpers/assert-single-compiler.js';
+/**
+ * Starts the build process for a group of entry files.
+ *
+ * @param groupBuildEntry - The map of entry files to be built.
+ * @param evolveOptions - The options for the build process.
+ * @returns A promise that resolves to the build result.
+ */
+export const startGroupEntryBuild = async (groupBuildEntry, evolveOptions) => {
+    // Try to load webpack configuration
+    const webpackConfig = await loadWebpackConfig('production', groupBuildEntry, evolveOptions);
+    const currCompiler = assertSingleCompiler(groupBuildEntry, webpackConfig, evolveOptions, false);
+    // 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 });
+        });
+    });
+};