@flatjs/evolve 1.8.1-next.65 → 1.8.1-next.67

package/dist/helpers/get-git-root.js

@@ -1 +1,4 @@
-import{searchParentDir}from"@armit/package";export const getGitRoot=r=>searchParentDir(r,".git");
+import { searchParentDir } from '@armit/package';
+export const getGitRoot = (searchFrom) => {
+    return searchParentDir(searchFrom, '.git');
+};

package/dist/helpers/get-html-plugin-config.d.ts

@@ -3,10 +3,18 @@ export declare const defaultHtmlPluginConfig: Required<MultiHtmlCDNEntryItem>;
 type Json = undefined | null | boolean | number | string | Json[] | {
     [prop: string]: Json;
 };
+export type HtmlPluginConfigConfigData = {
+    mode: 'development' | 'production';
+    /**
+     * The random `cdn` for config via `env` template
+     */
+    envCdn: string;
+};
+export type HtmlPluginConfigTokenType<T extends Json> = T | ((configData: HtmlPluginConfigConfigData) => T);
 /**
  * 获取html plugin 模版相关定义字段.
  * @param preferredValue 用户首选的值, 如果返回为undefined, 将使用默认值
  * @returns
  */
-export declare const getHtmlPluginConfig: <T extends Json>(key: keyof typeof defaultHtmlPluginConfig, mode: 'development' | 'production', preferredValue?: T | ((mode: 'development' | 'production') => T) | undefined) => T;
+export declare const getHtmlPluginConfig: <T extends Json>(key: keyof typeof defaultHtmlPluginConfig, configData: HtmlPluginConfigConfigData, preferredValue?: HtmlPluginConfigTokenType<T> | undefined) => T;
 export {};

package/dist/helpers/get-html-plugin-config.js

@@ -1 +1,47 @@
-import{polyfill,viewportScripts}from"../constants.js";import{getPackageDir}from"./get-pacakge-dir.js";export const defaultHtmlPluginConfig={title:"",favicon:"",headBeforeHtmlTags:[],inlineScripts:[],headBeforeStyles:[],headBeforeScripts:[...polyfill],bodyAfterScripts:[],viewport:viewportScripts,excludeCdnEnvs:["me","dev","ntv"],htmlMinify:!0,templatePath:getPackageDir("templates/html-plugin/index-{0}.html")};export const getHtmlPluginConfig=(t,e,i)=>{let o;if(void 0!==i&&(o="function"==typeof i?i(e):i),void 0===o){const i=defaultHtmlPluginConfig[t];return"function"==typeof i?i(e):i}return o};
+import { polyfill, viewportScripts } from '../constants.js';
+import { getPackageDir } from './get-pacakge-dir.js';
+export const defaultHtmlPluginConfig = {
+    // The page title
+    title: '',
+    // The page favicon url地址
+    favicon: '',
+    // The customized html tags should be inject to `<header />`
+    headBeforeHtmlTags: [],
+    // Allow us customized inline scripts into compiled html template.
+    inlineScripts: [],
+    // The ordered styles will be injected start of html head.
+    headBeforeStyles: [],
+    // The ordered scripts will be injected before html head.
+    headBeforeScripts: [...polyfill],
+    // The ordered scripts will be injected end of html body.
+    bodyAfterScripts: [],
+    // `allowPx2rem` default is true
+    viewport: viewportScripts,
+    // avoid use cdn `me`, `dev`, `ntv`
+    excludeCdnEnvs: ['me', 'dev', 'ntv'],
+    // `minify` is true, `dev` always don't minify.
+    htmlMinify: true,
+    // Default use It must be an absolute path.
+    templatePath: getPackageDir('templates/html-plugin/index-{0}.html'),
+};
+/**
+ * 获取html plugin 模版相关定义字段.
+ * @param preferredValue 用户首选的值, 如果返回为undefined, 将使用默认值
+ * @returns
+ */
+export const getHtmlPluginConfig = (key, configData, preferredValue) => {
+    let userValue;
+    if (typeof preferredValue !== 'undefined') {
+        userValue =
+            typeof preferredValue === 'function'
+                ? preferredValue(configData)
+                : preferredValue;
+    }
+    if (typeof userValue === 'undefined') {
+        const defaultValue = defaultHtmlPluginConfig[key];
+        return typeof defaultValue === 'function'
+            ? defaultValue(configData)
+            : defaultValue;
+    }
+    return userValue;
+};

