weboptimizer 2.0.1440 → 2.0.1441

package/browser.d.ts

@@ -0,0 +1,11 @@
+import { Browser, InitializedBrowser } from './type';
+export declare const browser: Browser;
+/**
+ * Provides a generic browser api in node or web contexts.
+ * @param replaceWindow - Indicates whether a potential existing window object
+ * should be replaced or not.
+ *
+ * @returns Determined environment.
+ */
+export declare const getInitializedBrowser: (replaceWindow?: boolean) => Promise<InitializedBrowser>;
+export default getInitializedBrowser;

package/configurator.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="webpack-env" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ResolvedConfiguration } from './type';
+export declare let loadedConfiguration: null | ResolvedConfiguration;
+/**
+ * Main entry point to determine current configuration.
+ * @param context - Location from where to build current application.
+ * @param currentWorkingDirectory - Current working directory to use as
+ * reference.
+ * @param commandLineArguments - Arguments to take into account.
+ * @param webOptimizerPath - Current optimizer context path.
+ * @param environment - Environment variables to take into account.
+ *
+ * @returns Nothing.
+ */
+export declare const load: (context?: string, currentWorkingDirectory?: string, commandLineArguments?: Array<string>, webOptimizerPath?: string, environment?: NodeJS.ProcessEnv) => ResolvedConfiguration;
+/**
+ * Get cached or determined configuration object.
+ * @returns Nothing.
+ */
+export declare const get: () => ResolvedConfiguration;
+export default get;

package/ejsLoader.d.ts

@@ -0,0 +1,35 @@
+import { Encoding, Mapping } from 'clientnode/type';
+import { Options, TemplateFunction as EJSTemplateFunction } from 'ejs';
+import { LoaderContext } from 'webpack';
+import { Extensions, Replacements } from './type';
+export type PreCompiledTemplateFunction = ((...parameters: Array<unknown>) => string);
+export type TemplateFunction = EJSTemplateFunction | PreCompiledTemplateFunction;
+export type CompilerOptions = Options & {
+    encoding: Encoding;
+    isString?: boolean;
+};
+export type CompileFunction = (template: string, options?: Partial<CompilerOptions>, compileSteps?: number) => TemplateFunction;
+export type LoaderConfiguration = Mapping<unknown> & {
+    compiler: Partial<CompilerOptions>;
+    compileSteps: number;
+    compress: {
+        html: Mapping<unknown>;
+        javaScript: Mapping<unknown>;
+    };
+    context: string;
+    debug: boolean;
+    extensions: Extensions;
+    locals?: Mapping<unknown>;
+    module: {
+        aliases: Mapping<string>;
+        replacements: Replacements;
+    };
+};
+/**
+ * Main transformation function.
+ * @param source - Input string to transform.
+ *
+ * @returns Transformed string.
+ */
+export declare const loader: (this: LoaderContext<LoaderConfiguration>, source: string) => string;
+export default loader;

package/helper.d.ts

