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

package/dist/main/start-build-dynamic.d.ts

@@ -1,6 +1,7 @@
 import { type PartialDeep } from 'type-fest';
 import { type ConfigLoaderOptions } from '../load-config/load-evolve-config.js';
 import { type FlatEvolveOptions } from '../types/types-options.js';
+import { type EvolveBuildResult } from './start-one-entry-build.js';
 export declare function getBuildEntryFiles(projectCwd: string, diffFiles: string[], allEntryInputs: string[]): Promise<string[]>;
 /**
  * Dynamic check which entry modules need to build.
@@ -16,4 +17,4 @@ export declare function dynamicCheckBuildEntryMap(projectCwd: string, earlyCommi
  * @param earlyCommit The diff based earlier commit hash
  * @param lastCommit If is omitted, it will have the same effect as using HEAD instead.
  */
-export declare const startDynamicBuild: (projectCwd: string, earlyCommit?: string, lastCommit?: string, overrideEvolveOptions?: PartialDeep<FlatEvolveOptions>, configLoaderOptions?: ConfigLoaderOptions) => Promise<import("./prepare-build.js").EvolveBuildResult[]>;
+export declare const startDynamicBuild: (projectCwd: string, earlyCommit?: string, lastCommit?: string, overrideEvolveOptions?: PartialDeep<FlatEvolveOptions>, configLoaderOptions?: ConfigLoaderOptions) => Promise<EvolveBuildResult[]>;

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

