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

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

@@ -1,32 +1 @@
-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,
-        });
-    });
-}
+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})}))}

package/dist/index.js

@@ -1,5 +1 @@
-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,41 +1 @@
-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;
-};
+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};

package/dist/load-config/types.js

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

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

@@ -1,42 +1 @@
-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,
-    });
-};
+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})};

package/dist/main/env-verify.js

@@ -1,21 +1 @@
-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 || {},
-        });
-    }
-};
+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||{}})};

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

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

package/dist/main/index.js

@@ -1,4 +1 @@
-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,38 +1 @@
-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);
-    }
-};
+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)}};

package/dist/main/prepare-serve.js

@@ -1,45 +1 @@
-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;
-    });
-};
+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))};

package/dist/main/prepare-static.js

@@ -1,30 +1 @@
-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.
+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)}`)};

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

@@ -1,157 +1 @@
-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;
-};
+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)}});if(d.tasks.length)try{await d.run()}catch(e){throw c.pool.terminate(),e}return c.pool.terminate(),f};

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

@@ -1,46 +1 @@
-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);
-};
+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)};

package/dist/main/start-build.js

@@ -1,53 +1 @@
-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;
-};
+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)}});if(d.tasks.length)try{await d.run()}catch(e){throw c.pool.terminate(),e}return c.pool.terminate(),m};

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

@@ -1,35 +1 @@
-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 });
-        });
-    });
-};
+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})}))}))};