@modern-js/utils 1.7.4 → 1.7.7

package/compiled/webpack-chain/types/index.d.ts

@@ -0,0 +1,388 @@
+import { Tapable } from 'tapable';
+import * as webpack from 'webpack';
+import * as https from 'https';
+
+export = Config;
+
+declare namespace __Config {
+  class Chained<Parent> {
+    end(): Parent;
+  }
+
+  class TypedChainedMap<Parent, Value> extends Chained<Parent> {
+    clear(): this;
+    delete(key: string): this;
+    has(key: string): boolean;
+    get(key: string): Value;
+    getOrCompute(key: string, compute: () => Value): Value;
+    set(key: string, value: Value): this;
+    merge(obj: { [key: string]: Value }): this;
+    entries(): { [key: string]: Value };
+    values(): Value[];
+    when(
+      condition: boolean,
+      trueBrancher: (obj: this) => void,
+      falseBrancher?: (obj: this) => void,
+    ): this;
+  }
+
+  class ChainedMap<Parent> extends TypedChainedMap<Parent, any> {}
+
+  class TypedChainedSet<Parent, Value> extends Chained<Parent> {
+    add(value: Value): this;
+    prepend(value: Value): this;
+    clear(): this;
+    delete(key: string): this;
+    has(key: string): boolean;
+    merge(arr: Value[]): this;
+    values(): Value[];
+    when(
+      condition: boolean,
+      trueBrancher: (obj: this) => void,
+      falseBrancher?: (obj: this) => void,
+    ): this;
+  }
+
+  class ChainedSet<Parent> extends TypedChainedSet<Parent, any> {}
+}
+
+declare class Config extends __Config.ChainedMap<void> {
+  devServer: Config.DevServer;
+  entryPoints: Config.TypedChainedMap<Config, Config.EntryPoint>;
+  module: Config.Module;
+  node: Config.ChainedMap<this>;
+  output: Config.Output;
+  optimization: Config.Optimization;
+  performance: Config.Performance;
+  plugins: Config.Plugins<this, webpack.Plugin>;
+  resolve: Config.Resolve;
+  resolveLoader: Config.ResolveLoader;
+
+  amd(value: { [moduleName: string]: boolean }): this;
+  bail(value: boolean): this;
+  cache(value: boolean | any): this;
+  devtool(value: Config.DevTool): this;
+  context(value: string): this;
+  externals(value: webpack.ExternalsElement | webpack.ExternalsElement[]): this;
+  loader(value: any): this;
+  name(value: string): this;
+  mode(value: 'none' | 'development' | 'production'): this;
+  parallelism(value: number): this;
+  profile(value: boolean): this;
+  recordsPath(value: string): this;
+  recordsInputPath(value: string): this;
+  recordsOutputPath(value: string): this;
+  stats(value: webpack.Options.Stats): this;
+  target(value: string): this;
+  watch(value: boolean): this;
+  watchOptions(value: webpack.Options.WatchOptions): this;
+
+  entry(name: string): Config.EntryPoint;
+  plugin(name: string): Config.Plugin<this, webpack.Plugin>;
+
+  toConfig(): webpack.Configuration;
+}
+
+declare namespace Config {
+  class Chained<Parent> extends __Config.Chained<Parent> {}
+  class TypedChainedMap<Parent, Value> extends __Config.TypedChainedMap<
+    Parent,
+    Value
+  > {}
+  class ChainedMap<Parent> extends __Config.TypedChainedMap<Parent, any> {}
+  class TypedChainedSet<Parent, Value> extends __Config.TypedChainedSet<
+    Parent,
+    Value
+  > {}
+  class ChainedSet<Parent> extends __Config.TypedChainedSet<Parent, any> {}
+
+  class Plugins<
+    Parent,
+    PluginType extends Tapable.Plugin = webpack.Plugin
+  > extends TypedChainedMap<Parent, Plugin<Parent, PluginType>> {}
+
+  class Plugin<Parent, PluginType extends Tapable.Plugin = webpack.Plugin>
+    extends ChainedMap<Parent>
+    implements Orderable {
+    init<P extends PluginType | PluginClass<PluginType>>(
+      value: (
+        plugin: P,
+        args: P extends PluginClass ? ConstructorParameters<P> : any[],
+      ) => PluginType,
+    ): this;
+    use<P extends string | PluginType | PluginClass<PluginType>>(
+      plugin: P,
+      args?: P extends PluginClass ? ConstructorParameters<P> : any[],
+    ): this;
+    tap<P extends PluginClass<PluginType>>(
+      f: (args: ConstructorParameters<P>) => ConstructorParameters<P>,
+    ): this;
+
+    // Orderable
+    before(name: string): this;
+    after(name: string): this;
+  }
+
+  class Module extends ChainedMap<Config> {
+    rules: TypedChainedMap<this, Rule>;
+    rule(name: string): Rule;
+    noParse(
+      noParse: RegExp | RegExp[] | ((contentPath: string) => boolean),
+    ): this;
+    strictExportPresence(value: boolean): this;
+  }
+
+  class Output extends ChainedMap<Config> {
+    auxiliaryComment(value: string | { [comment: string]: string }): this;
+    chunkFilename(value: string): this;
+    chunkLoadTimeout(value: number): this;
+    crossOriginLoading(value: boolean | string): this;
+    filename(value: string): this;
+    library(value: string): this;
+    libraryExport(value: string | string[]): this;
+    libraryTarget(value: string): this;
+    devtoolFallbackModuleFilenameTemplate(value: any): this;
+    devtoolLineToLine(value: any): this;
+    devtoolModuleFilenameTemplate(value: any): this;
+    devtoolNamespace(value: string): this;
+    globalObject(value: string): this;
+    hashFunction(value: string): this;
+    hashDigest(value: string): this;
+    hashDigestLength(value: number): this;
+    hashSalt(value: any): this;
+    hotUpdateChunkFilename(value: string): this;
+    hotUpdateFunction(value: any): this;
+    hotUpdateMainFilename(value: string): this;
+    jsonpFunction(value: string): this;
+    path(value: string): this;
+    pathinfo(value: boolean): this;
+    publicPath(value: string): this;
+    sourceMapFilename(value: string): this;
+    sourcePrefix(value: string): this;
+    strictModuleExceptionHandling(value: boolean): this;
+    umdNamedDefine(value: boolean): this;
+    futureEmitAssets(value: boolean): this;
+  }
+
+  class DevServer extends ChainedMap<Config> {
+    allowedHosts: TypedChainedSet<this, string>;
+
+    after(
+      value: (app: any, server: any, compiler: webpack.Compiler) => void,
+    ): this;
+    before(
+      value: (app: any, server: any, compiler: webpack.Compiler) => void,
+    ): this;
+    bonjour(value: boolean): this;
+    clientLogLevel(value: 'none' | 'error' | 'warning' | 'info'): this;
+    color(value: boolean): this;
+    compress(value: boolean): this;
+    contentBase(value: boolean | string | string[]): this;
+    disableHostCheck(value: boolean): this;
+    filename(value: string): this;
+    headers(value: { [header: string]: string }): this;
+    historyApiFallback(value: boolean | any): this;
+    host(value: string): this;
+    hot(value: boolean): this;
+    hotOnly(value: boolean): this;
+    http2(value: boolean): this;
+    https(value: boolean | https.ServerOptions): this;
+    index(value: string): this;
+    info(value: boolean): this;
+    inline(value: boolean): this;
+    lazy(value: boolean): this;
+    mimeTypes(value: Object): this;
+    noInfo(value: boolean): this;
+    open(value: boolean): this;
+    openPage(value: string | string[]): this;
+    overlay(value: boolean | { warnings?: boolean; errors?: boolean }): this;
+    pfx(value: string): this;
+    pfxPassphrase(value: string): this;
+    port(value: number): this;
+    progress(value: boolean): this;
+    proxy(value: any): this;
+    public(value: string): this;
+    publicPath(publicPath: string): this;
+    quiet(value: boolean): this;
+    setup(value: (expressApp: any) => void): this;
+    socket(value: string): this;
+    sockHost(value: string): this;
+    sockPath(value: string): this;
+    sockPort(value: number): this;
+    staticOptions(value: any): this;
+    stats(value: webpack.Options.Stats): this;
+    stdin(value: boolean): this;
+    useLocalIp(value: boolean): this;
+    watchContentBase(value: boolean): this;
+    watchOptions(value: any): this;
+    writeToDisk(value: boolean): this;
+  }
+
+  class Performance extends ChainedMap<Config> {
+    hints(value: boolean | 'error' | 'warning'): this;
+    maxEntrypointSize(value: number): this;
+    maxAssetSize(value: number): this;
+    assetFilter(value: (assetFilename: string) => boolean): this;
+  }
+
+  class EntryPoint extends TypedChainedSet<Config, string> {}
+
+  class Resolve<T = Config> extends ChainedMap<T> {
+    alias: TypedChainedMap<this, string>;
+    aliasFields: TypedChainedSet<this, string>;
+    descriptionFiles: TypedChainedSet<this, string>;
+    extensions: TypedChainedSet<this, string>;
+    mainFields: TypedChainedSet<this, string>;
+    mainFiles: TypedChainedSet<this, string>;
+    modules: TypedChainedSet<this, string>;
+    plugins: TypedChainedMap<this, Plugin<this, webpack.ResolvePlugin>>;
+
+    enforceExtension(value: boolean): this;
+    enforceModuleExtension(value: boolean): this;
+    unsafeCache(value: boolean | RegExp | RegExp[]): this;
+    symlinks(value: boolean): this;
+    cachePredicate(
+      value: (data: { path: string; request: string }) => boolean,
+    ): this;
+    cacheWithContext(value: boolean): this;
+
+    plugin(name: string): Plugin<this, webpack.ResolvePlugin>;
+  }
+
+  class ResolveLoader extends Resolve {
+    moduleExtensions: ChainedSet<this>;
+    packageMains: ChainedSet<this>;
+  }
+
+  class Rule<T = Module> extends ChainedMap<T> implements Orderable {
+    rules: TypedChainedMap<this, Rule<Rule>>;
+    oneOfs: TypedChainedMap<this, Rule<Rule>>;
+    uses: TypedChainedMap<this, Use>;
+    include: TypedChainedSet<this, webpack.Condition>;
+    exclude: TypedChainedSet<this, webpack.Condition>;
+    resolve: Resolve<Rule<T>>;
+
+    parser(value: { [optName: string]: any }): this;
+    test(value: webpack.Condition | webpack.Condition[]): this;
+    type(
+      value:
+        | 'javascript/auto'
+        | 'javascript/dynamic'
+        | 'javascript/esm'
+        | 'json'
+        | 'webassembly/experimental',
+    ): this;
+    enforce(value: 'pre' | 'post'): this;
+
+    use(name: string): Use<this>;
+    rule(name: string): Rule<Rule>;
+    oneOf(name: string): Rule<Rule>;
+    pre(): this;
+    post(): this;
+    before(name: string): this;
+    after(name: string): this;
+    resourceQuery(value: webpack.Condition | webpack.Condition[]): this;
+  }
+
+  class Optimization extends ChainedMap<Config> {
+    concatenateModules(value: boolean): this;
+    flagIncludedChunks(value: boolean): this;
+    mergeDuplicateChunks(value: boolean): this;
+    minimize(value: boolean): this;
+    minimizer(name: string): Config.Plugin<this, webpack.Plugin>;
+    namedChunks(value: boolean): this;
+    namedModules(value: boolean): this;
+    nodeEnv(value: boolean | string): this;
+    noEmitOnErrors(value: boolean): this;
+    occurrenceOrder(value: boolean): this;
+    portableRecords(value: boolean): this;
+    providedExports(value: boolean): this;
+    removeAvailableModules(value: boolean): this;
+    removeEmptyChunks(value: boolean): this;
+    runtimeChunk(value: boolean | 'single' | 'multiple' | RuntimeChunk): this;
+    sideEffects(value: boolean): this;
+    splitChunks(value: SplitChunksOptions): this;
+    usedExports(value: boolean): this;
+  }
+
+  interface RuntimeChunk {
+    name: string | RuntimeChunkFunction;
+  }
+
+  type RuntimeChunkFunction = (entryPoint: EntryPoint) => string;
+
+  interface SplitChunksOptions {
+    [name: string]: any;
+  }
+
+  interface LoaderOptions {
+    [name: string]: any;
+  }
+
+  class Use<Parent = Rule> extends ChainedMap<Parent> implements Orderable {
+    loader(value: string): this;
+    options(value: LoaderOptions): this;
+
+    tap(f: (options: LoaderOptions) => LoaderOptions): this;
+
+    // Orderable
+    before(name: string): this;
+    after(name: string): this;
+  }
+
+  type DevTool =
+    | 'eval'
+    | 'inline-source-map'
+    | 'cheap-eval-source-map'
+    | 'cheap-source-map'
+    | 'cheap-module-eval-source-map'
+    | 'cheap-module-source-map'
+    | 'eval-source-map'
+    | 'source-map'
+    | 'nosources-source-map'
+    | 'hidden-source-map'
+    | 'nosources-source-map'
+    | '@eval'
+    | '@inline-source-map'
+    | '@cheap-eval-source-map'
+    | '@cheap-source-map'
+    | '@cheap-module-eval-source-map'
+    | '@cheap-module-source-map'
+    | '@eval-source-map'
+    | '@source-map'
+    | '@nosources-source-map'
+    | '@hidden-source-map'
+    | '@nosources-source-map'
+    | '#eval'
+    | '#inline-source-map'
+    | '#cheap-eval-source-map'
+    | '#cheap-source-map'
+    | '#cheap-module-eval-source-map'
+    | '#cheap-module-source-map'
+    | '#eval-source-map'
+    | '#source-map'
+    | '#nosources-source-map'
+    | '#hidden-source-map'
+    | '#nosources-source-map'
+    | '#@eval'
+    | '#@inline-source-map'
+    | '#@cheap-eval-source-map'
+    | '#@cheap-source-map'
+    | '#@cheap-module-eval-source-map'
+    | '#@cheap-module-source-map'
+    | '#@eval-source-map'
+    | '#@source-map'
+    | '#@nosources-source-map'
+    | '#@hidden-source-map'
+    | '#@nosources-source-map'
+    | boolean;
+
+  interface PluginClass<PluginType extends Tapable.Plugin = webpack.Plugin> {
+    new (...opts: any[]): PluginType;
+  }
+
+  interface Orderable {
+    before(name: string): this;
+    after(name: string): this;
+  }
+}