@@ -1 +1,144 @@
-import{isAbsolute,join}from"node:path";import{getDiffFiles,getCommitIdOfBranch}from"@armit/git";import{arraysIntersect,logger}from"@flatjs/common";import{traverseGraph}from"@flatjs/graph";import{filterActivedEntriesByEntryInputs,filterActivedEntriesByModule}from"../helpers/filter-actived-entries.js";import{getGitRoot}from"../helpers/get-git-root.js";import{normalizeEvolveEntryMap}from"../helpers/normalize-entry-map.js";import{resolveEntryMapInputFiles}from"../helpers/resolve-entry-map-input-files.js";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{prepareBuild}from"./prepare-build.js";export async function getBuildEntryFiles(e,t,i){const r=[],n=[];for(const e of i)t.includes(e)?r.push(e):n.push(e);if(n.length){const i=await traverseGraph({input:n,projectCwd:e,treeNodeFilter:()=>!0});if(!i)return r;logger.debug(`DependencyGraph:\n${JSON.stringify(i,null,2)}`);for(const e of n){const n=i[e]||[];arraysIntersect(n,t)&&r.push(e)}}return r}export async function dynamicCheckBuildEntryMap(e,t,i,r,n){const o=await loadEvolveConfig({command:"build"},e,r,n);if(o.ci?.fixedBuildModules&&o.ci?.fixedBuildModules.length){logger.info("Use `fixedBuildModules` configuration to build...");return{buildEntries:filterActivedEntriesByModule(o.entryMap,o.ci?.fixedBuildModules),newEvolveOptions:o}}if(logger.info("Dynamicly checking code changed modules ..."),!t){const e=o.ci?.basedBranch||"master";logger.info(`Resolving base branch "${e}" commit hash ...`),t=await getCommitIdOfBranch(e)}let l=t?await getDiffFiles(t,i):[];const s=getGitRoot(e);if(!s)throw new Error(`No .git root (${e}) found`);if(l=l.map((e=>isAbsolute(e)?e:join(s,e))),logger.debug(`Diff files: \n${JSON.stringify(l,null,2)}`),!l.length)return logger.warn("It seems that there are no code files changed."),{buildEntries:{},newEvolveOptions:o};const a=await resolveEntryMapInputFiles(e,o.entryMap),d=await getBuildEntryFiles(e,l,a);logger.debug(`To build entry files: \n${JSON.stringify(d,null,2)}`);return{buildEntries:await filterActivedEntriesByEntryInputs(e,o.entryMap,d),newEvolveOptions:o}}export const startDynamicBuild=async(e,t,i,r={},n)=>{const{buildEntries:o,newEvolveOptions:l}=await dynamicCheckBuildEntryMap(e,t,i,r,n),s=Object.keys(o);if(!s.length)return logger.warn("No build entries providered!"),[];logger.info(`Start dynamic build:\n${JSON.stringify({buildEntries:s},null,2)}`);const a=normalizeEvolveEntryMap(o,l.entryMap);return prepareBuild(e,a,l)};
+import { isAbsolute, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getDirname } from '@armit/file-utility';
+import { getDiffFiles, getCommitIdOfBranch } from '@armit/git';
+import { createThreadPool } from '@armit/worker-threads';
+import { arraysIntersect, chalk, logger } from '@flatjs/common';
+import { traverseGraph } from '@flatjs/graph';
+import Listr from 'listr';
+import { filterActivedEntriesByEntryInputs, filterActivedEntriesByModule, } from '../helpers/filter-actived-entries.js';
+import { getGitRoot } from '../helpers/get-git-root.js';
+import { getMaxProcessTasks } from '../helpers/get-max-process-tasks.js';
+import { resolveEntryMapInputFiles } from '../helpers/resolve-entry-map-input-files.js';
+import { loadEvolveConfig, } from '../load-config/load-evolve-config.js';
+import { envVerify } from './env-verify.js';
+export async function getBuildEntryFiles(projectCwd, diffFiles, allEntryInputs) {
+    const toBuildEntryFiles = [];
+    const entryInputsPendingToCheck = [];
+    for (const entryInput of allEntryInputs) {
+        // If entry have been existed in diff files, need to rebuild.
+        if (diffFiles.includes(entryInput)) {
+            toBuildEntryFiles.push(entryInput);
+        }
+        else {
+            entryInputsPendingToCheck.push(entryInput);
+        }
+    }
+    // If there has pedding entry inputs to check.
+    if (entryInputsPendingToCheck.length) {
+        const graphDeps = await traverseGraph({
+            input: entryInputsPendingToCheck,
+            projectCwd,
+            treeNodeFilter: () => true,
+        });
+        if (!graphDeps) {
+            return toBuildEntryFiles;
+        }
+        logger.debug(`DependencyGraph:\n${JSON.stringify(graphDeps, null, 2)}`);
+        for (const entryInputToCheck of entryInputsPendingToCheck) {
+            const dependsFiles = graphDeps[entryInputToCheck] || [];
+            if (arraysIntersect(dependsFiles, diffFiles)) {
+                toBuildEntryFiles.push(entryInputToCheck);
+            }
+        }
+    }
+    return toBuildEntryFiles;
+}
+/**
+ * Dynamic check which entry modules need to build.
+ * @returns
+ */
+export async function dynamicCheckBuildEntryMap(projectCwd, earlyCommit, lastCommit, overrideEvolveOptions, configLoaderOptions) {
+    const command = {
+        command: 'build',
+    };
+    // 1. Try to load evolve configuration from `flatjs-evolve.config.ts`
+    const newEvolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    // 2. Check if we have fixed build modules.
+    if (newEvolveOptions.ci?.fixedBuildModules &&
+        newEvolveOptions.ci?.fixedBuildModules.length) {
+        logger.info('Use `fixedBuildModules` configuration to build...');
+        const buildEntries = filterActivedEntriesByModule(newEvolveOptions.entryMap, newEvolveOptions.ci?.fixedBuildModules);
+        return { buildEntries, newEvolveOptions };
+    }
+    logger.info('Dynamicly checking code changed modules ...');
+    // 3. Resolve diff files based on specificed branch.
+    // Check if we have fixed `early commit` if no resolve based on `Branch` from evolve config file.
+    if (!earlyCommit) {
+        const basedBranch = newEvolveOptions.ci?.basedBranch || 'master';
+        // Try resolve based branch commit hash.
+        logger.info(`Resolving base branch "${basedBranch}" commit hash ...`);
+        earlyCommit = await getCommitIdOfBranch(basedBranch);
+    }
+    // `packages/evolve/tests/main/fixtures/src/home/index.ts` without repo cwd.
+    let diffFiles = earlyCommit
+        ? await getDiffFiles(earlyCommit, lastCommit)
+        : [];
+    const gitRoot = getGitRoot(projectCwd);
+    if (!gitRoot) {
+        throw new Error(`No .git root (${projectCwd}) found`);
+    }
+    // Hack diff files with git repo root dir.
+    diffFiles = diffFiles.map((diffFile) => {
+        return isAbsolute(diffFile) ? diffFile : join(gitRoot, diffFile);
+    });
+    logger.debug(`Diff files: \n${JSON.stringify(diffFiles, null, 2)}`);
+    // No code changed here.
+    if (!diffFiles.length) {
+        logger.warn('It seems that there are no code files changed.');
+        return {
+            buildEntries: {},
+            newEvolveOptions,
+        };
+    }
+    // 4. Resolve entry input files.
+    const allEntryInputs = await resolveEntryMapInputFiles(projectCwd, newEvolveOptions.entryMap);
+    // 5. Flag changed entries (with absolute filepath)
+    const toBuildEntryFiles = await getBuildEntryFiles(projectCwd, diffFiles, allEntryInputs);
+    logger.debug(`To build entry files: \n${JSON.stringify(toBuildEntryFiles, null, 2)}`);
+    // 6. Filter entry map items which need to build.
+    const buildEntries = await filterActivedEntriesByEntryInputs(projectCwd, newEvolveOptions.entryMap, toBuildEntryFiles);
+    return { buildEntries, newEvolveOptions };
+}
+/**
+ * The main entry to start an evolve `build` with automatically detect modules which have been changed between two commits.
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param earlyCommit The diff based earlier commit hash
+ * @param lastCommit If is omitted, it will have the same effect as using HEAD instead.
+ */
+export const startDynamicBuild = async (projectCwd, earlyCommit, lastCommit, overrideEvolveOptions = {}, configLoaderOptions) => {
+    // 1. Fetch all changed files betwwen two `commit`
+    const { buildEntries, newEvolveOptions } = await dynamicCheckBuildEntryMap(projectCwd, earlyCommit, lastCommit, overrideEvolveOptions, configLoaderOptions);
+    await envVerify(projectCwd, newEvolveOptions);
+    const buildEntryKeys = Object.keys(buildEntries);
+    // Make sure that we have at least one build entry module.
+    if (!buildEntryKeys.length) {
+        logger.warn(`No build entries providered!`);
+        return [];
+    }
+    logger.info(`Start dynamic build:\n${JSON.stringify({ buildEntries: buildEntryKeys }, null, 2)}`);
+    const workerSize = getMaxProcessTasks(buildEntryKeys.length, newEvolveOptions.maxProcesses);
+    const workerPath = pathToFileURL(getDirname(import.meta.url, './start-build-worker.js')).toString();
+    const worker = await createThreadPool(workerPath, {
+        size: workerSize,
+    });
+    const buildTasks = new Listr([], {
+        concurrent: true,
+        exitOnError: true,
+    });
+    const buildResults = [];
+    for (const [entryKey] of Object.entries(buildEntries)) {
+        buildTasks.add({
+            title: `Build module ${chalk(['magenta'])(entryKey)} ...`,
+            task: async () => {
+                const buildResult = await worker.startBuildWorker(projectCwd, entryKey, overrideEvolveOptions, configLoaderOptions);
+                buildResults.push(buildResult);
+            },
+        });
+    }
+    if (buildTasks.tasks.length) {
+        await buildTasks.run();
+    }
+    worker.pool.terminate();
+    return buildResults;
+};

