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

package/dist/helpers/json-serializer.js

@@ -1 +1,52 @@
-function stringifyWithFns(n){return JSON.stringify(n,(function(n,t){if("function"==typeof t)try{return makeFunctionFromString(t),t.toString()}catch(n){return`function ${t.toString()}`}return t}))}function looksLikeAFunctionString(n){return!![/^function[^(]*\(([^()]*)\)\s*\{[\s\S]*\}$/m,/^(\s*async\s*)?(\w*\s*)\(([^)]*)\)\s*=>\s*(.*)$/m,/^\s*\w+\s*=>/m].find((t=>t.test(n)))}function makeFunctionFromString(funcString){return eval("("+funcString+")")}function parseWithFns(n){try{return JSON.parse(n,(function(n,t){return looksLikeAFunctionString(t)?makeFunctionFromString(t):t}))}catch(n){return{}}}export const jsonSerializer={stringify:stringifyWithFns,parse:parseWithFns};
+function stringifyWithFns(obj) {
+    return JSON.stringify(obj, function (key, value) {
+        if (typeof value === 'function') {
+            // handle property function
+            try {
+                // try test if it is a property function string
+                // e.g. var x = { inlineScripts () { console.log('Hello, world!'); } }
+                // eval(x.inlineScripts) will throw error
+                makeFunctionFromString(value);
+                return value.toString();
+            }
+            catch (err) {
+                // fix: ` inlineScripts () { console.log('Hello, world!'); }` to `function inlineScripts () { console.log('Hello, world!'); }`
+                return `function ${value.toString()}`;
+            }
+        }
+        return value;
+    });
+}
+function looksLikeAFunctionString(value) {
+    const funPattern = [
+        /^function[^(]*\(([^()]*)\)\s*\{[\s\S]*\}$/m,
+        // eslint-disable-next-line regexp/no-super-linear-backtracking
+        /^(\s*async\s*)?(\w*\s*)\(([^)]*)\)\s*=>\s*(.*)$/m,
+        // 仅包含一个参数的箭头
+        /^\s*\w+\s*=>/m,
+    ];
+    const matchFn = funPattern.find((s) => s.test(value));
+    return !!matchFn;
+}
+function makeFunctionFromString(funcString) {
+    return eval('(' + funcString + ')');
+}
+function parseWithFns(json) {
+    try {
+        return JSON.parse(json, function (key, value) {
+            if (looksLikeAFunctionString(value)) {
+                return makeFunctionFromString(value);
+            }
+            else {
+                return value;
+            }
+        });
+    }
+    catch (err) {
+        return {};
+    }
+}
+export const jsonSerializer = {
+    stringify: stringifyWithFns,
+    parse: parseWithFns,
+};

package/dist/helpers/merge-babel-options.js

