@flatjs/evolve 2.1.7 → 2.2.0-next.0

package/dist/build-server/base-compiler-watching.d.ts

@@ -0,0 +1,26 @@
+import type { Compiler, Configuration, Stats, Watching } from 'webpack';
+export type CompilerServerState = 'idle' | 'ready';
+export type StatsObjectOptions = Exclude<Configuration['stats'], boolean | string | undefined>;
+export type CallbackKey = 'done' | 'watchRun' | 'invalid';
+export type CallbackValue = ((stats?: Stats, error?: Error | Error[]) => void) | undefined;
+export type BaseCompilerWatchingContext = {
+    compiler: Compiler;
+    watching?: Watching;
+    state: CompilerServerState;
+    callbacks: {
+        [key in CallbackKey]: CallbackValue[];
+    };
+    stats?: Stats;
+};
+export declare const normalizeStatsOptions: (statsOptions: Configuration["stats"]) => StatsObjectOptions;
+export declare abstract class BaseCompilerWatching {
+    private context;
+    constructor(compiler: Compiler);
+    setupWatching(): void;
+    isReady(): boolean;
+    setCallback(key: CallbackKey, callback: CallbackValue): void;
+    invalidate(): Promise<void | Error>;
+    resume(): Promise<void>;
+    suspend(): Promise<void>;
+    close(): Promise<void | Error>;
+}

package/dist/build-server/base-compiler-watching.js

@@ -0,0 +1 @@
+import{logger}from"@flatjs/common";export const normalizeStatsOptions=t=>(void 0===t?t={preset:"normal"}:"boolean"==typeof t?t=t?{preset:"normal"}:{preset:"none"}:"string"==typeof t&&(t={preset:t}),t);const setupHooks=t=>{const e=t.compiler;e.hooks.watchRun.tap("flatjs-build-server",(function watchRun(){const e=t.callbacks.watchRun;for(const t of e)t?.();t.state="idle",t.stats=void 0,t.callbacks.watchRun=[]})),e.hooks.invalid.tap("flatjs-build-server",(function invalid(){"ready"===t.state&&logger.info("Compilation starting..."),t.state="idle",t.stats=void 0})),e.hooks.done.tap("flatjs-build-server",(function done(s){t.state="ready",t.stats=s,process.nextTick((()=>{const{callbacks:o}=t;if("ready"!==t.state)return;logger.debug(`Compilation finished: ${t.compiler.name}`);const n=normalizeStatsOptions(e.options.stats),i=s.toString(n);i&&logger.info(i);for(const t of o.done)t?.(s);t.callbacks.done=[]}))}))};export class BaseCompilerWatching{constructor(t){this.context={compiler:t,watching:void 0,state:"idle",callbacks:{done:[],watchRun:[],invalid:[]},stats:void 0},setupHooks(this.context),this.setupWatching()}setupWatching(){if(this.context.compiler.watching)this.context.watching=this.context.compiler.watching;else{const t=this.context.compiler.options.watchOptions||{};this.context.watching=this.context.compiler.watch({...t,aggregateTimeout:1e4,poll:!1},(t=>{this.context.state="ready",t&&logger.error(t)}))}}isReady(){return"ready"===this.context.state}setCallback(t,e){this.context.callbacks[t]||(this.context.callbacks[t]=[]),this.context.callbacks[t]?.push(e)}invalidate(){return new Promise(((t,e)=>{this.setCallback("done",((s,o)=>{o?e(o):t()})),this.context.watching?.invalidate()}))}resume(){return new Promise((t=>{this.context.watching?.suspended?(this.setCallback("watchRun",(()=>{t()})),this.context.watching?.resume()):t()}))}suspend(){return this.context.watching?.suspended||this.context.watching?.suspend(),Promise.resolve()}close(){return new Promise(((t,e)=>{this.context.compiler.close((s=>{s?e(s):t()}))}))}}

package/dist/build-server/compiler-server-manager.d.ts