package/dist/main/start-build-worker.d.ts

@@ -0,0 +1,14 @@
+import { type PartialDeep } from 'type-fest';
+import { type ConfigLoaderOptions } from '../load-config/load-evolve-config.js';
+import { type FlatEvolveOptions } from '../types/types-options.js';
+import { type EvolveBuildResult } from './start-one-entry-build.js';
+/**
+ * FIXME: The main entry to start an evolve `build`, NOTE: avoid pass configuration with `function` here.
+ * If you need to call build api avoid `worker` you can directly call `prepareBuild`
+ * @internal
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param entryKey The `entryKey` for one entry build task
+ * @param overrideEvolveOptions The overrided evolve options, NOTE: avoid pass configuration with `function` here.
+ * @param configLoaderOptions Evolve config loader options, NOTE: avoid pass configuration with `function` here.
+ */
+export declare const startBuildWorker: (projectCwd: string, entryKey: string, overrideEvolveOptions?: PartialDeep<FlatEvolveOptions>, configLoaderOptions?: ConfigLoaderOptions) => Promise<EvolveBuildResult>;

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

@@ -0,0 +1,41 @@
+import { filterActivedEntriesByModule } from '../helpers/filter-actived-entries.js';
+import { normalizeEvolveEntryMap } from '../helpers/normalize-entry-map.js';
+import { loadEvolveConfig, } from '../load-config/load-evolve-config.js';
+import { prepareBuild } from './prepare-build.js';
+/**
+ * FIXME: The main entry to start an evolve `build`, NOTE: avoid pass configuration with `function` here.
+ * If you need to call build api avoid `worker` you can directly call `prepareBuild`
+ * @internal
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param entryKey The `entryKey` for one entry build task
+ * @param overrideEvolveOptions The overrided evolve options, NOTE: avoid pass configuration with `function` here.
+ * @param configLoaderOptions Evolve config loader options, NOTE: avoid pass configuration with `function` here.
+ */
+export const startBuildWorker = async (projectCwd, entryKey, overrideEvolveOptions = {}, configLoaderOptions) => {
+    const command = {
+        command: 'build',
+    };
+    // Try to load evolve configuration from `flatjs-evolve.config.ts`
+    // FIXME: Cause of `worker-theads` do not support pass configuration with `function` reference.
+    const newEvolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    // FIXME: Cause of `worker threads` we need avoid pass entryItem config directly
+    // because we have some config node item with `function`
+    // It will break `worker threads` comunication, e.g below shown.
+    // DataCloneError: function (url) {
+    //   if (url.indexOf('dev.flatjs.com') > 0) return 'me';
+    //   if (url.indexOf('.qa.') > 0) retur...<omitted>... } could not be cloned.
+    //   at new DOMException (node:internal/per_context/domexception:53:5)
+    // So we need to re cacalculate the build entry via `entryKey`
+    const buildOneEntry = filterActivedEntriesByModule(newEvolveOptions.entryMap, [
+        // Make sure that the entryKey is correct match.
+        new RegExp(`^${entryKey}$`),
+    ]);
+    const buildEntryKeys = Object.keys(buildOneEntry);
+    // Make sure that we have at least one build entry module.
+    if (!buildEntryKeys.length) {
+        throw new Error(`No build entry resolved via "${entryKey}" on "startBuildWorker"!`);
+    }
+    const normalizedBuildOneEntry = normalizeEvolveEntryMap(buildOneEntry, newEvolveOptions.entryMap);
+    const buildEntryConfig = normalizedBuildOneEntry[entryKey];
+    return prepareBuild([entryKey, buildEntryConfig], newEvolveOptions);
+};

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