@@ -1 +1,45 @@
-import{babelMerge}from"@armit/babel-merge";import babelPluginImport from"@flatjs/babel-plugin-import";import{logger}from"@flatjs/common";import{reactBabelPreset,vueBabelPreset}from"@flatjs/evolve-preset-babel";import{moduleName}from"../constants.js";export const mergeBabelOption=(e=[],r={usePreset:"react"})=>{const t=e.map((e=>[babelPluginImport,{transformToDefaultImport:!1,libraryDirectory:"dist",...e},e.libraryName])),{usePreset:a="react",...l}=r,o="react"===a?reactBabelPreset():"vue"===a?vueBabelPreset():reactBabelPreset();let m={};try{m=babelMerge(o,l),m.plugins?m.plugins.unshift(...t):m.plugins=t}catch(e){logger.error(e,moduleName)}return{...m,babelrc:!1,compact:!1}};
+import { babelMerge } from '@armit/babel-merge';
+import babelPluginImport from '@flatjs/babel-plugin-import';
+import { logger } from '@flatjs/common';
+import { reactBabelPreset, vueBabelPreset } from '@flatjs/evolve-preset-babel';
+import { moduleName } from '../constants.js';
+export const mergeBabelOption = (modularImports = [], options = { usePreset: 'react' }) => {
+    const babelImports = modularImports.map((importItem) => {
+        return [
+            babelPluginImport,
+            {
+                transformToDefaultImport: false,
+                libraryDirectory: 'dist',
+                ...importItem,
+            },
+            importItem.libraryName,
+        ];
+    });
+    const { usePreset = 'react', ...overrideBabelOption } = options;
+    const baseBabelOption = usePreset === 'react'
+        ? reactBabelPreset()
+        : usePreset === 'vue'
+            ? vueBabelPreset()
+            : reactBabelPreset();
+    let mergedBabelOption = {};
+    try {
+        mergedBabelOption = babelMerge(baseBabelOption, overrideBabelOption);
+        // babelMerge only the last one will be retained, since there are multiple `@flatjs/babel-plugin-import` plugins with the same plugin id.
+        if (mergedBabelOption.plugins) {
+            mergedBabelOption.plugins.unshift(...babelImports);
+        }
+        else {
+            mergedBabelOption.plugins = babelImports;
+        }
+    }
+    catch (err) {
+        logger.error(err, moduleName);
+    }
+    const finalBabelOptions = {
+        ...mergedBabelOption,
+        babelrc: false,
+        // Turns out the compact option is set to auto by default which removes "superfluous whitespace characters and line terminators [...] on input sizes >100KB".
+        compact: false,
+    };
+    return finalBabelOptions;
+};

package/dist/helpers/normalize-check-entry-options.js

@@ -1 +1,28 @@
-import{urlJoin}from"@flatjs/common";import{ignoreEntryOptionKeys}from"../constants.js";import{deleteObjectKeys}from"./delete-object-keys.js";import{normalizeTemplateInjectTokens}from"./normalize-template-inject-tokens.js";export const normalizeCheckEntryOptions=(e,t,o=ignoreEntryOptionKeys)=>{const n={mode:e?"development":"production",envCdn:urlJoin(e?"http://dev.flatjs.com":"https://file.40017.cn/jinfu",["public"])},r=normalizeTemplateInjectTokens(n,t),i={...t,...r};return deleteObjectKeys(i,o)};
+import { urlJoin } from '@flatjs/common';
+import { ignoreEntryOptionKeys } from '../constants.js';
+import { deleteObjectKeys } from './delete-object-keys.js';
+import { normalizeTemplateInjectTokens } from './normalize-template-inject-tokens.js';
+/**
+ * Normalizes the check entry options.
+ *
+ * @param serveMode - A boolean indicating whether the serve mode is enabled.
+ * @param currEntryOption - The current entry option.
+ * @param ignoreOptionKeys - An array of keys to ignore in the entry option.
+ * @returns The normalized entry options.
+ */
+export const normalizeCheckEntryOptions = (serveMode, currEntryOption, ignoreOptionKeys = ignoreEntryOptionKeys) => {
+    const mode = serveMode ? 'development' : 'production';
+    const envCdnDomain = serveMode
+        ? 'http://dev.flatjs.com'
+        : 'https://file.40017.cn/jinfu';
+    const configData = {
+        mode: mode,
+        envCdn: urlJoin(envCdnDomain, ['public']),
+    };
+    const normalizeEntryOption = normalizeTemplateInjectTokens(configData, currEntryOption);
+    const normalizedEntryOptions = {
+        ...currEntryOption,
+        ...normalizeEntryOption,
+    };
+    return deleteObjectKeys(normalizedEntryOptions, ignoreOptionKeys);
+};

package/dist/helpers/normalize-entry-map.js