package/dist/applyOptionsChain.d.ts

@@ -1,6 +1,2 @@
-export declare const applyOptionsChain: <T, U>(defaults: T, options?: T | (T | ((config: T, utils?: U | undefined) => void | T))[] | ((config: T, utils?: U | undefined) => void | T) | undefined, utils?: U | undefined, mergeFn?: {
-    <T_1, U_1>(target: T_1, source: U_1): T_1 & U_1;
-    <T_2, U_2, V>(target: T_2, source1: U_2, source2: V): T_2 & U_2 & V;
-    <T_3, U_3, V_1, W>(target: T_3, source1: U_3, source2: V_1, source3: W): T_3 & U_3 & V_1 & W;
-    (target: object, ...sources: any[]): any;
-}) => T;
+export declare function applyOptionsChain<T, U>(defaults: T, options?: T | ((config: T, utils?: U) => T | void) | Array<T | ((config: T, utils?: U) => T | void)>, utils?: U, mergeFn?: typeof Object.assign): T;
+export declare function applyOptionsChain<T, U>(defaults: T, options: T | ((config: T, utils: U) => T | void) | Array<T | ((config: T, utils: U) => T | void)>, utils: U, mergeFn?: typeof Object.assign): T;

package/dist/applyOptionsChain.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyOptionsChain = void 0;
 // eslint-disable-next-line import/no-useless-path-segments
 const index_1 = require("./index");