@@ -1,12 +1,5 @@
 import { type PartialDeep } from 'type-fest';
 import { type ConfigLoaderOptions } from '../load-config/load-evolve-config.js';
 import { type FlatEvolveOptions } from '../types/types-options.js';
-import { type EvolveBuildResult } from './prepare-build.js';
-/**
- * The main entry to start an evolve `build`
- * @param projectCwd The Root directory (workspace) of this project.
- * @param buildModules The filter pattern to detect modules we want to build.
- * @param overrideEvolveOptions The overrided evolve options
- * @param configLoaderOptions Evolve config loader options
- */
+import { type EvolveBuildResult } from './start-one-entry-build.js';
 export declare const startBuild: (projectCwd: string, buildModules: string[], overrideEvolveOptions?: PartialDeep<FlatEvolveOptions>, configLoaderOptions?: ConfigLoaderOptions) => Promise<EvolveBuildResult[]>;

package/dist/main/start-build.js

@@ -1 +1,49 @@
-import{logger}from"@flatjs/common";import{filterActivedEntriesByModule}from"../helpers/filter-actived-entries.js";import{normalizeEvolveEntryMap}from"../helpers/normalize-entry-map.js";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{prepareBuild}from"./prepare-build.js";export const startBuild=async(r,e,o={},i)=>{const t=await loadEvolveConfig({command:"build"},r,o,i),l=filterActivedEntriesByModule(t.entryMap,e),n=Object.keys(l);if(!n.length)return logger.warn("No build entries providered!"),[];logger.info(`Start normal build:\n${JSON.stringify({buildEntries:n},null,2)}`);const a=normalizeEvolveEntryMap(l,t.entryMap);return prepareBuild(r,a,t)};
+import { pathToFileURL } from 'node:url';
+import { getDirname } from '@armit/file-utility';
+import { createThreadPool } from '@armit/worker-threads';
+import { chalk, logger } from '@flatjs/common';
+import Listr from 'listr';
+import { filterActivedEntriesByModule } from '../helpers/filter-actived-entries.js';
+import { getMaxProcessTasks } from '../helpers/get-max-process-tasks.js';
+import { loadEvolveConfig, } from '../load-config/load-evolve-config.js';
+import { envVerify } from './env-verify.js';
+export const startBuild = async (projectCwd, buildModules, overrideEvolveOptions = {}, configLoaderOptions) => {
+    const command = {
+        command: 'build',
+    };
+    // Try to load evolve configuration from `flatjs-evolve.config.ts`
+    const newEvolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    await envVerify(projectCwd, newEvolveOptions);
+    const buildEntries = filterActivedEntriesByModule(newEvolveOptions.entryMap, buildModules);
+    const buildEntryKeys = Object.keys(buildEntries);
+    // Make sure that we have at least one build entry module.
+    if (!buildEntryKeys.length) {
+        logger.warn(`No build entries providered!`);
+        return [];
+    }
+    logger.info(`Start standard build:\n${JSON.stringify({ buildEntries: buildEntryKeys }, null, 2)}`);
+    const workerSize = getMaxProcessTasks(buildEntryKeys.length, newEvolveOptions.maxProcesses);
+    const workerPath = pathToFileURL(getDirname(import.meta.url, './start-build-worker.js')).toString();
+    const worker = await createThreadPool(workerPath, {
+        size: workerSize,
+    });
+    const buildTasks = new Listr([], {
+        concurrent: true,
+        exitOnError: true,
+    });
+    const buildResults = [];
+    for (const [entryKey] of Object.entries(buildEntries)) {
+        buildTasks.add({
+            title: `Build module ${chalk(['magenta'])(entryKey)} ...`,
+            task: async () => {
+                const buildResult = await worker.startBuildWorker(projectCwd, entryKey, overrideEvolveOptions, configLoaderOptions);
+                buildResults.push(buildResult);
+            },
+        });
+    }
+    if (buildTasks.tasks.length) {
+        await buildTasks.run();
+    }
+    worker.pool.terminate();
+    return buildResults;
+};

