@flatjs/evolve 1.7.4 → 1.8.1-next.100

package/dist/plugins/circular-dependency/circular-dependency-plugin.js

@@ -0,0 +1 @@
+import{relative}from"node:path";import{mergeOptions}from"@flatjs/common";import Graph from"tarjan-graph";import webpack from"webpack";const BASE_ERROR="Circular dependency detected:\r\n",PLUGIN_TITLE="CircularDependencyPlugin";export class CircularDependencyPlugin{constructor(o={}){this.options=mergeOptions({exclude:/node_modules/,include:/.*/,failOnError:!0,allowAsyncCycles:!1,projectCwd:process.cwd()},o)}apply(o){const e=this.options.projectCwd;o.hooks.compilation.tap(PLUGIN_TITLE,(o=>{o.hooks.optimizeModules.tap(PLUGIN_TITLE,(t=>{this.options.onStart&&this.options.onStart({compilation:o});const n=new(Graph.default||Graph);for(const e of t){const t=[];for(const n of e.dependencies){if(n.constructor&&"CommonJsSelfReferenceDependency"===n.constructor.name)continue;let r=null;r=o.moduleGraph?o.moduleGraph.getModule(n):n.module,r&&(r instanceof webpack.NormalModule&&r.resource&&(this.options.allowAsyncCycles&&n.weak||e!==r&&t.push(r.identifier())))}n.add(e.identifier(),t)}const r=n.getCycles();this.isCyclic(r,o,e),this.options.onEnd&&this.options.onEnd({compilation:o})}))}))}isCyclic(o,e,t){o.forEach((o=>{const n=o.slice().reverse().map((o=>{const t=e.findModule(o.name);return t instanceof webpack.NormalModule&&t.resource||null}));if(n.every((o=>!o||this.options.exclude.test(o)||!this.options.include.test(o))))return;const r=n.map((o=>relative(t,o)));if(this.options.onDetected){try{this.options.onDetected({paths:r.concat([r[0]]),compilation:e})}catch(o){e.errors.push(o)}return}const s=new Error(BASE_ERROR.concat(r.concat([r[0]]).join(" -> ")));this.options.failOnError?e.errors.push(s):e.warnings.push(s)}))}}

package/dist/plugins/circular-dependency/index.d.ts

@@ -0,0 +1,7 @@
+import { type WebpackPlugin } from '../../create-webpack/types.js';
+import { type FlatEvolveOptions } from '../../types/types-options.js';
+/**
+ * Detect modules with circular dependencies when bundling with webpack for `development` mode.
+ * @returns
+ */
+export declare const createCircularDependencyPlugin: (serveMode: boolean, evolveOptions: FlatEvolveOptions) => WebpackPlugin[];

package/dist/plugins/circular-dependency/index.js

@@ -0,0 +1 @@
+import{CircularDependencyPlugin}from"./circular-dependency-plugin.js";export const createCircularDependencyPlugin=(e,n)=>e?[new CircularDependencyPlugin({projectCwd:n.projectCwd})]:[];

package/dist/plugins/clean-webpack/clean-webpack-plugin.d.ts

@@ -0,0 +1,67 @@
+import { type Compilation, type Compiler, type Stats } from 'webpack';
+export interface Options {
+    /**
+     * The project root.
+     */
+    projectCwd?: string;
+    /**
+     * Write Logs to Console
+     * (Always enabled when dry is true)
+     *
+     * default: false
+     */
+    verbose?: boolean;
+    /**
+     * Automatically remove all unused webpack assets on rebuild
+     *
+     * default: true
+     */
+    cleanStaleWebpackAssets?: boolean;
+    /**
+     * Do not allow removal of current webpack assets
+     *
+     * default: true
+     */
+    protectWebpackAssets?: boolean;
+    /**
+     * Removes files once prior to Webpack compilation
+     *   Not included in rebuilds (watch mode)
+     *
+     * Use !negative patterns to exclude files
+     *
+     * default: ['**\/*']
+     */
+    cleanOnceBeforeBuildPatterns?: string[];
+    /**
+     * Removes files after every build (including watch mode) that match this pattern.
+     * Used for files that are not created directly by Webpack.
+     *
+     * Use !negative patterns to exclude files
+     *
+     * default: []
+     */
+    cleanAfterEveryBuildPatterns?: string[];
+}
+export declare class CleanWebpackPlugin {
+    private readonly verbose;
+    private readonly cleanStaleWebpackAssets;
+    private readonly protectWebpackAssets;
+    private readonly cleanAfterEveryBuildPatterns;
+    private readonly cleanOnceBeforeBuildPatterns;
+    private currentAssets;
+    private initialClean;
+    private outputPath;
+    private projectCwd;
+    constructor(options?: Options);
+    apply(compiler: Compiler): void;
+    /**
+     * Initially remove files from output directory prior to build.
+     *
+     * Only happens once.
+     *
+     * Warning: It is recommended to initially clean your build directory outside of webpack to minimize unexpected behavior.
+     */
+    handleInitial(compilation: Compilation): void;
+    handleDone(stats: Stats): void;
+    removeFiles(patterns: string[]): void;
+}