-const applyOptionsChain = (defaults, options, utils, mergeFn = Object.assign) => {
+function applyOptionsChain(defaults, options, utils, mergeFn = Object.assign) {
     if (!options) {
         return defaults;
     }
@@ -20,11 +20,11 @@ const applyOptionsChain = (defaults, options, utils, mergeFn = Object.assign) =>
         }
     }
     else if (Array.isArray(options)) {
-        return options.reduce((memo, cur) => (0, exports.applyOptionsChain)(memo, cur, utils, mergeFn), defaults);
+        return options.reduce((memo, cur) => applyOptionsChain(memo, cur, utils, mergeFn), defaults);
     }
     else {
         throw new Error(`applyOptionsChain error:\ndefault options is: ${JSON.stringify(defaults)}`);
     }
     return defaults;
-};
+}
 exports.applyOptionsChain = applyOptionsChain;

package/dist/chainId.d.ts

@@ -0,0 +1,116 @@
+export declare const CHAIN_ID: {
+    /** Predefined rules */
+    readonly RULE: {
+        /** Rule for .mjs */
+        readonly MJS: "mjs";
+        /** Rule for predefined loaders */
+        readonly LOADERS: "loaders";
+    };
+    /** Predefined rule groups */
+    readonly ONE_OF: {
+        readonly JS: "js";
+        readonly TS: "ts";
+        readonly CSS: "css";
+        readonly LESS: "less";
+        readonly SASS: "sass";
+        readonly YAML: "yml";
+        readonly TOML: "toml";
+        readonly FALLBACK: "fallback";
+        readonly MARKDOWN: "markdown";
+        readonly BFF_CLIENT: "bff-client";
+        readonly CSS_MODULES: "css-modules";
+        readonly LESS_MODULES: "less-modules";
+        readonly SASS_MODULES: "sass-modules";
+        readonly SVG: "svg";
+        readonly SVG_URL: "svg-url";
+        readonly SVG_INLINE: "svg-inline";
+        readonly ASSETS: "assets";
+        readonly ASSETS_URL: "assets-url";
+        readonly ASSETS_INLINE: "assets-inline";
+    };
+    /** Predefined loaders */
+    readonly USE: {
+        /** ts-loader */
+        readonly TS: "ts";
+        /** css-loader */
+        readonly CSS: "css";
+        /** url-loader */
+        readonly URL: "url";
+        /** file-loader */
+        readonly FILE: "file";
+        /** @svgr/webpack */
+        readonly SVGR: "svgr";
+        /** yaml-loader */
+        readonly YAML: "yaml";
+        /** toml-loader */
+        readonly TOML: "toml";
+        /** html-loader */
+        readonly HTML: "html";
+        /** babel-loader */
+        readonly BABEL: "babel";
+        /** style-loader */
+        readonly STYLE: "style-loader";
+        /** postcss-loader */
+        readonly POSTCSS: "postcss";
+        /** markdown-loader */
+        readonly MARKDOWN: "markdown";
+        /** css-modules-typescript-loader */
+        readonly CSS_MODULES_TS: "css-modules-typescript";
+        /** mini-css-extract-plugin.loader */
+        readonly MINI_CSS_EXTRACT: "mini-css-extract";
+    };
+    /** Predefined plugins */
+    readonly PLUGIN: {
+        /** HotModuleReplacementPlugin */
+        readonly HMR: "hmr";
+        /** CopyWebpackPlugin */
+        readonly COPY: "copy";
+        /** HtmlWebpackPlugin */
+        readonly HTML: "html";
+        /** DefinePlugin */
+        readonly DEFINE: "define";
+        /** IgnorePlugin */
+        readonly IGNORE: "ignore";
+        /** BannerPlugin */
+        readonly BANNER: "banner";
+        /** Webpackbar */
+        readonly PROGRESS: "progress";
+        /** AppIconPlugin */
+        readonly APP_ICON: "app-icon";
+        /** LoadableWebpackPlugin */
+        readonly LOADABLE: "loadable";
+        /** WebpackManifestPlugin */
+        readonly MANIFEST: "webpack-manifest";
+        /** ForkTsCheckerWebpackPlugin */
+        readonly TS_CHECKER: "ts-checker";
+        /** InlineChunkHtmlPlugin */
+        readonly INLINE_HTML: "inline-html";
+        /** WebpackBundleAnalyzer */
+        readonly BUNDLE_ANALYZER: "bundle-analyze";
+        /** BottomTemplatePlugin */
+        readonly BOTTOM_TEMPLATE: "bottom-template";
+        /** MiniCssExtractPlugin */
+        readonly MINI_CSS_EXTRACT: "mini-css-extract";
+        /** ReactFastRefreshPlugin */
+        readonly REACT_FAST_REFRESH: "react-fast-refresh";
+        /** ProvidePlugin for node polyfill */
+        readonly NODE_POLYFILL_PROVIDE: "node-polyfill-provide";
+    };
+    /** Predefined minimizers */
+    readonly MINIMIZER: {
+        /** TerserWebpackPlugin */
+        readonly JS: "js";
+        /** CssMinimizerWebpackPlugin */
+        readonly CSS: "css";
+        /** ESBuildPlugin */
+        readonly ESBUILD: "js-css";
+    };
+    /** Predefined resolve plugins */
+    readonly RESOLVE_PLUGIN: {
+        /** ModuleScopePlugin */
+        readonly MODULE_SCOPE: "module-scope";
+        /** TsConfigPathsPlugin */
+        readonly TS_CONFIG_PATHS: "ts-config-paths";
+    };
+};
+export declare type ChainIdentifier = typeof CHAIN_ID;

