@jsenv/core 24.3.2 → 24.4.3

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/dev_server/toolbar/toolbar.injector.js

@@ -150,7 +150,9 @@ const injectToolbar = async () => {
       showToolbarTrigger()
     }
   })
-  sendCommandToToolbar(iframe, "renderToolbar")
+  addToolbarEventCallback(iframe, "toolbar_ready", () => {
+    sendCommandToToolbar(iframe, "renderToolbar")
+  })
 
   return iframe
 }

package/src/internal/dev_server/toolbar/toolbar.main.js

@@ -223,6 +223,12 @@ const sendEventToParent = (name, data) => {
   )
 }
 
+window.toolbar = {
+  render: renderToolbar,
+  show: showToolbar,
+  hide: () => hideToolbar(),
+}
+
 addExternalCommandCallback("renderToolbar", () => {
   renderToolbar()
 })
@@ -232,9 +238,4 @@ addExternalCommandCallback("showToolbar", () => {
 addExternalCommandCallback("hideToolbar", () => {
   hideToolbar()
 })
-
-window.toolbar = {
-  render: renderToolbar,
-  show: showToolbar,
-  hide: () => hideToolbar(),
-}
+sendEventToParent("toolbar_ready")

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

@@ -725,4 +725,86 @@
       });
     };
 
-}());
+}());
+
+(function(){/*
+ * SystemJS named register extension
+ * Supports System.register('name', [..deps..], function (_export, _context) { ... })
+ *
+ * Names are written to the registry as-is
+ * System.register('x', ...) can be imported as System.import('x')
+ */
+(function (global) {
+  var System = global.System;
+  setRegisterRegistry(System);
+  var systemJSPrototype = System.constructor.prototype;
+  var constructor = System.constructor;
+  var SystemJS = function () {
+    constructor.call(this);
+    setRegisterRegistry(this);
+  };
+  SystemJS.prototype = systemJSPrototype;
+  System.constructor = SystemJS;
+
+  var firstNamedDefine, firstName;
+
+  function setRegisterRegistry(systemInstance) {
+    systemInstance.registerRegistry = Object.create(null);
+    systemInstance.namedRegisterAliases = Object.create(null);
+  }
+
+  var register = systemJSPrototype.register;
+  systemJSPrototype.register = function (name, deps, declare) {
+    if (typeof name !== 'string')
+      return register.apply(this, arguments);
+    var define = [deps, declare];
+    this.registerRegistry[name] = define;
+    if (!firstNamedDefine) {
+      firstNamedDefine = define;
+      firstName = name;
+    }
+    Promise.resolve().then(function () {
+      firstNamedDefine = null;
+      firstName = null;
+    });
+    return register.apply(this, [deps, declare]);
+  };
+
+  var resolve = systemJSPrototype.resolve;
+  systemJSPrototype.resolve = function (id, parentURL) {
+    try {
+      // Prefer import map (or other existing) resolution over the registerRegistry
+      return resolve.call(this, id, parentURL);
+    } catch (err) {
+      if (id in this.registerRegistry) {
+        return this.namedRegisterAliases[id] || id;
+      }
+      throw err;
+    }
+  };
+
+  var instantiate = systemJSPrototype.instantiate;
+  systemJSPrototype.instantiate = function (url, firstParentUrl) {
+    var result = this.registerRegistry[url];
+    if (result) {
+      this.registerRegistry[url] = null;
+      return result;
+    } else {
+      return instantiate.call(this, url, firstParentUrl);
+    }
+  };
+
+  var getRegister = systemJSPrototype.getRegister;
+  systemJSPrototype.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);
+
+    if (firstName && url) {
+      this.namedRegisterAliases[firstName] = url;
+    }
+    var result = firstNamedDefine || register;
+    firstNamedDefine = null;
+    firstName = null;
+    return result;
+  };
+})(typeof self !== 'undefined' ? self : global);}());