package/dist/plugins/clean-webpack/clean-webpack-plugin.js

@@ -0,0 +1 @@
+import{rmSync}from"node:fs";import{relative}from"node:path";import{fileWalkSync}from"@armit/file-utility";import{logger}from"@flatjs/common";import{moduleName}from"../../constants.js";export class CleanWebpackPlugin{constructor(e={}){this.verbose=!0===e.verbose||!1,this.projectCwd=e.projectCwd||process.cwd(),this.cleanStaleWebpackAssets=!0!==e.cleanStaleWebpackAssets&&!1!==e.cleanStaleWebpackAssets||e.cleanStaleWebpackAssets,this.protectWebpackAssets=!0!==e.protectWebpackAssets&&!1!==e.protectWebpackAssets||e.protectWebpackAssets,this.cleanAfterEveryBuildPatterns=Array.isArray(e.cleanAfterEveryBuildPatterns)?e.cleanAfterEveryBuildPatterns:[],this.cleanOnceBeforeBuildPatterns=Array.isArray(e.cleanOnceBeforeBuildPatterns)?e.cleanOnceBeforeBuildPatterns:["**/*"],this.currentAssets=[],this.initialClean=!1,this.outputPath="",this.apply=this.apply.bind(this),this.handleInitial=this.handleInitial.bind(this),this.handleDone=this.handleDone.bind(this),this.removeFiles=this.removeFiles.bind(this)}apply(e){if(!e.options.output||!e.options.output.path)return void logger.warn("clean-webpack-plugin: options.output.path not defined. Plugin disabled...",moduleName);this.outputPath=e.options.output.path;const t=e.hooks;0!==this.cleanOnceBeforeBuildPatterns.length&&t.emit.tap("clean-webpack-plugin",(e=>{this.handleInitial(e)})),t.done.tap("clean-webpack-plugin",(e=>{this.handleDone(e)}))}handleInitial(e){if(this.initialClean)return;e.getStats().hasErrors()||(this.initialClean=!0,this.removeFiles(this.cleanOnceBeforeBuildPatterns))}handleDone(e){if(e.hasErrors())return void(this.verbose&&logger.warn("clean-webpack-plugin: pausing due to webpack errors",moduleName));const t=(e.toJson({assets:!0}).assets||[]).map((e=>e.name)),s=this.currentAssets.filter((e=>!1===t.includes(e)));this.currentAssets=t.sort();const i=[];!0===this.cleanStaleWebpackAssets&&0!==s.length&&i.push(...s),0!==this.cleanAfterEveryBuildPatterns.length&&i.push(...this.cleanAfterEveryBuildPatterns),0!==i.length&&this.removeFiles(i)}removeFiles(e){try{const t=fileWalkSync(e,{absolute:!0,unique:!0,cwd:this.outputPath,dot:!0,ignore:this.protectWebpackAssets?this.currentAssets:[]});for(const e of t)rmSync(e,{force:!0,recursive:!0});this.verbose&&t.forEach((e=>{const t=relative(this.projectCwd,e);logger.debug(`clean-webpack-plugin: removed ${t}`,moduleName)}))}catch(e){if(/Cannot delete files\/folders outside the current working directory\./.test(e.message)){throw new Error("clean-webpack-plugin: Cannot delete files/folders outside the current working directory. Can be overridden with the `dangerouslyAllowCleanPatternsOutsideProject` option.")}throw e}}}

package/dist/plugins/clean-webpack/index.d.ts

@@ -0,0 +1,9 @@
+import { type WebpackPlugin } from '../../create-webpack/types.js';
+import { type EntryMapItem } from '../../types/types-entry-map.js';
+import { type FlatEvolveOptions } from '../../types/types-options.js';
+/**
+ * Cleaning up the /dist folder for `production` build
+ * @param singleEntryItem
+ * @returns
+ */
+export declare const createCleanWebpackPlugin: (serveMode: boolean, entryMapItem: EntryMapItem, evolveOptions: FlatEvolveOptions) => WebpackPlugin[];

package/dist/plugins/clean-webpack/index.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{ensureSlash}from"@flatjs/common";import{CleanWebpackPlugin}from"./clean-webpack-plugin.js";export const createCleanWebpackPlugin=(e,n,o)=>e?[]:[new CleanWebpackPlugin({verbose:!0,projectCwd:o.projectCwd,cleanOnceBeforeBuildPatterns:[`${join(ensureSlash(n[0],!0),"**/*")}`]})];

package/dist/plugins/define-variable/define-variable-plugin.d.ts