package/dist/chainId.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHAIN_ID = void 0;
+exports.CHAIN_ID = {
+    /** Predefined rules */
+    RULE: {
+        /** Rule for .mjs */
+        MJS: 'mjs',
+        /** Rule for predefined loaders */
+        LOADERS: 'loaders',
+    },
+    /** Predefined rule groups */
+    ONE_OF: {
+        JS: 'js',
+        TS: 'ts',
+        CSS: 'css',
+        LESS: 'less',
+        SASS: 'sass',
+        YAML: 'yml',
+        TOML: 'toml',
+        FALLBACK: 'fallback',
+        MARKDOWN: 'markdown',
+        BFF_CLIENT: 'bff-client',
+        CSS_MODULES: 'css-modules',
+        LESS_MODULES: 'less-modules',
+        SASS_MODULES: 'sass-modules',
+        SVG: 'svg',
+        SVG_URL: 'svg-url',
+        SVG_INLINE: 'svg-inline',
+        ASSETS: 'assets',
+        ASSETS_URL: 'assets-url',
+        ASSETS_INLINE: 'assets-inline',
+    },
+    /** Predefined loaders */
+    USE: {
+        /** ts-loader */
+        TS: 'ts',
+        /** css-loader */
+        CSS: 'css',
+        /** url-loader */
+        URL: 'url',
+        /** file-loader */
+        FILE: 'file',
+        /** @svgr/webpack */
+        SVGR: 'svgr',
+        /** yaml-loader */
+        YAML: 'yaml',
+        /** toml-loader */
+        TOML: 'toml',
+        /** html-loader */
+        HTML: 'html',
+        /** babel-loader */
+        BABEL: 'babel',
+        /** style-loader */
+        STYLE: 'style-loader',
+        /** postcss-loader */
+        POSTCSS: 'postcss',
+        /** markdown-loader */
+        MARKDOWN: 'markdown',
+        /** css-modules-typescript-loader */
+        CSS_MODULES_TS: 'css-modules-typescript',
+        /** mini-css-extract-plugin.loader */
+        MINI_CSS_EXTRACT: 'mini-css-extract',
+    },
+    /** Predefined plugins */
+    PLUGIN: {
+        /** HotModuleReplacementPlugin */
+        HMR: 'hmr',
+        /** CopyWebpackPlugin */
+        COPY: 'copy',
+        /** HtmlWebpackPlugin */
+        HTML: 'html',
+        /** DefinePlugin */
+        DEFINE: 'define',
+        /** IgnorePlugin */
+        IGNORE: 'ignore',
+        /** BannerPlugin */
+        BANNER: 'banner',
+        /** Webpackbar */
+        PROGRESS: 'progress',
+        /** AppIconPlugin */
+        APP_ICON: 'app-icon',
+        /** LoadableWebpackPlugin */
+        LOADABLE: 'loadable',
+        /** WebpackManifestPlugin */
+        MANIFEST: 'webpack-manifest',
+        /** ForkTsCheckerWebpackPlugin */
+        TS_CHECKER: 'ts-checker',
+        /** InlineChunkHtmlPlugin */
+        INLINE_HTML: 'inline-html',
+        /** WebpackBundleAnalyzer */
+        BUNDLE_ANALYZER: 'bundle-analyze',
+        /** BottomTemplatePlugin */
+        BOTTOM_TEMPLATE: 'bottom-template',
+        /** MiniCssExtractPlugin */
+        MINI_CSS_EXTRACT: 'mini-css-extract',
+        /** ReactFastRefreshPlugin */
+        REACT_FAST_REFRESH: 'react-fast-refresh',
+        /** ProvidePlugin for node polyfill */
+        NODE_POLYFILL_PROVIDE: 'node-polyfill-provide',
+    },
+    /** Predefined minimizers */
+    MINIMIZER: {
+        /** TerserWebpackPlugin */
+        JS: 'js',
+        /** CssMinimizerWebpackPlugin */
+        CSS: 'css',
+        /** ESBuildPlugin */
+        ESBUILD: 'js-css',
+    },
+    /** Predefined resolve plugins */
+    RESOLVE_PLUGIN: {
+        /** ModuleScopePlugin */
+        MODULE_SCOPE: 'module-scope',
+        /** TsConfigPathsPlugin */
+        TS_CONFIG_PATHS: 'ts-config-paths',
+    },
+};

