On this page

webpack.util.comparators.compareChunkGroupsByIndex(a, b): void
  • a {ChunkGroup} first chunk group
  • b {ChunkGroup} second chunk group
  • Returns: {0|1|-1} compare result
Type:
{ParameterizedComparator<ChunkGraph, Chunk>}
webpack.util.comparators.compareChunksById(a, b): void
  • a {Chunk} chunk
  • b {Chunk} chunk
  • Returns: {0|1|-1} compare result
webpack.util.comparators.compareChunksNatural(chunkGraph): void
  • chunkGraph {ChunkGraph} the chunk graph
  • Returns: {Comparator} comparator
webpack.util.comparators.compareIds(a, b): 0 | 1 | -1
Attributes
a:<string> | <number>
first id
b:<string> | <number>
second id
Returns:
{0|1|-1} compare result
webpack.util.comparators.compareIterables(elementComparator): void
  • elementComparator {Comparator} comparator for elements
  • Returns: {Comparator<Iterable>} comparator for iterables of elements
webpack.util.comparators.compareLocations(a, b): void
  • a {DependencyLocation} A location node
  • b {DependencyLocation} A location node
  • Returns: {0|1|-1} sorting comparator value

Compare two locations

Type:
{ParameterizedComparator<Compiler, Module>}

Compare modules by their full name. This differs from comparing by identifier in that the values have been normalized to be relative to the compiler context.

Type:
{ParameterizedComparator<ChunkGraph, Module>}
webpack.util.comparators.compareModulesByIdentifier(a, b): void
  • a {Module} module
  • b {Module} module
  • Returns: {0|1|-1} compare result
Type:
{ParameterizedComparator<ChunkGraph, Module>}
Type:
{ParameterizedComparator<ModuleGraph, Module>}
Type:
{ParameterizedComparator<ModuleGraph, Module>}
webpack.util.comparators.compareNumbers(a, b): 0 | 1 | -1
Attributes
a:<number>
number
b:<number>
number
Returns:
{0|1|-1} compare result
webpack.util.comparators.compareSelect(getter, comparator): void
  • getter {Selector<T, R>} getter for value
  • comparator {Comparator} comparator
  • Returns: {Comparator} comparator
webpack.util.comparators.compareStrings(a, b): 0 | 1 | -1
Attributes
a:<string>
first string
b:<string>
second string
Returns:
{0|1|-1} compare result
webpack.util.comparators.compareStringsNumeric(a, b): 0 | 1 | -1
Attributes
a:<string>
string
b:<string>
string
Returns:
{0|1|-1} compare result
webpack.util.comparators.concatComparators(c1, c2, ...cRest?): void
  • c1 {Comparator} comparator
  • c2 {Comparator} comparator
  • cRest {Comparator[]} comparators
  • Returns: {Comparator} comparator
webpack.util.comparators.keepOriginalOrder(iterable): void
  • iterable {Iterable} original ordered list
  • Returns: {Comparator} comparator
webpack.util.comparators.sortWithSourceOrder(dependencies, dependencySourceOrderMap, onDependencyReSort?): void
  • dependencies {Dependency[]} dependencies
  • dependencySourceOrderMap {WeakMap<Dependency, DependencySourceOrder>} dependency source order map
  • onDependencyReSort <object> optional callback to set index for each dependency
  • Returns: {void}

For HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency, we should prioritize import order to match the behavior of running modules directly in a JS engine without a bundler. For other types like ConstDependency, we can instead prioritize usage order. https://github.com/webpack/webpack/pull/19686