@jsenv/core 24.3.3 → 24.4.4

package/src/internal/building/js/parseJsRessource.js

@@ -18,6 +18,7 @@ export const parseJsRessource = async (
 
   if (jsSourcemapUrl) {
     sourcemapReference = notifyReferenceFound({
+      referenceLabel: "js sourcemapping comment",
       contentTypeExpected: ["application/json", "application/octet-stream"],
       ressourceSpecifier: jsSourcemapUrl,
       // we don't really know the line or column
@@ -29,6 +30,7 @@ export const parseJsRessource = async (
     })
   } else {
     sourcemapReference = notifyReferenceFound({
+      referenceLabel: "js sourcemapping comment",
       contentType: "application/octet-stream",
       ressourceSpecifier: `${urlToFilename(jsUrl)}.map`,
       isPlaceholder: true,

package/src/internal/building/ressource_builder.js

@@ -3,7 +3,6 @@ import {
   urlToRelativeUrl,
   urlIsInsideOf,
   urlToParentUrl,
-  urlToBasename,
   urlToFilename,
 } from "@jsenv/filesystem"
 import { createLogger } from "@jsenv/logger"
@@ -34,10 +33,9 @@ export const createRessourceBuilder = (
     asOriginalServerUrl,
     urlToHumanUrl,
 
-    emitChunk,
     emitAsset,
     setAssetSource,
-    onJsModuleReference = () => {},
+    onJsModule,
     resolveRessourceUrl,
     lineBreakNormalization,
   },
@@ -122,6 +120,7 @@ export const createRessourceBuilder = (
   }
 
   const createReferenceFoundInJsModule = async ({
+    referenceLabel,
     jsUrl,
     jsLine,
     jsColumn,
@@ -136,6 +135,7 @@ export const createRessourceBuilder = (
       isImportAssertion,
       ressourceSpecifier,
       contentTypeExpected,
+      referenceLabel,
       referenceUrl: jsUrl,
       referenceLine: jsLine,
       referenceColumn: jsColumn,
@@ -168,6 +168,7 @@ export const createRessourceBuilder = (
     isImportAssertion,
     contentTypeExpected,
     ressourceSpecifier,
+    referenceLabel,
     referenceUrl,
     referenceColumn,
     referenceLine,
@@ -302,6 +303,7 @@ export const createRessourceBuilder = (
       isRessourceHint,
       isImportAssertion,
       contentTypeExpected,
+      referenceLabel,
       referenceUrl,
       referenceColumn,
       referenceLine,
@@ -321,12 +323,21 @@ export const createRessourceBuilder = (
 
     reference.ressource = ressource
     if (fromRollup && ressourceImporter.isEntryPoint) {
-      // do not add that reference, it's already know and would duplicate the html referencing a js file
-      // but do apply its effects
-      ressource.applyReferenceEffects(reference, { isJsModule })
+      // When HTML references JS, ressource builder has emitted the js chunk.
+      // so it already knows it exists and is part of references
+      // -> no need to push into reference (would incorrectly consider html references js twice)
+      // -> no need to log the js ressource (already logged during the HTML parsing)
     } else {
       ressource.references.push(reference)
-      ressource.applyReferenceEffects(reference, { isJsModule })
+      const effects = ressource.applyReferenceEffects(reference, { isJsModule })
+      logger.debug(
+        formatFoundReference({
+          reference,
+          referenceEffects: effects,
+          showReferenceSourceLocation,
+          shortenUrl,
+        }),
+      )
     }
 
     return reference
@@ -452,6 +463,7 @@ export const createRessourceBuilder = (
         isRessourceHint,
         contentTypeExpected,
         ressourceSpecifier,
+        referenceLabel,
         referenceLine,
         referenceColumn,
 
@@ -472,6 +484,7 @@ export const createRessourceBuilder = (
 
         const dependencyReference = createReference({
           ressourceSpecifier,
+          referenceLabel,
           referenceUrl: ressource.url,
           referenceLine,
           referenceColumn,
@@ -648,18 +661,12 @@ export const createRessourceBuilder = (
       }
     }
 
-    const onReference = (reference, infoFromReference) => {
+    const applyReferenceEffects = (reference, infoFromReference) => {
       const effects = []
       if (ressource.isEntryPoint) {
         if (ressource.contentType === "text/html") {
           effects.push(`parse html to find references`)
         }
-      } else {
-        effects.push(
-          `mark ${urlToHumanUrl(
-            ressource.url,
-          )} as referenced by ${urlToHumanUrl(reference.referenceUrl)}`,
-        )
       }
 
       if (reference.isRessourceHint) {
@@ -708,22 +715,18 @@ export const createRessourceBuilder = (
         }
 
         const jsModuleUrl = ressource.url
-
-        onJsModuleReference({
+        const rollupChunk = onJsModule({
+          ressource,
           jsModuleUrl,
           jsModuleIsInline: ressource.isInline,
           jsModuleSource: String(bufferBeforeBuild),
           line: reference.referenceLine,
           column: reference.referenceColumn,
         })
-
-        const name = urlToBasename(jsModuleUrl)
-        const rollupReferenceId = emitChunk({
-          id: jsModuleUrl,
-          name,
-        })
-        ressource.rollupReferenceId = rollupReferenceId
-        effects.push(`emit rollup chunk "${name}" (${rollupReferenceId})`)
+        ressource.rollupReferenceId = rollupChunk.rollupReferenceId
+        effects.push(
+          `emit rollup chunk "${rollupChunk.name}" (${rollupChunk.rollupReferenceId})`,
+        )
         return effects
       }
 
@@ -739,22 +742,9 @@ export const createRessourceBuilder = (
       effects.push(
         `emit rollup asset "${ressource.relativeUrl}" (${rollupReferenceId})`,
       )
-
       return effects
     }
 
-    const applyReferenceEffects = (reference, infoFromReference) => {
-      const referenceEffects = onReference(reference, infoFromReference)
-
-      logger.debug(
-        formatFoundReference({
-          reference,
-          referenceEffects,
-          showReferenceSourceLocation,
-        }),
-      )
-    }
-
     Object.assign(ressource, {
       applyReferenceEffects,
       getBufferAvailablePromise,

package/src/internal/building/ressource_builder_util.js

@@ -120,156 +120,29 @@ export const formatFoundReference = ({
   reference,
   showReferenceSourceLocation,
   referenceEffects,
+  shortenUrl,
 }) => {
-  const { isRessourceHint } = reference
-  if (isRessourceHint) {
-    return formatFoundRessourceHint({
-      reference,
-      showReferenceSourceLocation,
-      referenceEffects,
-    })
-  }
-
   const { ressource } = reference
   const { isEntryPoint } = ressource
   if (isEntryPoint) {
-    return formatCreateReferenceForEntry({
-      reference,
-      showReferenceSourceLocation,
-      referenceEffects,
-    })
-  }
-
-  const { isExternal } = ressource
-  if (isExternal) {
-    return formatFoundReferenceToExternalRessource({
-      reference,
-      showReferenceSourceLocation,
+    return `
+Start from entry file ${reference.ressource.relativeUrl}${appendEffects(
       referenceEffects,
-    })
+    )}`
   }
 
   const { isPlaceholder } = ressource
   if (isPlaceholder) {
-    return formatCreateRessourcePlaceholder({
-      reference,
-      showReferenceSourceLocation,
-      referenceEffects,
-    })
-  }
-
-  const { isInline, isJsModule } = ressource
-  if (isInline && !isJsModule) {
-    return formatFoundReferenceToInlineRessource({
-      reference,
-      showReferenceSourceLocation,
+    return `
+Create placeholder for ${showReferenceSourceLocation(reference)}${appendEffects(
       referenceEffects,
-    })
+    )}`
   }
 
-  if (isInline && isJsModule) {
-    return formatFoundReferenceToInlineModule({
-      reference,
-      showReferenceSourceLocation,
-      referenceEffects,
-    })
-  }
-
-  if (!isJsModule) {
-    return formatFoundReferenceToRessource({
-      reference,
-      showReferenceSourceLocation,
-      referenceEffects,
-    })
-  }
-
-  return formatFoundReferenceToModule({
-    reference,
-    showReferenceSourceLocation,
-    referenceEffects,
-  })
-}
-
-const formatCreateReferenceForEntry = ({ reference, referenceEffects }) => {
-  return `
-Start from entry file ${reference.ressource.relativeUrl}${appendEffects(
-    referenceEffects,
-  )}`
-}
-
-const formatFoundRessourceHint = ({
-  reference,
-  showReferenceSourceLocation,
-  referenceEffects,
-}) => {
-  return `
-Found ressource hint in ${showReferenceSourceLocation(
-    reference,
-  )}${appendEffects(referenceEffects)}`
-}
-
-const formatFoundReferenceToExternalRessource = ({
-  reference,
-  showReferenceSourceLocation,
-  referenceEffects,
-}) => {
-  return `
-Found external url in ${showReferenceSourceLocation(reference)}${appendEffects(
-    referenceEffects,
-  )}`
-}
-
-const formatCreateRessourcePlaceholder = ({
-  reference,
-  showReferenceSourceLocation,
-  referenceEffects,
-}) => {
-  return `
-Create placeholder for ressource in ${showReferenceSourceLocation(
-    reference,
-  )}${appendEffects(referenceEffects)}`
-}
-
-const formatFoundReferenceToInlineRessource = ({
-  reference,
-  showReferenceSourceLocation,
-  referenceEffects,
-}) => {
-  return `
-Found inline ressource in ${showReferenceSourceLocation(
-    reference,
-  )}${appendEffects(referenceEffects)}`
-}
-
-const formatFoundReferenceToInlineModule = ({
-  reference,
-  showReferenceSourceLocation,
-  referenceEffects,
-}) => {
-  return `
-Found inline module in ${showReferenceSourceLocation(reference)}${appendEffects(
-    referenceEffects,
-  )}`
-}
-
-const formatFoundReferenceToRessource = ({
-  reference,
-  showReferenceSourceLocation,
-  referenceEffects,
-}) => {
-  return `
-Found ressource in ${showReferenceSourceLocation(reference)}${appendEffects(
-    referenceEffects,
-  )}`
-}
-
-const formatFoundReferenceToModule = ({
-  reference,
-  showReferenceSourceLocation,
-  referenceEffects,
-}) => {
+  const { referenceLabel = "unlabelled reference" } = reference
   return `
-Found module script in ${showReferenceSourceLocation(reference)}${appendEffects(
+Found "${referenceLabel}" referencing "${shortenUrl(reference.ressource.url)}"
+  in ${showReferenceSourceLocation(reference)}${appendEffects(
     referenceEffects,
   )}`
 }

package/src/internal/building/svg/parseSvgRessource.js

@@ -60,6 +60,7 @@ const imageHrefVisitor = (image, { notifyReferenceFound }) => {
   }
 
   const hrefReference = notifyReferenceFound({
+    referenceLabel: "svg image href",
     ressourceSpecifier: hrefAttribute.value,
     ...referenceLocationFromHtmlNode(image, "href"),
   })
@@ -81,6 +82,7 @@ const useHrefVisitor = (use, { notifyReferenceFound }) => {
 
   const { hash } = new URL(href, "file://")
   const hrefReference = notifyReferenceFound({
+    referenceLabel: "svg use href",
     ressourceSpecifier: href,
     ...referenceLocationFromHtmlNode(use, "href"),
   })

package/src/internal/building/url_loader.js

@@ -30,6 +30,7 @@ export const createUrlLoader = ({
       const importer = urlImporterMap[url]
       const cssReference =
         await ressourceBuilder.createReferenceFoundInJsModule({
+          referenceLabel: "css import assertion",
           // If all references to a ressource are only import assertions
           // the file referenced do not need to be written on filesystem
           // as it was converted to a js file
@@ -84,6 +85,7 @@ export const createUrlLoader = ({
       const importer = urlImporterMap[url]
       const jsonReference =
         await ressourceBuilder.createReferenceFoundInJsModule({
+          referenceLabel: "json import assertion",
           // If all references to a ressource are only import assertions
           // the file referenced do not need to be written on filesystem
           // as it was converted to a js file
@@ -114,7 +116,7 @@ export const createUrlLoader = ({
 
     if (url in inlineModuleScripts) {
       const transformResult = await transformJs({
-        code: inlineModuleScripts[url],
+        code: String(inlineModuleScripts[url].bufferBeforeBuild),
         url: asOriginalUrl(url), // transformJs expect a file:// url
         projectDirectoryUrl,
         babelPluginMap,

package/src/internal/building/webmanifest/parseWebmanifestRessource.js

@@ -9,8 +9,9 @@ export const parseWebmanifestRessource = (
   const manifest = JSON.parse(manifestString)
   const { icons = [] } = manifest
 
-  const iconReferences = icons.map((icon) => {
+  const iconReferences = icons.map((icon, index) => {
     const iconReference = notifyReferenceFound({
+      referenceLabel: `web manifest icon ${index}`,
       ressourceSpecifier: icon.src,
     })
     return iconReference

package/src/internal/executing/executeConcurrently.js

@@ -11,7 +11,7 @@ import {
   normalizeStructuredMetaMap,
   urlToMeta,
 } from "@jsenv/filesystem"
-import { Abort } from "@jsenv/abort"
+import { Abort, createCallbackListNotifiedOnce } from "@jsenv/abort"
 
 import { launchAndExecute } from "../executing/launchAndExecute.js"
 import { reportToCoverage } from "./coverage/reportToCoverage.js"
@@ -34,6 +34,7 @@ export const executeConcurrently = async (
     defaultMsAllocatedPerExecution = 30000,
     cooldownBetweenExecutions = 0,
     maxExecutionsInParallel = 1,
+    stopAfterExecute,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
 
@@ -132,11 +133,13 @@ export const executeConcurrently = async (
     }
   }
 
-  let executionLog = createLog({ newLine: "around" })
+  let executionLog = createLog({ newLine: "" })
   let abortedCount = 0
   let timedoutCount = 0
   let erroredCount = 0
   let completedCount = 0
+  const stopAfterAllExecutionCallbackList = createCallbackListNotifiedOnce()
+
   const executionsDone = await executeInParallel({
     multipleExecutionsOperation,
     maxExecutionsInParallel,
@@ -153,12 +156,7 @@ export const executeConcurrently = async (
         measurePerformance: false,
         collectPerformance: false,
         captureConsole: true,
-        // stopAfterExecute: true to ensure runtime is stopped once executed
-        // because we have what we wants: execution is completed and
-        // we have associated coverage and capturedConsole
-        // passsing false means all node process and browsers launched stays opened
-        // (can eventually be used for debug)
-        stopAfterExecute: true,
+        stopAfterExecute,
         stopAfterExecuteReason: "execution-done",
         allocatedMs: defaultMsAllocatedPerExecution,
         ...paramsFromStep,
@@ -212,6 +210,7 @@ export const executeConcurrently = async (
             collectCoverage: coverage,
             coverageIgnorePredicate,
             coverageForceIstanbul,
+            stopAfterAllExecutionCallbackList,
             ...executionParams.runtimeParams,
           },
           executeParams: {
@@ -258,6 +257,9 @@ export const executeConcurrently = async (
           erroredCount,
           completedCount,
         })
+        log = `${log}
+
+`
         const { columns = 80 } = process.stdout
         log = wrapAnsi(log, columns, {
           trim: false,
@@ -277,12 +279,16 @@ export const executeConcurrently = async (
           // nothing to do, we reuse the current executionLog object
         } else {
           executionLog.destroy()
-          executionLog = createLog({ newLine: "around" })
+          executionLog = createLog({ newLine: "" })
         }
       }
     },
   })
 
+  if (stopAfterExecute) {
+    stopAfterAllExecutionCallbackList.notify()
+  }
+
   const summaryCounts = reportToSummary(report)
 
   const summary = {

package/src/internal/executing/executePlan.js

@@ -26,6 +26,7 @@ export const executePlan = async (
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    stopAfterExecute,
     cooldownBetweenExecutions,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
@@ -156,6 +157,7 @@ export const executePlan = async (
 
       defaultMsAllocatedPerExecution,
       maxExecutionsInParallel,
+      stopAfterExecute,
       cooldownBetweenExecutions,
       completedExecutionLogMerging,
       completedExecutionLogAbbreviation,

package/src/internal/runtime/s.js

@@ -599,7 +599,7 @@
   var autoImportCandidates = {};
   var systemRegister = systemJSPrototype.register;
   var inlineScriptCount = 0;
-  systemJSPrototype.register = function (deps, declare) {
+  systemJSPrototype.register = function (deps, declare, autoUrl) {
     if (hasDocument && document.readyState === 'loading' && typeof deps !== 'string') {
       var scripts = document.querySelectorAll('script[src]');
       var lastScript = scripts[scripts.length - 1];
@@ -608,6 +608,9 @@
       if (lastScript) {
         lastAutoImportUrl = lastScript.src;
       }
+      else if (autoUrl) {
+        lastAutoImportUrl = autoUrl
+      }
       else {
         inlineScriptCount++
         lastAutoImportUrl = document.location.href + "__inline_script__" + inlineScriptCount;
@@ -725,4 +728,39 @@
       });
     };
 
+}());
+
+(function(){
+  var envGlobal = typeof self !== 'undefined' ? self : global;
+  var System = envGlobal.System;
+  var register = System.register;
+  var registerRegistry = Object.create(null)
+
+  System.register = function (name, deps, declare) {
+    if (typeof name !== 'string') return register.apply(this, arguments);
+    var define = [deps, declare];
+    var url = System.resolve(`./${name}`);
+    registerRegistry[url] = define;
+    return register.call(this, deps, declare, url);
+  };
+
+  var instantiate = System.instantiate;
+  System.instantiate = function (url, firstParentUrl) {
+    var result = registerRegistry[url];
+
+    if (result) {
+      registerRegistry[url] = null;
+      return result;
+    } else {
+      return instantiate.call(this, url, firstParentUrl);
+    }
+  };
+
+  var getRegister = System.getRegister;
+  System.getRegister = function (url) {
+    // Calling getRegister() because other extras need to know it was called so they can perform side effects
+    var register = getRegister.call(this, url);
+    var result = registerRegistry[url] || register;
+    return result;
+  };
 }());