webpack-atoms

createAtoms: (options?: WebpackAtomsOptions) => WebpackAtoms;

type AstroturfRuleFactory = RuleFactory<AstroTurfOptions> & {
    sass: RuleFactory<AstroTurfOptions>;
    less: RuleFactory<AstroTurfOptions>;
};

type ContextualRuleFactory<T = {}> = RuleFactory<T> & {
    internal: RuleFactory<T>;
    external: RuleFactory<T>;
};

type Env = 'production' | 'test' | 'development';

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

type LoaderResolver<T extends {}> = (options?: T) => RuleSetUseItem;

type PluginAtoms = BuiltinPlugins & {
    define: PluginFactory;
    extractCss: PluginFactory;
    html: PluginFactory;
    loaderOptions: PluginFactory;
    moment: PluginFactory;
    minifyJs: PluginFactory;
    minifyCss: PluginFactory;
    unusedFiles: PluginFactory;
    favicons: PluginFactory;
    copy: PluginFactory;
};

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

type RuleFactory<T extends {} = {}> = (options?: T) => Rule;

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[];
};

type WebpackAtomsOptions = {
    babelConfig?: {};
    browsers?: string[];
    vendorRegex?: RegExp;
    env?: Env | null;
    assetRelativeRoot?: string;
    disableMiniExtractInDev?: boolean;
    ignoreBrowserslistConfig?: boolean;
};