package/dist/helpers/get-max-process-tasks.d.ts

@@ -0,0 +1 @@
+export declare const getMaxProcessTasks: (totalTasks: number, maxProcesses?: string | number) => number;

package/dist/helpers/get-max-process-tasks.js

@@ -0,0 +1,7 @@
+import { cpus } from 'node:os';
+export const getMaxProcessTasks = (totalTasks, maxProcesses) => {
+    const maxCpu = Math.max(1, typeof maxProcesses === 'string' && maxProcesses.endsWith('%')
+        ? Math.round((cpus().length * Number(maxProcesses.slice(0, -1))) / 100)
+        : Number(maxProcesses));
+    return totalTasks > maxCpu ? maxCpu : totalTasks;
+};

package/dist/helpers/get-pacakge-dir.js

@@ -1 +1,13 @@
-import{join}from"node:path";import{getDirname}from"@armit/file-utility";import{searchPackageDir}from"@armit/package";export const getPackageDir=(...r)=>{const e=getDirname(import.meta.url),o=searchPackageDir({cwd:e});if(!o)throw new Error("Could not resolve package root for `flatjs/evolve`");return join(o,...r)};
+import { join } from 'node:path';
+import { getDirname } from '@armit/file-utility';
+import { searchPackageDir } from '@armit/package';
+export const getPackageDir = (...paths) => {
+    const dir = getDirname(import.meta.url);
+    const packageDir = searchPackageDir({
+        cwd: dir,
+    });
+    if (!packageDir) {
+        throw new Error('Could not resolve package root for `flatjs/evolve`');
+    }
+    return join(packageDir, ...paths);
+};

package/dist/helpers/index.js

@@ -1 +1,15 @@
-export*from"./allow-px2rem-for-module.js";export*from"./assert-only-single-entry-item.js";export*from"./chunk-entry-map.js";export*from"./enable-bundle-hashname-for-module.js";export*from"./get-bundle-file-name.js";export*from"./get-html-plugin-config.js";export*from"./get-pacakge-dir.js";export*from"./merge-babel-options.js";export*from"./normalize-entry-map.js";export*from"./open-page.js";export*from"./print-log.js";export*from"./refresh-evolve-mock-options.js";export*from"./script-injects.js";export*from"./should-enable-react-fast-refresh.js";export*from"./split-to-multi-compiler.js";
+export * from './allow-px2rem-for-module.js';
+export * from './assert-only-single-entry-item.js';
+export * from './chunk-entry-map.js';
+export * from './enable-bundle-hashname-for-module.js';
+export * from './get-bundle-file-name.js';
+export * from './get-html-plugin-config.js';
+export * from './get-pacakge-dir.js';
+export * from './merge-babel-options.js';
+export * from './normalize-entry-map.js';
+export * from './open-page.js';
+export * from './print-log.js';
+export * from './refresh-evolve-mock-options.js';
+export * from './script-injects.js';
+export * from './should-enable-react-fast-refresh.js';
+export * from './split-to-multi-compiler.js';

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

