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

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

@@ -1,139 +1 @@
-import _ from 'lodash';
-import { ignoreEntryOptionKeys, maxEntryGroupSize } 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';
-/**
- * Groups the manual entries based on their group names.
- * @param manualEntries - The map of manual entries.
- * @returns An array of grouped manual entries.
- */
-export const manualGrouping = (manualEntries) => {
-    const manualGroupEntryMap = _.groupBy(manualEntries, (entry) => {
-        return entry['groupName'];
-    });
-    const evolveEntryMapList = [];
-    for (const [, groupItem] of Object.entries(manualGroupEntryMap)) {
-        const evolveEntryMapItem = groupItem.reduce((prev, curr) => {
-            prev[curr.entryName] = _.omitBy(curr, 'entryName');
-            return prev;
-        }, {});
-        evolveEntryMapList.push(evolveEntryMapItem);
-    }
-    return evolveEntryMapList;
-};
-/**
- * Reduces an array of autoEntries into groups based on their options.
- * Each group is represented by a groupKey and contains an EvolveEntryMap.
- *
- * @param evolveOptions - The FlatEvolveOptions object.
- * @param autoEntries - An array of EvolveEntryMapContent objects with an additional entryName property.
- * @param ignoreOptionKeys - An array of keys to ignore when comparing entry options.
- * @param serveMode - A boolean indicating whether the function is running in serve mode.
- * @returns An object where each key represents a groupKey and its value is an EvolveEntryMap.
- */
-export const autoGroupingReduce = (autoEntries, ignoreOptionKeys = [], serveMode) => {
-    return _.reduce(autoEntries, (prev, curr, index) => {
-        let lastGroupingKey = `auto_grouping_reduce-${index}`;
-        const currEntryOptions = normalizeCheckEntryOptions(serveMode, curr.options, ignoreOptionKeys);
-        for (const [groupingKey, groupEntryMap] of Object.entries(prev)) {
-            const firsEntryMap = Object.values(groupEntryMap)[0];
-            const firstEntryOptions = normalizeCheckEntryOptions(serveMode, firsEntryMap.options, ignoreOptionKeys);
-            if (isDeepEqual(currEntryOptions, firstEntryOptions)) {
-                lastGroupingKey = groupingKey;
-                break;
-            }
-        }
-        prev[lastGroupingKey] = _.merge(prev[lastGroupingKey], {
-            [curr.entryName]: _.omitBy(curr, 'entryName'),
-        });
-        return prev;
-    }, {});
-};
-/**
- * Assigns a group name to each entry in the evolveEntryMapList based on the projectVirtualPath.
- *
- * @param evolveOptions - The options for the evolve process.
- * @param evolveEntryMapList - The list of evolve entry maps.
- * @returns The updated list of evolve entry maps with group names assigned.
- */
-export const autoAssignGroupName = (evolveOptions, evolveEntryMapList) => {
-    const { projectVirtualPath } = evolveOptions;
-    const evolveEntryMapItemList = [];
-    let index = 0;
-    for (const evolveEntryMap of evolveEntryMapList) {
-        const evolveEntryMapItem = {};
-        const groupName = normalizeGroupName(projectVirtualPath, index++);
-        for (const [entryName, entryContent] of Object.entries(evolveEntryMap)) {
-            entryContent.groupName = groupName;
-            evolveEntryMapItem[entryName] = entryContent;
-        }
-        evolveEntryMapItemList.push(evolveEntryMapItem);
-    }
-    return evolveEntryMapItemList;
-};
-/**
- * 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.
- *
- * @param evolveOptions - The FlatEvolveOptions object.
- * @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 maxGroupSize - The maximum size of each group. Defaults to maxEntryGroupSize.
- * @param serveMode - A boolean indicating whether the serve mode is enabled.
- * @returns An array of EvolveEntryMap representing the grouped entries.
- */
-export const autoGrouping = (evolveOptions, autoEntries, ignoreOptionKeys = [], maxGroupSize = maxEntryGroupSize, serveMode) => {
-    const autoGroupingReduceMap = autoGroupingReduce(autoEntries, ignoreOptionKeys, serveMode);
-    const autoGroupEntryMapList = [];
-    // slice each group
-    for (const [, groupItem] of Object.entries(autoGroupingReduceMap)) {
-        const groupKeys = Object.keys(groupItem);
-        if (groupKeys.length > maxGroupSize) {
-            for (let i = 0; i < groupKeys.length; i += maxGroupSize) {
-                const sliceGroupKeys = groupKeys.slice(i, i + maxGroupSize);
-                const sliceEvolveEntryMap = sliceGroupKeys.reduce((prev, curr) => {
-                    prev[curr] = groupItem[curr];
-                    return prev;
-                }, {});
-                autoGroupEntryMapList.push(sliceEvolveEntryMap);
-            }
-        }
-        else {
-            autoGroupEntryMapList.push(groupItem);
-        }
-    }
-    return autoAssignGroupName(evolveOptions, autoGroupEntryMapList);
-};
-/**
- * Splits the served entries into groups based on the given options.
- *
- * @param evolveEntries - The map of served entries.
- * @param ignoreOptionKeys - The list of option keys to ignore.
- * @returns An array of evolve entry maps representing the groups.
- */
-export const splitToEntryGroup = (evolveEntries, evolveOptions, ignoreOptionKeys = ignoreEntryOptionKeys, serveMode) => {
-    const { isolation = false } = evolveOptions;
-    if (isolation) {
-        const evolveEntryMapList = [];
-        for (const [entryName, entryContent] of Object.entries(evolveEntries)) {
-            entryContent.groupName = entryName;
-            evolveEntryMapList.push({
-                [entryName]: entryContent,
-            });
-        }
-        return evolveEntryMapList;
-    }
-    const evolveEntryFlatList = _.flatMap(evolveEntries, (entryOption, entryName) => {
-        return {
-            ...entryOption,
-            entryName,
-        };
-    });
-    const evolveEntryGroupMap = _.groupBy(evolveEntryFlatList, (entry) => {
-        return entry.groupingSource;
-    });
-    const manualEvolveEntryMapList = manualGrouping(evolveEntryGroupMap['manual']);
-    const autoEvolveEntryMapList = autoGrouping(evolveOptions, evolveEntryGroupMap['auto'], ignoreOptionKeys, maxEntryGroupSize, serveMode);
-    return [...manualEvolveEntryMapList, ...autoEvolveEntryMapList];
-};
+import _ from"lodash";import{ignoreEntryOptionKeys,maxEntryGroupSize}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=maxEntryGroupSize,n)=>{const s=autoGroupingReduce(e,t,n),u=[];for(const[,o]of Object.entries(s)){const e=Object.keys(o);if(e.length>r)for(let t=0;t<e.length;t+=r){const n=e.slice(t,t+r).reduce(((e,t)=>(e[t]=o[t],e)),{});u.push(n)}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,maxEntryGroupSize,r)]};