@@ -0,0 +1,30 @@
+import type { ConfigLoaderOptions } from '../load-config/types.js';
+import type { EvolveBuildResult } from '../main/start-group-entry-build.js';
+import type { EvolveEntryMap } from '../types/types-entry-map.js';
+import type { FlatEvolveOptions } from '../types/types-options.js';
+/**
+ * Compares two arrays of build modules and returns a new array containing modules that are present in the second array but not in the first.
+ * @param originalBuildModules - The original array of build modules.
+ * @param buildModules - The new array of build modules to compare with the original.
+ * @returns A promise that resolves to an array of new build modules not present in the original array.
+ */
+export declare const diffBuildModules: (originalBuildModules: string[], buildModules: string[]) => Promise<string[]>;
+/**
+ * Splits the entry map into groups based on the given build modules and options.
+ * @param buildModules - The list of build modules to filter the entry map by.
+ * @param newEvolveOptions - The evolve options to use for splitting the entry map.
+ * @param groupCount - The number of groups to split the entry map into. Defaults to 0.
+ * @returns A promise that resolves to an array of EvolveEntryMap, each representing a group.
+ */
+export declare const splitGroupEntryMap: (buildModules: string[], newEvolveOptions: FlatEvolveOptions, groupCount?: number) => Promise<EvolveEntryMap[]>;
+declare class CompilerServerManager {
+    private factoryList;
+    private globalCompilerServer;
+    private createNormalCompilerServerFactory;
+    prepareNormalCompiler(projectCwd: string, buildModules: string[], evolveOptions: FlatEvolveOptions, configLoaderOptions?: ConfigLoaderOptions): Promise<string[]>;
+    prepareGlobalCompiler(evolveOptions: FlatEvolveOptions): Promise<void>;
+    checkGlobalCompiler(): Promise<void>;
+    recompile(): Promise<EvolveBuildResult[]>;
+}
+export declare const compilerServerManager: CompilerServerManager;
+export {};

package/dist/build-server/compiler-server-manager.js

@@ -0,0 +1 @@
+import{requireResolve}from"@armit/package";import{logger}from"@flatjs/common";import{createBuildServerCompiler}from"../compiler/create-build-server-compiler.js";import{createBuildServerGlobalCompiler}from"../compiler/create-build-server-global-compiler.js";import{ignoreEntryOptionKeys}from"../constants.js";import{filterActivedEntriesByModule}from"../helpers/filter-actived-entries.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{envVerify}from"../main/env-verify.js";import{CompilerServer}from"./compiler-server.js";import{GlobalCompilerServer}from"./global-compiler-server.js";export const diffBuildModules=async(r,e)=>{const o=[];for(const t of e){r.find((r=>r===t))||o.push(t)}return o};export const splitGroupEntryMap=async(r,e,o=0)=>{const t=filterActivedEntriesByModule(e.entryMap,r),i=normalizeEvolveEntryMap(t,e.entryMap);return splitToEntryGroup(i,e,ignoreEntryOptionKeys,!1,o)};class CompilerServerManager{constructor(){this.factoryList=[]}async createNormalCompilerServerFactory(r,e){const o=[];for(const t of r){const r=await createBuildServerCompiler(t,e),i=new CompilerServer(r,{watchFiles:[],setupExitSignals:!1});await i.start(),this.factoryList.push({compilerName:r.name,compilerServer:i,entryMap:t}),o.push(r.name)}return o}async prepareNormalCompiler(r,e,o,t){const i=this.factoryList.map((r=>Object.keys(r.entryMap))).flat(),l=await diffBuildModules(i,e);if(!l.length)return logger.debug("Build modules is empty!"),[];const a={projectCwd:r,command:"build",resolve:requireResolve},s=await loadEvolveConfig(a,r,o,t);await envVerify(r,s);const p=this.factoryList.length,n=await splitGroupEntryMap(l,s,p);return n.length?this.createNormalCompilerServerFactory(n,s):(logger.debug("Build entries is empty!"),[])}async prepareGlobalCompiler(r){if(this.globalCompilerServer)return;const e=await createBuildServerGlobalCompiler(r);e&&(this.globalCompilerServer=new GlobalCompilerServer(e),await this.globalCompilerServer.start())}async checkGlobalCompiler(){await this.globalCompilerServer.recompile()}async recompile(){if(!this.factoryList.length)return[];for(const r of this.factoryList){const{compilerServer:e}=r;await e.recompile()}return this.factoryList.map((r=>({name:Object.keys(r.entryMap)})))}}export const compilerServerManager=new CompilerServerManager;

package/dist/build-server/compiler-server.d.ts

@@ -0,0 +1,38 @@
+import type { ChokidarOptions } from 'chokidar';
+import type { Compiler } from 'webpack';
+export type WatchFiles = {
+    paths: string[] | string;
+    options?: ChokidarOptions;
+};
+export type CompilerServerOptions = {
+    watchFiles: WatchFiles[];
+    setupExitSignals?: boolean;
+    onStaticChanged?: (item: any) => void;
+};
+export declare class CompilerServer {
+    private readonly compiler;
+    private readonly options;
+    private staticWatchers;
+    private watching;
+    private listeners;
+    constructor(compiler: Compiler, options: CompilerServerOptions);
+    start(): Promise<void>;
+    recompile(): Promise<void>;
+    /**
+     * Start the compiler server with a callback
+     * @param callback - The callback function
+     */
+    startCallback(callback?: (err?: Error) => void): void;
+    /**
+     * Stop the compiler server
+     */
+    stop(): Promise<void>;
+    /**
+     * Stop the compiler server with a callback
+     * @param callback - The callback function
+     */
+    stopCallback(callback?: (err?: Error) => void): void;
+    private initialize;
+    private setupWatchFiles;
+    private watchFiles;
+}

