mini-css-extract-plugin

  • Version 2.9.2
  • Published
  • 134 kB
  • 2 dependencies
  • MIT license

Install

npm i mini-css-extract-plugin
yarn add mini-css-extract-plugin
pnpm add mini-css-extract-plugin

Overview

extracts CSS into separate files

Index

Variables

variable loader

var loader: string;

    variable loader

    var loader: string;

      variable pluginName

      const pluginName: string;
      • {any} TODO

      variable pluginName

      const pluginName: string;
      • {any} TODO

      variable pluginSymbol

      const pluginSymbol: Symbol;

        variable pluginSymbol

        const pluginSymbol: Symbol;

          Classes

          class MiniCssExtractPlugin

          class MiniCssExtractPlugin {}

            constructor

            constructor(options?: PluginOptions);
            • Parameter options

            method apply

            apply: (compiler: any) => void;
            • Parameter compiler

            method getCompilationHooks

            static getCompilationHooks: (
            compilation: any
            ) => MiniCssExtractPluginCompilationHooks;
            • Returns all hooks for the given compilation

              Parameter compilation

              the compilation

              Returns

              {MiniCssExtractPluginCompilationHooks} hooks

            method getCssDependency

            static getCssDependency: (webpack: any) => CssDependencyConstructor;
            • Parameter webpack

              Returns

              {CssDependencyConstructor}

            method getCssModule

            static getCssModule: (webpack: any) => CssModuleConstructor;
            • Parameter webpack

              Returns

              {CssModuleConstructor}

            Type Aliases

            type AssetInfo

            type AssetInfo = import('webpack').AssetInfo;

              type Chunk

              type Chunk = import('webpack').Chunk;

                type ChunkGraph

                type ChunkGraph = import('webpack').ChunkGraph;

                  type ChunkGroup

                  type ChunkGroup = Parameters<import('webpack').Chunk['isInGroup']>[0];

                    type Compilation

                    type Compilation = import('webpack').Compilation;

                      type Compiler

                      type Compiler = import('webpack').Compiler;

                        type Configuration

                        type Configuration = import('webpack').Configuration;

                          type CssDependency

                          type CssDependency = Dependency & CssModuleDependency;

                            type CssDependencyConstructor

                            type CssDependencyConstructor = new (
                            loaderDependency: CssDependencyOptions,
                            context: string | null,
                            identifierIndex: number
                            ) => CssDependency;

                              type CssDependencyOptions

                              type CssDependencyOptions = Omit<LoaderDependency, 'context'>;

                                type CssModule

                                type CssModule = import('webpack').Module & {
                                content: Buffer;
                                media?: string | undefined;
                                sourceMap?: Buffer | undefined;
                                supports?: string | undefined;
                                layer?: string | undefined;
                                assets?:
                                | {
                                [key: string]: any;
                                }
                                | undefined;
                                assetsInfo?: Map<string, import('webpack').AssetInfo> | undefined;
                                };

                                  type CssModuleConstructor

                                  type CssModuleConstructor = new (dependency: CssModuleDependency) => CssModule;

                                    type CssModuleDependency

                                    type CssModuleDependency = {
                                    context: string | null;
                                    identifier: string;
                                    identifierIndex: number;
                                    content: Buffer;
                                    sourceMap?: Buffer | undefined;
                                    media?: string | undefined;
                                    supports?: string | undefined;
                                    layer?: TODO;
                                    assetsInfo?: Map<string, import('webpack').AssetInfo> | undefined;
                                    assets?:
                                    | {
                                    [key: string]: any;
                                    }
                                    | undefined;
                                    };

                                      type Dependency

                                      type Dependency = import('webpack').Dependency;

                                        type LoaderDependency

                                        type LoaderDependency = import('./loader.js').Dependency;

                                          type LoaderOptions

                                          type LoaderOptions = {
                                          publicPath?:
                                          | string
                                          | ((resourcePath: string, rootContext: string) => string)
                                          | undefined;
                                          emit?: boolean | undefined;
                                          esModule?: boolean | undefined;
                                          layer?: string | undefined;
                                          defaultExport?: boolean | undefined;
                                          };

                                            type MiniCssExtractPluginCompilationHooks

                                            type MiniCssExtractPluginCompilationHooks = {
                                            beforeTagInsert: import('tapable').SyncWaterfallHook<[string, VarNames], string>;
                                            linkPreload: SyncWaterfallHook<[string, Chunk]>;
                                            linkPrefetch: SyncWaterfallHook<[string, Chunk]>;
                                            };

                                              type Module

                                              type Module = import('webpack').Module;

                                                type NormalizedPluginOptions

                                                type NormalizedPluginOptions = {
                                                filename: Required<Configuration>['output']['filename'];
                                                chunkFilename?: Required<Configuration>['output']['chunkFilename'];
                                                ignoreOrder: boolean;
                                                insert?: string | ((linkTag: HTMLLinkElement) => void) | undefined;
                                                attributes?: Record<string, string> | undefined;
                                                linkType?: string | false | undefined;
                                                runtime: boolean;
                                                experimentalUseImportModule?: boolean | undefined;
                                                };

                                                  type PluginOptions

                                                  type PluginOptions = {
                                                  filename?: Required<Configuration>['output']['filename'];
                                                  chunkFilename?: Required<Configuration>['output']['chunkFilename'];
                                                  ignoreOrder?: boolean | undefined;
                                                  insert?: string | ((linkTag: HTMLLinkElement) => void) | undefined;
                                                  attributes?: Record<string, string> | undefined;
                                                  linkType?: string | false | undefined;
                                                  runtime?: boolean | undefined;
                                                  experimentalUseImportModule?: boolean | undefined;
                                                  };

                                                    type RuntimeOptions

                                                    type RuntimeOptions = {
                                                    insert: string | ((linkTag: HTMLLinkElement) => void) | undefined;
                                                    linkType: string | false | 'text/css';
                                                    attributes: Record<string, string> | undefined;
                                                    };

                                                      type Schema

                                                      type Schema = import('schema-utils/declarations/validate').Schema;

                                                        type Source

                                                        type Source = import('webpack').sources.Source;

                                                          type TODO

                                                          type TODO = any;

                                                            type VarNames

                                                            type VarNames = {
                                                            tag: string;
                                                            chunkId: string;
                                                            href: string;
                                                            resolve: string;
                                                            reject: string;
                                                            };

                                                              type WebpackError

                                                              type WebpackError = import('webpack').WebpackError;

                                                                Package Files (1)

                                                                Dependencies (2)

                                                                Dev Dependencies (35)

                                                                Peer Dependencies (1)

                                                                Badge

                                                                To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/mini-css-extract-plugin.

                                                                • Markdown
                                                                  [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/mini-css-extract-plugin)
                                                                • HTML
                                                                  <a href="https://www.jsdocs.io/package/mini-css-extract-plugin"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>