xhs-mp-pack 1.1.0-beta.0

package/dist/PluginManager.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// module
+const AssetModulesPlugin_1 = __importDefault(require("@/module/asset/AssetModulesPlugin"));
+const JavascriptModulesPlugin_1 = require("@/module/javascript/JavascriptModulesPlugin");
+const JsonModulesPlugin_1 = __importDefault(require("@/module/json/JsonModulesPlugin"));
+const ExternalsPlugin_1 = __importDefault(require("@/module/ExternalsPlugin"));
+const InferAsyncModulesPlugin_1 = __importDefault(require("@/module/async-modules/InferAsyncModulesPlugin"));
+const JavascriptMetaInfoPlugin_1 = __importDefault(require("@/module/JavascriptMetaInfoPlugin"));
+const RuntimePlugin_1 = __importDefault(require("@/module/RuntimePlugin"));
+const RecordIdsPlugin_1 = __importDefault(require("@/plugins/RecordIdsPlugin"));
+const CompatibilityPlugin_1 = __importDefault(require("@/plugins/CompatibilityPlugin"));
+const ConstPlugin_1 = __importDefault(require("@/plugins/ConstPlugin"));
+const ExportsInfoApiPlugin_1 = __importDefault(require("@/module/ExportsInfoApiPlugin"));
+const UseStrictPlugin_1 = __importDefault(require("@/plugins/UseStrictPlugin"));
+const WarnCaseSensitiveModulesPlugin_1 = __importDefault(require("@/plugins/WarnCaseSensitiveModulesPlugin"));
+const TemplatedPathPlugin_1 = __importDefault(require("@/template/TemplatedPathPlugin"));
+const DataUriPlugin_1 = __importDefault(require("@/module/uri/DataUriPlugin"));
+const FileUriPlugin_1 = __importDefault(require("@/module/uri/FileUriPlugin"));
+const CommonJsPlugin_1 = __importDefault(require("@/dependencies/commonjs/CommonJsPlugin"));
+const HarmonyModulesPlugin_1 = __importDefault(require("@/dependencies/harmony/HarmonyModulesPlugin"));
+const ImportMetaContextPlugin_1 = __importDefault(require("@/dependencies/import/ImportMetaContextPlugin"));
+const ImportMetaPlugin_1 = __importDefault(require("@/dependencies/import/ImportMetaPlugin"));
+const ImportPlugin_1 = __importDefault(require("@/dependencies/import/ImportPlugin"));
+const LoaderPlugin_1 = __importDefault(require("@/dependencies/loader/LoaderPlugin"));
+const URLPlugin_1 = __importDefault(require("@/dependencies/URLPlugin"));
+const ArrayPushCallbackChunkFormatPlugin_1 = __importDefault(require("@/chunk/chunkFormat/ArrayPushCallbackChunkFormatPlugin"));
+const JsonpChunkLoadingPlugin_1 = __importDefault(require("@/chunk/chunkLoading/JsonpChunkLoadingPlugin"));
+const EvalSourceMapDevToolPlugin_1 = __importDefault(require("@/sourcemap/EvalSourceMapDevToolPlugin"));
+const SourceMapDevToolPlugin_1 = __importDefault(require("@/sourcemap/SourceMapDevToolPlugin"));
+const EvalDevToolModulePlugin_1 = __importDefault(require("@/sourcemap/EvalDevToolModulePlugin"));
+const DefaultStatsFactoryPlugin_1 = __importDefault(require("@/plugins/DefaultStatsFactoryPlugin"));
+const DefaultStatsPresetPlugin_1 = __importDefault(require("@/plugins/DefaultStatsPresetPlugin"));
+const DefaultStatsPrinterPlugin_1 = __importDefault(require("@/plugins/DefaultStatsPrinterPlugin"));
+const cleverMerge_1 = require("@/base/cleverMerge");
+const LazyModuleFactoryPlugin_1 = __importDefault(require("./module/LazyModuleFactoryPlugin"));
+// runtime
+const APIPlugin_1 = __importDefault(require("./plugins/APIPlugin"));
+// dependencies
+const DynamicEntryPlugin_1 = __importDefault(require("./dependencies/entry/DynamicEntryPlugin"));
+// output library
+const EnableLibraryPlugin_1 = __importDefault(require("./library/EnableLibraryPlugin"));
+// output chunkFormat
+// output chunkLoading
+// id
+const NaturalModuleIdsPlugin_1 = __importDefault(require("./ids/NaturalModuleIdsPlugin"));
+const NamedModuleIdsPlugin_1 = __importDefault(require("./ids/NamedModuleIdsPlugin"));
+const DeterministicModuleIdsPlugin_1 = __importDefault(require("./ids/DeterministicModuleIdsPlugin"));
+const NaturalChunkIdsPlugin_1 = __importDefault(require("./ids/NaturalChunkIdsPlugin"));
+const NamedChunkIdsPlugin_1 = __importDefault(require("./ids/NamedChunkIdsPlugin"));
+const DeterministicChunkIdsPlugin_1 = __importDefault(require("./ids/DeterministicChunkIdsPlugin"));
+// sourcemap
+// optimize
+const ModuleInfoHeaderPlugin_1 = __importDefault(require("./plugins/optimize/ModuleInfoHeaderPlugin"));
+const EnsureChunkConditionsPlugin_1 = __importDefault(require("./plugins/optimize/EnsureChunkConditionsPlugin"));
+const RemoveParentModulesPlugin_1 = __importDefault(require("./plugins/optimize/RemoveParentModulesPlugin"));
+const RemoveEmptyChunksPlugin_1 = __importDefault(require("./plugins/optimize/RemoveEmptyChunksPlugin"));
+const MergeDuplicateChunksPlugin_1 = __importDefault(require("./plugins/optimize/MergeDuplicateChunksPlugin"));
+const FlagIncludedChunksPlugin_1 = __importDefault(require("./plugins/optimize/FlagIncludedChunksPlugin"));
+const SideEffectsFlagPlugin_1 = __importDefault(require("./plugins/optimize/SideEffectsFlagPlugin"));
+const FlagDependencyExportsPlugin_1 = __importDefault(require("./plugins/optimize/FlagDependencyExportsPlugin"));
+const FlagDependencyUsagePlugin_1 = __importDefault(require("./plugins/optimize/FlagDependencyUsagePlugin"));
+const InnerGraphPlugin_1 = __importDefault(require("./plugins/optimize/InnerGraphPlugin"));
+const MangleExportsPlugin_1 = __importDefault(require("./plugins/optimize/MangleExportsPlugin"));
+const ModuleConcatenationPlugin_1 = __importDefault(require("./plugins/optimize/ModuleConcatenationPlugin"));
+const SplitChunksPlugin_1 = __importDefault(require("./plugins/optimize/SplitChunksPlugin"));
+const RuntimeChunkPlugin_1 = __importDefault(require("./plugins/optimize/RuntimeChunkPlugin"));
+const RealContentHashPlugin_1 = __importDefault(require("./plugins/optimize/RealContentHashPlugin"));
+const NoEmitOnErrorsPlugin_1 = __importDefault(require("./plugins/optimize/NoEmitOnErrorsPlugin"));
+// cache
+const AddManagedPathsPlugin_1 = __importDefault(require("./cache/AddManagedPathsPlugin"));
+const NodeStuffPlugin_1 = __importDefault(require("./plugins/NodeStuffPlugin"));
+// stat
+class PluginManager {
+    setup(options, compiler) {
+        compiler.outputPath = options.output.path;
+        compiler.recordsInputPath = options.recordsInputPath || null;
+        compiler.recordsOutputPath = options.recordsOutputPath || null;
+        compiler.name = options.name;
+        // module
+        new JavascriptModulesPlugin_1.JavascriptModulesPlugin().apply(compiler);
+        new JsonModulesPlugin_1.default().apply(compiler);
+        new AssetModulesPlugin_1.default().apply(compiler);
+        if (options.externals) {
+            new ExternalsPlugin_1.default(options.externalsType, options.externals).apply(compiler);
+        }
+        if (options.mode !== 'production') {
+            new LazyModuleFactoryPlugin_1.default({}).apply(compiler);
+        }
+        // 输出的chunkFormat
+        new ArrayPushCallbackChunkFormatPlugin_1.default().apply(compiler);
+        // chunkLoading
+        new JsonpChunkLoadingPlugin_1.default().apply(compiler);
+        // output library
+        if (options.output.enabledLibraryTypes.length > 0) {
+            for (const type of options.output.enabledLibraryTypes) {
+                new EnableLibraryPlugin_1.default(type).apply(compiler);
+            }
+        }
+        // sorcemap
+        this.setupSourceMap(compiler, options);
+        if (options.output.pathinfo) {
+            new ModuleInfoHeaderPlugin_1.default(options.output.pathinfo !== true).apply(compiler);
+        }
+        new RuntimePlugin_1.default().apply(compiler);
+        new InferAsyncModulesPlugin_1.default().apply(compiler);
+        new DataUriPlugin_1.default().apply(compiler);
+        new FileUriPlugin_1.default().apply(compiler);
+        new CompatibilityPlugin_1.default().apply(compiler);
+        new HarmonyModulesPlugin_1.default({
+            topLevelAwait: options.experiments.topLevelAwait,
+        }).apply(compiler);
+        new CommonJsPlugin_1.default().apply(compiler);
+        new LoaderPlugin_1.default({}).apply(compiler);
+        new APIPlugin_1.default({
+            module: options.output.module,
+        }).apply(compiler);
+        new ExportsInfoApiPlugin_1.default().apply(compiler);
+        // new WebpackIsIncludedPlugin().apply(compiler)
+        new ConstPlugin_1.default().apply(compiler);
+        new UseStrictPlugin_1.default().apply(compiler);
+        new ImportPlugin_1.default().apply(compiler);
+        new ImportMetaContextPlugin_1.default().apply(compiler);
+        new ImportMetaPlugin_1.default().apply(compiler);
+        new URLPlugin_1.default().apply(compiler);
+        options.node = { global: true, __filename: 'mock', __dirname: 'mock' };
+        new NodeStuffPlugin_1.default(options.node).apply(compiler);
+        new DefaultStatsFactoryPlugin_1.default().apply(compiler);
+        new DefaultStatsPresetPlugin_1.default().apply(compiler);
+        new DefaultStatsPrinterPlugin_1.default().apply(compiler);
+        new JavascriptMetaInfoPlugin_1.default().apply(compiler);
+        this.setupEntryPlugins(compiler, options);
+        this.setupIdPlugins(compiler, options);
+        this.setupOptimizePlugins(compiler, options);
+        new TemplatedPathPlugin_1.default().apply(compiler);
+        new RecordIdsPlugin_1.default({
+            portableIds: options.optimization.portableRecords,
+        }).apply(compiler);
+        new WarnCaseSensitiveModulesPlugin_1.default().apply(compiler);
+        new AddManagedPathsPlugin_1.default(options.snapshot.managedPaths, options.snapshot.immutablePaths).apply(compiler);
+        this.setupCachePlugins(compiler, options);
+        if (!compiler.inputFileSystem) {
+            throw new Error('No input filesystem provided');
+        }
+        compiler.resolverFactory.hooks.resolveOptions
+            .for('normal')
+            .tap('PluginManager', resolveOptions => {
+            resolveOptions = (0, cleverMerge_1.cleverMerge)(options.resolve, resolveOptions);
+            resolveOptions.fileSystem = compiler.inputFileSystem;
+            return resolveOptions;
+        });
+        compiler.resolverFactory.hooks.resolveOptions
+            .for('context')
+            .tap('PluginManager', resolveOptions => {
+            resolveOptions = (0, cleverMerge_1.cleverMerge)(options.resolve, resolveOptions);
+            resolveOptions.fileSystem = compiler.inputFileSystem;
+            resolveOptions.resolveToContext = true;
+            return resolveOptions;
+        });
+        compiler.resolverFactory.hooks.resolveOptions
+            .for('loader')
+            .tap('PluginManager', resolveOptions => {
+            resolveOptions = (0, cleverMerge_1.cleverMerge)(options.resolveLoader, resolveOptions);
+            resolveOptions.fileSystem = compiler.inputFileSystem;
+            return resolveOptions;
+        });
+        compiler.hooks.afterResolvers.call(compiler);
+        return options;
+    }
+    setupIdPlugins(compiler, options) {
+        const moduleIds = options.optimization.moduleIds;
+        if (moduleIds) {
+            switch (moduleIds) {
+                case 'natural': {
+                    new NaturalModuleIdsPlugin_1.default().apply(compiler);
+                    break;
+                }
+                case 'named': {
+                    new NamedModuleIdsPlugin_1.default().apply(compiler);
+                    break;
+                }
+                case 'deterministic': {
+                    new DeterministicModuleIdsPlugin_1.default().apply(compiler);
+                    break;
+                }
+                default:
+                    throw new Error(`webpack bug: moduleIds: ${moduleIds} is not implemented`);
+            }
+        }
+        const chunkIds = options.optimization.chunkIds;
+        if (chunkIds) {
+            switch (chunkIds) {
+                case 'natural': {
+                    new NaturalChunkIdsPlugin_1.default().apply(compiler);
+                    break;
+                }
+                case 'named': {
+                    new NamedChunkIdsPlugin_1.default().apply(compiler);
+                    break;
+                }
+                case 'deterministic': {
+                    new DeterministicChunkIdsPlugin_1.default().apply(compiler);
+                    break;
+                }
+                default:
+                    throw new Error(`webpack bug: chunkIds: ${chunkIds} is not implemented`);
+            }
+        }
+    }
+    setupCachePlugins(compiler, options) {
+        if (options.cache && typeof options.cache === 'object') {
+            // cache
+            // if (isFinite(options.maxGenerations)) {
+            //   const MemoryWithGcCachePlugin = require('./cache/MemoryWithGcCachePlugin').default
+            //   new MemoryWithGcCachePlugin({
+            //     maxGenerations: options.maxGenerations,
+            //   }).apply(compiler)
+            // } else {
+            //   const MemoryCachePlugin = require('./cache/MemoryCachePlugin').default
+            //   new MemoryCachePlugin().apply(compiler)
+            // }
+            // if (options.cacheUnaffected) {
+            //   if (!options.experiments.cacheUnaffected) {
+            //     throw new Error(
+            //       "'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled",
+            //     )
+            //   }
+            //   compiler.moduleMemCaches = new Map()
+            // }
+            // filesystem
+            // const cacheOptions = options.cache
+            // for (const key in cacheOptions.buildDependencies) {
+            //   const list = cacheOptions.buildDependencies[key]
+            //   new AddBuildDependenciesPlugin(list).apply(compiler)
+            // }
+            // if (!isFinite(cacheOptions.maxMemoryGenerations)) {
+            //   new MemoryCachePlugin().apply(compiler)
+            // } else if (cacheOptions.maxMemoryGenerations !== 0) {
+            //   new MemoryWithGcCachePlugin({
+            //     maxGenerations: cacheOptions.maxMemoryGenerations,
+            //   }).apply(compiler)
+            // }
+            // new IdleFileCachePlugin(
+            //   new PackFileCacheStrategy({
+            //     compiler,
+            //     fs: compiler.intermediateFileSystem,
+            //     context: options.context,
+            //     cacheLocation: cacheOptions.cacheLocation,
+            //     version: cacheOptions.version,
+            //     logger: compiler.getInfrastructureLogger('webpack.cache.PackFileCacheStrategy'),
+            //     snapshot: options.snapshot,
+            //     maxAge: cacheOptions.maxAge,
+            //     profile: cacheOptions.profile,
+            //     allowCollectingMemory: cacheOptions.allowCollectingMemory,
+            //     compression: cacheOptions.compression,
+            //     readonly: cacheOptions.readonly,
+            //   }),
+            //   cacheOptions.idleTimeout,
+            //   cacheOptions.idleTimeoutForInitialStore,
+            //   cacheOptions.idleTimeoutAfterLargeChanges,
+            // ).apply(compiler)
+            // new ResolverCachePlugin().apply(compiler)
+        }
+    }
+    setupSourceMap(compiler, options) {
+        if (options.devtool) {
+            if (options.devtool.includes('source-map')) {
+                const hidden = options.devtool.includes('hidden');
+                const inline = options.devtool.includes('inline');
+                const evalWrapped = options.devtool.includes('eval');
+                const cheap = options.devtool.includes('cheap');
+                const moduleMaps = options.devtool.includes('module');
+                const noSources = options.devtool.includes('nosources');
+                const Plugin = evalWrapped ? EvalSourceMapDevToolPlugin_1.default : SourceMapDevToolPlugin_1.default;
+                new Plugin({
+                    filename: inline ? null : options.output.sourceMapFilename,
+                    moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
+                    fallbackModuleFilenameTemplate: options.output.devtoolFallbackModuleFilenameTemplate,
+                    append: hidden ? false : undefined,
+                    module: moduleMaps ? true : !cheap,
+                    columns: !cheap,
+                    noSources,
+                    namespace: options.output.devtoolNamespace,
+                }).apply(compiler);
+            }
+            else if (options.devtool.includes('eval')) {
+                new EvalDevToolModulePlugin_1.default({
+                    moduleFilenameTemplate: options.output.devtoolModuleFilenameTemplate,
+                    namespace: options.output.devtoolNamespace,
+                }).apply(compiler);
+            }
+        }
+    }
+    setupEntryPlugins(compiler, options) {
+        new DynamicEntryPlugin_1.default(compiler.context, options.entry).apply(compiler);
+    }
+    setupOptimizePlugins(compiler, options) {
+        new EnsureChunkConditionsPlugin_1.default().apply(compiler);
+        if (options.optimization.removeAvailableModules) {
+            new RemoveParentModulesPlugin_1.default().apply(compiler);
+        }
+        if (options.optimization.removeEmptyChunks) {
+            new RemoveEmptyChunksPlugin_1.default().apply(compiler);
+        }
+        if (options.optimization.mergeDuplicateChunks) {
+            new MergeDuplicateChunksPlugin_1.default().apply(compiler);
+        }
+        if (options.optimization.flagIncludedChunks) {
+            new FlagIncludedChunksPlugin_1.default().apply(compiler);
+        }
+        if (options.optimization.sideEffects) {
+            new SideEffectsFlagPlugin_1.default(options.optimization.sideEffects === true).apply(compiler);
+        }
+        if (options.optimization.providedExports) {
+            new FlagDependencyExportsPlugin_1.default().apply(compiler);
+        }
+        if (options.optimization.usedExports) {
+            new FlagDependencyUsagePlugin_1.default(options.optimization.usedExports === 'global').apply(compiler);
+        }
+        if (options.optimization.innerGraph) {
+            new InnerGraphPlugin_1.default().apply(compiler);
+        }
+        if (options.optimization.mangleExports) {
+            new MangleExportsPlugin_1.default(options.optimization.mangleExports !== 'size').apply(compiler);
+        }
+        if (options.optimization.concatenateModules) {
+            new ModuleConcatenationPlugin_1.default().apply(compiler);
+        }
+        if (options.optimization.splitChunks) {
+            new SplitChunksPlugin_1.default(options.optimization.splitChunks).apply(compiler);
+        }
+        if (options.optimization.runtimeChunk) {
+            new RuntimeChunkPlugin_1.default(options.optimization.runtimeChunk).apply(compiler);
+        }
+        if (!options.optimization.emitOnErrors) {
+            new NoEmitOnErrorsPlugin_1.default().apply(compiler);
+        }
+        if (options.optimization.realContentHash) {
+            new RealContentHashPlugin_1.default({
+                hashFunction: options.output.hashFunction,
+                hashDigest: options.output.hashDigest,
+            }).apply(compiler);
+        }
+        if (options.optimization.minimize) {
+            for (const minimizer of options.optimization.minimizer) {
+                if (typeof minimizer === 'function') {
+                    minimizer.call(compiler, compiler);
+                }
+                else if (minimizer !== '...' && minimizer) {
+                    minimizer.apply(compiler);
+                }
+            }
+        }
+    }
+}
+exports.default = PluginManager;