package/dist/build-server/compiler-server.js

@@ -0,0 +1 @@
+import chokidar from"chokidar";import{logger}from"@flatjs/common";import{createCompilerWatching}from"./create-compiler-watching.js";export class CompilerServer{constructor(t,s){this.compiler=t,this.options=s,this.staticWatchers=[],this.listeners=[],this.watching=createCompilerWatching(t)}async start(){await this.initialize(),await this.setupWatchFiles(),logger.debug("Compiler server started")}async recompile(){try{await this.watching.resume(),await this.watching.invalidate()}finally{await this.watching.suspend()}}startCallback(t=()=>{}){this.start().then((()=>t()),t).catch(t)}async stop(){await Promise.all(this.staticWatchers.map((t=>t.close()))),this.staticWatchers=[];for(const t of this.listeners)process.removeListener(t.name,t.listener);this.listeners=[]}stopCallback(t=()=>{}){this.stop().then((()=>t()),t).catch(t)}initialize(){if(this.options.setupExitSignals){const t=["SIGINT","SIGTERM"];let s=!1;for(const i of t){const listener=()=>{s&&process.exit(),logger.info("Gracefully shutting down. To force exit, press ^C again. Please wait..."),s=!0,this.stopCallback((()=>{"function"==typeof this.compiler.close?this.compiler.close((()=>{process.exit()})):process.exit()}))};this.listeners.push({name:i,listener:listener}),process.on(i,listener),process.on(i,(()=>this.stop()))}}}setupWatchFiles(){const t=this.options.watchFiles;if(t.length>0)for(const s of t)this.watchFiles(s.paths,s.options)}watchFiles(t,s){const i=chokidar.watch(t,s);i.on("change",(t=>{this.options.onStaticChanged&&this.options.onStaticChanged(t)})),this.staticWatchers.push(i)}}

package/dist/build-server/create-compiler-watching.d.ts

@@ -0,0 +1,14 @@
+import type { Compiler, Stats } from 'webpack';
+import { BaseCompilerWatching } from './base-compiler-watching.js';
+export declare class CompilerWatching extends BaseCompilerWatching {
+    private readonly compiler;
+    constructor(compiler: Compiler);
+    private ready;
+    waitUntilValid: (callback?: (stats?: Stats) => void) => void;
+}
+/**
+ * Creates a new instance of CompilerWatching with the given compiler.
+ * @param compiler - The compiler instance to be watched.
+ * @returns A new instance of CompilerWatcher.
+ */
+export declare const createCompilerWatching: (compiler: Compiler) => CompilerWatching;

package/dist/build-server/create-compiler-watching.js

@@ -0,0 +1 @@
+import{logger}from"@flatjs/common";import{BaseCompilerWatching}from"./base-compiler-watching.js";export class CompilerWatching extends BaseCompilerWatching{constructor(i){super(i),this.compiler=i,this.waitUntilValid=i=>{this.ready(i)}}ready(i){if(this.isReady())i?.();else{const e=this.compiler.options.name;logger.info("wait until bundle finished"+(e?`: ${e}`:"")),i&&this.setCallback("done",i)}}}export const createCompilerWatching=i=>new CompilerWatching(i);

package/dist/build-server/create-global-compiler-watching.d.ts

@@ -0,0 +1,13 @@
+import type { Compiler } from 'webpack';
+import { BaseCompilerWatching } from './base-compiler-watching.js';
+export type GlobalCompilerWatchingContext = {
+    compiler: Compiler;
+    tsCheckerCallback?: (err: null | Error) => void;
+};
+export declare class GlobalCompilerWatching extends BaseCompilerWatching {
+    readonly compiler: Compiler;
+    private globalContext;
+    constructor(compiler: Compiler);
+    checkTsErrors(): Promise<void | Error>;
+}
+export declare const createGlobalCompilerWatching: (compiler: Compiler) => GlobalCompilerWatching;

package/dist/build-server/create-global-compiler-watching.js

