Move modularization code into JS file. NFC (#24533)

Its much easier to generate JS code using out JS template system than
emitting directly from python.

Split out from #23261

Author: sbc100

eslint.config.mjs

@@ -29,6 +29,7 @@ export default [{
     'src/lib/',
     'src/runtime_*.js',
     'src/shell*.js',
+    'src/modularize.js',
     'src/preamble*.js',
     'src/postlibrary.js',
     'src/postamble*.js',

src/modularize.js

@@ -0,0 +1,111 @@
+/**
+ * @license
+ * Copyright 2025 The Emscripten Authors
+ * SPDX-License-Identifier: MIT
+ */
+
+// This code implements the `-sMODULARIZE` settings by taking the generated
+// JS program code (INNER_JS_CODE) and wrapping it in a factory function.
+
+#if SOURCE_PHASE_IMPORTS
+import source wasmModule from './{settings.WASM_BINARY_FILE}';
+#endif
+
+#if ENVIRONMENT_MAY_BE_WEB && !EXPORT_ES6 && !(MINIMAL_RUNTIME && !PTHREADS)
+// Single threaded MINIMAL_RUNTIME programs do not need access to
+// document.currentScript, so a simple export declaration is enough.
+var {{{ EXPORT_NAME }}} = (() => {
+  // When MODULARIZE this JS may be executed later,
+  // after document.currentScript is gone, so we save it.
+  // In EXPORT_ES6 mode we can just use 'import.meta.url'.
+  var _scriptName = typeof document != 'undefined' ? document.currentScript?.src : undefined;
+  return {{{ asyncIf(WASM_ASYNC_COMPILATION || (EXPORT_ES6 && ENVIRONMENT_MAY_BE_NODE)) }}}function(moduleArg = {}) {
+    var moduleRtn;
+
+<<< INNER_JS_CODE >>>
+
+    return moduleRtn;
+  };
+})();
+#else
+// When targetting node and ES6 we use `await import ..` in the generated code
+// so the outer function needs to be marked as async.
+{{{ asyncIf(WASM_ASYNC_COMPILATION || (EXPORT_ES6 && ENVIRONMENT_MAY_BE_NODE)) }}}function {{{ EXPORT_NAME }}}(moduleArg = {}) {
+  var moduleRtn;
+
+<<< INNER_JS_CODE >>>
+
+  return moduleRtn;
+}
+#endif
+
+// Export using a UMD style export, or ES6 exports if selected
+#if EXPORT_ES6
+export default {{{ EXPORT_NAME }}};
+#elif !MINIMAL_RUNTIME
+if (typeof exports === 'object' && typeof module === 'object') {
+  module.exports = {{{ EXPORT_NAME }}};
+  // This default export looks redundant, but it allows TS to import this
+  // commonjs style module.
+  module.exports.default = {{{ EXPORT_NAME }}};
+} else if (typeof define === 'function' && define['amd'])
+  define([], () => {{{ EXPORT_NAME }}});
+#endif
+
+#if PTHREADS
+
+// Create code for detecting if we are running in a pthread.
+// Normally this detection is done when the module is itself run but
+// when running in MODULARIZE mode we need use this to know if we should
+// run the module constructor on startup (true only for pthreads).
+#if ENVIRONMENT_MAY_BE_WEB || ENVIRONMENT_MAY_BE_WORKER
+var isPthread = globalThis.self?.name?.startsWith('em-pthread');
+#if ENVIRONMENT_MAY_BE_NODE
+// In order to support both web and node we also need to detect node here.
+var isNode = {{{ nodeDetectionCode() }}};
+if (isNode) isPthread = {{{ nodePthreadDetection() }}}
+#endif
+#else ENVIRONMENT_MAY_BE_NODE
+var isPthread = {{{ nodePthreadDetection() }}}
+// When running as a pthread, construct a new instance on startup
+#endif
+
+#if MODULARIZE == 'instance'
+isPthread && init();
+#else
+isPthread && {{{ EXPORT_NAME }}}();
+#endif
+
+#endif // PTHREADS
+
+#if WASM_WORKERS
+
+// Same as above for for WASM_WORKERS
+// Normally this detection is done when the module is itself run but
+// when running in MODULARIZE mode we need use this to know if we should
+// run the module constructor on startup (true only for pthreads).
+#if ENVIRONMENT_MAY_BE_WEB || ENVIRONMENT_MAY_BE_WORKER
+var isWW = globalThis.self?.name == 'em-ww';
+// In order to support both web and node we also need to detect node here.
+#if ENVIRONMENT_MAY_BE_NODE
+#if !PTHREADS
+var isNode = {{{ nodeDetectionCode() }}};
+#endif
+if (isNode) isWW = {{{ nodeWWDetection() }}};
+#endif
+#elif ENVIRONMENT_MAY_BE_NODE
+var isWW = {{{ nodeWWDetection() }}};
+#endif
+
+#if AUDIO_WORKLET
+isWW ||= typeof AudioWorkletGlobalScope !== 'undefined';
+// When running as a wasm worker, construct a new instance on startup
+#endif
+
+#if MODULARIZE == 'instance'
+isWW && init();
+#else
+isWW && {{{ EXPORT_NAME }}}();
+#endif
+
+#endif // WASM_WORKERS

src/parseTools.mjs

@@ -1097,6 +1097,26 @@ function nodeDetectionCode() {
   return "typeof process == 'object' && process.versions?.node && process.type != 'renderer'";
 }
 
+function nodePthreadDetection() {
+  // Under node we detect that we are running in a pthread by checking the
+  // workerData property.
+  if (EXPORT_ES6) {
+    return "(await import('worker_threads')).workerData === 'em-pthread'";
+  } else {
+    return "require('worker_threads').workerData === 'em-pthread'";
+  }
+}
+
+function nodeWWDetection() {
+  // Under node we detect that we are running in a wasm worker by checking the
+  // workerData property.
+  if (EXPORT_ES6) {
+    return "(await import('worker_threads')).workerData === 'em-ww'";
+  } else {
+    return "require('worker_threads').workerData === 'em-ww'";
+  }
+}
+
 addToCompileTimeContext({
   ATEXITS,
   ATPRERUNS,
@@ -1169,4 +1189,6 @@ addToCompileTimeContext({
   storeException,
   to64,
   toIndexType,
+  nodePthreadDetection,
+  nodeWWDetection,
 });

test/code_size/hello_webgl2_wasm.json

@@ -1,10 +1,10 @@
 {
   "a.html": 454,
   "a.html.gz": 328,
-  "a.js": 4391,
-  "a.js.gz": 2255,
+  "a.js": 4386,
+  "a.js.gz": 2252,
   "a.wasm": 8286,
   "a.wasm.gz": 5617,
-  "total": 13131,
-  "total_gz": 8200
+  "total": 13126,
+  "total_gz": 8197
 }

test/code_size/hello_webgl2_wasm2js.json

@@ -1,8 +1,8 @@
 {
   "a.html": 346,
   "a.html.gz": 262,
-  "a.js": 18083,
-  "a.js.gz": 9785,
-  "total": 18429,
-  "total_gz": 10047
+  "a.js": 18078,
+  "a.js.gz": 9781,
+  "total": 18424,
+  "total_gz": 10043
 }

test/code_size/hello_webgl_wasm.json

@@ -1,10 +1,10 @@
 {
   "a.html": 454,
   "a.html.gz": 328,
-  "a.js": 3929,
-  "a.js.gz": 2096,
+  "a.js": 3924,
+  "a.js.gz": 2092,
   "a.wasm": 8286,
   "a.wasm.gz": 5617,
-  "total": 12669,
-  "total_gz": 8041
+  "total": 12664,
+  "total_gz": 8037
 }

test/code_size/hello_webgl_wasm2js.json

@@ -1,8 +1,8 @@
 {
   "a.html": 346,
   "a.html.gz": 262,
-  "a.js": 17610,
-  "a.js.gz": 9616,
-  "total": 17956,
-  "total_gz": 9878
+  "a.js": 17605,
+  "a.js.gz": 9614,
+  "total": 17951,
+  "total_gz": 9876
 }

test/other/codesize/test_codesize_minimal_esm.gzsize

@@ -1 +1 @@
-1236
+1234

test/other/codesize/test_codesize_minimal_esm.jssize

@@ -1 +1 @@
-2556
+2551

tools/link.py

@@ -2436,126 +2436,11 @@ def phase_binaryen(target, options, wasm_target):
     write_file(final_js, js)
 
 
-def node_pthread_detection():
-  # Under node we detect that we are running in a pthread by checking the
-  # workerData property.
-  if settings.EXPORT_ES6:
-    return "(await import('worker_threads')).workerData === 'em-pthread';\n"
-  else:
-    return "require('worker_threads').workerData === 'em-pthread'\n"
-
-
-def node_ww_detection():
-  # Under node we detect that we are running in a wasm worker by checking the
-  # workerData property.
-  if settings.EXPORT_ES6:
-    return "(await import('worker_threads')).workerData === 'em-ww';\n"
-  else:
-    return "require('worker_threads').workerData === 'em-ww'\n"
-
-
 def modularize():
   global final_js
-  logger.debug(f'Modularizing, assigning to var {settings.EXPORT_NAME}')
-  generated_js = read_file(final_js)
-
-  # When targetting node and ES6 we use `await import ..` in the generated code
-  # so the outer function needs to be marked as async.
-  if settings.WASM_ASYNC_COMPILATION or (settings.EXPORT_ES6 and settings.ENVIRONMENT_MAY_BE_NODE):
-    maybe_async = 'async '
-  else:
-    maybe_async = ''
-
-  wrapper_function = '''
-%(maybe_async)sfunction(moduleArg = {}) {
-  var moduleRtn;
-
-%(generated_js)s
-
-  return moduleRtn;
-}
-''' % {
-      'maybe_async': maybe_async,
-      'generated_js': generated_js,
-    }
-
-  # In MODULARIZE mode this JS may be executed later, after
-  # document.currentScript is gone, so we need to capture it on load using a
-  # closure. In EXPORT_ES6 mode we can just use 'import.meta.url'.
-  capture_currentScript = settings.ENVIRONMENT_MAY_BE_WEB and not settings.EXPORT_ES6
-  # Single threaded MINIMAL_RUNTIME programs do not need access to
-  # document.currentScript, so a simple export declaration is enough.
-  if settings.MINIMAL_RUNTIME and not settings.PTHREADS:
-    capture_currentScript = False
-
-  if not capture_currentScript:
-    src = f'var {settings.EXPORT_NAME} = {wrapper_function};'
-  else:
-    src = f'''\
-var {settings.EXPORT_NAME} = (() => {{
-  var _scriptName = typeof document != 'undefined' ? document.currentScript?.src : undefined;
-  return ({wrapper_function});
-}})();
-'''
-
-  if settings.SOURCE_PHASE_IMPORTS:
-    src = f"import source wasmModule from './{settings.WASM_BINARY_FILE}';\n\n" + src
-
-  # Export using a UMD style export, or ES6 exports if selected
-  if settings.EXPORT_ES6:
-    src += 'export default %s;\n' % settings.EXPORT_NAME
-  elif not settings.MINIMAL_RUNTIME:
-    src += '''\
-if (typeof exports === 'object' && typeof module === 'object') {
-  module.exports = %(EXPORT_NAME)s;
-  // This default export looks redundant, but it allows TS to import this
-  // commonjs style module.
-  module.exports.default = %(EXPORT_NAME)s;
-} else if (typeof define === 'function' && define['amd'])
-  define([], () => %(EXPORT_NAME)s);
-''' % {'EXPORT_NAME': settings.EXPORT_NAME}
-
-  if settings.PTHREADS:
-    # Create code for detecting if we are running in a pthread.
-    # Normally this detection is done when the module is itself run but
-    # when running in MODULARIZE mode we need use this to know if we should
-    # run the module constructor on startup (true only for pthreads).
-    if settings.ENVIRONMENT_MAY_BE_WEB or settings.ENVIRONMENT_MAY_BE_WORKER:
-      src += "var isPthread = globalThis.self?.name?.startsWith('em-pthread');\n"
-      # In order to support both web and node we also need to detect node here.
-      if settings.ENVIRONMENT_MAY_BE_NODE:
-        src += f'var isNode = {node_detection_code()};\n'
-        src += f'if (isNode) isPthread = {node_pthread_detection()}\n'
-    elif settings.ENVIRONMENT_MAY_BE_NODE:
-      src += f'var isPthread = {node_pthread_detection()}\n'
-    src += '// When running as a pthread, construct a new instance on startup\n'
-    if settings.MODULARIZE == 'instance':
-      src += 'isPthread && init();\n'
-    else:
-      src += 'isPthread && %s();\n' % settings.EXPORT_NAME
-
-  if settings.WASM_WORKERS:
-    # Same as above for for WASM_WORKERS
-    # Normally this detection is done when the module is itself run but
-    # when running in MODULARIZE mode we need use this to know if we should
-    # run the module constructor on startup (true only for pthreads).
-    if settings.ENVIRONMENT_MAY_BE_WEB or settings.ENVIRONMENT_MAY_BE_WORKER:
-      src += "var isWW = globalThis.self?.name == 'em-ww';\n"
-      # In order to support both web and node we also need to detect node here.
-      if settings.ENVIRONMENT_MAY_BE_NODE:
-        if not settings.PTHREADS:
-          src += f'var isNode = {node_detection_code()};\n'
-        src += f'if (isNode) isWW = {node_ww_detection()}\n'
-    elif settings.ENVIRONMENT_MAY_BE_NODE:
-      src += f'var isWW = {node_ww_detection()}\n'
-    if settings.AUDIO_WORKLET:
-      src += "isWW ||= typeof AudioWorkletGlobalScope !== 'undefined';\n"
-    src += '// When running as a wasm worker, construct a new instance on startup\n'
-    if settings.MODULARIZE == 'instance':
-      src += 'isWW && init();\n'
-    else:
-      src += 'isWW && %s();\n' % settings.EXPORT_NAME
-
+  logger.debug(f'Modularizing, creating factory function called `{settings.EXPORT_NAME}`')
+  src = building.read_and_preprocess(utils.path_from_root('src/modularize.js'), expand_macros=True)
+  src = do_replace(src, '<<< INNER_JS_CODE >>>', read_file(final_js))
   final_js += '.modular.js'
   write_file(final_js, src)
   shared.get_temp_files().note(final_js)