package/dist/ResolverFactory.d.ts

@@ -0,0 +1,7 @@
+export default class ResolverFactory {
+    hooks: any;
+    cache: Map<any, any>;
+    constructor();
+    get(type: any, resolveOptions?: {}): any;
+    _create(type: any, resolveOptionsWithDepType: any): import("enhanced-resolve").Resolver;
+}

package/dist/ResolverFactory.js

@@ -0,0 +1,84 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const enhanced_resolve_1 = require("enhanced-resolve");
+const tapable_1 = require("tapable");
+const cleverMerge_1 = require("@/base/cleverMerge");
+// need to be hoisted on module level for caching identity
+const EMPTY_RESOLVE_OPTIONS = {};
+const convertToResolveOptions = resolveOptionsWithDepType => {
+    const { dependencyType, plugins } = resolveOptionsWithDepType, remaining = __rest(resolveOptionsWithDepType, ["dependencyType", "plugins"]);
+    const partialOptions = Object.assign(Object.assign({}, remaining), { plugins: plugins === null || plugins === void 0 ? void 0 : plugins.filter(item => item !== '...') });
+    if (!partialOptions.fileSystem) {
+        throw new Error("fileSystem is missing in resolveOptions, but it's required for enhanced-resolve");
+    }
+    // These weird types validate that we checked all non-optional properties
+    const options = partialOptions;
+    return (0, cleverMerge_1.removeOperations)((0, cleverMerge_1.resolveByProperty)(options, 'byDependency', dependencyType));
+};
+class ResolverFactory {
+    constructor() {
+        this.hooks = Object.freeze({
+            resolveOptions: new tapable_1.HookMap(() => new tapable_1.SyncWaterfallHook(['resolveOptions'])),
+            resolver: new tapable_1.HookMap(() => new tapable_1.SyncHook(['resolver', 'resolveOptions', 'userResolveOptions'])),
+        });
+        this.cache = new Map();
+    }
+    get(type, resolveOptions = EMPTY_RESOLVE_OPTIONS) {
+        let typedCaches = this.cache.get(type);
+        if (!typedCaches) {
+            typedCaches = {
+                direct: new WeakMap(),
+                stringified: new Map(),
+            };
+            this.cache.set(type, typedCaches);
+        }
+        const cachedResolver = typedCaches.direct.get(resolveOptions);
+        if (cachedResolver) {
+            return cachedResolver;
+        }
+        const ident = JSON.stringify(resolveOptions);
+        const resolver = typedCaches.stringified.get(ident);
+        if (resolver) {
+            typedCaches.direct.set(resolveOptions, resolver);
+            return resolver;
+        }
+        const newResolver = this._create(type, resolveOptions);
+        typedCaches.direct.set(resolveOptions, newResolver);
+        typedCaches.stringified.set(ident, newResolver);
+        return newResolver;
+    }
+    _create(type, resolveOptionsWithDepType) {
+        const originalResolveOptions = Object.assign({}, resolveOptionsWithDepType);
+        const resolveOptions = convertToResolveOptions(this.hooks.resolveOptions.for(type).call(resolveOptionsWithDepType));
+        // @ts-ignore
+        const resolver = enhanced_resolve_1.ResolverFactory.createResolver(resolveOptions);
+        if (!resolver) {
+            throw new Error('No resolver created');
+        }
+        const childCache = new WeakMap();
+        // @ts-ignore
+        resolver.withOptions = options => {
+            const cacheEntry = childCache.get(options);
+            if (cacheEntry !== undefined)
+                return cacheEntry;
+            const mergedOptions = (0, cleverMerge_1.cachedCleverMerge)(originalResolveOptions, options);
+            const resolver = this.get(type, mergedOptions);
+            childCache.set(options, resolver);
+            return resolver;
+        };
+        this.hooks.resolver.for(type).call(resolver, resolveOptions, originalResolveOptions);
+        return resolver;
+    }
+}
+exports.default = ResolverFactory;