@@ -0,0 +1 @@
+import ForkTsCheckerWebpackPlugin from"fork-ts-checker-webpack-plugin";import{BaseCompilerWatching}from"./base-compiler-watching.js";const setupTsCheckerHooks=e=>{const{compiler:r}=e;ForkTsCheckerWebpackPlugin.getCompilerHooks(r).issues.tap("flatjs-build-server",(function issues(r){const o=r.filter((e=>"error"===e.severity)),s=o.length?new Error(`TS_CHECKER_ERROR: \n ${JSON.stringify(o,null,2)}`):null;return e.tsCheckerCallback?.(s),e.tsCheckerCallback=void 0,r}))};export class GlobalCompilerWatching extends BaseCompilerWatching{constructor(e){super(e),this.compiler=e,this.globalContext={compiler:e,tsCheckerCallback:void 0},setupTsCheckerHooks(this.globalContext)}async checkTsErrors(){return new Promise(((e,r)=>{this.globalContext.tsCheckerCallback=o=>{o?r(o.message):e()}}))}}export const createGlobalCompilerWatching=e=>new GlobalCompilerWatching(e);

package/dist/build-server/global-compiler-server.d.ts

@@ -0,0 +1,8 @@
+import type { Compiler } from 'webpack';
+export declare class GlobalCompilerServer {
+    readonly compiler: Compiler;
+    private watching;
+    constructor(compiler: Compiler);
+    start(): Promise<void>;
+    recompile(): Promise<void>;
+}

package/dist/build-server/global-compiler-server.js

@@ -0,0 +1 @@
+import{logger}from"@flatjs/common";import{createGlobalCompilerWatching}from"./create-global-compiler-watching.js";export class GlobalCompilerServer{constructor(a){this.compiler=a,this.watching=createGlobalCompilerWatching(a)}async start(){logger.debug("Global compiler server started")}async recompile(){try{await this.watching.resume(),await this.watching.invalidate(),await this.watching.checkTsErrors()}finally{await this.watching.suspend()}}}

package/dist/build-server/index.d.ts

@@ -0,0 +1,5 @@
+export * from './compiler-server.js';
+export * from './compiler-server-manager.js';
+export * from './create-compiler-watching.js';
+export * from './create-compiler-watching.js';
+export * from './create-global-compiler-watching.js';

package/dist/build-server/index.js

@@ -0,0 +1 @@
+export*from"./compiler-server.js";export*from"./compiler-server-manager.js";export*from"./create-compiler-watching.js";export*from"./create-compiler-watching.js";export*from"./create-global-compiler-watching.js";

package/dist/compiler/create-build-server-compiler.d.ts

@@ -0,0 +1,5 @@
+import type { Compiler } from 'webpack';
+import type { FlatCliOptions } from '../types/types-cli-options.js';
+import { type EvolveEntryMap } from '../types/types-entry-map.js';
+import { type FlatEvolveOptions } from '../types/types-options.js';
+export declare const createBuildServerCompiler: (groupEntries: EvolveEntryMap, evolveOptions: FlatEvolveOptions, cliOptions?: FlatCliOptions) => Promise<Compiler>;

package/dist/compiler/create-build-server-compiler.js

@@ -0,0 +1 @@
+import webpack from"webpack";import{ensureSlash,mergeOptions}from"@flatjs/common";import{ignoreEntryOptionKeys}from"../constants.js";import{loadWebpackConfig}from"../create-webpack/load-webpack-config.js";import{EvolveBuildError}from"../errors/evolve-build-error.js";import{assertSingleCompiler}from"../helpers/assert-single-compiler.js";import{printCompilerError}from"../helpers/print-log.js";import{verifyGroupEntryOptions}from"../helpers/verify-group-entry-options.js";export const createBuildServerCompiler=async(r,o,e)=>{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 i=o.multiHtmlCdn?.prod||[];if(!i.length)throw new Error(`No CDN config for env:"prod", groupName: ${t.groupName}`);const n=ensureSlash(i[Math.floor(Math.random()*i.length)],!0);try{const i=t.options?.useRelativeAssetPath,p=mergeOptions(o,{webpack:{publicPath:i?"auto":n}}),s=await loadWebpackConfig("production",r,p,e),a=assertSingleCompiler(r,s,p,!1);return webpack(a)}catch(r){const o=printCompilerError(r);throw new EvolveBuildError("BUILD_ERROR",o)}};

package/dist/compiler/create-build-server-global-compiler.d.ts

@@ -0,0 +1,3 @@
+import webpack from 'webpack';
+import type { FlatEvolveOptions } from '../types/types-options.js';
+export declare const createBuildServerGlobalCompiler: (evolveOptions: FlatEvolveOptions) => Promise<webpack.Compiler | undefined>;

package/dist/compiler/create-build-server-global-compiler.js

@@ -0,0 +1 @@
+import webpack from"webpack";import{logger}from"@flatjs/common";import{createGlobalCompilerConfig}from"../compiler/create-global-compiler.js";export const createBuildServerGlobalCompiler=async r=>{const o=createGlobalCompilerConfig(!0,r);if(!o)return;return webpack(o,(r=>{r&&logger.error(r)}))};

package/dist/compiler/create-global-compiler.d.ts

