webpack-atoms/lib/index.d.ts

Small atomic bits for crafting webpack configs

import HtmlWebpackPlugin from 'html-webpack-plugin';
import MiniCssExtractPlugin from 'mini-css-extract-plugin';
import { RuleSetRule, RuleSetUseItem } from 'webpack';
import builtinPlugins from './plugins';
import { StatsOptions } from './stats';
import type { FaviconWebpackPlugionOptions } from 'favicons-webpack-plugin/src/options';
export type { FaviconWebpackPlugionOptions, HtmlWebpackPlugin };
export declare type Env = 'production' | 'test' | 'development';
export declare type LoaderResolver<T extends {}> = (options?: T) => RuleSetUseItem;
declare type Rule = RuleSetRule;
export declare type RuleFactory<T extends {} = {}> = (options?: T) => Rule;
export declare type ContextualRuleFactory<T = {}> = RuleFactory<T> & {
    internal: RuleFactory<T>;
    external: RuleFactory<T>;
};
export interface AstroTurfOptions {
    getFileName?(path: string, opts: AstroTurfOptions, id: string): string;
    allowGlobal?: boolean;
    extension?: string;
    tagName?: string;
    styleTag?: string;
    useAltLoader?: boolean;
    enableCssProp?: boolean;
}
export declare type AstroturfRuleFactory = RuleFactory<AstroTurfOptions> & {
    sass: RuleFactory<AstroTurfOptions>;
    less: RuleFactory<AstroTurfOptions>;
};
declare type PluginInstance = any;
declare type PluginFactory = (...args: any) => PluginInstance;
declare type BuiltinPlugins = typeof builtinPlugins;
declare type StatAtoms = {
    none: StatsOptions;
    minimal: StatsOptions;
};
export declare type WebpackAtomsOptions = {
    babelConfig?: {};
    browsers?: string[];
    vendorRegex?: RegExp;
    env?: Env | null;
    assetRelativeRoot?: string;
    disableMiniExtractInDev?: boolean;
    ignoreBrowserslistConfig?: boolean;
};
export declare type LoaderAtoms = {
    json: LoaderResolver<any>;
    yaml: LoaderResolver<any>;
    null: LoaderResolver<any>;
    raw: LoaderResolver<any>;
    style: LoaderResolver<any>;
    css: LoaderResolver<any>;
    miniCssExtract: LoaderResolver<{
        disable?: boolean;
        fallback?: RuleSetUseItem;
    } & MiniCssExtractPlugin.PluginOptions>;
    astroturf: LoaderResolver<any>;
    postcss: LoaderResolver<{
        browsers?: string[];
        postcssOptions?: Record<string, any> | ((...args: any[]) => Record<string, any>);
    }>;
    less: LoaderResolver<any>;
    sass: LoaderResolver<any>;
    file: LoaderResolver<any>;
    url: LoaderResolver<any>;
    js: LoaderResolver<any>;
    imports: LoaderResolver<any>;
    exports: LoaderResolver<any>;
};
declare type JsRule = RuleFactory<any> & {
    inlineCss: RuleFactory<any>;
};
export declare type RuleAtoms = {
    js: JsRule;
    yaml: RuleFactory<any>;
    fonts: RuleFactory<any>;
    images: RuleFactory<any>;
    audioVideo: RuleFactory<any>;
    files: RuleFactory<any>;
    css: ContextualRuleFactory;
    postcss: ContextualRuleFactory;
    less: ContextualRuleFactory;
    sass: ContextualRuleFactory;
    astroturf: AstroturfRuleFactory;
};
export declare type PluginAtoms = BuiltinPlugins & {
    define: PluginFactory;
    extractCss: PluginFactory;
    html: PluginFactory;
    loaderOptions: PluginFactory;
    moment: PluginFactory;
    minifyJs: PluginFactory;
    minifyCss: PluginFactory;
    unusedFiles: PluginFactory;
    favicons: PluginFactory;
    copy: PluginFactory;
};
export declare type WebpackAtoms = {
    loaders: LoaderAtoms;
    rules: RuleAtoms;
    plugins: PluginAtoms;
    stats: StatAtoms;
    makeExternalOnly: (original: RuleFactory<any>) => RuleFactory<any>;
    makeInternalOnly: (original: RuleFactory<any>) => RuleFactory<any>;
    makeExtractLoaders: (options: {
        extract?: boolean;
    }, config: {
        fallback: RuleSetUseItem;
        use: RuleSetUseItem[];
    }) => RuleSetUseItem[];
};
declare function createAtoms(options?: WebpackAtomsOptions): WebpackAtoms;
declare const makeExternalOnly: (original: RuleFactory<any>) => RuleFactory<any>, makeInternalOnly: (original: RuleFactory<any>) => RuleFactory<any>, makeExtractLoaders: (options: {
    extract?: boolean;
}, config: {
    fallback: RuleSetUseItem;
    use: RuleSetUseItem[];
}) => RuleSetUseItem[], stats: StatAtoms, loaders: LoaderAtoms, rules: RuleAtoms, plugins: PluginAtoms;
export { makeExternalOnly, makeInternalOnly, makeExtractLoaders, loaders, rules, plugins, stats, createAtoms, };