Give mill the ability to re-write ESModule imports at link time

.devcontainer/devcontainer.json

@@ -0,0 +1,41 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/ubuntu
+{
+	"name": "Ubuntu",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/base:jammy",
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"scalameta.metals",
+				"usernamehw.errorlens",
+				"vscjava.vscode-java-pack",
+				"github.copilot",
+				"github.vscode-github-actions",
+				"github.vscode-pull-request-github",
+				"eamodio.gitlens"
+			]
+		}
+	},
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	"features": {
+		"ghcr.io/devcontainers/features/java:1": {
+			"version":17
+		},
+		"ghcr.io/devcontainers/features/node:1":{
+		}
+	},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "./mill -v && ./mill __.prepareOffline && ./mill mill.bsp.BSP/install && ./mill __.compile"
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

build.sc

@@ -189,6 +189,7 @@ object Deps {
   val fansi = ivy"com.lihaoyi::fansi:0.4.0"
   val jarjarabrams = ivy"com.eed3si9n.jarjarabrams::jarjar-abrams-core:1.14.0"
   val requests = ivy"com.lihaoyi::requests:0.8.0"
+  val esModuleRemap = ivy"com.armanbilge::scalajs-importmap:0.1.1"
 
   /** Used to manage transitive versions. */
   val transitiveDeps = Seq(
@@ -816,7 +817,8 @@ object scalajslib extends MillStableScalaModule with BuildInfo {
       Deps.Scalajs_1.scalajsEnvJsdomNodejs,
       Deps.Scalajs_1.scalajsEnvExoegoJsdomNodejs,
       Deps.Scalajs_1.scalajsEnvPhantomjs,
-      Deps.Scalajs_1.scalajsEnvSelenium
+      Deps.Scalajs_1.scalajsEnvSelenium,
+      Deps.esModuleRemap
     )
   }
 }

scalajslib/src/mill/scalajslib/ScalaJSModule.scala

