44
55"use strict" ;
66
7+ const RuntimeGlobals = require ( "../RuntimeGlobals" ) ;
8+
79/** @import Chunk from "../Chunk" */
810/** @import ChunkGraph from "../ChunkGraph" */
911/** @import RuntimeModule from "../RuntimeModule" */
1012
11- /** @type {Map<string, RegExp> } */
12- const assignmentCache = new Map ( ) ;
13-
1413// Every character the regexp grammar gives a meaning to, so a global naming one is
1514// matched literally rather than reinterpreted — a lone `\` included.
1615const REGEXP_META = / [ . * + ? ^ $ { } ( ) | [ \] \\ ] / g;
1716
18- /**
19- * Matches an assignment onto a handler map, as the modules installing one emit it.
20- * @param {string } handlers the handler map global
21- * @returns {RegExp } a global regexp capturing the handler key
22- */
23- const assignmentRegExp = ( handlers ) => {
24- const cached = assignmentCache . get ( handlers ) ;
25- if ( cached !== undefined ) return cached ;
26- const regExp = new RegExp (
27- `${ handlers . replace ( REGEXP_META , "\\$&" ) } \\.([\\w$]+)\\s*=` ,
28- "g"
29- ) ;
30- assignmentCache . set ( handlers , regExp ) ;
31- return regExp ;
32- } ;
17+ // An assignment onto any handler map hanging off the require global, as the modules
18+ // installing one emit it: `__webpack_require__.<map>.<key> =`.
19+ const MAP_ASSIGNMENT = new RegExp (
20+ `${ RuntimeGlobals . require . replace ( REGEXP_META , "\\$&" ) } \\.([\\w$]+)\\.([\\w$]+)\\s*=` ,
21+ "g"
22+ ) ;
23+
24+ /** @type {WeakMap<Chunk, Map<string, string | null>> } */
25+ const chunkHandlerKeys = new WeakMap ( ) ;
3326
3427/**
3528 * Reads a sibling's code without caching output that is not final yet: a module
@@ -50,10 +43,41 @@ const readCode = (runtimeModule) => {
5043 }
5144} ;
5245
46+ /**
47+ * Reads every handler key a chunk's runtime modules install, mapping each handler
48+ * map to its sole key or to `null` where several modules install onto it.
49+ * @param {ChunkGraph } chunkGraph the chunk graph
50+ * @param {Chunk } chunk the chunk to scan
51+ * @returns {Map<string, string | null> } the sole key per handler map
52+ */
53+ const scanChunk = ( chunkGraph , chunk ) => {
54+ /** @type {Map<string, string | null> } */
55+ const keys = new Map ( ) ;
56+ for ( const module of chunkGraph . getChunkRuntimeModulesIterable ( chunk ) ) {
57+ // A module that reads a map rather than installing onto one would generate in
58+ // a cycle, and it installs nothing the scan needs.
59+ if ( module . _dispatchesChunkHandlers ) continue ;
60+ const code = readCode ( module ) ;
61+ if ( code === null ) continue ;
62+ MAP_ASSIGNMENT . lastIndex = 0 ;
63+ let match ;
64+ while ( ( match = MAP_ASSIGNMENT . exec ( code ) ) !== null ) {
65+ const map = `${ RuntimeGlobals . require } .${ match [ 1 ] } ` ;
66+ const previous = keys . get ( map ) ;
67+ keys . set (
68+ map ,
69+ previous === undefined || previous === match [ 2 ] ? match [ 2 ] : null
70+ ) ;
71+ }
72+ }
73+ return keys ;
74+ } ;
75+
5376/**
5477 * The one key a chunk's other runtime modules install on a handler map, or `null`
5578 * when they install several — read from what they emit, so a handler added later is
56- * counted without being declared anywhere.
79+ * counted without being declared anywhere. A map that does not hang off the require
80+ * global is never specialized, which the general dispatch covers.
5781 * @param {RuntimeModule } runtimeModule the runtime module rendering the dispatch
5882 * @param {string } handlers the handler map global
5983 * @returns {string | null } the sole handler key, or `null`
@@ -64,21 +88,15 @@ const getOnlyHandlerKey = (runtimeModule, handlers) => {
6488 ) ;
6589 const chunk = /** @type {Chunk | undefined } */ ( runtimeModule . chunk ) ;
6690 if ( chunkGraph === undefined || chunk === undefined ) return null ;
67- const regExp = assignmentRegExp ( handlers ) ;
68- /** @type {string | null } */
69- let only = null ;
70- for ( const module of chunkGraph . getChunkRuntimeModulesIterable ( chunk ) ) {
71- if ( module === runtimeModule || module . _dispatchesChunkHandlers ) continue ;
72- const code = readCode ( module ) ;
73- if ( code === null ) continue ;
74- regExp . lastIndex = 0 ;
75- let match ;
76- while ( ( match = regExp . exec ( code ) ) !== null ) {
77- if ( only !== null && only !== match [ 1 ] ) return null ;
78- only = match [ 1 ] ;
79- }
91+ // The scan reads every sibling once, so the maps a chunk's other dispatchers ask
92+ // about later cost nothing to answer.
93+ let keys = chunkHandlerKeys . get ( chunk ) ;
94+ if ( keys === undefined ) {
95+ keys = scanChunk ( chunkGraph , chunk ) ;
96+ chunkHandlerKeys . set ( chunk , keys ) ;
8097 }
81- return only ;
98+ const only = keys . get ( handlers ) ;
99+ return only === undefined ? null : only ;
82100} ;
83101
84102module . exports . getOnlyHandlerKey = getOnlyHandlerKey ;
0 commit comments