@@ -0,0 +1,284 @@
+import { Encoding, Mapping } from 'clientnode/type';
+import { BuildConfiguration, Extensions, GivenInjection, GivenInjectionConfiguration, NormalizedGivenInjection, PathConfiguration, PackageDescriptor, Replacements, ResolvedBuildConfiguration, SpecificExtensions } from './type';
+export declare const KNOWN_FILE_EXTENSIONS: Array<string>;
+/**
+ * Provides a class of static methods with generic use cases.
+ */
+export declare class Helper {
+    /**
+     * Determines whether given file path is within given list of file
+     * locations.
+     * @param filePath - Path to file to check.
+     * @param locationsToCheck - Locations to take into account.
+     *
+     * @returns Value "true" if given file path is within one of given
+     * locations or "false" otherwise.
+     */
+    static isFilePathInLocation(this: void, filePath: string, locationsToCheck: Array<string>): boolean;
+    /**
+     * Strips loader informations form given module request including loader
+     * prefix and query parameter.
+     * @param moduleID - Module request to strip.
+     *
+     * @returns Given module id stripped.
+     */
+    static stripLoader(this: void, moduleID: string): string;
+    /**
+     * Converts given list of path to a normalized list with unique values.
+     * @param paths - File paths.
+     *
+     * @returns The given file path list with normalized unique values.
+     */
+    static normalizePaths(this: void, paths: Array<string>): Array<string>;
+    /**
+     * Applies file path/name placeholder replacements with given bundle
+     * associated informations.
+     * @param template - File path to process placeholder in.
+     * @param scope - Scope to use for processing.
+     *
+     * @returns Processed file path.
+     */
+    static renderFilePathTemplate(this: void, template: string, scope?: Mapping<number | string>): string;
+    /**
+     * Converts given request to a resolved request with given context
+     * embedded.
+     * @param request - Request to determine.
+     * @param context - Context of given request to resolve relative to.
+     * @param referencePath - Path to resolve local modules relative to.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param relativeModuleLocations - List of relative directory paths to
+     * search for modules in.
+     *
+     * @returns A new resolved request.
+     */
+    static applyContext(this: void, request: string, context?: string, referencePath?: string, aliases?: Mapping, moduleReplacements?: Replacements, relativeModuleLocations?: Array<string>): false | string;
+    /**
+     * Check if given request points to an external dependency not maintained
+     * by current package context.
+     * @param request - Request to determine.
+     * @param context - Context of current project.
+     * @param requestContext - Context of given request to resolve relative to.
+     * @param normalizedGivenInjection - Mapping of chunk names to modules
+     * which should be injected.
+     * @param relativeExternalModuleLocations - Array of paths where external
+     * modules take place.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param extensions - List of file and module extensions to take into
+     * account.
+     * @param referencePath - Path to resolve local modules relative to.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     * @param relativeModuleLocations - List of relative file path to search
+     * for modules in.
+     * @param packageEntryFileNames - List of package entry file names to
+     * search for. The magic name "__package__" will search for an appreciate
+     * entry in a "package.json" file.
+     * @param packageMainPropertyNames - List of package file main property
+     * names to search for package representing entry module definitions.
+     * @param packageAliasPropertyNames - List of package file alias property
+     * names to search for package specific module aliases.
+     * @param includePattern - Array of regular expressions to explicitly mark
+     * as external dependency.
+     * @param excludePattern - Array of regular expressions to explicitly mark
+     * as internal dependency.
+     * @param inPlaceNormalLibrary - Indicates whether normal libraries should
+     * be external or not.
+     * @param inPlaceDynamicLibrary - Indicates whether requests with
+     * integrated loader configurations should be marked as external or not.
+     * @param encoding - Encoding for file names to use during file traversing.
+     *
+     * @returns A new resolved request indicating whether given request is an
+     * external one.
+     */
+    static determineExternalRequest(this: void, request: string, context?: string, requestContext?: string, normalizedGivenInjection?: NormalizedGivenInjection, relativeExternalModuleLocations?: Array<string>, aliases?: Mapping, moduleReplacements?: Replacements, extensions?: Extensions, referencePath?: string, pathsToIgnore?: Array<string>, relativeModuleLocations?: Array<string>, packageEntryFileNames?: Array<string>, packageMainPropertyNames?: Array<string>, packageAliasPropertyNames?: Array<string>, includePattern?: Array<string | RegExp>, excludePattern?: Array<string | RegExp>, inPlaceNormalLibrary?: boolean, inPlaceDynamicLibrary?: boolean, encoding?: Encoding): null | string;
+    /**
+     * Determines asset type of given file.
+     * @param filePath - Path to file to analyse.
+     * @param buildConfiguration - Meta informations for available asset
+     * types.
+     * @param paths - List of paths to search if given path doesn't reference
+     * a file directly.
+     *
+     * @returns Determined file type or "null" of given file couldn't be
+     * determined.
+     */
+    static determineAssetType(this: void, filePath: string, buildConfiguration: BuildConfiguration, paths: PathConfiguration): null | string;
+    /**
+     * Adds a property with a stored array of all matching file paths, which
+     * matches each build configuration in given entry path and converts given
+     * build configuration into a sorted array were javaScript files takes
+     * precedence.
+     * @param configuration - Given build configurations.
+     * @param entryPath - Path to analyse nested structure.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     * @param mainFileBasenames - File basenames to sort into the front.
+     *
+     * @returns Converted build configuration.
+     */
+    static resolveBuildConfigurationFilePaths(this: void, configuration: BuildConfiguration, entryPath?: string, pathsToIgnore?: Array<string>, mainFileBasenames?: Array<string>): ResolvedBuildConfiguration;
+    /**
+     * Determines all file and directory paths related to given internal
+     * modules as array.
+     * @param givenInjection - List of module ids or module file paths.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of module replacements to take into
+     * account.
+     * @param extensions - List of file and module extensions to take into
+     * account.
+     * @param context - File path to resolve relative to.
+     * @param referencePath - Path to search for local modules.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     * @param relativeModuleLocations - List of relative file path to search
+     * for modules in.
+     * @param packageEntryFileNames - List of package entry file names to
+     * search for. The magic name "__package__" will search for an appreciate
+     * entry in a "package.json" file.
+     * @param packageMainPropertyNames - List of package file main property
+     * names to search for package representing entry module definitions.
+     * @param packageAliasPropertyNames - List of package file alias property
+     * names to search for package specific module aliases.
+     * @param encoding - File name encoding to use during file traversing.
+     *
+     * @returns Object with a file path and directory path key mapping to
+     * corresponding list of paths.
+     */
+    static determineModuleLocations(this: void, givenInjection: GivenInjection, aliases?: Mapping, moduleReplacements?: Replacements, extensions?: SpecificExtensions, context?: string, referencePath?: string, pathsToIgnore?: Array<string>, relativeModuleLocations?: Array<string>, packageEntryFileNames?: Array<string>, packageMainPropertyNames?: Array<string>, packageAliasPropertyNames?: Array<string>, encoding?: Encoding): {
+        directoryPaths: Array<string>;
+        filePaths: Array<string>;
+    };
+    /**
+     * Determines a list of concrete file paths for given module id pointing to
+     * a folder which isn't a package.
+     * @param normalizedGivenInjection - Injection data structure of modules
+     * with folder references to resolve.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param context - File path to determine relative to.
+     * @param referencePath - Path to resolve local modules relative to.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     *
+     * @returns Given injections with resolved folder pointing modules.
+     */
+    static resolveModulesInFolders(this: void, normalizedGivenInjection: NormalizedGivenInjection, aliases?: Mapping, moduleReplacements?: Replacements, context?: string, referencePath?: string, pathsToIgnore?: Array<string>): NormalizedGivenInjection;
+    /**
+     * Every injection definition type can be represented as plain object
+     * (mapping from chunk name to array of module ids). This method converts
+     * each representation into the normalized plain object notation.
+     * @param givenInjection - Given entry injection to normalize.
+     *
+     * @returns Normalized representation of given entry injection.
+     */
+    static normalizeGivenInjection(this: void, givenInjection: GivenInjection): NormalizedGivenInjection;
+    /**
+     * Determines all concrete file paths for given injection which are marked
+     * with the "__auto__" indicator.
+     * @param givenInjection - Given entry and external injection to take
+     * into account.
+     * @param buildConfigurations - Resolved build configuration.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param extensions - List of file and module extensions to take into
+     * account.
+     * @param context - File path to use as starting point.
+     * @param referencePath - Reference path from where local files should be
+     * resolved.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     *
+     * @returns Given injection with resolved marked indicators.
+     */
+    static resolveAutoInjection<T extends GivenInjectionConfiguration>(this: void, givenInjection: T, buildConfigurations: ResolvedBuildConfiguration, aliases?: Mapping, moduleReplacements?: Replacements, extensions?: Extensions, context?: string, referencePath?: string, pathsToIgnore?: Array<string>): T;
+    /**
+     * Determines all module file paths.
+     * @param buildConfigurations - Resolved build configuration.
+     * @param moduleFilePathsToExclude - A list of modules file paths to
+     * exclude (specified by path or id) or a mapping from chunk names to
+     * module ids.
+     * @param context - File path to use as starting point.
+     *
+     * @returns All determined module file paths.
+     */
+    static getAutoInjection(this: void, buildConfigurations: ResolvedBuildConfiguration, moduleFilePathsToExclude: Array<string>, context: string): Mapping;
+    /**
+     * Determines a resolved module file path in given package path.
+     * @param packagePath - Path to package to resolve in.
+     * @param packageMainPropertyNames - List of package file main property
+     * names to search for package representing entry module definitions.
+     * @param packageAliasPropertyNames - List of package file alias property
+     * names to search for package specific module aliases.
+     * @param encoding - Encoding to use for file names during file traversing.
+     *
+     * @returns Path if found and / or additional package aliases to consider.
+     */
+    static determineModuleFilePathInPackage(this: void, packagePath: string, packageMainPropertyNames?: Array<string>, packageAliasPropertyNames?: Array<string>, encoding?: Encoding): {
+        fileName: null | string;
+        packageAliases: Mapping | null;
+    };
+    /**
+     * Determines a concrete file path for given module id.
+     * @param moduleID - Module id to determine.
+     * @param aliases - Mapping of aliases to take into account.
+     * @param moduleReplacements - Mapping of replacements to take into
+     * account.
+     * @param extensions - List of file and module extensions to take into
+     * account.
+     * @param context - File path to determine relative to.
+     * @param referencePath - Path to resolve local modules relative to.
+     * @param pathsToIgnore - Paths which marks location to ignore.
+     * @param relativeModuleLocations - List of relative file path to search
+     * for modules in.
+     * @param packageEntryFileNames - List of package entry file names to
+     * search for. The magic name "__package__" will search for an appreciate
+     * entry in a "package.json" file.
+     * @param packageMainPropertyNames - List of package file main property
+     * names to search for package representing entry module definitions.
+     * @param packageAliasPropertyNames - List of package file alias property
+     * names to search for package specific module aliases.
+     * @param encoding - Encoding to use for file names during file traversing.
+     *
+     * @returns File path or given module id if determinations has failed or
+     * wasn't necessary.
+     */
+    static determineModuleFilePath(this: void, moduleID: false | string, aliases?: Mapping, moduleReplacements?: Replacements, extensions?: SpecificExtensions, context?: string, referencePath?: string, pathsToIgnore?: Array<string>, relativeModuleLocations?: Array<string>, packageEntryFileNames?: Array<string>, packageMainPropertyNames?: Array<string>, packageAliasPropertyNames?: Array<string>, encoding?: Encoding): null | string;
+    /**
+     * Determines a concrete file path for given module id.
+     * @param moduleID - Module id to determine.
+     * @param aliases - Mapping of aliases to take into account.
+     *
+     * @returns The alias applied given module id.
+     */
+    static applyAliases(this: void, moduleID: string, aliases: Mapping): string;
+    /**
+     * Determines a concrete file path for given module id.
+     * @param moduleID - Module id to determine.
+     * @param replacements - Mapping of regular expressions to their
+     * corresponding replacements.
+     *
+     * @returns The replacement applied given module id.
+     */
+    static applyModuleReplacements(this: void, moduleID: false | string, replacements: Replacements): false | string;
+    /**
+     * Determines the nearest package configuration file from given file path.
+     * @param start - Reference location to search from.
+     * @param fileName - Package configuration file name.
+     *
+     * @returns Determined file path.
+     */
+    static findPackageDescriptorFilePath(this: void, start: Array<string> | string, fileName?: string): null | string;
+    /**
+     * Determines the nearest package configuration from given module file
+     * path.
+     * @param modulePath - Module path to take as reference location (leaf in
+     * tree).
+     * @param fileName - Package configuration file name.
+     *
+     * @returns A object containing found parsed configuration an their
+     * corresponding file path.
+     */
+    static getClosestPackageDescriptor(this: void, modulePath: string, fileName?: string): null | PackageDescriptor;
+}
+export default Helper;