@@ -75,6 +75,11 @@ trait ScalaJSModule extends scalalib.ScalaModule { outer =>
     val commonDeps = Seq(
       ivy"org.scala-js::scalajs-sbt-test-adapter:${scalaJSVersion()}"
     )
+    val maybeImportMap = scalaJSVersion() match {
+      case s"1.$n.$_" if n.toIntOption.exists(_ < 16) => Seq[Dep]()
+      case _ => Seq(ivy"com.armanbilge::scalajs-importmap:0.1.1")
+    }
+
     val envDeps = scalaJSBinaryVersion() match {
       case "0.6" =>
         Seq(
@@ -89,7 +94,7 @@ trait ScalaJSModule extends scalalib.ScalaModule { outer =>
     // we need to use the scala-library of the currently running mill
     resolveDependencies(
       repositoriesTask(),
-      (commonDeps.iterator ++ envDeps)
+      (commonDeps.iterator ++ envDeps ++ maybeImportMap)
         .map(Lib.depToBoundDep(_, mill.main.BuildInfo.scalaVersion, "")),
       ctx = Some(T.log)
     )
@@ -130,7 +135,8 @@ trait ScalaJSModule extends scalalib.ScalaModule { outer =>
       esFeatures = esFeatures(),
       moduleSplitStyle = moduleSplitStyle(),
       outputPatterns = scalaJSOutputPatterns(),
-      minify = scalaJSMinify()
+      minify = scalaJSMinify(),
+      esModuleMap = esModuleRemap()
     )
   }
 
@@ -172,7 +178,8 @@ trait ScalaJSModule extends scalalib.ScalaModule { outer =>
       esFeatures: ESFeatures,
       moduleSplitStyle: ModuleSplitStyle,
       outputPatterns: OutputPatterns,
-      minify: Boolean
+      minify: Boolean,
+      esModuleMap: Map[String, String]
   )(implicit ctx: mill.api.Ctx): Result[Report] = {
     val outputPath = ctx.dest
 
@@ -192,7 +199,8 @@ trait ScalaJSModule extends scalalib.ScalaModule { outer =>
       esFeatures = esFeatures,
       moduleSplitStyle = moduleSplitStyle,
       outputPatterns = outputPatterns,
-      minify = minify
+      minify = minify,
+      esModuleMap = esModuleMap
     )
   }
 
@@ -266,6 +274,10 @@ trait ScalaJSModule extends scalalib.ScalaModule { outer =>
 
   def scalaJSOptimizer: Target[Boolean] = T { true }
 
+  def esModuleRemap: Target[Map[String, String]] = T {
+    Map.empty[String, String]
+  }
+
   /** Whether to emit a source map. */
   def scalaJSSourceMap: Target[Boolean] = T { true }
 
@@ -346,7 +358,8 @@ trait TestScalaJSModule extends ScalaJSModule with TestModule {
       esFeatures = esFeatures(),
       moduleSplitStyle = moduleSplitStyle(),
       outputPatterns = scalaJSOutputPatterns(),
-      minify = scalaJSMinify()
+      minify = scalaJSMinify(),
+      esModuleMap = esModuleRemap()
     )
   }
 

scalajslib/src/mill/scalajslib/worker/ScalaJSWorker.scala

@@ -161,7 +161,8 @@ private[scalajslib] class ScalaJSWorker extends AutoCloseable {
       esFeatures: api.ESFeatures,
       moduleSplitStyle: api.ModuleSplitStyle,
       outputPatterns: api.OutputPatterns,
-      minify: Boolean
+      minify: Boolean,
+      esModuleMap: Map[String, String]
   )(implicit ctx: Ctx.Home): Result[api.Report] = {
     bridge(toolsClasspath).link(
       runClasspath = runClasspath.iterator.map(_.path.toNIO).toSeq,
@@ -176,7 +177,8 @@ private[scalajslib] class ScalaJSWorker extends AutoCloseable {
       esFeatures = toWorkerApi(esFeatures),
       moduleSplitStyle = toWorkerApi(moduleSplitStyle),
       outputPatterns = toWorkerApi(outputPatterns),
-      minify = minify
+      minify = minify,
+      esModuleMap = esModuleMap
     ) match {
       case Right(report) => Result.Success(fromWorkerApi(report))
       case Left(message) => Result.Failure(message)

scalajslib/test/resources/esModuleRemap/src/app/App.scala

@@ -0,0 +1,16 @@
+package app
+
+import scala.scalajs.js
+import scala.scalajs.js.annotation._ 
+
+object App {  
+  def main(args: Array[String]): Unit = {
+    println(linspace(-10.0, 10.0, 10))
+  }
+}
+
+@js.native
+@JSImport("@stdlib/linspace", JSImport.Default)
+object linspace extends js.Object {
+  def apply(start: Double, stop: Double, num: Int): Any = js.native
+}

scalajslib/test/src/mill/scalajslib/FullOptESModuleTests.scala

@@ -29,7 +29,7 @@ object FullOptESModuleTests extends TestSuite {
 
     test("fullOpt with ESModule moduleKind") {
       val result =
-        fullOptESModuleModuleEvaluator(FullOptESModuleModule.fullOptESModuleModule.fullOpt)
+        fullOptESModuleModuleEvaluator(FullOptESModuleModule.fullOptESModuleModule.fullLinkJS)
       assert(result.isRight)
     }
   }

scalajslib/test/src/mill/scalajslib/MultiModuleTests.scala

@@ -6,6 +6,7 @@ import mill.eval.EvaluatorPaths
 import mill.util._
 import mill.scalalib._
 import utest._
+import mill.scalajslib.internal.ScalaJSUtils
 object MultiModuleTests extends TestSuite {
   val workspacePath = TestUtil.getOutPathStatic() / "multi-module"
   val sourcePath = os.pwd / "scalajslib" / "test" / "resources" / "multi-module"
@@ -39,10 +40,11 @@ object MultiModuleTests extends TestSuite {
     prepareWorkspace()
 
     def checkOpt(optimize: Boolean) = {
-      val task = if (optimize) MultiModule.client.fullOpt else MultiModule.client.fastOpt
+      val task = if (optimize) MultiModule.client.fullLinkJS else MultiModule.client.fastLinkJS
       val Right((linked, evalCount)) = evaluator(task)
+      val processedReport = ScalaJSUtils.getReportMainFilePathRef(linked)
 
-      val runOutput = ScalaJsUtils.runJS(linked.path)
+      val runOutput = ScalaJsUtils.runJS(processedReport.path)
       assert(
         evalCount > 0,
         runOutput == "Hello from Scala.js, result is: 3\n"

scalajslib/test/src/mill/scalajslib/RemapEsModuleTests.scala

@@ -0,0 +1,77 @@
+package mill.scalajslib
+
+import mill.define.Discover
+import mill.util.{TestEvaluator, TestUtil}
+import utest._
+import mill.define.Target
+import mill.scalajslib.api.ModuleKind
+
+object EsModuleRemapTests extends TestSuite {
+  val workspacePath = TestUtil.getOutPathStatic() / "esModuleRemap"
+
+  val remapTo = "https://cdn.jsdelivr.net/gh/stdlib-js/array-base-linspace@esm/index.mjs"
+
+  object EsModuleRemap extends TestUtil.BaseModule {
+
+    object sourceMapModule extends ScalaJSModule {
+      override def millSourcePath = workspacePath
+      override def scalaVersion = sys.props.getOrElse("TEST_SCALA_2_13_VERSION", ???)
+      override def scalaJSVersion = "1.16.0"
+      override def scalaJSSourceMap = false
+      override def moduleKind = ModuleKind.ESModule
+
+      override def esModuleRemap: Target[Map[String, String]] = Map(
+        "@stdlib/linspace" -> remapTo
+      )
+    }
+
+    object OldJsModule extends ScalaJSModule {
+      override def millSourcePath = workspacePath
+      override def scalaVersion = sys.props.getOrElse("TEST_SCALA_2_13_VERSION", ???)
+      override def scalaJSVersion = "1.15.0"
+      override def scalaJSSourceMap = false
+      override def moduleKind = ModuleKind.ESModule
+
+      override def esModuleRemap: Target[Map[String, String]] = Map(
+        "@stdlib/linspace" -> remapTo
+      )
+    }
+
+    override lazy val millDiscover = Discover[this.type]
+  }
+
+  val millSourcePath = os.pwd / "scalajslib" / "test" / "resources" / "esModuleRemap"
+
+  val evaluator = TestEvaluator.static(EsModuleRemap)
+
+  val tests: Tests = Tests {
+    prepareWorkspace()
+
+    test("should remap the esmodule") {
+      val Right((report, _)) =
+        evaluator(EsModuleRemap.sourceMapModule.fastLinkJS)
+      val publicModules = report.publicModules.toSeq
+      assert(publicModules.length == 1)
+      val main = publicModules.head
+      assert(main.jsFileName == "main.js")
+      val mainPath = report.dest.path / "main.js"
+      assert(os.exists(mainPath))
+      val rawJs = os.read.lines(mainPath)
+      assert(rawJs(1).contains(remapTo))
+    }
+
+    test("should throw for older scalaJS versions") {
+      val Left(ex) = evaluator(EsModuleRemap.OldJsModule.fastLinkJS)
+      val error = ex.asFailing.get.toString()
+      assert(error.contains("will work with scalaJS 1.16 and above. You are using scalaJS 1.15.0"))
+    }
+
+  }
+
+  def prepareWorkspace(): Unit = {
+    os.remove.all(workspacePath)
+    os.makeDir.all(workspacePath / os.up)
+    os.copy(millSourcePath, workspacePath)
+  }
+
+}

scalajslib/worker-api/src/mill/scalajslib/worker/api/ScalaJSWorkerApi.scala

@@ -17,7 +17,8 @@ private[scalajslib] trait ScalaJSWorkerApi {
       esFeatures: ESFeatures,
       moduleSplitStyle: ModuleSplitStyle,
       outputPatterns: OutputPatterns,
-      minify: Boolean
+      minify: Boolean,
+      esModuleMap: Map[String, String]
   ): Either[String, Report]
 
   def run(config: JsEnvConfig, report: Report): Unit

scalajslib/worker/1/src/mill/scalajslib/worker/ScalaJSWorkerImpl.scala

@@ -25,6 +25,8 @@ import org.scalajs.testing.adapter.{TestAdapterInitializer => TAI}
 import scala.collection.mutable
 import scala.ref.SoftReference
 
+import com.armanbilge.sjsimportmap.ImportMappedIRFile
+
 class ScalaJSWorkerImpl extends ScalaJSWorkerApi {
   private case class LinkerInput(
       isFullLinkJS: Boolean,
@@ -169,7 +171,8 @@ class ScalaJSWorkerImpl extends ScalaJSWorkerApi {
       esFeatures: ESFeatures,
       moduleSplitStyle: ModuleSplitStyle,
       outputPatterns: OutputPatterns,
-      minify: Boolean
+      minify: Boolean,
+      esModuleMap: Map[String, String] = Map[String, String]()
   ): Either[String, Report] = {
     // On Scala.js 1.2- we want to use the legacy mode either way since
     // the new mode is not supported and in tests we always use legacy = false
@@ -202,21 +205,41 @@ class ScalaJSWorkerImpl extends ScalaJSWorkerApi {
 
     val resultFuture = (for {
       (irContainers, _) <- irContainersAndPathsFuture
-      irFiles <- irFileCacheCache.cached(irContainers)
+      irFiles0 <- irFileCacheCache.cached(irContainers)
+      irFiles = if (esModuleMap.isEmpty) {
+        irFiles0
+      } else {
+        if (!minorIsGreaterThanOrEqual(16)) {
+          throw new Exception(
+            s"Remapping EsModule imports will work with scalaJS 1.16 and above. You are using scalaJS ${ScalaJSVersions.current} - consider upgrading?"
+          )
+        }
+        val remapFct = esModuleMap.toSeq.foldLeft((in: String) => in) { case (fct, (s1, s2)) =>
+          val fct2: (String => String) = (in => in.replace(s1, s2))
+          (in => fct(fct2(in)))
+        }
+        irFiles0.map { ImportMappedIRFile.fromIRFile(_)(remapFct) }
+      }
       report <-
         if (useLegacy) {
+          // This uses the legacy linker interface, which is deprecated. The compiler will warn us about it, but the warnings are intentional in a legacy block. Suppress them.
           val jsFileName = "out.js"
           val jsFile = new File(dest, jsFileName).toPath()
+          @annotation.nowarn
           var linkerOutput = LinkerOutput(PathOutputFile(jsFile))
             .withJSFileURI(java.net.URI.create(jsFile.getFileName.toString))
+
           val sourceMapNameOpt = Option.when(sourceMap)(s"${jsFile.getFileName}.map")
           sourceMapNameOpt.foreach { sourceMapName =>
             val sourceMapFile = jsFile.resolveSibling(sourceMapName)
+            @annotation.nowarn
+            val outFct = PathOutputFile(sourceMapFile)
             linkerOutput = linkerOutput
-              .withSourceMap(PathOutputFile(sourceMapFile))
+              .withSourceMap(outFct)
               .withSourceMapURI(java.net.URI.create(sourceMapFile.getFileName.toString))
           }
-          linker.link(irFiles, moduleInitializers, linkerOutput, logger).map {
+          @annotation.nowarn
+          val report = linker.link(irFiles, moduleInitializers, linkerOutput, logger).map {
             file =>
               Report(
                 publicModules = Seq(Report.Module(
@@ -228,6 +251,7 @@ class ScalaJSWorkerImpl extends ScalaJSWorkerApi {
                 dest = dest
               )
           }
+          report
         } else {
           val linkerOutput = PathOutputDirectory(dest.toPath())
           linker.link(
@@ -270,20 +294,22 @@ class ScalaJSWorkerImpl extends ScalaJSWorkerApi {
       else runConfig0
         .withInheritErr(false)
         .withInheritOut(false)
-        .withOnOutputStream { case (Some(processOut), Some(processErr)) =>
-          val sources = Seq(
-            (processOut, System.out, "spawnSubprocess.stdout", false, () => true),
-            (processErr, System.err, "spawnSubprocess.stderr", false, () => true)
-          )
-
-          for ((std, dest, name, checkAvailable, runningCheck) <- sources) {
-            val t = new Thread(
-              new mill.main.client.InputPumper(std, dest, checkAvailable, () => runningCheck()),
-              name
+        .withOnOutputStream {
+          case (Some(processOut), Some(processErr)) =>
+            val sources = Seq(
+              (processOut, System.out, "spawnSubprocess.stdout", false, () => true),
+              (processErr, System.err, "spawnSubprocess.stderr", false, () => true)
             )
-            t.setDaemon(true)
-            t.start()
-          }
+
+            for ((std, dest, name, checkAvailable, runningCheck) <- sources) {
+              val t = new Thread(
+                new mill.main.client.InputPumper(std, dest, checkAvailable, () => runningCheck()),
+                name
+              )
+              t.setDaemon(true)
+              t.start()
+            }
+          case _ => ??? // should not happen
         }
     Run.runInterruptible(env, input, runConfig)
   }