aurelia-webpack-plugin

  • Version 4.0.0
  • Published
  • 60.7 kB
  • 4 dependencies
  • MIT license

Install

npm i aurelia-webpack-plugin
yarn add aurelia-webpack-plugin
pnpm add aurelia-webpack-plugin

Overview

A plugin for webpack that enables bundling Aurelia applications.

Index

Variables

variable dependencyImports

const dependencyImports: Symbol;

    variable preserveModuleName

    const preserveModuleName: Symbol;

      Classes

      class AureliaDependenciesPlugin

      class AureliaDependenciesPlugin {}

        constructor

        constructor(...methods: string[]);

          method apply

          apply: (compiler: any) => void;

            class AureliaPlugin

            class AureliaPlugin {}

              constructor

              constructor(options?: Partial<Options>);

                property options

                options: Options;

                  method addEntry

                  addEntry: (options: any, modules: string | string[]) => void;

                    method apply

                    apply: (compiler: any) => void;

                      class ConventionDependenciesPlugin

                      class ConventionDependenciesPlugin extends BaseIncludePlugin {}

                        constructor

                        constructor(
                        glob: string,
                        conventions?: string | Convention | (string | Convention)[]
                        );
                        • glob: a pattern that filters which files are affected

                        property conventions

                        conventions: Convention[];

                          method parser

                          parser: (compilation: any, parser: any, addDependency: AddDependency) => void;

                            class DistPlugin

                            class DistPlugin {}

                              constructor

                              constructor(dist: string);

                                method apply

                                apply: (resolver: any) => void;

                                  class GlobDependenciesPlugin

                                  class GlobDependenciesPlugin extends BaseIncludePlugin {}

                                    constructor

                                    constructor(hash: { [module: string]: string | string[] });
                                    • Each hash member is a module name, for which globbed value(s) will be added as dependencies

                                    method apply

                                    apply: (compiler: any) => void;

                                      method parser

                                      parser: (compilation: any, parser: any, addDependency: AddDependency) => void;

                                        class HtmlDependenciesPlugin

                                        class HtmlDependenciesPlugin extends BaseIncludePlugin {}

                                          method parser

                                          parser: (compilation: any, parser: any, addDependency: AddDependency) => void;

                                            class ModuleDependenciesPlugin

                                            class ModuleDependenciesPlugin extends BaseIncludePlugin {}

                                              constructor

                                              constructor(hash: ModuleDependenciesPluginOptions);
                                              • Each hash member is a module name, for which additional module names (or options) are added as dependencies.

                                              property hash

                                              hash: { [name: string]: (string | DependencyOptionsEx)[] };

                                                property modules

                                                modules: { [module: string]: (string | DependencyOptionsEx)[] };

                                                  property root

                                                  root: string;

                                                    method apply

                                                    apply: (compiler: any) => void;

                                                      method parser

                                                      parser: (compilation: any, parser: any, addDependency: AddDependency) => void;

                                                        class PreserveExportsPlugin

                                                        class PreserveExportsPlugin {}

                                                          method apply

                                                          apply: (compiler: any) => void;

                                                            class PreserveModuleNamePlugin

                                                            class PreserveModuleNamePlugin {}

                                                              constructor

                                                              constructor(isDll?: boolean);

                                                                method apply

                                                                apply: (compiler: any) => void;

                                                                  Interfaces

                                                                  interface ModuleDependenciesPluginOptions

                                                                  interface ModuleDependenciesPluginOptions {}

                                                                    index signature

                                                                    [module: string]:
                                                                    | undefined
                                                                    | string
                                                                    | DependencyOptionsEx
                                                                    | (undefined | string | DependencyOptionsEx)[];

                                                                      interface Options

                                                                      interface Options {}

                                                                        property aureliaApp

                                                                        aureliaApp?: string;

                                                                          property aureliaConfig

                                                                          aureliaConfig: string | string[];

                                                                            property dist

                                                                            dist: string;

                                                                              property entry

                                                                              entry?: string | string[];

                                                                                property features

                                                                                features: {
                                                                                ie?: boolean;
                                                                                svg?: boolean;
                                                                                unparser?: boolean;
                                                                                polyfills?: Polyfills;
                                                                                };

                                                                                  property includeAll

                                                                                  includeAll: false | string;

                                                                                    property moduleMethods

                                                                                    moduleMethods: string[];

                                                                                      property noHtmlLoader

                                                                                      noHtmlLoader: boolean;

                                                                                        property noInlineView

                                                                                        noInlineView: boolean;

                                                                                          property noModulePathResolve

                                                                                          noModulePathResolve: boolean;

                                                                                            property noWebpackLoader

                                                                                            noWebpackLoader: boolean;

                                                                                              property pal

                                                                                              pal?: string;

                                                                                                property viewsExtensions

                                                                                                viewsExtensions: string | Convention | (string | Convention)[];

                                                                                                  property viewsFor

                                                                                                  viewsFor: string;

                                                                                                    Type Aliases

                                                                                                    type Convention

                                                                                                    type Convention = (filename: string) => string;

                                                                                                      type Polyfills

                                                                                                      type Polyfills = 'es2015' | 'es2016' | 'esnext' | 'none';

                                                                                                        Package Files (10)

                                                                                                        Dependencies (4)

                                                                                                        Dev Dependencies (3)

                                                                                                        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/aurelia-webpack-plugin.

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