package/dist/main/start-one-entry-build.d.ts

@@ -0,0 +1,13 @@
+import { type EvolveEntryMap } from '../types/types-entry-map.js';
+import { type FlatEvolveOptions } from '../types/types-options.js';
+export type EvolveBuildResult = {
+    name?: string;
+    warningStats?: unknown;
+};
+/**
+ * The helpers to build one entry at a time
+ * @param singleBuildEntry The single entry
+ * @param buildPublicPath
+ * @param evolveOptions
+ */
+export declare const startOneEntryBuild: (singleBuildEntry: EvolveEntryMap, evolveOptions: FlatEvolveOptions) => Promise<EvolveBuildResult>;

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

@@ -0,0 +1,35 @@
+import webpack from 'webpack';
+import { loadWebpackConfig } from '../create-webpack/load-webpack-config.js';
+import { splitToMultiCompilerConfigs } from '../helpers/split-to-multi-compiler.js';
+/**
+ * The helpers to build one entry at a time
+ * @param singleBuildEntry The single entry
+ * @param buildPublicPath
+ * @param evolveOptions
+ */
+export const startOneEntryBuild = async (singleBuildEntry, evolveOptions) => {
+    // Try to load webpack configuration
+    const webpackConfig = await loadWebpackConfig('production', singleBuildEntry, evolveOptions);
+    const compilerConfigs = splitToMultiCompilerConfigs(singleBuildEntry, webpackConfig, evolveOptions);
+    if (compilerConfigs.length > 1) {
+        throw new Error('startOneEntryBuild() only support `compiler` at a time');
+    }
+    const currCompiler = compilerConfigs[0];
+    // Run the single build.
+    return new Promise((resolve, reject) => {
+        webpack(currCompiler, (err, stats) => {
+            if (err) {
+                // Handle errors here
+                return reject(err);
+            }
+            const statsJson = stats?.toJson();
+            if (statsJson?.errors?.length) {
+                return reject(statsJson.errors);
+            }
+            if (evolveOptions.rejectWarnings && statsJson?.warnings?.length) {
+                return reject(statsJson.warnings);
+            }
+            resolve({ name: currCompiler.name, warningStats: statsJson?.warnings });
+        });
+    });
+};