@@ -0,0 +1,14 @@
+import { type WebpackPlugin } from '../../create-webpack/types.js';
+import { type FlatEvolveOptions } from '../../types/types-options.js';
+/**
+ * The DefinePlugin replaces variables in your code with other values or expressions at compile time.
+ * ```ts
+ * `__SENTRY_DEBUG__`
+ * `process.env.FLAT_BUILD_DATE`
+ * `process.env.FLAT_COMMIT_HASH`
+ * `process.env.FLAT_BRANCH_NAME`
+ * `process.env.FLAT_RELEASE_VERSION`
+ * ```
+ * @returns
+ */
+export declare const createBuiltinDefineVariables: (serveMode: boolean, evolveOptions: FlatEvolveOptions) => Promise<WebpackPlugin[]>;

package/dist/plugins/define-variable/define-variable-plugin.js

@@ -0,0 +1 @@
+import{getLastCommitHash,gitBranchName}from"@armit/git";import webpack from"webpack";export const createBuiltinDefineVariables=async(e,i)=>{const t=await getLastCommitHash(),n=await gitBranchName();return[new webpack.DefinePlugin({__SENTRY_DEBUG__:e,"process.env.FLAT_BUILD_DATE":JSON.stringify((new Date).toISOString()),"process.env.FLAT_COMMIT_HASH":JSON.stringify(t),"process.env.FLAT_BRANCH_NAME":JSON.stringify(n),"process.env.FLAT_RELEASE_VERSION":JSON.stringify(i.ci?.releaseVersion||t),...i.pluginOptions.definePlugin})]};

package/dist/plugins/define-variable/index.d.ts

@@ -0,0 +1 @@
+export * from './define-variable-plugin.js';

package/dist/plugins/define-variable/index.js

@@ -0,0 +1 @@
+export*from"./define-variable-plugin.js";

package/dist/plugins/html-inject-scripts/plugin-html-inject-script.d.ts

@@ -0,0 +1,8 @@
+import type { HtmlTagObject } from 'html-webpack-plugin';
+import type { Compiler, WebpackPluginInstance } from 'webpack';
+export declare class HtmlInjectScriptPlugin implements WebpackPluginInstance {
+    scripts: string[];
+    constructor(scripts?: string[]);
+    processScripts(): HtmlTagObject[];
+    apply(compiler: Compiler): void;
+}

package/dist/plugins/html-inject-scripts/plugin-html-inject-script.js

@@ -0,0 +1 @@
+import htmlWebpackPlugin from"html-webpack-plugin";const PLUGIN_PREFIX="HtmlInjectScriptPlugin";export class HtmlInjectScriptPlugin{constructor(t){this.scripts=t||[]}processScripts(){return this.scripts.filter(Boolean).map((t=>({tagName:"script",innerHTML:t,voidTag:!1,attributes:{},meta:{plugin:"html-inject-script-webpack-plugin"}})))}apply(t){t.hooks.compilation.tap(`${PLUGIN_PREFIX}_compilation`,(t=>{htmlWebpackPlugin.getHooks(t).alterAssetTags.tap(`${PLUGIN_PREFIX}_alterAssetTags`,(t=>(t.assetTags.scripts.unshift(...this.processScripts()),t)))}))}}

package/dist/plugins/module-federation/external-template-remotes.d.ts

@@ -0,0 +1,4 @@
+import { type Compiler } from 'webpack';
+export declare class ExternalTemplateRemotesPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/plugins/module-federation/external-template-remotes.js

@@ -0,0 +1 @@
+import webpackSources from"webpack-sources";const PLUGIN_NAME="ExternalTemplateRemotesPlugin",isExternalModule=e=>"ExternalModule"===e.constructor.name;function extractUrlAndGlobal(e){const t=e.indexOf("@");if(t<=0||t===e.length-1)throw new Error(`Invalid request "${e}"`);return[e.substring(t+1),e.substring(0,t)]}export class ExternalTemplateRemotesPlugin{apply(e){e.hooks.make.tap(PLUGIN_NAME,(e=>{const t=[];e.hooks.buildModule.tap(PLUGIN_NAME,(e=>{isExternalModule(e)&&"script"===e.externalType&&t.push(e)})),e.hooks.afterCodeGeneration.tap(PLUGIN_NAME,(()=>{t.forEach((t=>{const o=extractUrlAndGlobal(t.request)[0],n=toExpression(o),r=e.codeGenerationResults.get(t,void 0).sources,s=r.get("javascript");if(s){const e=new webpackSources.RawSource(s.source().toString().replace(`"${o}"`,n));r.set("javascript",e)}}))}))}))}}function toExpression(e){const t=[],o=[];let n=!1,r=!1;for(const s of e)if("["===s){if(n){r=!0;break}n=!0,o.length&&(t.push(`"${o.join("")}"`),o.length=0)}else if("]"===s){if(!n){r=!0;break}n=!1,o.length&&(t.push(`${o.join("")}`),o.length=0),o.length=0}else o.push(s);if(n||r)throw new Error(`Invalid template URL "${e}"`);return o.length&&t.push(`"${o.join("")}"`),t.join(" + ")}

package/dist/plugins/module-federation/index.d.ts