@@ -1,2 +1,4 @@
+import webpack from 'webpack';
 import { type FlatEvolveOptions } from '../types/types-options.js';
+export declare const createGlobalCompilerConfig: (serveMode: boolean, evolveOptions: FlatEvolveOptions) => false | webpack.Configuration;
 export declare const createGlobalCompiler: (serveMode: boolean, evolveOptions: FlatEvolveOptions) => Promise<boolean>;

package/dist/compiler/create-global-compiler.js

@@ -1 +1 @@
-import webpack from"webpack";import{getDirname}from"@armit/file-utility";import{createExternals}from"../create-webpack/create-externals.js";import{createResolve}from"../create-webpack/create-resolve.js";import{ruleBabel}from"../create-webpack/rule-sets/rule-scripts.js";import{createTsCheckerPlugins}from"../plugins/ts-checker/ts-checker-plugin.js";export const createGlobalCompiler=async(e,r)=>{const{projectCwd:t,webpack:o,devServer:a,globalCompilerOptions:c}=r,{runTsChecker:l=!0}=c||{};if(!l)return!1;const s=e?"development":"production",n=a?.watchOptions||{},p=[ruleBabel({})],i=[...createTsCheckerPlugins(e,r)],m={context:t,mode:s,watch:e,name:"flat/evolve/global-compiler",entry:{".global-compiler-bundle":["."]},resolve:createResolve(t,o),module:{rules:p},plugins:i,watchOptions:n,devtool:!1,externals:createExternals(o?.externals),cache:{type:"memory"},performance:{},output:{environment:{},path:getDirname(import.meta.url,"./")}};return new Promise(((e,r)=>{webpack(m,(t=>{if(t)return r(t.message);e(!0)}))}))};
+import webpack from"webpack";import{getDirname}from"@armit/file-utility";import{createExternals}from"../create-webpack/create-externals.js";import{createResolve}from"../create-webpack/create-resolve.js";import{ruleBabel}from"../create-webpack/rule-sets/rule-scripts.js";import{createTsCheckerPlugins}from"../plugins/ts-checker/ts-checker-plugin.js";export const createGlobalCompilerConfig=(e,r)=>{const{projectCwd:t,webpack:o,devServer:a,globalCompilerOptions:l}=r,{runTsChecker:c=!0}=l||{};if(!c)return!1;const n=e?"development":"production",s=a?.watchOptions||{},p=[ruleBabel({})],i=[...createTsCheckerPlugins(e,r)];return{context:t,mode:n,watch:e,name:"flat/evolve/global-compiler",entry:{".global-compiler-bundle":["."]},resolve:createResolve(t,o),module:{rules:p},plugins:i,watchOptions:s,devtool:!1,externals:createExternals(o?.externals),cache:{type:"memory"},performance:{},output:{environment:{},path:getDirname(import.meta.url,"./")}}};export const createGlobalCompiler=async(e,r)=>{const t=createGlobalCompilerConfig(e,r);return!!t&&new Promise(((e,r)=>{webpack(t,(t=>{if(t)return r(t.message);e(!0)}))}))};

package/dist/helpers/split-to-entry-group.d.ts

@@ -28,7 +28,7 @@ export declare const autoGroupingReduce: (autoEntries: (EvolveEntryMapContent &
  * @param evolveEntryMapList - The list of evolve entry maps.
  * @returns The updated list of evolve entry maps with group names assigned.
  */
-export declare const autoAssignGroupName: (evolveOptions: FlatEvolveOptions, evolveEntryMapList: Array<EvolveEntryMap>) => Array<EvolveEntryMap>;
+export declare const autoAssignGroupName: (evolveOptions: FlatEvolveOptions, evolveEntryMapList: Array<EvolveEntryMap>, originalGroupCount?: number) => Array<EvolveEntryMap>;
 /**
  * Groups the given autoEntries into multiple EvolveEntryMap based on their options.
  * If the group size exceeds the maximum group size, it will be sliced into smaller groups.
@@ -37,16 +37,20 @@ export declare const autoAssignGroupName: (evolveOptions: FlatEvolveOptions, evo
  * @param autoEntries - An array of EvolveEntryMapContent objects with an additional entryName property.
  * @param ignoreOptionKeys - An array of keys to ignore in the EvolveEntryItemOption object.
  * @param serveMode - A boolean indicating whether the serve mode is enabled.
+ * @param originalGroupCount - The original group count.
  * @returns An array of EvolveEntryMap representing the grouped entries.
  */
 export declare const autoGrouping: (evolveOptions: FlatEvolveOptions, autoEntries: (EvolveEntryMapContent & {
     entryName: string;
-})[], ignoreOptionKeys: Array<keyof EvolveEntryItemOption> | undefined, serveMode: boolean) => Array<EvolveEntryMap>;
+})[], ignoreOptionKeys: Array<keyof EvolveEntryItemOption> | undefined, serveMode: boolean, originalGroupCount?: number) => Array<EvolveEntryMap>;
 /**
  * Splits the served entries into groups based on the given options.
  *
  * @param evolveEntries - The map of served entries.
+ * @param evolveOptions - The FlatEvolveOptions object.
  * @param ignoreOptionKeys - The list of option keys to ignore.
+ * @param serveMode - A boolean indicating whether the serve mode is enabled.
+ * @param originalGroupCount - The original group count.
  * @returns An array of evolve entry maps representing the groups.
  */