@@ -1 +1,59 @@
-import{join}from"node:path";import _ from"lodash";const normalizeEntryGroupOptions=o=>o&&o.groupName?{groupName:o.groupName,groupingSource:"manual"}:{groupingSource:"auto"};export const normalizeEvolveEntryName=(o,r)=>{const e=o.replace(/^\//,""),n=r.replace(/^\//,"");return(e.startsWith(n)?e:join(n,e)).replace(/\/$/,"")};export const normalizeEvolveEntryMap=(o={},r={})=>{const e={};for(const[n,t]of Object.entries(r)){const r={options:{}};if(o[n]){const p=normalizeEntryGroupOptions(t);e[n]=_.merge({},r,t,o[n],p)}}return e};
+import { join } from 'node:path';
+import _ from 'lodash';
+/**
+ * Normalizes the entry group options based on the provided entry map content.
+ * If the entry map content has a group name, the grouping source will be set to 'manual'.
+ * Otherwise, the grouping source will be set to 'auto'.
+ *
+ * @param entryMapContent - The entry map content to normalize.
+ * @returns The normalized entry group options containing the group name and grouping source.
+ */
+const normalizeEntryGroupOptions = (entryMapContent) => {
+    if (entryMapContent && entryMapContent.groupName) {
+        return {
+            groupName: entryMapContent.groupName,
+            groupingSource: 'manual',
+        };
+    }
+    return {
+        groupingSource: 'auto',
+    };
+};
+/**
+ * Make sure that we have correct `virtualPath` for each webpack `entry`
+ * @param entryName the entryName defined via `flatjs-evolve.config.ts`.
+ * @param evolveOptions
+ * @returns
+ */
+export const normalizeEvolveEntryName = (entryName, projectVirtualPath) => {
+    const servedEntryName = entryName.replace(/^\//, '');
+    const virtualPath = projectVirtualPath.replace(/^\//, '');
+    const withVirtualPath = servedEntryName.startsWith(virtualPath);
+    // Make sure that we have correct `virtualPath` for each webpack `entry`
+    const finalEntryName = withVirtualPath
+        ? servedEntryName
+        : join(virtualPath, servedEntryName);
+    return finalEntryName.replace(/\/$/, '');
+};
+/**
+ * Normalize flatjs.evolve entry map definition data.
+ * Merge default entry item configuration values.
+ * @param activedEntryMap actived entries
+ * @param definedEntryMap defined entries in flatjs.evolve.js
+ * @param projectVirtualPath virtual path for current `project`
+ */
+export const normalizeEvolveEntryMap = (activedEntryMap = {}, definedEntryMap = {}) => {
+    const newActivedEntries = {};
+    for (const [entryKey, itemConfig] of Object.entries(definedEntryMap)) {
+        // Setup default entry options.
+        const defaultEntryItemConfig = {
+            options: {},
+        };
+        if (activedEntryMap[entryKey]) {
+            // Perfect entry group option
+            const entryItemGroupConfig = normalizeEntryGroupOptions(itemConfig);
+            newActivedEntries[entryKey] = _.merge({}, defaultEntryItemConfig, itemConfig, activedEntryMap[entryKey], entryItemGroupConfig);
+        }
+    }
+    return newActivedEntries;
+};

package/dist/helpers/normalize-group-name.js

@@ -1 +1,16 @@
-import{normalizeEvolveEntryName}from"./normalize-entry-map.js";export const normalizeGroupName=(r,o)=>{const e=Array.from({length:26},((r,o)=>String.fromCharCode(65+o))),m=[...Array.from({length:26},((r,o)=>String.fromCharCode(97+o))),...e],n=Math.floor(o/52);return normalizeEvolveEntryName(`${m[o%52]}${n||""}`,r)};
+import { normalizeEvolveEntryName } from './normalize-entry-map.js';
+/**
+ * Normalizes the group name based on the project virtual path and index.
+ *
+ * @param projectVirtualPath - The virtual path of the project.
+ * @param index - The index used to generate the group name.
+ * @returns The normalized group name.
+ */
+export const normalizeGroupName = (projectVirtualPath, index) => {
+    const upperCase = Array.from({ length: 26 }, (_, i) => String.fromCharCode(65 + i));
+    const lowerCase = Array.from({ length: 26 }, (_, i) => String.fromCharCode(97 + i));
+    const alphabetArray = [...lowerCase, ...upperCase];
+    const time = Math.floor(index / 52);
+    const alphabetCode = alphabetArray[index % 52];
+    return normalizeEvolveEntryName(`${alphabetCode}${time || ''}`, projectVirtualPath);
+};

package/dist/helpers/normalize-page-proxy.js

@@ -1 +1,9 @@
-export const normalizePageProxy=(e="/pages")=>"/"+(e.replace(/^\//,"").replace(/\/$/,"")||"pages");
+/**
+ * We need to normalize the page proxy to  make sure that we have prefix slash.
+ * @param pageProxy `/pages`
+ * @returns The normalized page proxy
+ */
+export const normalizePageProxy = (pageProxy = '/pages') => {
+    const proxy = pageProxy.replace(/^\//, '').replace(/\/$/, '');
+    return `/` + (proxy || 'pages');
+};

package/dist/helpers/normalize-resolve-alias.js

@@ -1 +1,7 @@
-import{resolve}from"node:path";export const normalizeResolveAlias=(e,o={})=>{for(const[r,t]of Object.entries(o))o[r]=resolve(e,t);return o};
+import { resolve } from 'node:path';
+export const normalizeResolveAlias = (projectCwd, alias = {}) => {
+    for (const [symbol, path] of Object.entries(alias)) {
+        alias[symbol] = resolve(projectCwd, path);
+    }
+    return alias;
+};

package/dist/helpers/normalize-template-inject-tokens.js

@@ -1 +1,22 @@
-import{getHtmlPluginConfig}from"./get-html-plugin-config.js";export const normalizeTemplateInjectTokens=(e,t)=>({headBeforeHtmlTags:getHtmlPluginConfig("headBeforeHtmlTags",e,t?.headBeforeHtmlTags),inlineScripts:getHtmlPluginConfig("inlineScripts",e,t?.inlineScripts),headBeforeStyles:getHtmlPluginConfig("headBeforeStyles",e,t?.headBeforeStyles),headBeforeScripts:getHtmlPluginConfig("headBeforeScripts",e,t?.headBeforeScripts),bodyAfterScripts:getHtmlPluginConfig("bodyAfterScripts",e,t?.bodyAfterScripts)});
+import { getHtmlPluginConfig, } from './get-html-plugin-config.js';
+/**
+ * Normalizes the template inject tokens based on the provided configuration data and entry options.
+ *
+ * @param configData - The configuration data for the HTML plugin.
+ * @param currEntryOption - The current entry option for the evolve item.
+ * @returns An object containing the normalized template inject tokens.
+ */
+export const normalizeTemplateInjectTokens = (configData, currEntryOption) => {
+    return {
+        // The customized html tags should be inject to <header />
+        headBeforeHtmlTags: getHtmlPluginConfig('headBeforeHtmlTags', configData, currEntryOption?.headBeforeHtmlTags),
+        // Allow us customized inline scripts into compiled html template.
+        inlineScripts: getHtmlPluginConfig('inlineScripts', configData, currEntryOption?.inlineScripts),
+        // The ordered styles will be injected start of html head.
+        headBeforeStyles: getHtmlPluginConfig('headBeforeStyles', configData, currEntryOption?.headBeforeStyles),
+        // The ordered scripts will be injected before html head.
+        headBeforeScripts: getHtmlPluginConfig('headBeforeScripts', configData, currEntryOption?.headBeforeScripts),
+        // The ordered scripts will be injected end of html body.
+        bodyAfterScripts: getHtmlPluginConfig('bodyAfterScripts', configData, currEntryOption?.bodyAfterScripts),
+    };
+};

package/dist/helpers/open-page.js

@@ -1 +1,15 @@
-import opn from"better-opn";export const openPage=n=>{try{opn(n)}catch(n){console.warn("Unable to open browser. If you are running in a headless environment\n")}};
+import opn from 'better-opn';
+/**
+ * A better opn. Reuse the same tab on Chrome for
+ * @example
+ * `http://xxx.domain.com:3001/pages`
+ * @param openUrl the page url try to open.
+ */
+export const openPage = (openUrl) => {
+    try {
+        opn(openUrl);
+    }
+    catch (err) {
+        console.warn(`Unable to open browser. If you are running in a headless environment\n`);
+    }
+};

package/dist/helpers/print-log.js

@@ -1 +1,49 @@
-import{logger}from"@flatjs/common";import{moduleName}from"../constants.js";export const printInfo=(r,o=!1)=>{o||logger.info(r,moduleName)};export const printError=r=>{logger.error(r,moduleName)};const formatCompilerError=(r,o=[])=>{if(!r)return o;if("string"==typeof r)o.push(r);else if(Array.isArray(r))for(const e of r)formatCompilerError(e,o);else if("object"==typeof r){const e=r.stack||r.message;delete r.stack,delete r.message;const t={...r,_newMsg:e};for(const[,r]of Object.entries(t))formatCompilerError(r,o)}return o};export const printCompilerError=r=>{const o=formatCompilerError(r,[]);for(const r of o)console.log(r);return o};
+import { logger } from '@flatjs/common';
+import { moduleName } from '../constants.js';
+export const printInfo = (message, silent = false) => {
+    if (!silent) {
+        logger.info(message, moduleName);
+    }
+};
+export const printError = (message) => {
+    logger.error(message, moduleName);
+};
+const formatCompilerError = (errors, formattedMessages = []) => {
+    if (!errors) {
+        return formattedMessages;
+    }
+    if (typeof errors === 'string') {
+        formattedMessages.push(errors);
+    }
+    else if (Array.isArray(errors)) {
+        for (const error of errors) {
+            formatCompilerError(error, formattedMessages);
+        }
+    }
+    else if (typeof errors === 'object') {
+        // Only need to show `stack` or `message`
+        const onlyOneMsg = errors.stack || errors.message;
+        delete errors.stack;
+        delete errors.message;
+        const newErrors = {
+            ...errors,
+            _newMsg: onlyOneMsg,
+        };
+        for (const [, value] of Object.entries(newErrors)) {
+            formatCompilerError(value, formattedMessages);
+        }
+    }
+    return formattedMessages;
+};
+/**
+ * Do not use `logger` to print webpack compiler error, cause of it may have it's message formatting.
+ * @param errors
+ * @returns
+ */
+export const printCompilerError = (errors) => {
+    const newErrors = formatCompilerError(errors, []);
+    for (const message of newErrors) {
+        console.log(message);
+    }
+    return newErrors;
+};

package/dist/helpers/refresh-evolve-mock-options.js

@@ -1 +1,34 @@
-import{requireResolve}from"@flatjs/common";import{loadMockConfig,getMockCwd}from"@flatjs/mock";import _ from"lodash";export const refreshEvolveMockOptions=async(o,t,e)=>{const s=t.devServer,r=e?.esmLoaderOptions,i=r?.externals||[],n={projectCwd:o,resolve:requireResolve},c=await loadMockConfig(n,o,s?.mockOptions||{},_.merge({},e,{configFile:"flatjs-mock",esmLoaderOptions:{externals:[...i,"@flatjs/mock"]}}));if(s){s.mockOptions=c||{},s.mockOptions&&!s.mockOptions.https&&(s.mockOptions.https=s?.https);const o=getMockCwd(c);Array.isArray(s?.watchOptions?.ignored)&&s?.watchOptions?.ignored.push(o)}return t};
+import { requireResolve } from '@flatjs/common';
+import { loadMockConfig, getMockCwd, } from '@flatjs/mock';
+import _ from 'lodash';
+export const refreshEvolveMockOptions = async (projectCwd, evolveOptions, configLoaderOptions) => {
+    const devServer = evolveOptions.devServer;
+    const esmLoaderOptions = configLoaderOptions?.esmLoaderOptions;
+    const externals = esmLoaderOptions?.externals || [];
+    const command = {
+        projectCwd,
+        resolve: requireResolve,
+    };
+    // Try to load mock configuration from `flatjs-mock.config.ts`
+    const newMockOptions = await loadMockConfig(command, projectCwd, (devServer?.mockOptions || {}), _.merge({}, configLoaderOptions, {
+        configFile: 'flatjs-mock',
+        esmLoaderOptions: {
+            // load `flatjs-mock.config.ts` it will always import { defineConfig } from `@flatjs/mock`
+            externals: [...externals, '@flatjs/mock'],
+        },
+    }));
+    // we always has `devServer` config node.
+    if (devServer) {
+        devServer.mockOptions = newMockOptions || {};
+        if (devServer.mockOptions && !devServer.mockOptions.https) {
+            devServer.mockOptions.https = devServer?.https;
+        }
+        // Dynamic resolve mock work root directory
+        const mockCwd = getMockCwd(newMockOptions);
+        // always push mockCwd into watchOptions ignored.
+        if (Array.isArray(devServer?.watchOptions?.ignored)) {
+            devServer?.watchOptions?.ignored.push(mockCwd);
+        }
+    }
+    return evolveOptions;
+};

package/dist/helpers/resolve-entry-map-input-files.js

@@ -1 +1,20 @@
-import{fileWalk}from"@armit/file-utility";import{arrayUnique}from"@flatjs/common";export const resolveEntryMapInputFiles=async(t,r)=>{const e=[];for(const[,t]of Object.entries(r)){const r=t.entry.map((t=>t.replace(/.(?:js|jsx|tsx|ts)$/,"")+".*"));e.push(...r)}const o=arrayUnique(e);return await fileWalk(o,{cwd:t,absolute:!0})};
+import { fileWalk } from '@armit/file-utility';
+import { arrayUnique } from '@flatjs/common';
+/**
+ * Transform all entry files via `entryMap`
+ * @param projectCwd The project root directory
+ * @param entryMap The evolve entryMap definition
+ * @returns The absolute entry input files.
+ */
+export const resolveEntryMapInputFiles = async (projectCwd, entryMap) => {
+    const pattern = [];
+    for (const [, config] of Object.entries(entryMap)) {
+        const entries = config.entry.map((s) => s.replace(/.(?:js|jsx|tsx|ts)$/, '') + '.*');
+        pattern.push(...entries);
+    }
+    const walkPattern = arrayUnique(pattern);
+    return await fileWalk(walkPattern, {
+        cwd: projectCwd,
+        absolute: true,
+    });
+};

package/dist/helpers/script-injects.js

@@ -1 +1,39 @@
-export function httpUrlJoin(n="",e=""){return n.replace(/\/$/,"")+"/"+e.replace(/^\//,"")}export function cdnFinder(n,e){const r=window.location.href,o=/[?&]env(=([^&#]*)|&|#|$)/.exec(r);let t=o&&o[2]?decodeURIComponent(o[2].replace(/\+/g," ")):"prod";t=e&&e(r)||t;const c=n[t]||n.prod||[];return c[Math.floor(Math.random()*c.length)].replace(/\/$/,"")+"/"}export function findEnvCdn(n={},e="prod"){const r=n[e]||n.prod||[];return r[Math.floor(Math.random()*r.length)]}export function injectFederationScripts(n,e=function cdnResolver(){}){return`window.evolveFetchMicroWidgets = function () {\n    var cdnConfig = ${JSON.stringify(n)};\n    var cdnResolver = ${e.toString()};\n    var cdnFinder = ${cdnFinder.toString()};\n    return (cdnFinder(cdnConfig, cdnResolver) || '').replace(/\\/$/, '');\n  }\n  `}
+export function httpUrlJoin(first = '', second = '') {
+    return first.replace(/\/$/, '') + '/' + second.replace(/^\//, '');
+}
+/**
+ * To extract the best matched CDN configuration url address, either use URL `query.env` or customize the `envRresolver`
+ * @param cdnConfig List of pre-configured cdn urls for each environment
+ * @param envResolver Get the specific environment variable by the currently requested host url address.
+ * @returns Returns the best matching address with a suffix (`/`)
+ */
+export function cdnFinder(cdnConfig, envResolver) {
+    // eslint-disable-next-line regexp/no-unused-capturing-group
+    const regex = /[?&]env(=([^&#]*)|&|#|$)/;
+    const locationHref = window.location.href;
+    const results = regex.exec(locationHref);
+    let env = results && results[2]
+        ? decodeURIComponent(results[2].replace(/\+/g, ' '))
+        : 'prod';
+    // If we have customized cdn resolver using it first.
+    env = (envResolver && envResolver(locationHref)) || env;
+    const matchedCdnList = cdnConfig[env] || cdnConfig['prod'] || [];
+    const matchedCdn = matchedCdnList[Math.floor(Math.random() * matchedCdnList.length)];
+    // ensure has endfix slash
+    return matchedCdn.replace(/\/$/, '') + '/';
+}
+export function findEnvCdn(cdnConfig = {}, env = 'prod') {
+    const matchedCdnList = cdnConfig[env] || cdnConfig['prod'] || [];
+    return matchedCdnList[Math.floor(Math.random() * matchedCdnList.length)];
+}
+export function injectFederationScripts(cdnConfig, cdnResolver = function cdnResolver() {
+    return undefined;
+}) {
+    return `window.evolveFetchMicroWidgets = function () {
+    var cdnConfig = ${JSON.stringify(cdnConfig)};
+    var cdnResolver = ${cdnResolver.toString()};
+    var cdnFinder = ${cdnFinder.toString()};
+    return (cdnFinder(cdnConfig, cdnResolver) || '').replace(/\\/$/, '');
+  }
+  `;
+}

package/dist/helpers/should-enable-react-fast-refresh.js

@@ -1 +1,14 @@
-export const shouldEnableReactFastRefresh=(e,o,t)=>{const r=o[1],s=!!r.options?.moduleFederation,a=!!r.options?.output?.library;return e&&"react"===t.loaderOptions.babelOptions?.usePreset&&!s&&!a&&!0!==t.devServer?.liveReload};
+export const shouldEnableReactFastRefresh = (serveMode, entryMapItem, evolveOptions) => {
+    const entryItemOption = entryMapItem[1];
+    // Check if the entry item has module federation
+    const hasModuleFederation = !!entryItemOption.options?.moduleFederation;
+    // Check if the entry item is a library, The library module can not run in the browser individually.
+    const isEntryItemLibrary = !!entryItemOption.options?.output?.library;
+    // Inject `react-refresh` if we are using preset `react`
+    return (serveMode &&
+        evolveOptions.loaderOptions.babelOptions?.usePreset === 'react' &&
+        !hasModuleFederation &&
+        !isEntryItemLibrary &&
+        // No specificed `liveReload` config
+        evolveOptions.devServer?.liveReload !== true);
+};

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

@@ -22,13 +22,13 @@ export declare const autoGroupingReduce: (autoEntries: (EvolveEntryMapContent &
     entryName: string;
 })[], ignoreOptionKeys: (keyof EvolveEntryItemOption)[] | undefined, serveMode: boolean) => Record<string, EvolveEntryMap>;
 /**
- * Assigns group names to entries in the autoGroupingReduceMap based on the projectVirtualPath.
+ * Assigns a group name to each entry in the evolveEntryMapList based on the projectVirtualPath.
  *
- * @param evolveOptions - The FlatEvolveOptions object containing the projectVirtualPath.
- * @param autoGroupingReduceMap - The Record object containing the groupEntryMap for each groupingKey.
- * @returns The Record object with assigned group names for each entry in the autoGroupingReduceMap.
+ * @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 declare const autoAssignGroupName: (evolveOptions: FlatEvolveOptions, autoGroupingReduceMap: Record<string, EvolveEntryMap>) => Record<string, EvolveEntryMap>;
+export declare const autoAssignGroupName: (evolveOptions: FlatEvolveOptions, evolveEntryMapList: Array<EvolveEntryMap>) => 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.

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

@@ -1 +1,139 @@
-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,s]of Object.entries(e)){const e={},u=normalizeGroupName(t,n++);for(const[o,t]of Object.entries(s))t.groupName=u,e[o]=t;r[o]=e}return r};export const autoGrouping=(o,e,t=[],r=maxEntryGroupSize,n)=>{const s=autoGroupingReduce(e,t,n),u=autoAssignGroupName(o,s),i=[];for(const[,o]of Object.entries(u)){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)),{});i.push(n)}else i.push(o)}return i};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)]};
+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];
+};

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

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

package/dist/index.js

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