• Version 5.0.2
  • Published
  • 75.8 kB
  • 4 dependencies
  • MIT license


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


A plugin for webpack that enables bundling Aurelia applications.



variable dependencyImports

const dependencyImports: Symbol;

    variable preserveModuleName

    const preserveModuleName: Symbol;


      class AureliaDependenciesPlugin

      class AureliaDependenciesPlugin {}


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

          method apply

          apply: (compiler: any) => void;

            class AureliaPlugin

            class AureliaPlugin {}


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


                        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(dist: string);

                                method apply

                                apply: (resolver: any) => void;

                                  class GlobDependenciesPlugin

                                  class GlobDependenciesPlugin extends BaseIncludePlugin {}


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

                                                property modules

                                                modules: { [module: string]: any[] };

                                                  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(isDll?: boolean);

                                                                method apply

                                                                apply: (compiler: any) => void;


                                                                  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: AureliaModuleConfig | AureliaModuleConfig[];
                                                                          • A single config or a list of configurations to ensure the AureliaPlugin can bundle appropriate modules for the aurelia-loader to load at runtime.

                                                                            aurelia-framework exposes configuration helpers like .standardConfiguration() etc..., that load plugins (aurelia-templating-binding, aurelia-templating-resources, aurelia-templating-router etc...), but we can't know if they are actually used or not at build time.

                                                                            This config gives users the ability to indicate what are used at build time. Custom config is performed in use code and can use .moduleName() like normal.

                                                                          property dist

                                                                          dist: string;
                                                                          • A dist folder to look for in *all* modules. Possible values for the core Aurelia modules are: - es2015 - commonjs - amd - native-modules

                                                                            Note: application may choose to have a different dist types for their modules, and not use the above modules.

                                                                            Note: In the future, multiple dist with fallback may be supported to help application specify the dist with as latest syntaxes as possible.

                                                                          property entry

                                                                          entry?: string | string[];

                                                                            property features

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

                                                                              property includeAll

                                                                              includeAll: false | string;
                                                                              • if a string is given, include everything inside that folder, recursively.

                                                                              property moduleMethods

                                                                              moduleMethods: string[];

                                                                                property noHtmlLoader

                                                                                noHtmlLoader: boolean;

                                                                                  property noInlineView

                                                                                  noInlineView: boolean;

                                                                                    property noModulePathResolve

                                                                                    noModulePathResolve: boolean;

                                                                                      property noWebpackLoader

                                                                                      noWebpackLoader: boolean;

                                                                                        property pal

                                                                                        pal?: string;
                                                                                        • An application can use this config to specify what PAL module to use.

                                                                                          Possible values are: - aurelia-pal-browser - aurelia-pal-worker - aurelia-pal-nodejs

                                                                                          By default, it'll be determined based on the webpack configuration.

                                                                                        property viewsExtensions

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

                                                                                          property viewsFor

                                                                                          viewsFor: string;

                                                                                            Type Aliases

                                                                                            type AureliaModuleConfig

                                                                                            type AureliaModuleConfig = keyof typeof configModuleNames | 'standard' | 'basic';

                                                                                              type Convention

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

                                                                                                type Polyfills

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

                                                                                                  Package Files (10)

                                                                                                  Dependencies (4)

                                                                                                  Dev Dependencies (46)

                                                                                                  Peer Dependencies (1)


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

                                                                                                  You may also use to create a custom badge linking to

                                                                                                  • Markdown
                                                                                                  • HTML
                                                                                                    <a href=""><img src="" alt=""></a>