package/dist/Watching.d.ts

@@ -0,0 +1,41 @@
+import Stats from '@/base/stats/Stats';
+declare class Watching {
+    startTime: any;
+    invalid: boolean;
+    handler: any;
+    callbacks: any[];
+    _closeCallbacks: any[];
+    closed: boolean;
+    suspended: boolean;
+    blocked: boolean;
+    buildReason: string;
+    _isBlocked: () => boolean;
+    _onChange: () => void;
+    _onInvalid: () => void;
+    watchOptions: {
+        aggregateTimeout?: number;
+    };
+    compiler: any;
+    running: boolean;
+    _initial: boolean;
+    _invalidReported: boolean;
+    _needRecords: boolean;
+    watcher: any;
+    pausedWatcher: any;
+    _collectedChangedFiles: any;
+    _collectedRemovedFiles: any;
+    lastWatcherStartTime: number;
+    constructor(compiler: any, watchOptions: any, handler: any);
+    _mergeWithCollected(changedFiles: any, removedFiles: any): void;
+    _go(fileTimeInfoEntries?: any, contextTimeInfoEntries?: any, changedFiles?: any, removedFiles?: any): void;
+    _getStats(compilation: any): Stats;
+    _done(err: any, compilation?: any): void;
+    watch(files: any, dirs: any, missing: any): void;
+    invalidateWithReason(reason: any, callback: any): void;
+    invalidate(callback: any): void;
+    _invalidate(fileTimeInfoEntries?: ReadonlyMap<string, any | 'ignore'>, contextTimeInfoEntries?: ReadonlyMap<string, any | 'ignore'>, changedFiles?: ReadonlySet<string>, removedFiles?: ReadonlySet<string>): void;
+    suspend(): void;
+    resume(): void;
+    close(callback: any): void;
+}
+export default Watching;