-export declare const splitToEntryGroup: (evolveEntries: EvolveEntryMap, evolveOptions: FlatEvolveOptions, ignoreOptionKeys: Array<keyof EvolveEntryItemOption> | undefined, serveMode: boolean) => Array<EvolveEntryMap>;
+export declare const splitToEntryGroup: (evolveEntries: EvolveEntryMap, evolveOptions: FlatEvolveOptions, ignoreOptionKeys: Array<keyof EvolveEntryItemOption> | undefined, serveMode: boolean, originalGroupCount?: number) => Array<EvolveEntryMap>;

package/dist/helpers/split-to-entry-group.js

@@ -1 +1 @@
-import _ from"lodash";import{ignoreEntryOptionKeys}from"../constants.js";import{isDeepEqual}from"./is-deep-equal.js";import{normalizeCheckEntryOptions}from"./normalize-check-entry-options.js";import{normalizeGroupName}from"./normalize-group-name.js";export const manualGrouping=o=>{const e=_.groupBy(o,(o=>o.groupName)),t=[];for(const[,o]of Object.entries(e)){const e=o.reduce(((o,e)=>(o[e.entryName]=_.omitBy(e,"entryName"),o)),{});t.push(e)}return t};export const autoGroupingReduce=(o,e=[],t)=>_.reduce(o,((o,r,n)=>{let s=`auto_grouping_reduce-${n}`;const u=normalizeCheckEntryOptions(t,r.options,e);for(const[r,n]of Object.entries(o)){const o=Object.values(n)[0],i=normalizeCheckEntryOptions(t,o.options,e);if(isDeepEqual(u,i)){s=r;break}}return o[s]=_.merge(o[s],{[r.entryName]:_.omitBy(r,"entryName")}),o}),{});export const autoAssignGroupName=(o,e)=>{const{projectVirtualPath:t}=o,r=[];let n=0;for(const o of e){const e={},s=normalizeGroupName(t,n++);for(const[t,r]of Object.entries(o))r.groupName=s,e[t]=r;r.push(e)}return r};export const autoGrouping=(o,e,t=[],r)=>{const{maxEntryGroupSize:n=10}=o,s=autoGroupingReduce(e,t,r),u=[];for(const[,o]of Object.entries(s)){const e=Object.keys(o);if(e.length>n)for(let t=0;t<e.length;t+=n){const r=e.slice(t,t+n).reduce(((e,t)=>(e[t]=o[t],e)),{});u.push(r)}else u.push(o)}return autoAssignGroupName(o,u)};export const splitToEntryGroup=(o,e,t=ignoreEntryOptionKeys,r)=>{const{isolation:n=!1}=e;if(n){const e=[];for(const[t,r]of Object.entries(o))r.groupName=t,e.push({[t]:r});return e}const s=_.flatMap(o,((o,e)=>({...o,entryName:e}))),u=_.groupBy(s,(o=>o.groupingSource));return[...manualGrouping(u.manual),...autoGrouping(e,u.auto,t,r)]};
+import _ from"lodash";import{ignoreEntryOptionKeys}from"../constants.js";import{isDeepEqual}from"./is-deep-equal.js";import{normalizeCheckEntryOptions}from"./normalize-check-entry-options.js";import{normalizeGroupName}from"./normalize-group-name.js";export const manualGrouping=o=>{const e=_.groupBy(o,(o=>o.groupName)),t=[];for(const[,o]of Object.entries(e)){const e=o.reduce(((o,e)=>(o[e.entryName]=_.omitBy(e,"entryName"),o)),{});t.push(e)}return t};export const autoGroupingReduce=(o,e=[],t)=>_.reduce(o,((o,r,n)=>{let s=`auto_grouping_reduce-${n}`;const u=normalizeCheckEntryOptions(t,r.options,e);for(const[r,n]of Object.entries(o)){const o=Object.values(n)[0],i=normalizeCheckEntryOptions(t,o.options,e);if(isDeepEqual(u,i)){s=r;break}}return o[s]=_.merge(o[s],{[r.entryName]:_.omitBy(r,"entryName")}),o}),{});export const autoAssignGroupName=(o,e,t=0)=>{const{projectVirtualPath:r}=o,n=[];let s=t;for(const o of e){const e={},t=normalizeGroupName(r,s++);for(const[r,n]of Object.entries(o))n.groupName=t,e[r]=n;n.push(e)}return n};export const autoGrouping=(o,e,t=[],r,n=0)=>{const{maxEntryGroupSize:s=10}=o,u=autoGroupingReduce(e,t,r),i=[];for(const[,o]of Object.entries(u)){const e=Object.keys(o);if(e.length>s)for(let t=0;t<e.length;t+=s){const r=e.slice(t,t+s).reduce(((e,t)=>(e[t]=o[t],e)),{});i.push(r)}else i.push(o)}return autoAssignGroupName(o,i,n)};export const splitToEntryGroup=(o,e,t=ignoreEntryOptionKeys,r,n=0)=>{const{isolation:s=!1}=e;if(s){const e=[];for(const[t,r]of Object.entries(o))r.groupName=t,e.push({[t]:r});return e}const u=_.flatMap(o,((o,e)=>({...o,entryName:e}))),i=_.groupBy(u,(o=>o.groupingSource));return[...manualGrouping(i.manual),...autoGrouping(e,i.auto,t,r,n)]};

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './build-server/index.js';
 export * from './define-config/index.js';
 export * from './load-config/index.js';
 export * from './main/index.js';

