Commit 1bebe75

- `lib/optimize/` — optimization plugins (`SplitChunksPlugin`, `ConcatenatedModule`, …), `CircularModulesPlugin` (flags import cycles), `LazyBarrels` (finds barrel files worth deferring) and the `PureExpressionDependency` only `InnerGraphPlugin` emits. The three data structures each of one plugin reads are here, not in `lib/util/`: `Queue` (`FlagDependencyExportsPlugin`), `TupleQueue` (`FlagDependencyUsagePlugin`) and `LazyBucketSortedSet` (`LimitChunkCountPlugin`). `ConcatenationScope` is scope hoisting's protocol: only `ConcatenatedModule` constructs one; any generator renders through it.

**Name a class for what it does, and the file for the class.** The name says the idea, and ends in the suffix its kind uses — `*Plugin`, `*Dependency`, `*RuntimeModule`, `*Warning`, `*Error`, `*Module`, `*Factory`, `*Generator`, `*Parser`, `*Template` (546 of 668 PascalCase files in `lib/`). A file exporting one class takes that name; where the two disagree, rename whichever is wrong — often the file. Exempt: core nouns (`Compiler`, `Chunk`), helper and data-structure modules, and any module exporting several things.

**A name never** invents a role suffix (`lib/` has no `*Controller`, `*Manager`, `*Service` or `*Util` — a class that controls a thing is the thing), carries a `Webpack` prefix where the bare word is free, or repeats another class in `lib/`, since a stack trace and `types.d.ts` show the name alone.

const LazyBarrels = require("./optimize/LazyBarrels");

/** @type {LazyBarrels} */

this._lazyBarrels = new LazyBarrels(this);

const hasLazyBarrel = this._lazyBarrels.classify(module);

this._lazyBarrels.unlazyForDependency(

this._lazyBarrels.unlazyForDependency(

this._lazyBarrels.unlazyForDependency(

const unlazyItems = this._lazyBarrels.request(module, dependencies);

this._lazyBarrels.clear();

const PLUGIN_NAME = "HoistContainerReferencesPlugin";

class HoistContainerReferencesPlugin {

module.exports = HoistContainerReferencesPlugin;

const HoistContainerReferencesPlugin = require("./HoistContainerReferencesPlugin");

new HoistContainerReferencesPlugin().apply(compiler);

class Logger {

throw new Error(`No such label '${label}' for Logger.timeLog()`);

throw new Error(`No such label '${label}' for Logger.timeEnd()`);

throw new Error(`No such label '${label}' for Logger.timeAggregate()`);

module.exports.Logger = Logger;

const getProvidedExportsEtag = (module, lazyBarrels, hashFunction) => {

const lazyRequests = lazyBarrels.getLazyRequests(module);

const lazyBarrels = compilation._lazyBarrels;

lazyBarrels,

lazyBarrels,

class LazyBarrels {

module.exports = LazyBarrels;

const { Logger, LogType } = require("../../lib/logging/Logger");

const createLogger = () => {

/** @type {[string, EXPECTED_ANY[]][]} */

const entries = [];

const logger = new Logger(

(type, args) => entries.push([type, args || []]),

(name) => createLogger().logger

);

return { logger, entries };

describe("Logger", () => {

it("should log the elapsed time of a started label", () => {

const { logger, entries } = createLogger();

logger.time("build");

logger.timeLog("build");

logger.timeEnd("build");

expect(entries).toHaveLength(2);

for (const [type, args] of entries) {

expect(type).toBe(LogType.time);

expect(args[0]).toBe("build");

expect(typeof args[1]).toBe("number");

expect(typeof args[2]).toBe("number");

}

});

it("should throw for a label that was never started", () => {

const { logger } = createLogger();

expect(() => logger.timeLog("missing")).toThrow(

"No such label 'missing' for Logger.timeLog()"

);

expect(() => logger.timeEnd("missing")).toThrow(

"No such label 'missing' for Logger.timeEnd()"

);

expect(() => logger.timeAggregate("missing")).toThrow(

"No such label 'missing' for Logger.timeAggregate()"

);

});

it("should throw once a label has been ended", () => {

const { logger } = createLogger();

logger.time("build");

logger.timeEnd("build");

expect(() => logger.timeEnd("build")).toThrow(

"No such label 'build' for Logger.timeEnd()"

);

});

it("should sum the aggregated times of a label", () => {

const { logger, entries } = createLogger();

logger.time("hash");

logger.timeAggregate("hash");

logger.time("hash");

logger.timeAggregate("hash");

expect(entries).toHaveLength(0);

logger.timeAggregateEnd("hash");

expect(entries).toHaveLength(1);

expect(entries[0][0]).toBe(LogType.time);

expect(entries[0][1][0]).toBe("hash");

});

it("should ignore ending an aggregate that was never collected", () => {

const { logger, entries } = createLogger();

logger.timeAggregateEnd("never");

logger.time("other");

logger.timeAggregate("other");

logger.timeAggregateEnd("missing");

expect(entries).toHaveLength(0);

});