package/dist/main/start-serve.js

@@ -1 +1,32 @@
-import{logger}from"@flatjs/common";import{filterActivedEntriesByModule}from"../helpers/filter-actived-entries.js";import{normalizeEvolveEntryMap}from"../helpers/normalize-entry-map.js";import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{prepareServe}from"./prepare-serve.js";export const startServe=async(e,r,o={},t)=>{const n=await loadEvolveConfig({command:"serve"},e,o,t),i=filterActivedEntriesByModule(n.entryMap,r),l=Object.keys(i);if(!l.length)return logger.warn("No served entries providered!"),[];logger.info({servedEntries:l});const a=normalizeEvolveEntryMap(i,n.entryMap);return prepareServe(e,a,n)};
+import { logger } from '@flatjs/common';
+import { filterActivedEntriesByModule } from '../helpers/filter-actived-entries.js';
+import { normalizeEvolveEntryMap } from '../helpers/normalize-entry-map.js';
+import { loadEvolveConfig, } from '../load-config/load-evolve-config.js';
+import { prepareServe } from './prepare-serve.js';
+/**
+ * The main entry to start evolve serve
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param serveModules The filter pattern to detect modules we want to serve.
+ * @param overrideEvolveOptions The overrided evolve options
+ * @param configLoaderOptions Evolve config loader options
+ */
+export const startServe = async (projectCwd, serveModules, overrideEvolveOptions = {}, configLoaderOptions) => {
+    const command = {
+        command: 'serve',
+    };
+    // Try to load evolve configuration from `flatjs-evolve.config.ts`
+    const evolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    const servedEntries = filterActivedEntriesByModule(evolveOptions.entryMap, serveModules);
+    const servedEntryKeys = Object.keys(servedEntries);
+    // Make sure that we have at least one serve entry module.
+    if (!servedEntryKeys.length) {
+        logger.warn(`No served entries providered!`);
+        return [];
+    }
+    logger.info({
+        servedEntries: servedEntryKeys,
+    });
+    // Normalized served entries to make sure we have latested entry options.
+    const normalizedServedEntries = normalizeEvolveEntryMap(servedEntries, evolveOptions.entryMap);
+    return prepareServe(projectCwd, normalizedServedEntries, evolveOptions);
+};