@@ -0,0 +1 @@
+export * from './module-federation.js';

package/dist/plugins/module-federation/index.js

@@ -0,0 +1 @@
+export*from"./module-federation.js";

package/dist/plugins/module-federation/module-federation.d.ts

@@ -0,0 +1,4 @@
+import { type WebpackPluginInstance } from 'webpack';
+import { type EntryMapItem } from '../../types/types-entry-map.js';
+import { type FlatEvolveOptions } from '../../types/types-options.js';
+export declare const createModuleFederationPlugin: (serveMode: boolean, entryMapItem: EntryMapItem, evolveOptions: FlatEvolveOptions) => WebpackPluginInstance[];

package/dist/plugins/module-federation/module-federation.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{ensureSlash}from"@flatjs/common";import webpack from"webpack";import{normalizeEvolveEntryName}from"../../helpers/normalize-entry-map.js";import{injectFederationScripts}from"../../helpers/script-injects.js";import{HtmlInjectScriptPlugin}from"../html-inject-scripts/plugin-html-inject-script.js";import{ExternalTemplateRemotesPlugin}from"./external-template-remotes.js";const normalizeWidgetName=(e="")=>e.replace(/[/-]/g,"_").toLowerCase(),remoteFileName=e=>join(e,"micro-remote-module.js");export const createModuleFederationPlugin=(e,t,r)=>{const o=r.projectVirtualPath,[n,i]=t,m=r.multiHtmlCdn,a=r.multiHtmlCdnEnvResolver,l=i.options?.moduleFederation,s=[];if(l){const{remotes:t,exposes:r,...i}=l,p=remoteFileName(n),c=normalizeWidgetName(n),u=(r?Array.isArray(r)?r:[r]:[]).map((e=>{const t={};for(const[r,o]of Object.entries(e))t[r]={...o,name:join(n,o.name.replace(/^\//,""))};return t})),d=(t||[]).map((({name:e,endpoint:t})=>{const r=normalizeEvolveEntryName(e,o),n=normalizeWidgetName(r),i=remoteFileName(r);return{[n]:`${n}@${t?ensureSlash(t(e,r),!1):"[window.evolveFetchMicroWidgets()]"}/${i}`}}));s.push(new webpack.container.ModuleFederationPlugin({name:c,filename:p,remotes:d,exposes:u,...i}),new ExternalTemplateRemotesPlugin),e||s.unshift(new HtmlInjectScriptPlugin([injectFederationScripts(m,a)]))}return s};

package/dist/plugins/multi-html/index.d.ts

@@ -0,0 +1,4 @@
+import { type WebpackPlugin } from '../../create-webpack/types.js';
+import { type EntryMapItem } from '../../types/types-entry-map.js';
+import { type FlatEvolveOptions } from '../../types/types-options.js';
+export declare const createHtmlPlugins: (serveMode: boolean, entryMapItem: EntryMapItem, evolveOptions: FlatEvolveOptions) => WebpackPlugin[];

package/dist/plugins/multi-html/index.js

@@ -0,0 +1 @@
+import{FlatEvolveMultiCdnPlugin}from"./multi-html-cdn-plugin.js";import{createMultiHtmlWebpackPlugin}from"./multi-html-plugin.js";export const createHtmlPlugins=(t,l,u)=>{const i=[];if(t)return i;const n=Object.keys(u.multiHtmlCdn);return i.push(...createMultiHtmlWebpackPlugin(t,u,l,n)),i.push(new FlatEvolveMultiCdnPlugin(u)),i};

package/dist/plugins/multi-html/multi-html-cdn-plugin.d.ts

@@ -0,0 +1,17 @@
+import { type Compiler } from 'webpack';
+import { type FlatEvolveOptions } from '../../types/index.js';
+export declare class FlatEvolveMultiCdnPlugin {
+    private pluginName;
+    private requireFn;
+    private config;
+    private cdnResolver;
+    constructor(evolveOptions: FlatEvolveOptions);
+    /**
+     * Apply the plugin to check if there are non initial chunks which need to be imported using `require-ensure` or `import`
+     * https://github.com/webpack/webpack/blob/3d653290fafe385277b48e5a36807124618b9561/lib/MainTemplate.js#L158
+     * https://www.npmjs.com/package/vscode-webpack-debugger
+     * https://www.cnblogs.com/Scar007/p/9166068.html
+     * https://www.cnblogs.com/pluslius/p/10271537.html
+     */
+    apply(compiler: Compiler): void;
+}

package/dist/plugins/multi-html/multi-html-cdn-plugin.js

@@ -0,0 +1 @@
+import{basename}from"node:path";import HtmlWebpackPlugin from"html-webpack-plugin";import webpack from"webpack";import{cdnFinder,findEnvCdn,httpUrlJoin}from"../../helpers/script-injects.js";export class FlatEvolveMultiCdnPlugin{constructor(e){if(this.pluginName="FlatEvolveMultiCdnPlugin",this.requireFn=webpack.RuntimeGlobals.publicPath,this.config=e.multiHtmlCdn,this.cdnResolver=e.multiHtmlCdnEnvResolver||function cdnResolver(){},!this.config?.prod)throw new Error("We must setup `prod` for each CDN config node!")}apply(e){e.hooks.thisCompilation.tap(this.pluginName,(e=>{e.mainTemplate.hooks.requireExtensions.tap(this.pluginName,((n,t)=>{const i=[];i.push("// Dynamic assets path override(`@flatjs/evolve`) plugin-multi-html-cdn`)");const s=e.chunkGraph?.getTreeRuntimeRequirements(t);return s&&s.has(webpack.RuntimeGlobals.requireScope)&&(i.push("(function () {"),i.push(webpack.Template.indent("var flatjsMultiCdn = {")),i.push(webpack.Template.indent(webpack.Template.indent([`cdnConfig: ${JSON.stringify(this.config||{})},`]))),i.push(webpack.Template.indent(webpack.Template.indent([`cdnResolver: ${this.cdnResolver.toString()},`]))),i.push(webpack.Template.indent(webpack.Template.indent([`cdnFinder: ${cdnFinder.toString()}`]))),i.push(webpack.Template.indent("};")),i.push(webpack.Template.indent(`${this.requireFn} = flatjsMultiCdn.cdnFinder(flatjsMultiCdn.cdnConfig, flatjsMultiCdn.cdnResolver) || ${this.requireFn};`)),i.push("})();")),webpack.Template.asString(i)}))})),e.hooks.compilation.tap(this.pluginName,(e=>{HtmlWebpackPlugin.getHooks(e).beforeAssetTagGeneration.tap(this.pluginName,(e=>{const{assets:n}=e,{userOptions:t}=e.plugin,i=t.multiCdn,s=n.publicPath,a=n.js.map((e=>{if(i.disabled)return basename(e);const n=findEnvCdn(this.config,i.env);return httpUrlJoin(n,e.replace(s,""))})),p=n.css.map((e=>{if(i.disabled)return basename(e);const n=findEnvCdn(this.config,i.env);return httpUrlJoin(n,e.replace(s,""))}));return e.assets.js=a,e.assets.css=p,e}))}))}}

package/dist/plugins/multi-html/multi-html-plugin.d.ts

@@ -0,0 +1,11 @@
+import { type WebpackPlugin } from '../../create-webpack/types.js';
+import { type EntryMapItem } from '../../types/types-entry-map.js';
+import { type EvolveMultiCdnEnvType } from '../../types/types-multi-html.js';
+import { type FlatEvolveOptions } from '../../types/types-options.js';
+/**
+ * Create `html-webpack-plugin` for this build, refer to best practices
+ * We'd better pass only one entry for each `build` cycle
+ * @param buildEntryItem the entries for this `build`
+ * @param allEnv
+ */
+export declare const createMultiHtmlWebpackPlugin: (serveMode: boolean, evolveOptions: FlatEvolveOptions, entryMapItem: EntryMapItem, allEnv: Array<EvolveMultiCdnEnvType>) => WebpackPlugin[];

package/dist/plugins/multi-html/multi-html-plugin.js

@@ -0,0 +1 @@
+import HtmlWebpackPlugin from"html-webpack-plugin";import{allowPx2remForModule}from"../../helpers/allow-px2rem-for-module.js";import{getHtmlPluginConfig}from"../../helpers/get-html-plugin-config.js";import{findEnvCdn}from"../../helpers/script-injects.js";const minifyOpts={minifyJS:!0,removeComments:!0,collapseWhitespace:!0,collapseBooleanAttributes:!1};export const createMultiHtmlWebpackPlugin=(e,t,i,l)=>{const[n,o]=i,r=[],{options:m}=o,g=e?"development":"production";for(const e of l){const l={mode:g,envCdn:findEnvCdn(t.multiHtmlCdn,e)};r.push(new HtmlWebpackPlugin({inject:"body",title:getHtmlPluginConfig("title",l,m?.title),chunks:[n],minify:!1!==m?.htmlMinify&&!["me","dev"].includes(e)&&minifyOpts,filename:`${n}/index${"prod"===e?"":`-${e}`}.html`,template:getHtmlPluginConfig("templatePath",l,m?.templatePath).replace("{0}",e),templateParameters:{title:getHtmlPluginConfig("title",l,m?.title),favicon:getHtmlPluginConfig("favicon",l,m?.favicon),headBeforeHtmlTags:getHtmlPluginConfig("headBeforeHtmlTags",l,m?.headBeforeHtmlTags),inlineScripts:getHtmlPluginConfig("inlineScripts",l,m?.inlineScripts),headBeforeStyles:getHtmlPluginConfig("headBeforeStyles",l,m?.headBeforeStyles),headBeforeScripts:getHtmlPluginConfig("headBeforeScripts",l,m?.headBeforeScripts),bodyAfterScripts:getHtmlPluginConfig("bodyAfterScripts",l,m?.bodyAfterScripts),viewport:allowPx2remForModule(i,t)?getHtmlPluginConfig("viewport",l,m?.viewport):""},multiCdn:{env:e,disabled:(m?.excludeCdnEnvs||["me","dev","ntv"]).includes(e)}}))}return r};

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types-dev-server.js';
+export * from './types-entry-map.js';
+export * from './types-federation.js';
+export * from './types-modular-import.js';
+export * from './types-multi-html.js';
+export * from './types-options.js';
+export * from './types-loader-options.js';
+export * from './types-webpack.js';

package/dist/types/index.js

@@ -0,0 +1 @@
+export*from"./types-dev-server.js";export*from"./types-entry-map.js";export*from"./types-federation.js";export*from"./types-modular-import.js";export*from"./types-multi-html.js";export*from"./types-options.js";export*from"./types-loader-options.js";export*from"./types-webpack.js";

package/dist/types/types-ci.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The CI pipeline execute `priority` as below
+ * 1. Fixed module build depends on config : `fixedBuildModules` of `flatjs-evolve.config.ts`
+ * 2. Dynamic build depends on commits (`flat build evolve --commits=""`)
+ * 3. Normally build manually using (`flat build evolve -m "a;b"`)
+ */
+export type FlatEvolveCI = {
+    /**
+     * The build module patterns, `Highest Priority First`
+     * Support "a;b;c" RegExp pattern; `new RegExp(`${pattern}`).test(entryKey)`
+     */
+    fixedBuildModules?: string[];
+    /**
+     * Dynamic build depends on persistent `branch`, e.g. `main`,`master`,`release`
+     * @default `origin/master`
+     */
+    basedBranch: string;
+    /**
+     * The release version will setup to `process.env.FLAT_RELEASE_VERSION`
+     * @default ''
+     */
+    releaseVersion?: string;
+};

package/dist/types/types-ci.js

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

package/dist/types/types-dev-server.d.ts

@@ -0,0 +1,65 @@
+import { type SecureContextHttps, type FlatMockOptions } from '@flatjs/mock';
+import { type RequestHandler } from 'express';
+import { type Configuration } from 'webpack';
+import { type ClientConfiguration } from 'webpack-dev-server';
+import { type EvolveEntryMapContent } from './types-entry-map.js';
+export interface WebpackWatchOptions {
+    /**
+     * Delay the rebuilt after the first change. Value is a time in ms.
+     */
+    aggregateTimeout?: number;
+    /**
+     * Resolve symlinks and watch symlink and real file. This is usually not needed as webpack already resolves symlinks ('resolve.symlinks').
+     */
+    followSymlinks?: boolean;
+    /**
+     * Ignore some files from watching (glob pattern or regexp).
+     */
+    ignored?: string | RegExp | string[];
+    /**
+     * Enable polling mode for watching.
+     */
+    poll?: number | boolean;
+}
+export type FlatEvolveDevServerOptions = {
+    /**
+     * Allow us provider customized middlewares for `page`, `modules`
+     */
+    middlewares?: RequestHandler[];
+    /**
+     * Turn on watch mode. This means that after the initial build, webpack will continue to watch for changes in any of the resolved files.
+     * In webpack-dev-server watch mode is enabled by default.
+     * This configuration will be merged into `webpack-dev-server`
+     */
+    watchOptions?: Configuration['watchOptions'];
+    /**
+     * Allow us costomized global serve data injected into `window.GLOBAL = {...globalData}`
+     */
+    defaultServeGlobalData?: (entryItem: EvolveEntryMapContent, hostUrl: string) => Promise<Record<string, unknown>> | Record<string, unknown>;
+    /**
+     * The value indicates if we will auto open broswers page for `serve`
+     * @default true
+     */
+    autoOpen?: boolean;
+    /**
+     * Enables reload/refresh the page(s) when file changes are detected (`auto` by default).
+     * @default undefined
+     */
+    liveReload?: true;
+    /**
+     * Enables a full-screen overlay in the browser when there are compiler errors or warnings.
+     * @default {
+     *   errors: true,
+     *   warnings: false,
+     * }
+     */
+    clientOverlay?: ClientConfiguration['overlay'];
+    /**
+     * The customized config options of `flatjs/mock`, it will override options `flatjs-mock.config.ts`
+     */
+    mockOptions?: Omit<FlatMockOptions, 'projectCwd'>;
+    /**
+     * Provide your own certificate using the https option
+     */
+    https?: SecureContextHttps;
+};

package/dist/types/types-dev-server.js

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

package/dist/types/types-entry-map.d.ts

@@ -0,0 +1,71 @@
+import { type ModuleFederationOptions } from './types-federation.js';
+import { type MultiHtmlCDNEntryItem } from './types-multi-html.js';
+/**
+ * The configuration options for each entry item.
+ */
+export interface EvolveEntryItemOption extends MultiHtmlCDNEntryItem {
+    /**
+     * The value indicates if we need to Px convert to rem.
+     * @default entryItemOption?.allowPx2rem ?? pluginLoaderOptions?.pixelOptions?.enabled
+     */
+    allowPx2rem?: boolean;
+    /**
+     * Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on `output.libraryTarget`.
+     * Note It will merged with globall externals configuration and apply for current entry compiler
+     */
+    externals?: Record<string, string>;
+    /**
+     * If all we use `contenthash` bundle name.
+     * @default true
+     */
+    enableBundleHashName?: boolean;
+    /**
+     * Allow customized module `link` on `/pages`
+     * @default undefined
+     */
+    servePageMainLinkFn?: (link: string, options: {
+        entryName: string;
+        hostUri: string;
+        virtualPath: string;
+    }) => string;
+    /**
+     * For `serve`
+     * Customized module template to proxy the modules template.
+     * If providered, it must be an absolute path. path.join(__dirname, `templates/module.html`)
+     * Normally it will find file `${projectCwd}/templates/module.html` automatically
+     */
+    serveModuleTemplate?: string;
+    /**
+     * For `serve`
+     * Attach fixed global data for specificed entry.
+     * Will merged into `window.GLOBAL = {...globalData}`
+     * @default {}
+     */
+    serveGlobalData?: Record<string, unknown>;
+    /**
+     * Multiple separate builds should form a single application.
+     * This is often known as Micro-Frontends, but is not limited to that.
+     */
+    moduleFederation?: ModuleFederationOptions;
+    /**
+     * The value indicates if we need to build relative asset public path?
+     * @default false
+     */
+    useRelativeAssetPath?: boolean;
+    /**
+     * The filter will try filter which mock defs files will be loaded for this `entryItem` while `serve`.
+     * @default undefined
+     */
+    mockFilters?: Array<string | RegExp>;
+}
+export type EvolveEntryMapContent = {
+    entry: [string, ...string[]];
+    options?: EvolveEntryItemOption;
+};
+export interface EvolveEntryMap {
+    /**
+     * <entryChunkName>: {}
+     */
+    [entryName: string]: EvolveEntryMapContent;
+}
+export type EntryMapItem = [string, EvolveEntryMapContent];

package/dist/types/types-entry-map.js

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

package/dist/types/types-federation.d.ts

@@ -0,0 +1,120 @@
+import { type LibraryOptions } from 'webpack';
+/**
+ * Advanced configuration for modules that should be shared in the share scope.
+ */
+interface SharedConfig {
+    /**
+     * Include the provided and fallback module directly instead behind an async request. This allows to use this shared module in initial load too. All possible shared modules need to be eager too.
+     */
+    eager?: boolean;
+    /**
+     * Provided module that should be provided to share scope. Also acts as fallback module if no shared module is found in share scope or version isn't valid. Defaults to the property name.
+     */
+    import?: string | false;
+    /**
+     * Package name to determine required version from description file. This is only needed when package name can't be automatically determined from request.
+     */
+    packageName?: string;
+    /**
+     * Version requirement from module in share scope.
+     */
+    requiredVersion?: string | false;
+    /**
+     * Module is looked up under this key from the share scope.
+     */
+    shareKey?: string;
+    /**
+     * Share scope name.
+     */
+    shareScope?: string;
+    /**
+     * Allow only a single version of the shared module in share scope (disabled by default).
+     */
+    singleton?: boolean;
+    /**
+     * Do not accept shared module if version is not valid (defaults to yes, if local fallback module is available and shared module is not a singleton, otherwise no, has no effect if there is no required version specified).
+     */
+    strictVersion?: boolean;
+    /**
+     * Version of the provided module. Will replace lower matching versions, but not higher.
+     */
+    version?: string | false;
+}
+interface SharedObject {
+    [index: string]: string | SharedConfig;
+}
+/**
+ * Advanced configuration for modules that should be exposed by this container.
+ */
+export interface ExposesConfig {
+    /**
+     * Request to a module that should be exposed by this container.
+     * @example `import: './src/home/widget.tsx'`
+     */
+    import: string | string[];
+    /**
+     * Custom chunk name for the exposed module.
+     * Do not include `normalizedEntryName` e.g.(`flatjs/evolve/home`)
+     * @example `exposed-micro-module-home-widget` => `flatjs/evolve/home/exposed-micro-module-home-widget`
+     */
+    name: string;
+}
+/**
+ * Modules that should be exposed by this container. Property names are used as public paths.
+ */
+export interface ExposesObject {
+    /**
+     *  @example `'./Widget': { name, import }`
+     */
+    [index: string]: ExposesConfig;
+}
+export interface ModuleFederationRemote {
+    /**
+     * Normally it can be the entryPath like `${projectVirtualPath}/home`
+     * it will formatted into `evolve_demo_home`
+     * Note: We need to config `declare module 'evolve_demo_home/Widget` in `global.d.ts`;
+     * @example `home`
+     */
+    name: string;
+    /**
+     * The remote app resouce endpoint base path with prefix of `projectVirtualPath`
+     * Normally This is only required when an external project module as remote widget.
+     */
+    endpoint?: (entryName: string, normalizedEntryName: string) => string;
+}
+/**
+ * Multiple separate builds should form a single application.
+ * This is often known as Micro-Frontends, but is not limited to that.
+ */
+export type ModuleFederationOptions = {
+    /**
+     * Container locations and request scopes from which modules should be resolved and loaded at runtime. When provided, property name is used as request scope, otherwise request scope is automatically inferred from container location.
+     * {`${projectVirtualPath}/home`,`${projectVirtualPath}/mine`}
+     */
+    remotes?: Array<ModuleFederationRemote>;
+    /**
+     * Options for library.
+     */
+    library?: LibraryOptions;
+    /**
+     * The external type of the remote containers.
+     */
+    remoteType?: 'import' | 'var' | 'module' | 'assign' | 'this' | 'window' | 'self' | 'global' | 'commonjs' | 'commonjs2' | 'commonjs-module' | 'commonjs-static' | 'amd' | 'amd-require' | 'umd' | 'umd2' | 'jsonp' | 'system' | 'promise' | 'script' | 'node-commonjs';
+    /**
+     * Modules that should be exposed by this container. When provided, property name is used as public name, otherwise public name is automatically inferred from request.
+     */
+    exposes?: ExposesObject[] | ExposesObject;
+    /**
+     * The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.
+     */
+    runtime?: string | false;
+    /**
+     * Share scope name used for all shared modules (defaults to 'default').
+     */
+    shareScope?: string;
+    /**
+     * Modules that should be shared in the share scope. When provided, property names are used to match requested modules in this compilation.
+     */
+    shared?: (string | SharedObject)[] | SharedObject;
+};
+export {};

package/dist/types/types-federation.js

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

package/dist/types/types-loader-options.d.ts

@@ -0,0 +1,76 @@
+import { type TransformOptions } from '@babel/core';
+import { type PostcssPluginPixelOptions } from '@flatjs/forge-postcss-plugin-pixel';
+import { type AcceptedPlugin } from 'postcss';
+import { type ModularImportOption } from './types-modular-import.js';
+export type BabelInputOptions = Pick<TransformOptions, 'presets' | 'plugins'>;
+/**
+ * Builtin babel options, provider default `builin` presets.
+ * can be override by customized `presets` & `plugins`
+ */
+export type BuiltinBabelOptions = BabelInputOptions & {
+    /**
+     * extra babel `plugins` or `presets`
+     * @default `react`
+     */
+    usePreset?: 'react' | 'vue';
+};
+/**
+ * The configurations for `builtin` rule set options
+ */
+export interface RuleSetLoaderOptions {
+    /**
+     * Now webpack will automatically choose between resource and inline by following
+     * a default condition: a file with size less than 8kb will be treated as a inline module type and resource module type otherwise.
+     * @default `4 * 1024` (4KB)
+     */
+    assetDataUrlMaxSize?: number;
+    /**
+     * The configurations of `css-loader`
+     */
+    cssLoaderOptions?: Record<string, unknown>;
+    /**
+     * The config for `Less`
+     */
+    lessOptions?: Record<string, unknown>;
+    /**
+     * Modular import plugin for babel, compatible with antd, antd-mobile, lodash, material-ui, and so on.
+     * https://github.com/ant-design/babel-plugin-import
+     * @default []
+     */
+    modularImports?: ModularImportOption[];
+    /**
+     * The value indicates whether runs typescript type checker and linter on separate process.
+     * @default true
+     */
+    runTsChecker?: boolean;
+    /**
+     * The configration options of `postcss-loader`
+     */
+    postcssOptions?: {
+        /**
+         * The overrided configurations of `cssnano-preset-default`
+         * sometimes we need to disabled some rules for `default cssnano preset`
+         * @link https://www.npmjs.com/package/cssnano-preset-default
+         * @example
+         * Disable `postcss-minify-font-values` rule to avoid transitions from `font-weight:bold` to `font-weight:700`
+         * ```json
+         * cssnanoOptions: { minifyFontValues: false }
+         * ```
+         */
+        cssnanoOptions?: Record<string, unknown>;
+        /**
+         * Allow to extends extra plugins of `postcss-loader`
+         * @example `['tailwindcss', {}]`
+         */
+        plugins?: Array<AcceptedPlugin | string | [string, Record<string, unknown>]>;
+    };
+    /**
+     * The babel options for `babel-loader`
+     */
+    babelOptions?: BuiltinBabelOptions;
+    /**
+     * The config options fro `@flatjs/forge-postcss-plugin-plugin`
+     * If provider it will use default options of `forgePostcssPluginPixel`
+     */
+    pixelOptions?: false | Partial<PostcssPluginPixelOptions>;
+}

package/dist/types/types-loader-options.js

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