package/dist/index.js

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

package/dist/main/create-build-server.d.ts

@@ -0,0 +1,15 @@
+import { type PartialDeep } from 'type-fest';
+import { type ConfigLoaderOptions } from '../load-config/types.js';
+import { type FlatEvolveOptions } from '../types/types-options.js';
+export declare class BuildServer {
+    /**
+     * Build the modules
+     * @param earlyCommit - The early commit
+     * @param lastCommit - The last commit
+     * @param overrideEvolveOptions - The override evolve options
+     * @param configLoaderOptions - The config loader options
+     * @returns The build results
+     */
+    build(projectCwd: string, earlyCommit?: string, lastCommit?: string, overrideEvolveOptions?: PartialDeep<FlatEvolveOptions>, configLoaderOptions?: ConfigLoaderOptions): Promise<import("./start-group-entry-build.js").EvolveBuildResult[]>;
+}
+export declare const createBuildServer: () => BuildServer;

package/dist/main/create-build-server.js

@@ -0,0 +1 @@
+import{compilerServerManager}from"../build-server/compiler-server-manager.js";import{dynamicCheckBuildEntryMap}from"./start-build-dynamic.js";export class BuildServer{async build(e,r,a,i={},l){const{buildEntries:o,newEvolveOptions:c}=await dynamicCheckBuildEntryMap(e,r,a,i,l);await compilerServerManager.prepareGlobalCompiler(c),await compilerServerManager.checkGlobalCompiler();const p=Object.keys(o);await compilerServerManager.prepareNormalCompiler(e,p,c,l);return await compilerServerManager.recompile()}}export const createBuildServer=()=>new BuildServer;

package/dist/main/index.d.ts

@@ -1,4 +1,6 @@
+export * from './create-build-server.js';
 export * from './start-build.js';
 export * from './start-build-dynamic.js';
+export * from './start-group-entry-build.js';
 export * from './start-serve.js';
 export * from './start-static.js';

package/dist/main/index.js

@@ -1 +1 @@
-export*from"./start-build.js";export*from"./start-build-dynamic.js";export*from"./start-serve.js";export*from"./start-static.js";
+export*from"./create-build-server.js";export*from"./start-build.js";export*from"./start-build-dynamic.js";export*from"./start-group-entry-build.js";export*from"./start-serve.js";export*from"./start-static.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flatjs/evolve",
-  "version": "2.1.7",
+  "version": "2.2.0-next.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -35,66 +35,67 @@
     "typecheck": "tsc --project ./tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@armit/babel-merge": "^0.2.6",