package/dist/main/start-static.js

@@ -1 +1,16 @@
-import{loadEvolveConfig}from"../load-config/load-evolve-config.js";import{prepareStatic}from"./prepare-static.js";export const startStatic=async(o,t={},a)=>{const r=await loadEvolveConfig({command:"static"},o,t,a);return prepareStatic(o,r)};
+import { loadEvolveConfig, } from '../load-config/load-evolve-config.js';
+import { prepareStatic } from './prepare-static.js';
+/**
+ * The main entry to start evolve static server to proxy all modules of `production` build
+ * @param projectCwd The Root directory (workspace) of this project.
+ * @param overrideEvolveOptions The overrided evolve options
+ * @param configLoaderOptions Evolve config loader options
+ */
+export const startStatic = async (projectCwd, overrideEvolveOptions = {}, configLoaderOptions) => {
+    const command = {
+        command: 'static',
+    };
+    // Try to load evolve configuration from `flatjs-evolve.config.ts`
+    const evolveOptions = await loadEvolveConfig(command, projectCwd, overrideEvolveOptions, configLoaderOptions);
+    return prepareStatic(projectCwd, evolveOptions);
+};

package/dist/minimizer/create-minimizers.js

@@ -1 +1,25 @@
-import{logger}from"@flatjs/common";import{moduleName}from"../constants.js";import{printInfo}from"../helpers/print-log.js";import{imageMinimizer}from"./image-minimizer.js";import{terserMinimizer}from"./terser-minimizer.js";export const createMinimizers=(i,r)=>{const e=[];if(i)return logger.debug("Ignore minimizer plugin for `serve` mode",moduleName),e;if(!1===r?.minimizer)return printInfo("Note `minimizer` has been disabled for now"),e;const m=imageMinimizer();m&&r?.minimizer?.imageMin&&e.push(m);const n=terserMinimizer(r?.minimizer?.terserOptions||{});return e.push(n),e};
+import { logger } from '@flatjs/common';
+import { moduleName } from '../constants.js';
+import { printInfo } from '../helpers/print-log.js';
+import { imageMinimizer } from './image-minimizer.js';
+import { terserMinimizer } from './terser-minimizer.js';
+export const createMinimizers = (serveMode, webpackOptions) => {
+    const minimizers = [];
+    if (serveMode) {
+        logger.debug('Ignore minimizer plugin for `serve` mode', moduleName);
+        return minimizers;
+    }
+    if (webpackOptions?.minimizer === false) {
+        printInfo('Note `minimizer` has been disabled for now');
+        return minimizers;
+    }
+    if (webpackOptions?.minimizer?.imageMin) {
+        const imageMinPlugin = imageMinimizer();
+        if (imageMinPlugin) {
+            minimizers.push(imageMinPlugin);
+        }
+    }
+    const terserPlugin = terserMinimizer(webpackOptions?.minimizer?.terserOptions || {});
+    minimizers.push(terserPlugin);
+    return minimizers;
+};

package/dist/minimizer/default-options.js

@@ -1 +1,14 @@
-export const defaultTerserOptions={ecma:void 0,parse:{},compress:{},mangle:!0,module:!1,output:void 0,toplevel:!1,ie8:!1,keep_classnames:void 0,keep_fnames:!1,safari10:!1};
+export const defaultTerserOptions = {
+    ecma: undefined,
+    parse: {},
+    compress: {},
+    // Note `mangle.properties` is `false` by default.
+    mangle: true,
+    module: false,
+    output: undefined,
+    toplevel: false,
+    ie8: false,
+    keep_classnames: undefined,
+    keep_fnames: false,
+    safari10: false,
+};

package/dist/minimizer/image-minimizer.js