package/dist/compiled.d.ts

@@ -26,7 +26,8 @@ export { default as dotenvExpand } from '../compiled/dotenv-expand';
 export { default as browserslist } from '../compiled/browserslist';
 export { default as recursiveReaddir } from '../compiled/recursive-readdir';
 export { program, Command } from '../compiled/commander';
-export { Signale, type SignaleOptions } from '../compiled/signale';
+export { Signale } from '../compiled/signale';
+export type { SignaleOptions } from '../compiled/signale';
 export type { IOptions as GlobOptions } from '../compiled/glob';
 export type { GlobbyOptions } from '../compiled/globby';
 export type { FSWatcher, WatchOptions } from '../compiled/chokidar';

package/dist/index.d.ts

@@ -31,3 +31,4 @@ export * from './emptyDir';
 export * from './getServerConfig';
 export * from './ssr';
 export * from './analyzeProject';
+export * from './chainId';

package/dist/index.js

@@ -43,3 +43,4 @@ __exportStar(require("./emptyDir"), exports);
 __exportStar(require("./getServerConfig"), exports);
 __exportStar(require("./ssr"), exports);
 __exportStar(require("./analyzeProject"), exports);
+__exportStar(require("./chainId"), exports);

package/dist/monorepo.js

@@ -30,7 +30,11 @@ exports.isPnpmWorkspaces = isPnpmWorkspaces;
 const isMonorepo = (root) => (0, exports.isLerna)(root) || (0, exports.isYarnWorkspaces)(root) || (0, exports.isPnpmWorkspaces)(root);
 exports.isMonorepo = isMonorepo;
 const isModernjsMonorepo = (root) => {
-    const json = JSON.parse(fs_1.default.readFileSync(path_1.default.join(root, 'package.json'), 'utf8'));
+    const pkgJsonPath = path_1.default.join(root, 'package.json');
+    if (!fs_1.default.existsSync(pkgJsonPath)) {
+        return false;
+    }
+    const json = JSON.parse(fs_1.default.readFileSync(pkgJsonPath, 'utf8'));
     const deps = {
         ...(json.dependencies || {}),
         ...(json.devDependencies || {}),