-    "@armit/config-loader": "^0.3.0",
-    "@armit/file-utility": "^0.2.6",
-    "@armit/git": "^0.2.6",
-    "@armit/package": "^0.2.10",
-    "@babel/core": "^7.25.9",
-    "@clack/prompts": "^0.7.0",
-    "@discoveryjs/json-ext": "0.6.2",
-    "@flatjs/babel-plugin-import": "2.1.5",
-    "@flatjs/common": "2.1.5",
-    "@flatjs/evolve-preset-babel": "2.1.5",
-    "@flatjs/forge-postcss-plugin-pixel": "2.1.5",
-    "@flatjs/graph": "2.1.5",
-    "@flatjs/mock": "2.2.1",
+    "@armit/babel-merge": "^0.2.8",
+    "@armit/config-loader": "^0.3.2",
+    "@armit/file-utility": "^0.2.8",
+    "@armit/git": "^0.2.8",
+    "@armit/package": "^0.2.12",
+    "@babel/core": "^7.26.0",
+    "@clack/prompts": "^0.9.0",
+    "@discoveryjs/json-ext": "0.6.3",
+    "@flatjs/babel-plugin-import": "2.2.0-next.0",
+    "@flatjs/common": "2.2.0-next.0",
+    "@flatjs/evolve-preset-babel": "2.2.0-next.0",
+    "@flatjs/forge-postcss-plugin-pixel": "2.2.0-next.0",
+    "@flatjs/graph": "2.2.0-next.0",
+    "@flatjs/mock": "2.3.0-next.0",
     "@pmmmwh/react-refresh-webpack-plugin": "^0.5.15",
     "@types/babel__core": "^7.20.5",
     "babel-loader": "^9.2.1",
     "better-opn": "^3.0.2",
     "case-sensitive-paths-webpack-plugin": "^2.4.0",
-    "ci-info": "^4.0.0",
+    "chokidar": "^4.0.3",
+    "ci-info": "^4.1.0",
     "css-loader": "^7.1.2",
     "cssnano": "^7.0.6",
-    "express": "^4.21.1",
+    "express": "^4.21.2",
     "fork-ts-checker-webpack-plugin": "^9.0.2",
-    "happy-dom": "^15.7.4",
+    "happy-dom": "^15.11.7",
     "html-webpack-plugin": "^5.6.3",
-    "image-minimizer-webpack-plugin": "^4.1.0",
-    "less": "^4.2.0",
+    "image-minimizer-webpack-plugin": "^4.1.3",
+    "less": "^4.2.1",
     "less-loader": "^12.2.0",
     "listr": "^0.14.3",
     "lodash": "^4.17.21",
     "log-update": "^6.1.0",
-    "mini-css-extract-plugin": "^2.9.1",
-    "postcss": "^8.4.47",
+    "mini-css-extract-plugin": "^2.9.2",
+    "postcss": "^8.4.49",
     "postcss-loader": "^8.1.1",
-    "react-refresh": "^0.14.2",
+    "react-refresh": "^0.16.0",
     "svgo": "^3.3.2",
     "tarjan-graph": "^3.0.0",
-    "terser-webpack-plugin": "^5.3.10",
-    "tinypool": "^1.0.1",
-    "tsconfig-paths-webpack-plugin": "^4.1.0",
-    "type-fest": "^4.26.1",
-    "typescript": "^5.6.3",
-    "webpack": "^5.95.0",
+    "terser-webpack-plugin": "^5.3.11",
+    "tinypool": "^1.0.2",
+    "tsconfig-paths-webpack-plugin": "^4.2.0",
+    "type-fest": "^4.30.2",
+    "typescript": "^5.7.2",
+    "webpack": "^5.97.1",
     "webpack-bundle-analyzer": "^4.10.2",
-    "webpack-dev-server": "^5.1.0",
+    "webpack-dev-server": "^5.2.0",
     "webpack-sources": "^3.2.3"
   },
   "devDependencies": {
-    "@dimjs/lang": "2.0.0",
-    "@dimjs/model": "2.0.1",
-    "@dimjs/model-react": "2.0.1",
-    "@dimjs/utils": "2.0.2",
-    "@flatjs/testing": "2.1.5",
-    "@hyperse/eslint-config-hyperse": "^1.2.6",
-    "@swc/core": "1.7.39",
+    "@dimjs/lang": "2.0.1",
+    "@dimjs/model": "2.0.2",
+    "@dimjs/model-react": "2.0.2",
+    "@dimjs/utils": "2.0.3",
+    "@flatjs/testing": "2.2.0-next.0",
+    "@hyperse/eslint-config-hyperse": "^1.2.8",
+    "@swc/core": "1.10.1",
     "@types/express": "5.0.0",
     "@types/listr": "0.14.9",
-    "@types/node": "22.7.9",
-    "eslint": "^9.13.0",
+    "@types/node": "22.10.2",
+    "eslint": "^9.17.0",
     "imagemin-gifsicle": "7.0.0",
     "imagemin-jpegtran": "8.0.0",
     "imagemin-pngquant": "10.0.0",
@@ -102,8 +103,8 @@
     "npm-run-all": "4.1.5",
     "react": "18.3.1",
     "rimraf": "6.0.1",
-    "vite-tsconfig-paths": "5.0.1",
-    "vitest": "2.1.3",
+    "vite-tsconfig-paths": "5.1.4",
+    "vitest": "2.1.8",
     "vue-loader": "17.4.2"
   },
   "peerDependencies": {