@@ -1 +1,45 @@
-import{logger,requireResolve}from"@flatjs/common";import{reactBabelPreset,vueBabelPreset}from"@flatjs/evolve-preset-babel";import babelMerge from"babel-merge";import{moduleName}from"../constants.js";export const mergeBabelOption=(e=[],r={usePreset:"react"})=>{const t=e.map((e=>[requireResolve("babel-plugin-import"),{transformToDefaultImport:!1,libraryDirectory:"dist",...e},e.libraryName])),{usePreset:a="react",...l}=r,o="react"===a?reactBabelPreset():"vue"===a?vueBabelPreset():reactBabelPreset();let s={};try{s=babelMerge(o,l),s.plugins?s.plugins.unshift(...t):s.plugins=t}catch(e){logger.error(e,moduleName)}return{...s,babelrc:!1,compact:!1}};
+import { logger, requireResolve } from '@flatjs/common';
+import { reactBabelPreset, vueBabelPreset } from '@flatjs/evolve-preset-babel';
+import babelMerge from 'babel-merge';
+import { moduleName } from '../constants.js';
+export const mergeBabelOption = (modularImports = [], options = { usePreset: 'react' }) => {
+    const babelImports = modularImports.map((importItem) => {
+        return [
+            requireResolve('babel-plugin-import'),
+            {
+                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 `babel-plugin-import` plugins with the same plugin id.
+        // https://github.com/ant-design/babel-plugin-import
+        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-entry-map.js

@@ -1 +1,38 @@
-import{join}from"node:path";import _ from"lodash";export const normalizeEvolveEntryName=(o,e)=>{const r=o.replace(/^\//,""),t=e.replace(/^\//,"");return(r.startsWith(t)?r:join(t,r)).replace(/\/$/,"")};export const normalizeEvolveEntryMap=(o={},e={})=>{const r={};for(const[t,n]of Object.entries(e)){const e={options:{}};o[t]&&(r[t]=_.merge({},e,n,o[t])),_.merge(n,e)}return r};
+import { join } from 'node:path';
+import _ from 'lodash';
+/**
+ * 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
+ */
+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]) {
+            newActivedEntries[entryKey] = _.merge({}, defaultEntryItemConfig, itemConfig, activedEntryMap[entryKey]);
+        }
+        _.merge(itemConfig, defaultEntryItemConfig);
+    }
+    return newActivedEntries;
+};

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,23 @@
-import{loadMockConfig}from"@flatjs/mock";import _ from"lodash";export const refreshEvolveMockOptions=async(o,t,s)=>{const e=t.devServer,n=s?.esmLoaderOptions,r=n?.externals||[],c=await loadMockConfig(o,e?.mockOptions||{},_.merge({},s,{configFile:"flatjs-mock",esmLoaderOptions:{externals:[...r,"@flatjs/mock"]}}));return e&&(e.mockOptions=c||{},e.mockOptions&&!e.mockOptions.https&&(e.mockOptions.https=e?.https)),t};
+import { loadMockConfig } 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 || [];
+    // Try to load mock configuration from `flatjs-mock.config.ts`
+    const newMockOptions = await loadMockConfig(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;
+        }
+    }
+    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,8 @@
-export const shouldEnableReactFastRefresh=(e,t,o)=>{const s=t[1],n=!!s.options?.moduleFederation;return e&&"react"===o.loaderOptions.babelOptions?.usePreset&&!n};
+export const shouldEnableReactFastRefresh = (serveMode, entryMapItem, evolveOptions) => {
+    const entryItemOption = entryMapItem[1];
+    const hasModuleFederation = !!entryItemOption.options?.moduleFederation;
+    // Inject `react-refresh` if we are using preset `react`
+    return (serveMode &&
+        evolveOptions.loaderOptions.babelOptions?.usePreset === 'react' &&
+        !hasModuleFederation);
+};

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

@@ -1 +1,22 @@
-import{mergeOptions}from"@flatjs/common";import{normalizeEvolveEntryName}from"./normalize-entry-map.js";export function splitToMultiCompilerConfigs(e,o,t){const r=[];for(const[o,n]of Object.entries(e)){const e=normalizeEvolveEntryName(o,t.projectVirtualPath);r.push({[e]:n.entry})}return r.map((e=>mergeOptions(o,{name:Object.keys(e)[0],entry:e})))}
+import { mergeOptions } from '@flatjs/common';
+import { normalizeEvolveEntryName } from './normalize-entry-map.js';
+/**
+ * Split the `webpack` to make sure that we have separated compiler process for each module
+ * @param webpackConfig `Omit<Configuration, 'entry'>` webpack final configuration
+ */
+export function splitToMultiCompilerConfigs(servedEntries, webpackConfig, evolveOptions) {
+    const result = [];
+    for (const [entryName, entryItem] of Object.entries(servedEntries)) {
+        // Make sure that we have correct `virtualPath` for each webpack `entry`
+        const normalizedEntryName = normalizeEvolveEntryName(entryName, evolveOptions.projectVirtualPath);
+        result.push({
+            [normalizedEntryName]: entryItem.entry,
+        });
+    }
+    return result.map((newEntry) => {
+        return mergeOptions(webpackConfig, {
+            name: Object.keys(newEntry)[0],
+            entry: newEntry,
+        });
+    });
+}

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';

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 +1,35 @@
-import{mergeOptions,logger,searchConfig}from"@flatjs/common";import{configFileName,moduleName}from"../constants.js";import{defaultEvolveOptions}from"../default-options.js";import{refreshEvolveMockOptions}from"../helpers/refresh-evolve-mock-options.js";export const loadEvolveConfig=async(o,e,t={},n={configFile:configFileName,esmLoaderOptions:{externals:["@flatjs/evolve","@flatjs/mock"]}})=>{const{configFile:i,esmLoaderOptions:s}=n,r=await searchConfig(i,e,{esm:{...s,projectCwd:e}});let l={};l="function"==typeof r?.config?r?.config(o):r?.config||{};const f=mergeOptions(defaultEvolveOptions,l),m=mergeOptions(f,t),a=mergeOptions(m,{projectCwd:e}),c=await refreshEvolveMockOptions(e,a,n);return logger.debug(`Load evolve config:\n${JSON.stringify(c,null,2)}`,moduleName),c};
+import { mergeOptions, logger, searchConfig, } from '@flatjs/common';
+import { configFileName, moduleName } from '../constants.js';
+import { defaultEvolveOptions } from '../default-options.js';
+import { refreshEvolveMockOptions } from '../helpers/refresh-evolve-mock-options.js';
+export const loadEvolveConfig = async (configEnv, projectCwd, overrideOptions = {}, configLoaderOptions = {
+    configFile: configFileName,
+    esmLoaderOptions: {
+        externals: ['@flatjs/evolve', '@flatjs/mock'],
+    },
+}) => {
+    const { configFile, esmLoaderOptions } = configLoaderOptions;
+    const data = await searchConfig(configFile, projectCwd, {
+        esm: {
+            ...esmLoaderOptions,
+            projectCwd,
+        },
+    });
+    let localData = {};
+    if (typeof data?.config === 'function') {
+        localData = 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);
+    return latestEvolveOptions;
+};

package/dist/main/env-verify.js

@@ -1 +1,21 @@
-import{illegalPackageChecker,keepPackageDepsUpToDateForNonMonoRepo}from"@armit/package";export const envVerify=async(e,a)=>{const{packageInstallChecker:o,needVerifyPackages:r}=a;!1!==o&&o?.enabled&&await illegalPackageChecker({cwd:e,modules:o?.detectModules,throwError:o?.throwError,showAllInstalledGraph:o?.showAllInstalledGraph}),!1!==r&&await keepPackageDepsUpToDateForNonMonoRepo({cwd:e,autoUpgrade:!0,needVerifyPackages:r||{}})};
+import { illegalPackageChecker, keepPackageDepsUpToDateForNonMonoRepo, } from '@armit/package';
+export const envVerify = async (projectCwd, evolveOptions) => {
+    const { packageInstallChecker, needVerifyPackages } = evolveOptions;
+    if (packageInstallChecker !== false && packageInstallChecker?.enabled) {
+        // Verify local install node modules
+        await illegalPackageChecker({
+            cwd: projectCwd,
+            modules: packageInstallChecker?.detectModules,
+            throwError: packageInstallChecker?.throwError,
+            showAllInstalledGraph: packageInstallChecker?.showAllInstalledGraph,
+        });
+    }
+    if (needVerifyPackages !== false) {
+        // Keep package deps up to date for non-monorepo
+        await keepPackageDepsUpToDateForNonMonoRepo({
+            cwd: projectCwd,
+            autoUpgrade: true,
+            needVerifyPackages: needVerifyPackages || {},
+        });
+    }
+};

package/dist/main/index.js

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

package/dist/main/prepare-build.d.ts

@@ -1,13 +1,9 @@
-import { type EvolveEntryMap } from '../types/types-entry-map.js';
+import { type EntryMapItem } from '../types/types-entry-map.js';
 import { type FlatEvolveOptions } from '../types/types-options.js';
-export type EvolveBuildResult = {
-    name?: string;
-    warningStats?: unknown;
-};
+import { type EvolveBuildResult } from './start-one-entry-build.js';
 /**
  * The main entry to start an evolve `build`
- * @param buildEntries All webpack entries we prepare to build.
+ * @param entryMapItem The `entryMapItem` for one entry build task
  * @param evolveOptions FlatEvolveOptions
- * @param clearCache The value indicates if we need to clear webpack cache resources.
  */
-export declare const prepareBuild: (projectCwd: string, buildEntries: EvolveEntryMap, evolveOptions: FlatEvolveOptions) => Promise<EvolveBuildResult[]>;
+export declare const prepareBuild: (entryMapItem: EntryMapItem, evolveOptions: FlatEvolveOptions) => Promise<EvolveBuildResult>;

package/dist/main/prepare-build.js

@@ -1 +1,38 @@
-import{cpus}from"node:os";import{ensureSlash,logger,mergeOptions}from"@flatjs/common";import ora from"ora";import webpack from"webpack";import{loadWebpackConfig}from"../create-webpack/load-webpack-config.js";import{EvolveBuildError}from"../errors/evolve-build-error.js";import{chunkEntryMap}from"../helpers/chunk-entry-map.js";import{printCompilerError}from"../helpers/print-log.js";import{splitToMultiCompilerConfigs}from"../helpers/split-to-multi-compiler.js";import{envVerify}from"./env-verify.js";const getMaxProcessTasks=(r,o)=>Math.max(1,"string"==typeof o&&o.endsWith("%")?Math.round(cpus().length*Number(o.slice(0,-1))/100):Number(o)||r),startSingleEntryBuild=async(r,o)=>{const t=await loadWebpackConfig("production",r,o),e=splitToMultiCompilerConfigs(r,t,o);if(e.length>1)throw new Error("startSingleEntryBuild() only support `compiler` at a time");const n=e[0];return new Promise(((r,t)=>{webpack(n,((e,s)=>{if(e)return t(e);const i=s?.toJson();return i?.errors?.length?t(i.errors):o.rejectWarnings&&i?.warnings?.length?t(i.warnings):void r({name:n.name,warningStats:i?.warnings})}))}))};export const prepareBuild=async(r,o,t)=>{await envVerify(r,t);const e=t.multiHtmlCdn?.prod||[];if(!e.length)throw new Error('No CDN configuration for env: "prod"');const n=ensureSlash(e[Math.floor(Math.random()*e.length)],!0),s=[],i=chunkEntryMap(o,getMaxProcessTasks(Object.keys(o).length,t.maxProcesses)),a=i.length;logger.info(`Preparing to run total ${a} tasks...`);for(let r=0;r<a;r++){const o=ora(`Run building task id:${r+1} ...`).start();try{const e=i[r],a=[];for(const[r,o]of Object.entries(e)){const e={[r]:o},s=o.options?.useRelativeAssetPath;a.push(startSingleEntryBuild(e,mergeOptions(t,{webpack:{publicPath:s?"auto":n}})))}const l=await Promise.all(a);s.push(...l),o.succeed()}catch(r){o.fail();const t=printCompilerError(r);throw new EvolveBuildError("BUILD_ERROR",t)}}return s};
+import { ensureSlash, mergeOptions } from '@flatjs/common';
+import { EvolveBuildError } from '../errors/evolve-build-error.js';
+import { printCompilerError } from '../helpers/print-log.js';
+import { startOneEntryBuild, } from './start-one-entry-build.js';
+/**
+ * The main entry to start an evolve `build`
+ * @param entryMapItem The `entryMapItem` for one entry build task
+ * @param evolveOptions FlatEvolveOptions
+ */
+export const prepareBuild = async (entryMapItem, evolveOptions) => {
+    const [entryKey, entryConfig] = entryMapItem;
+    // Fetch all configuration cdn
+    const cdnPath = evolveOptions.multiHtmlCdn?.prod || [];
+    if (!cdnPath.length) {
+        throw new Error(`No CDN config for env:"prod", moduleName: ${entryKey}`);
+    }
+    // Random choose one to publicPath
+    const cdnPublicPath = ensureSlash(cdnPath[Math.floor(Math.random() * cdnPath.length)], true);
+    // Construct single entry map item to build.
+    const toBuildEntryMapItem = {
+        [entryKey]: entryConfig,
+    };
+    try {
+        const useRelativeAssetPath = entryConfig.options?.useRelativeAssetPath;
+        const buildEvolveOptions = mergeOptions(evolveOptions, {
+            webpack: {
+                // Only for `assets` used at styling files (e.g.`xxx.less`)
+                publicPath: useRelativeAssetPath ? 'auto' : cdnPublicPath,
+            },
+        });
+        return await startOneEntryBuild(toBuildEntryMapItem, buildEvolveOptions);
+    }
+    catch (err) {
+        const formattedErrors = printCompilerError(err);
+        // Need re-throw error, in order to third API can capture this error.
+        throw new EvolveBuildError(`BUILD_ERROR`, formattedErrors);
+    }
+};

package/dist/main/prepare-serve.js

@@ -1 +1,36 @@
-import{urlJoin}from"@flatjs/common";import{attachMockMiddlewares}from"@flatjs/mock";import{createAppPageRoute,createDevServer,createDevServerCompilerTasks,createDevServerEntries}from"../dev-server/index.js";import{openPage}from"../helpers/index.js";import{envVerify}from"./env-verify.js";export const prepareServe=async(e,r,t)=>{await envVerify(e,t);const{app:a,devPort:o,devHostUri:i}=await createDevServer(t);await attachMockMiddlewares(a,{...t.devServer?.mockOptions,projectCwd:e});const s=await createDevServerEntries(o,r,t);createAppPageRoute(e,a,i,s,t);const v=urlJoin(i,["/pages"]);t.devServer?.autoOpen&&openPage(v);const p=await createDevServerCompilerTasks(e,v,s,t);return Promise.all(p).then((()=>a))};
+import { urlJoin } from '@flatjs/common';
+import { attachMockMiddlewares } from '@flatjs/mock';
+import { createAppPageRoute, createDevServer, createDevServerCompilerTasks, createDevServerEntries, } from '../dev-server/index.js';
+import { openPage } from '../helpers/index.js';
+import { envVerify } from './env-verify.js';
+/**
+ * The main entry to start evolve serve
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param servedEntries All normalized webpack entries we have served.
+ * @param evolveOptions FlatEvolveOptions
+ */
+export const prepareServe = async (projectCwd, servedEntries, evolveOptions) => {
+    // Verify if we have an correct project local environment.
+    await envVerify(projectCwd, evolveOptions);
+    // Create pure dev server.
+    const { app, devPort, devHostUri } = await createDevServer(evolveOptions);
+    // Attach core handlers for mock
+    await attachMockMiddlewares(app, {
+        ...evolveOptions.devServer?.mockOptions,
+        projectCwd,
+    });
+    // Create dev-server configurationn for all servedEntries.
+    const servedDevServerEntries = await createDevServerEntries(devPort, servedEntries, evolveOptions);
+    // Create new route `/pages*`,`*` to pure dev server
+    createAppPageRoute(projectCwd, app, devHostUri, servedDevServerEntries, evolveOptions);
+    const mainPage = urlJoin(devHostUri, ['/pages']);
+    // Open page via browser
+    if (evolveOptions.devServer?.autoOpen) {
+        openPage(mainPage);
+    }
+    // Create dev-server compiler tasks
+    const serveTasks = await createDevServerCompilerTasks(projectCwd, mainPage, servedDevServerEntries, evolveOptions);
+    return Promise.all(serveTasks).then(() => {
+        return app;
+    });
+};

package/dist/main/prepare-static.js

@@ -1 +1,28 @@
-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{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=urlJoin(o,["/pages"]);r.devServer?.autoOpen&&openPage(t),logger.info(`${"static page".padEnd(12," ")} ➩ ${chalk(["cyan"])(t)}`)};
+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 { 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 mainPage = urlJoin(devHostUri, ['/pages']);
+    // 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.