package/dist/helpers/verify-group-entry-options.js

@@ -1,21 +1 @@
-import { ignoreEntryOptionKeys } from '../constants.js';
-import { isDeepEqual } from './is-deep-equal.js';
-import { normalizeCheckEntryOptions } from './normalize-check-entry-options.js';
-/**
- * Verifies if the options of all entries in a group are equal, excluding specified keys.
- *
- * @param groupEvolveEntryMap - The map of group entries.
- * @param ignoreOptionKeys - The keys to be ignored when comparing options.
- * @returns A boolean indicating if the options of all entries are equal.
- */
-export const verifyGroupEntryOptions = (groupEvolveEntryMap, ignoreOptionKeys = ignoreEntryOptionKeys, serveMode) => {
-    const groupEvolveEntryMapValues = Object.values(groupEvolveEntryMap);
-    if (groupEvolveEntryMapValues.length === 1) {
-        return true;
-    }
-    const firstEntryMap = groupEvolveEntryMapValues.shift();
-    const firstEntryOptions = normalizeCheckEntryOptions(serveMode, firstEntryMap?.options, ignoreOptionKeys);
-    return groupEvolveEntryMapValues.every((entryOption) => {
-        return isDeepEqual(firstEntryOptions, normalizeCheckEntryOptions(serveMode, entryOption.options, ignoreOptionKeys));
-    });
-};
+import{ignoreEntryOptionKeys}from"../constants.js";import{isDeepEqual}from"./is-deep-equal.js";import{normalizeCheckEntryOptions}from"./normalize-check-entry-options.js";export const verifyGroupEntryOptions=(n,o=ignoreEntryOptionKeys,t)=>{const e=Object.values(n);if(1===e.length)return!0;const r=e.shift(),i=normalizeCheckEntryOptions(t,r?.options,o);return e.every((n=>isDeepEqual(i,normalizeCheckEntryOptions(t,n.options,o))))};

package/dist/index.d.ts

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

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-entry-map.js";export*from"./types/types-options.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{logger,mergeOptions}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/loaders/loader-icon.cjs

@@ -9,7 +9,8 @@ const svgOptimize = (buffer, svgoOption) => {
     return data;
 };
 const iconLoader = function iconLoader(source) {
-    this.cacheable && this.cacheable(true);
+    if (this.cacheable)
+        this.cacheable(true);
     const options = this.getOptions();
     const callback = this.async();
     try {

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

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

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.d.ts

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

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-build-dynamic.js";export*from"./start-serve.js";export*from"./start-static.js";

package/dist/main/prepare-build.js

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

package/dist/main/prepare-serve.js

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

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)}`)};