@@ -1 +1,56 @@
-import{projectHasYarn}from"@armit/package";import{chalk,logger,requireResolve}from"@flatjs/common";import ImageMinimizerPlugin from"image-minimizer-webpack-plugin";import{moduleName}from"../constants.js";const logs=new Map;export const imageMinimizer=()=>{const e=[["svgo",{}],["gifsicle",{}],["jpegtran",{}],["pngquant",{}]].map((e=>{const i=e[0];try{return requireResolve(`imagemin-${i}`),e}catch(e){if(!logs.get(i)){logs.set(i,!0);const e=chalk(["magenta"])(`"${projectHasYarn()?"yarn add":"npm install"} imagemin-${i} -D"`);logger.warn(`Execute ${e} for assets optimization`,moduleName)}return null}})).filter(Boolean);return e.length?new ImageMinimizerPlugin({minimizer:{implementation:ImageMinimizerPlugin.imageminMinify,options:{plugins:e}}}):null};
+import { projectHasYarn } from '@armit/package';
+import { chalk, logger, requireResolve } from '@flatjs/common';
+import ImageMinimizerPlugin from 'image-minimizer-webpack-plugin';
+import { moduleName } from '../constants.js';
+const logs = new Map();
+/**
+ * brew install libpng
+ * brew install gifsicle
+ * @returns
+ */
+export const imageMinimizer = () => {
+    const suggestedPlugins = [
+        // Svgo configuration here https://github.com/svg/svgo#configuration
+        ['svgo', {}],
+        ['gifsicle', {}],
+        ['jpegtran', {}],
+        ['pngquant', {}],
+    ];
+    const logMessage = [];
+    const availabledPlugins = suggestedPlugins
+        .map((item) => {
+        const moduleId = item[0];
+        try {
+            requireResolve(`imagemin-${moduleId}`);
+            return item;
+        }
+        catch (err) {
+            if (!logs.get(moduleId)) {
+                logs.set(moduleId, true);
+                const command = chalk(['magenta'])(`"${projectHasYarn() ? 'yarn add' : 'npm install'} imagemin-${moduleId} -D"`);
+                logMessage.push(`Execute ${command} for assets optimization`);
+            }
+            return null;
+        }
+    })
+        .filter(Boolean);
+    if (logMessage.length) {
+        for (const msg of logMessage) {
+            logger.warn(msg, moduleName);
+        }
+    }
+    if (availabledPlugins.length) {
+        return new ImageMinimizerPlugin({
+            minimizer: {
+                // Recommended squoosh options for lossless optimization
+                implementation: ImageMinimizerPlugin.imageminMinify,
+                options: {
+                    // Lossless optimization with custom option
+                    // Feel free to experiment with options for better result for you
+                    plugins: availabledPlugins,
+                },
+            },
+        });
+    }
+    return null;
+};

package/dist/minimizer/index.js

@@ -1 +1 @@
-export*from"./create-minimizers.js";
+export * from './create-minimizers.js';

package/dist/minimizer/terser-minimizer.js

@@ -1,3 +1,15 @@
-import{mergeOptions}from"@flatjs/common";import TerserPlugin from"terser-webpack-plugin";import{defaultTerserOptions}from"./default-options.js";export const terserMinimizer=e=>new TerserPlugin({parallel:!0,
-// Disable Extract all or some (use /^\**!|@preserve|@license|@cc_on/i RegExp) comments.
-extractComments:!1,terserOptions:mergeOptions(defaultTerserOptions,e)});
+import { mergeOptions } from '@flatjs/common';
+import TerserPlugin from 'terser-webpack-plugin';
+import { defaultTerserOptions } from './default-options.js';
+/**
+ * https://github.com/webpack-contrib/terser-webpack-plugin#terseroptions
+ */
+export const terserMinimizer = (terserOptions) => {
+    return new TerserPlugin({
+        parallel: true,
+        // Disable Extract all or some (use /^\**!|@preserve|@license|@cc_on/i RegExp) comments.
+        extractComments: false,
+        // Terser minify options.
+        terserOptions: mergeOptions(defaultTerserOptions, terserOptions),
+    });
+};

package/dist/minimizer/types.js

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