package/index.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env babel-node
+/// <reference types="webpack-env" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Main entry point.
+ * @param context - Location from where to build current application.
+ * @param currentWorkingDirectory - Current working directory to use as
+ * reference.
+ * @param commandLineArguments - Arguments to take into account.
+ * @param webOptimizerPath - Current optimizer context path.
+ * @param environment - Environment variables to take into account.
+ *
+ * @returns Nothing.
+ */
+declare const main: (context?: string, currentWorkingDirectory?: string, commandLineArguments?: Array<string>, webOptimizerPath?: string, environment?: NodeJS.ProcessEnv) => Promise<() => void>;
+export default main;

package/jestEnvironmentBrowser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Implements the default browser environment to run script context in.
+ */
+export declare class BrowserEnvironment {
+    /**
+     * @returns Nothing.
+     */
+    setup(): Promise<void>;
+    /**
+     * @returns Nothing.
+     */
+    teardown(): void;
+    /**
+     * @returns Null.
+     */
+    runScript(): null;
+}
+export default BrowserEnvironment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weboptimizer",
-  "version": "2.0.1440",
+  "version": "2.0.1441",
   "description": "A generic web optimizer, (module) bundler and development environment.",
   "keywords": [
     "webpack",
@@ -69,7 +69,7 @@
     "build:types": "tsc --declaration --emitDeclarationOnly",
     "check": "yarn check:types; yarn lint",
     "check:types": "tsc --noEmit",
-    "clear": "rimraf apiDocumentation 'plugins/*.d.ts' 'plugins/*.js' browser.d.ts configurator.d.ts ejsLoader.d.ts helper.d.ts index.d.ts jestEnvironmentBrowser.d.ts stylelintConfigurator.d.ts type.d.ts webpackConfigurator.d.ts '*.js' '*.compiled.*' '*.compiled' 'test/*.js' 'test/*.compiled.*' 'test/*.d.ts' '*.html' '*.log' node_modules/weboptimizer .coverage .nyc_output || true",
+    "clear": "rimraf apiDocumentation 'plugins/*.d.ts' 'plugins/*.js' browser.d.ts configurator.d.ts ejsLoader.d.ts helper.d.ts index.d.ts jestSetup.d.ts jestEnvironmentBrowser.d.ts stylelintConfigurator.d.ts type.d.ts webpackConfigurator.d.ts '*.js' '*.compiled.*' '*.compiled' 'test/*.js' 'test/*.compiled.*' 'test/*.d.ts' '*.html' '*.log' node_modules/weboptimizer .coverage .nyc_output || true",
     "document": "yarn build:plain && jsdoc --package ./package.json --readme ./readme.md --destination apiDocumentation *.js",
     "lint": "yarn lint:base",
     "lint:base": "eslint --ignore-pattern '**/exclude/*' --ignore-pattern '*.compiled.*' --ignore-pattern '*.d.ts' --ignore-pattern '*.js' --parser-options=project:tsconfig.json '*.ts' 'test/*.ts'",

package/stylelintConfigurator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/type.d.ts

@@ -0,0 +1,483 @@
+/// <reference types="webpack-env" />
+/// <reference types="node" />
+import { AnyFunction, Encoding, Mapping, PlainObject, SecondParameter } from 'clientnode/type';
+import FaviconWebpackPlugin from 'favicons-webpack-plugin';
+import { FaviconWebpackPlugionOptions as FaviconWebpackPluginOptions } from 'favicons-webpack-plugin/src/options';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import ImageMinimizerWebpackPlugin, { PluginOptions as ImageMinimizerOptions } from 'image-minimizer-webpack-plugin';
+import { JSDOM } from 'jsdom';
+import MiniCSSExtractPlugin from 'mini-css-extract-plugin';
+import TerserWebpackPlugin from 'terser-webpack-plugin';
+import { DefinePlugin as WebpackDefinePlugin, Configuration as BaseWebpackConfiguration, IgnorePlugin as WebpackIgnorePlugin, library as webpackLibrary, ModuleOptions as WebpackModuleOptions, RuleSetRule as WebpackRuleSetRule, RuleSetUseItem as WebpackRuleSetUseItem, WebpackOptionsNormalized } from 'webpack';
+import { WebpackPartial as WorkboxBaseCommonOptions, BasePartial as WorkboxCommonOptions, WebpackGenerateSWOptions as WorkboxGenerateSWOptions, WebpackInjectManifestOptions as WorkboxInjectManifestOptions } from 'workbox-build';
+import OfflinePlugin from 'workbox-webpack-plugin';
+export interface Browser {
+    debug: boolean;
+    domContentLoaded: boolean;
+    DOM: typeof JSDOM | null;
+    initialized: boolean;
+    instance: JSDOM | null;
+    window: null | Window;
+    windowLoaded: boolean;
+}
+export interface InitializedBrowser extends Browser {
+    DOM: typeof JSDOM;
+    instance: JSDOM;
+    window: Window;
+}
+export interface PackageConfiguration {
+    name: string;
+    version: string;
+}
+export interface PackageDescriptor {
+    configuration: PackageConfiguration;
+    filePath: string;
+}
+export type Replacements = Mapping<SecondParameter<string['replace']>>;
+export type Resolvable = {
+    [_K in '__evaluate__' | '__execute__']?: Resolvable;
+} & Mapping<unknown>;
+export interface RedundantRequest {
+    path: string;
+    version: string;
+}
+export type ExternalAliases = Mapping<Mapping | string | ((_request: string, _key: string) => string)>;
+export type GivenInjection = AnyFunction | string | Array<string> | Mapping<string | Array<string>>;
+export type NormalizedGivenInjection = Mapping<Array<string>>;
+export interface GivenInjectionConfiguration {
+    autoExclude: Array<string>;
+    entry: GivenInjection;
+    external: GivenInjection;
+}
+export type IgnorePattern = WebpackIgnorePlugin['options'] | {
+    contextRegExp?: string;
+    resourceRegExp?: string;
+};
+export interface InjectionConfiguration {
+    autoExclude: Array<string>;
+    chunks: NonNullable<BaseWebpackConfiguration['optimization']>['splitChunks'];
+    entry: {
+        given: GivenInjection;
+        normalized: NormalizedGivenInjection;
+    };
+    external: {
+        aliases: ExternalAliases;
+        implicit: {
+            pattern: {
+                exclude: Array<RegExp | string>;
+                include: Array<RegExp | string>;
+            };
+        };
+        modules: BaseWebpackConfiguration['externals'];
+    };
+    externalAliases: Mapping;
+    ignorePattern: Array<IgnorePattern> | IgnorePattern;
+    implicitExternalExcludePattern: Array<RegExp | string>;
+    implicitExternalIncludePattern: Array<RegExp | string>;
+}
+export interface HTMLTransformationOptions {
+    hashAlgorithm: string;
+    htmlPlugin: typeof HtmlWebpackPlugin;
+    files: Array<HTMLConfiguration>;
+}
+export interface InPlaceAssetsIntoHTMLOptions {
+    cascadingStyleSheet: InPlaceAssetConfiguration;
+    javaScript: InPlaceAssetConfiguration;
+    htmlPlugin: typeof HtmlWebpackPlugin;
+}
+export interface AssetPathConfiguration {
+    base: string;
+    cascadingStyleSheet: string;
+    data: string;
+    font: string;
+    image: string;
+    javaScript: string;
+    template: string;
+}
+export interface BasePathConfiguration {
+    base: string;
+    context: string;
+    source: {
+        asset: AssetPathConfiguration;
+        base: string;
+    };
+    target: {
+        asset: AssetPathConfiguration;
+        base: string;
+        manifest: string;
+        public: string;
+    };
+}
+export interface PathConfiguration extends BasePathConfiguration {
+    apiDocumentation: string;
+    base: string;
+    configuration: {
+        javaScript: string;
+        json: string;
+        typeScript: string;
+    };
+    context: string;
+    ignore: Array<string>;
+    tidyUp: Array<string>;
+    tidyUpGlobs: Array<string>;
+    tidyUpOnClear: Array<string>;
+    tidyUpOnClearGlobs: Array<string>;
+}
+export type DefaultPathConfiguration = BasePathConfiguration & Resolvable;
+export interface BuildConfigurationItem {
+    extension: string;
+    ignoredExtension: string;
+    filePathPattern: string;
+    outputExtension: string;
+}
+export type BuildConfiguration = Mapping<BuildConfigurationItem>;
+export declare const SubConfigurationTypes: readonly ["debug", "document", "test", "test:browser"];
+export declare const TaskTypes: readonly ["build", "serve", "debug", "document", "test", "test:browser"];
+export type BooleanExpression = boolean | null | string;
+export interface AdditionalLoaderConfiguration {
+    exclude?: BooleanExpression;
+    include?: BooleanExpression;
+    test: string;
+    use: Array<WebpackLoader> | WebpackLoader | string;
+}
+export interface AdditionalLoaderConfigurations {
+    post: Array<AdditionalLoaderConfiguration>;
+    pre: Array<AdditionalLoaderConfiguration>;
+}
+export interface AdditionalLoader {
+    post: Array<string>;
+    pre: Array<string>;
+}
+export interface WebpackLoader {
+    loader: string;
+    options?: Mapping<unknown>;
+}
+export type ResourceLoaderConfiguration = WebpackLoader & {
+    exclude: BooleanExpression;
+    include: BooleanExpression;
+    loader: Array<string>;
+    regularExpression: string;
+};
+export interface LoaderConfiguration extends ResourceLoaderConfiguration {
+    additional: AdditionalLoaderConfigurations;
+}
+export interface WebpackLoaderConfiguration {
+    exclude: WebpackLoaderIndicator;
+    include: WebpackLoaderIndicator;
+    test: RegExp;
+    use: Array<WebpackLoader> | WebpackLoader;
+}
+export type WebpackLoaderIndicator = WebpackRuleSetRule['include'];
+export interface Command {
+    arguments: Array<string>;
+    command: string;
+    indicator?: string;
+}
+export interface CommandLineArguments {
+    build: Command;
+    document: Array<Command> | Command;
+    lint: Array<Command> | Command;
+    serve: Array<Command> | Command;
+    test: Array<Command> | Command;
+    'test:browser': Array<Command> | Command;
+    'check:types': Array<Command> | Command;
+}
+export type NodeEnvironment = BaseWebpackConfiguration['node'] & {
+    '#': string;
+};
+export interface PluginConfiguration {
+    name: {
+        initializer: string;
+        module: string;
+    };
+    parameters: Array<unknown>;
+}
+export interface DefaultConfiguration {
+    contextType: string;
+    debug: boolean;
+    document: PlainObject;
+    encoding: Encoding;
+    givenCommandLineArguments: Array<string>;
+    library: boolean;
+    nodeEnvironment: NodeEnvironment;
+    path: DefaultPathConfiguration;
+    plugins: Array<PluginConfiguration>;
+    test: PlainObject;
+    'test:browser': PlainObject;
+}
+export type ExportFormat = 'amd' | 'amd-require' | 'assign' | 'global' | 'jsonp' | 'var' | 'this' | 'commonjs' | 'commonjs2' | 'umd';
+export interface HTMLConfiguration {
+    filename: string;
+    template: {
+        filePath: string;
+        options?: PlainObject;
+        postCompileOptions: PlainObject;
+        request: string;
+        use: Array<WebpackLoader> | WebpackLoader;
+    };
+}
+export interface MetaConfiguration {
+    default: DefaultConfiguration;
+    debug: Resolvable;
+    library: Resolvable;
+}
+export interface ResolvedBuildConfigurationItem extends BuildConfigurationItem {
+    filePaths: Array<string>;
+    type: string;
+}
+export interface Extensions {
+    file: {
+        external: Array<string>;
+        internal: Array<string>;
+    };
+}
+export interface SpecificExtensions {
+    file: Array<string>;
+}
+export interface InPlaceAssetConfiguration {
+    body?: Array<RegExp | string> | RegExp | string;
+    head?: Array<RegExp | string> | RegExp | string;
+}
+export interface InPlaceConfiguration {
+    cascadingStyleSheet: InPlaceAssetConfiguration;
+    externalLibrary: {
+        normal: boolean;
+        dynamic: boolean;
+    };
+    javaScript: InPlaceAssetConfiguration;
+    otherMaximumFileSizeLimitInByte: number;
+}
+export interface ResolvedConfiguration {
+    assetPattern: Mapping<{
+        excludeFilePathRegularExpression: string;
+        includeFilePathRegularExpression: string;
+        pattern: string;
+    }>;
+    buildContext: {
+        definitions: WebpackDefinePlugin['definitions'];
+        types: BuildConfiguration;
+    };
+    cache?: {
+        main?: WebpackOptionsNormalized['cache'];
+        unsafe?: WebpackModuleOptions['unsafeCache'];
+    };
+    commandLine: CommandLineArguments;
+    contextType: string;
+    debug: boolean;
+    development: {
+        includeClient?: boolean | null;
+        server: (WebpackOptionsNormalized['devServer'] & {
+            hot: boolean;
+            host: string;
+            https: boolean;
+            liveReload: boolean;
+            port: number;
+        });
+        tool: WebpackOptionsNormalized['devtool'];
+    };
+    document: PlainObject;
+    encoding: Encoding;
+    exportFormat: {
+        external: ExportFormat;
+        globalObject: string;
+        self: ExportFormat;
+    };
+    extensions: Extensions;
+    favicon: FaviconWebpackPluginOptions;
+    files: {
+        additionalPaths: Array<string>;
+        compose: {
+            cascadingStyleSheet: string | ((_asset: unknown) => string);
+            image: string;
+            javaScript: string;
+        };
+        defaultHTML: HTMLConfiguration;
+        html: Array<HTMLConfiguration>;
+    };
+    givenCommandLineArguments: Array<string>;
+    hashAlgorithm: string;
+    injection: InjectionConfiguration;
+    inPlace: InPlaceConfiguration;
+    library: boolean;
+    libraryName: string;
+    loader: {
+        aliases: Mapping;
+        directoryNames: Array<string>;
+        extensions: {
+            file: Array<string>;
+        };
+        resolveSymlinks: boolean;
+    };
+    module: {
+        additional: AdditionalLoaderConfigurations;
+        aliases: Mapping;
+        cascadingStyleSheet: ResourceLoaderConfiguration;
+        directoryNames: Array<string>;
+        enforceDeduplication: boolean;
+        html: LoaderConfiguration;
+        locations: {
+            directoryPaths: Array<string>;
+            filePaths: Array<string>;
+        };
+        optimizer: BaseWebpackConfiguration['optimization'] & {
+            babelMinify?: {
+                bundle?: {
+                    plugin?: PlainObject;
+                    transform?: PlainObject;
+                };
+                module?: PlainObject;
+            };
+            cssnano: PlainObject;
+            data: ResourceLoaderConfiguration;
+            font: {
+                eot: ResourceLoaderConfiguration;
+                svg: ResourceLoaderConfiguration;
+                ttf: ResourceLoaderConfiguration;
+                woff: ResourceLoaderConfiguration;
+            };
+            htmlMinifier?: PlainObject;
+            image: {
+                content: ImageMinimizerOptions<unknown, unknown>;
+                exclude: string;
+                loader: Array<string>;
+            };
+        };
+        preprocessor: {
+            cascadingStyleSheet: WebpackLoader & {
+                additional: AdditionalLoader & {
+                    plugins: AdditionalLoader;
+                };
+                postcssPresetEnv: PlainObject;
+            };
+            ejs: LoaderConfiguration;
+            html: LoaderConfiguration;
+            javaScript: LoaderConfiguration;
+            json: {
+                exclude: string;
+                loader: string;
+            };
+        };
+        provide: Mapping | null;
+        replacements: {
+            context: Array<[string, string]>;
+            normal: Replacements;
+        };
+        resolveSymlinks: boolean;
+        skipParseRegularExpressions: WebpackModuleOptions['noParse'];
+        style: WebpackLoader;
+    };
+    name: string;
+    needed: Mapping<boolean>;
+    nodeENV: false | null | string;
+    nodeEnvironment: NodeEnvironment;
+    offline: {
+        common: WorkboxBaseCommonOptions & WorkboxCommonOptions;
+        injectionManifest: WorkboxInjectManifestOptions;
+        serviceWorker: WorkboxGenerateSWOptions;
+        use: 'injectionManifest' | 'serviceWorker';
+    };
+    package: {
+        aliasPropertyNames: Array<string>;
+        main: {
+            fileNames: Array<string>;
+            propertyNames: Array<string>;
+        };
+    };
+    path: PathConfiguration;
+    performanceHints: BaseWebpackConfiguration['performance'];
+    plugins: Array<PluginConfiguration>;
+    showConfiguration: boolean;
+    stylelint: PlainObject;
+    targetTechnology: {
+        boilerplate: string;
+        payload: string;
+    };
+    test: PlainObject;
+    'test:browser': PlainObject;
+    webpack: WebpackConfiguration;
+}
+export type ResolvedBuildConfiguration = Array<ResolvedBuildConfigurationItem>;
+export type RuntimeInformation = PlainObject & {
+    givenCommandLineArguments: Array<string>;
+};
+export interface WebpackConfiguration extends BaseWebpackConfiguration {
+    devServer: Mapping<unknown>;
+    replaceWebOptimizer: WebpackConfiguration;
+}
+export type RuleSet = Array<WebpackRuleSetUseItem>;
+export type RuleSetRule = WebpackRuleSetRule & {
+    use: RuleSet;
+};
+export interface GenericLoader {
+    ejs: RuleSetRule;
+    script: RuleSetRule;
+    html: {
+        ejs: RuleSetRule;
+        html: RuleSetRule;
+        main: {
+            test: RegExp;
+            use: Array<WebpackLoader> | WebpackLoader;
+        };
+    };
+    style: RuleSetRule;
+    font: {
+        eot: RuleSetRule;
+        svg: RuleSetRule;
+        ttf: RuleSetRule;
+        woff: RuleSetRule;
+    };
+    image: RuleSetRule;
+    data: RuleSetRule;
+}
+export type Loader = GenericLoader & Mapping<WebpackRuleSetRule>;
+export interface EvaluationScope {
+    configuration: ResolvedConfiguration;
+    isFilePathInDependencies: (_filePath: string) => boolean;
+    loader: Loader;
+    require: typeof require;
+}
+export interface WebpackBaseAssets {
+    outputName: string;
+    plugin: HtmlWebpackPlugin;
+}
+export interface WebpackAssets extends WebpackBaseAssets {
+    bodyTags: HtmlWebpackPlugin.HtmlTagObject[];
+    headTags: HtmlWebpackPlugin.HtmlTagObject[];
+    outputName: string;
+    publicPath: string;
+    plugin: HtmlWebpackPlugin;
+}
+export type WebpackPlugin = webpackLibrary.AbstractLibraryPlugin<unknown> & Mapping<unknown>;
+export type WebpackPlugins = Mapping<WebpackPlugin> & {
+    Favicon?: typeof FaviconWebpackPlugin;
+    GenerateServiceWorker?: typeof OfflinePlugin.GenerateSW;
+    HTML?: typeof HtmlWebpackPlugin;
+    ImageMinimizer?: typeof ImageMinimizerWebpackPlugin;
+    InjectManifest?: typeof OfflinePlugin.InjectManifest;
+    Offline?: {
+        GenerateSW: typeof OfflinePlugin.GenerateSW;
+        InjectManifest: typeof OfflinePlugin.InjectManifest;
+    };
+    MiniCSSExtract?: typeof MiniCSSExtractPlugin;
+    Terser?: typeof TerserWebpackPlugin;
+};
+export type WebpackResolveData = Parameters<WebpackIgnorePlugin['checkIgnore']>[0];
+export type WebpackExtendedResolveData = WebpackResolveData & {
+    createData: {
+        rawRequest: string;
+        request: string;
+        resource: string;
+        userRequest: string;
+    };
+};
+export interface HTMLWebpackPluginAssetTagGroupsData {
+    bodyTags: HtmlWebpackPlugin.HtmlTagObject[];
+    headTags: HtmlWebpackPlugin.HtmlTagObject[];
+    outputName: string;
+    plugin: HtmlWebpackPlugin;
+}
+export interface HTMLWebpackPluginBeforeEmitData {
+    html: string;
+    outputName: string;
+    plugin: HtmlWebpackPlugin;
+}

package/webpackConfigurator.d.ts

@@ -0,0 +1,4 @@
+import { WebpackConfiguration } from './type';
+export declare const optionalRequire: <T = unknown>(id: string) => T | null;
+export declare let webpackConfiguration: WebpackConfiguration;
+export default webpackConfiguration;