@jsenv/core 28.1.1 → 28.2.0

package/src/omega/url_graph.js

@@ -1,12 +1,11 @@
 import { urlToRelativeUrl } from "@jsenv/urls"
+
 import { urlSpecifierEncoding } from "./url_specifier_encoding.js"
 
-export const createUrlGraph = ({
-  clientFileChangeCallbackList,
-  clientFilesPruneCallbackList,
-  onCreateUrlInfo = () => {},
-  includeOriginalUrls,
-} = {}) => {
+export const createUrlGraph = () => {
+  const createUrlInfoCallbackRef = { current: () => {} }
+  const prunedUrlInfosCallbackRef = { current: () => {} }
+
   const urlInfoMap = new Map()
   const getUrlInfo = (url) => urlInfoMap.get(url)
   const deleteUrlInfo = (url) => {
@@ -18,15 +17,18 @@ export const createUrlGraph = ({
       }
     }
   }
-
   const reuseOrCreateUrlInfo = (url) => {
     const existingUrlInfo = getUrlInfo(url)
     if (existingUrlInfo) return existingUrlInfo
     const urlInfo = createUrlInfo(url)
     urlInfoMap.set(url, urlInfo)
-    onCreateUrlInfo(urlInfo)
+    createUrlInfoCallbackRef.current(urlInfo)
     return urlInfo
   }
+  const getParentIfInline = (urlInfo) => {
+    return urlInfo.isInline ? getUrlInfo(urlInfo.inlineUrlSite.url) : urlInfo
+  }
+
   const inferReference = (specifier, parentUrl) => {
     const parentUrlInfo = getUrlInfo(parentUrl)
     if (!parentUrlInfo) {
@@ -39,36 +41,33 @@ export const createUrlGraph = ({
     )
     return firstReferenceOnThatUrl
   }
-  const findDependent = (url, predicate) => {
-    const urlInfo = getUrlInfo(url)
-    if (!urlInfo) {
-      return null
+  const visitDependents = (urlInfo, visitor) => {
+    const seen = [urlInfo.url]
+    let stopped = false
+    const stop = () => {
+      stopped = true
     }
-    const visitDependents = (urlInfo) => {
-      for (const dependentUrl of urlInfo.dependents) {
-        const dependent = getUrlInfo(dependentUrl)
-        if (predicate(dependent)) {
-          return dependent
+    const iterate = (currentUrlInfo) => {
+      for (const dependentUrl of currentUrlInfo.dependents) {
+        if (seen.includes(dependentUrl)) {
+          continue
+        }
+        seen.push(dependentUrl)
+        const dependentUrlInfo = getUrlInfo(dependentUrl)
+        visitor(dependentUrlInfo, stop)
+        if (stopped) {
+          return dependentUrlInfo
         }
-        return visitDependents(dependent)
+        iterate(dependentUrlInfo)
       }
       return null
     }
-    return visitDependents(urlInfo)
+    return iterate(urlInfo)
   }
 
   const updateReferences = (urlInfo, references) => {
     const setOfDependencyUrls = new Set()
-
-    // for import assertion "file.css?as_css_module" depends on "file.css"
-    // this is enabled only for dev where there is autoreload
-    // during build the css file must be considered as not referenced
-    // (except if referenced explicitely by something else) so that
-    // the css file does not appear in the build directory
-    if (includeOriginalUrls && urlInfo.originalUrl !== urlInfo.url) {
-      setOfDependencyUrls.add(urlInfo.originalUrl)
-    }
-
+    const setOfImplicitUrls = new Set()
     references.forEach((reference) => {
       if (reference.isResourceHint) {
         // resource hint are a special kind of reference.
@@ -79,67 +78,83 @@ export const createUrlGraph = ({
         // by <link> as dependency and it's fine
         return
       }
-      setOfDependencyUrls.add(reference.url)
+      const dependencyUrl = reference.url
+      setOfDependencyUrls.add(dependencyUrl)
+      // an implicit reference do not appear in the file but a non-explicited file have an impact on it
+      // (package.json on import resolution for instance)
+      // in that case:
+      // - file depends on the implicit file (it must autoreload if package.json is modified)
+      // - cache validity for the file depends on the implicit file (it must be re-cooked in package.json is modified)
+      if (reference.isImplicit) {
+        setOfImplicitUrls.add(dependencyUrl)
+      }
     })
-    const urlsToRemove = Array.from(urlInfo.dependencies).filter(
-      (dep) => !setOfDependencyUrls.has(dep),
-    )
-    pruneDependencies(urlInfo, urlsToRemove)
-    urlInfo.references = references
     setOfDependencyUrls.forEach((dependencyUrl) => {
-      const dependencyUrlInfo = reuseOrCreateUrlInfo(dependencyUrl)
       urlInfo.dependencies.add(dependencyUrl)
+      const dependencyUrlInfo = reuseOrCreateUrlInfo(dependencyUrl)
       dependencyUrlInfo.dependents.add(urlInfo.url)
     })
-    return urlInfo
-  }
-  const pruneDependencies = (firstUrlInfo, urlsToRemove) => {
+    setOfImplicitUrls.forEach((implicitUrl) => {
+      urlInfo.implicitUrls.add(implicitUrl)
+      if (urlInfo.isInline) {
+        const parentUrlInfo = getUrlInfo(urlInfo.inlineUrlSite.url)
+        parentUrlInfo.implicitUrls.add(implicitUrl)
+      }
+    })
     const prunedUrlInfos = []
-    const removeDependencies = (urlInfo, urlsToPrune) => {
-      urlsToPrune.forEach((urlToPrune) => {
-        urlInfo.dependencies.delete(urlToPrune)
-        const dependencyUrlInfo = getUrlInfo(urlToPrune)
-        if (!dependencyUrlInfo) {
-          return
-        }
-        dependencyUrlInfo.dependents.delete(urlInfo.url)
-        if (dependencyUrlInfo.dependents.size === 0) {
-          removeDependencies(
-            dependencyUrlInfo,
-            Array.from(dependencyUrlInfo.dependencies),
-          )
-          prunedUrlInfos.push(dependencyUrlInfo)
-        }
-      })
-    }
-    removeDependencies(firstUrlInfo, urlsToRemove)
-    if (prunedUrlInfos.length === 0) {
-      return
+    const pruneDependency = (urlInfo, urlToClean) => {
+      urlInfo.dependencies.delete(urlToClean)
+      const dependencyUrlInfo = getUrlInfo(urlToClean)
+      if (!dependencyUrlInfo) {
+        return
+      }
+      dependencyUrlInfo.dependents.delete(urlInfo.url)
+      if (dependencyUrlInfo.dependents.size === 0) {
+        dependencyUrlInfo.dependencies.forEach((dependencyUrl) => {
+          pruneDependency(dependencyUrlInfo, dependencyUrl)
+        })
+        prunedUrlInfos.push(dependencyUrlInfo)
+      }
     }
-    prunedUrlInfos.forEach((prunedUrlInfo) => {
-      prunedUrlInfo.modifiedTimestamp = Date.now()
-      if (prunedUrlInfo.isInline) {
-        // should we always delete?
-        deleteUrlInfo(prunedUrlInfo.url)
+    urlInfo.dependencies.forEach((dependencyUrl) => {
+      if (!setOfDependencyUrls.has(dependencyUrl)) {
+        pruneDependency(urlInfo, dependencyUrl)
       }
     })
-    if (clientFilesPruneCallbackList) {
-      clientFilesPruneCallbackList.forEach((callback) => {
-        callback({
-          firstUrlInfo,
-          prunedUrlInfos,
-        })
+    if (prunedUrlInfos.length) {
+      prunedUrlInfos.forEach((prunedUrlInfo) => {
+        prunedUrlInfo.modifiedTimestamp = Date.now()
+        if (prunedUrlInfo.isInline) {
+          // should we always delete?
+          deleteUrlInfo(prunedUrlInfo.url)
+        }
       })
+      prunedUrlInfosCallbackRef.current(prunedUrlInfos, urlInfo)
     }
-  }
-
-  if (clientFileChangeCallbackList) {
-    clientFileChangeCallbackList.push(({ url }) => {
-      const urlInfo = getUrlInfo(url)
-      if (urlInfo) {
-        considerModified(urlInfo, Date.now())
+    urlInfo.implicitUrls.forEach((implicitUrl) => {
+      if (!setOfDependencyUrls.has(implicitUrl)) {
+        let implicitUrlComesFromInlineContent = false
+        for (const dependencyUrl of urlInfo.dependencies) {
+          const dependencyUrlInfo = getUrlInfo(dependencyUrl)
+          if (
+            dependencyUrlInfo.isInline &&
+            dependencyUrlInfo.implicitUrls.has(implicitUrl)
+          ) {
+            implicitUrlComesFromInlineContent = true
+            break
+          }
+        }
+        if (!implicitUrlComesFromInlineContent) {
+          urlInfo.implicitUrls.delete(implicitUrl)
+        }
+        if (urlInfo.isInline) {
+          const parentUrlInfo = getUrlInfo(urlInfo.inlineUrlSite.url)
+          parentUrlInfo.implicitUrls.delete(implicitUrl)
+        }
       }
     })
+    urlInfo.references = references
+    return urlInfo
   }
 
   const considerModified = (urlInfo, modifiedTimestamp = Date.now()) => {
@@ -150,6 +165,7 @@ export const createUrlGraph = ({
       }
       seen.push(urlInfo.url)
       urlInfo.modifiedTimestamp = modifiedTimestamp
+      urlInfo.originalContentEtag = undefined
       urlInfo.contentEtag = undefined
       urlInfo.dependents.forEach((dependentUrl) => {
         const dependentUrlInfo = getUrlInfo(dependentUrl)
@@ -168,30 +184,20 @@ export const createUrlGraph = ({
     iterate(urlInfo)
   }
 
-  const getRelatedUrlInfos = (url) => {
-    const urlInfosUntilNotInline = []
-    const parentUrlInfo = getUrlInfo(url)
-    if (parentUrlInfo) {
-      urlInfosUntilNotInline.push(parentUrlInfo)
-      if (parentUrlInfo.inlineUrlSite) {
-        urlInfosUntilNotInline.push(
-          ...getRelatedUrlInfos(parentUrlInfo.inlineUrlSite.url),
-        )
-      }
-    }
-    return urlInfosUntilNotInline
-  }
-
   return {
+    createUrlInfoCallbackRef,
+    prunedUrlInfosCallbackRef,
+
     urlInfoMap,
     reuseOrCreateUrlInfo,
     getUrlInfo,
     deleteUrlInfo,
+    getParentIfInline,
+
     inferReference,
-    findDependent,
     updateReferences,
     considerModified,
-    getRelatedUrlInfos,
+    visitDependents,
 
     toObject: () => {
       const data = {}
@@ -217,26 +223,25 @@ export const createUrlGraph = ({
 }
 
 const createUrlInfo = (url) => {
-  return {
+  const urlInfo = {
     error: null,
     modifiedTimestamp: 0,
+    originalContentEtag: null,
     contentEtag: null,
-    dependsOnPackageJson: false,
-    isValid,
+    isWatched: false,
+    isValid: () => false,
     data: {}, // plugins can put whatever they want here
     references: [],
     dependencies: new Set(),
     dependents: new Set(),
+    implicitUrls: new Set(),
     type: undefined, // "html", "css", "js_classic", "js_module", "importmap", "json", "webmanifest", ...
     subtype: undefined, // "worker", "service_worker", "shared_worker" for js, otherwise undefined
     contentType: "", // "text/html", "text/css", "text/javascript", "application/json", ...
     url,
     originalUrl: undefined,
-    generatedUrl: null,
     filename: "",
     isEntryPoint: false,
-    isInline: false,
-    inlineUrlSite: null,
     shouldHandle: undefined,
     originalContent: undefined,
     content: undefined,
@@ -244,9 +249,18 @@ const createUrlInfo = (url) => {
     sourcemap: null,
     sourcemapReference: null,
     sourcemapIsWrong: false,
+
+    generatedUrl: null,
+    sourcemapGeneratedUrl: null,
+    injected: false,
+
+    isInline: false,
+    inlineUrlSite: null,
+    jsQuote: null, // maybe move to inlineUrlSite?
+
     timing: {},
     headers: {},
   }
+  // Object.preventExtensions(urlInfo) // useful to ensure all properties are declared here
+  return urlInfo
 }
-
-const isValid = () => false

package/src/plugins/autoreload/jsenv_plugin_autoreload_client.js

@@ -19,6 +19,7 @@ export const jsenvPluginAutoreloadClient = () => {
         const htmlAst = parseHtmlString(htmlUrlInfo.content)
         const [autoreloadClientReference] = context.referenceUtils.inject({
           type: "script_src",
+          subtype: "js_module",
           expectedType: "js_module",
           specifier: autoreloadClientFileUrl,
         })

package/src/plugins/autoreload/jsenv_plugin_autoreload_server.js

@@ -134,48 +134,46 @@ export const jsenvPluginAutoreloadServer = ({
             })
           }
         })
-        clientFilesPruneCallbackList.push(
-          ({ prunedUrlInfos, firstUrlInfo }) => {
-            const mainHotUpdate = propagateUpdate(firstUrlInfo)
-            const cause = `following files are no longer referenced: ${prunedUrlInfos.map(
-              (prunedUrlInfo) => formatUrlForClient(prunedUrlInfo.url),
-            )}`
-            // now check if we can hot update the main resource
-            // then if we can hot update all dependencies
-            if (mainHotUpdate.declined) {
+        clientFilesPruneCallbackList.push((prunedUrlInfos, firstUrlInfo) => {
+          const mainHotUpdate = propagateUpdate(firstUrlInfo)
+          const cause = `following files are no longer referenced: ${prunedUrlInfos.map(
+            (prunedUrlInfo) => formatUrlForClient(prunedUrlInfo.url),
+          )}`
+          // now check if we can hot update the main resource
+          // then if we can hot update all dependencies
+          if (mainHotUpdate.declined) {
+            notifyDeclined({
+              cause,
+              reason: mainHotUpdate.reason,
+              declinedBy: mainHotUpdate.declinedBy,
+            })
+            return
+          }
+          // main can hot update
+          let i = 0
+          const instructions = []
+          while (i < prunedUrlInfos.length) {
+            const prunedUrlInfo = prunedUrlInfos[i++]
+            if (prunedUrlInfo.data.hotDecline) {
               notifyDeclined({
                 cause,
-                reason: mainHotUpdate.reason,
-                declinedBy: mainHotUpdate.declinedBy,
+                reason: `a pruned file declines hot reload`,
+                declinedBy: formatUrlForClient(prunedUrlInfo.url),
               })
               return
             }
-            // main can hot update
-            let i = 0
-            const instructions = []
-            while (i < prunedUrlInfos.length) {
-              const prunedUrlInfo = prunedUrlInfos[i++]
-              if (prunedUrlInfo.data.hotDecline) {
-                notifyDeclined({
-                  cause,
-                  reason: `a pruned file declines hot reload`,
-                  declinedBy: formatUrlForClient(prunedUrlInfo.url),
-                })
-                return
-              }
-              instructions.push({
-                type: "prune",
-                boundary: formatUrlForClient(prunedUrlInfo.url),
-                acceptedBy: formatUrlForClient(firstUrlInfo.url),
-              })
-            }
-            notifyAccepted({
-              cause,
-              reason: mainHotUpdate.reason,
-              instructions,
+            instructions.push({
+              type: "prune",
+              boundary: formatUrlForClient(prunedUrlInfo.url),
+              acceptedBy: formatUrlForClient(firstUrlInfo.url),
             })
-          },
-        )
+          }
+          notifyAccepted({
+            cause,
+            reason: mainHotUpdate.reason,
+            instructions,
+          })
+        })
       },
     },
     serve: (request, { rootDirectoryUrl, urlGraph }) => {

package/src/plugins/autoreload/jsenv_plugin_hmr.js

@@ -3,12 +3,13 @@ export const jsenvPluginHmr = () => {
     name: "jsenv:hmr",
     appliesDuring: "dev",
     redirectUrl: (reference) => {
-      const urlObject = new URL(reference.url)
-      if (!urlObject.searchParams.has("hmr")) {
+      if (!reference.searchParams.has("hmr")) {
         reference.data.hmr = false
         return null
       }
+
       reference.data.hmr = true
+      const urlObject = new URL(reference.url)
       // "hmr" search param goal is to mark url as enabling hmr:
       // this goal is achieved when we reach this part of the code
       // We get rid of this params so that urlGraph and other parts of the code

package/src/plugins/bundling/js_module/{bundle_js_module.js → bundle_js_modules.js}

@@ -21,7 +21,7 @@ const regeneratorRuntimeClientFileUrl = new URL(
   import.meta.url,
 ).href
 
-export const bundleJsModule = async ({
+export const bundleJsModules = async ({
   jsModuleUrlInfos,
   context,
   options,
@@ -35,7 +35,11 @@ export const bundleJsModule = async ({
     runtimeCompat,
     sourcemaps,
   } = context
-  const { babelHelpersChunk = true, include } = options
+  const {
+    babelHelpersChunk = true,
+    include,
+    preserveDynamicImport = false,
+  } = options
   const { jsModuleBundleUrlInfos } = await buildWithRollup({
     signal,
     logger,
@@ -49,6 +53,7 @@ export const bundleJsModule = async ({
 
     include,
     babelHelpersChunk,
+    preserveDynamicImport,
   })
   return jsModuleBundleUrlInfos
 }
@@ -63,12 +68,18 @@ const rollupPluginJsenv = ({
 
   include,
   babelHelpersChunk,
+  preserveDynamicImport,
 
   resultRef,
 }) => {
   let _rollupEmitFile = () => {
     throw new Error("not implemented")
   }
+  const format = jsModuleUrlInfos.some((jsModuleUrlInfo) =>
+    jsModuleUrlInfo.filename.endsWith(".cjs"),
+  )
+    ? "cjs"
+    : "esm"
   const emitChunk = (chunk) => {
     return _rollupEmitFile({
       type: "chunk",
@@ -118,7 +129,16 @@ const rollupPluginJsenv = ({
         const rollupFileInfo = rollupResult[fileName]
         // there is 3 types of file: "placeholder", "asset", "chunk"
         if (rollupFileInfo.type === "chunk") {
+          let url
+          if (rollupFileInfo.facadeModuleId) {
+            url = fileUrlConverter.asFileUrl(rollupFileInfo.facadeModuleId)
+          } else {
+            url = new URL(rollupFileInfo.fileName, buildDirectoryUrl).href
+          }
           const jsModuleBundleUrlInfo = {
+            url,
+            originalUrl: url,
+            type: format === "esm" ? "js_module" : "common_js",
             data: {
               generatedBy: "rollup",
               bundleRelativeUrl: rollupFileInfo.fileName,
@@ -126,16 +146,13 @@ const rollupPluginJsenv = ({
                 rollupFileInfo.imports.length > 0 ||
                 rollupFileInfo.dynamicImports.length > 0,
             },
+            sourceUrls: Object.keys(rollupFileInfo.modules).map((id) =>
+              fileUrlConverter.asFileUrl(id),
+            ),
             contentType: "text/javascript",
             content: rollupFileInfo.code,
             sourcemap: rollupFileInfo.map,
           }
-          let url
-          if (rollupFileInfo.facadeModuleId) {
-            url = fileUrlConverter.asFileUrl(rollupFileInfo.facadeModuleId)
-          } else {
-            url = new URL(rollupFileInfo.fileName, buildDirectoryUrl).href
-          }
           jsModuleBundleUrlInfos[url] = jsModuleBundleUrlInfo
         }
       })
@@ -146,11 +163,7 @@ const rollupPluginJsenv = ({
     outputOptions: (outputOptions) => {
       // const sourcemapFile = buildDirectoryUrl
       Object.assign(outputOptions, {
-        format: jsModuleUrlInfos.some((jsModuleUrlInfo) =>
-          jsModuleUrlInfo.filename.endsWith(".cjs"),
-        )
-          ? "cjs"
-          : "esm",
+        format,
         dir: fileUrlConverter.asFilePath(buildDirectoryUrl),
         sourcemap: sourcemaps === "file" || sourcemaps === "inline",
         // sourcemapFile,
@@ -210,11 +223,33 @@ const rollupPluginJsenv = ({
         // },
       })
     },
+    // https://rollupjs.org/guide/en/#resolvedynamicimport
+    resolveDynamicImport: (specifier, importer) => {
+      if (preserveDynamicImport) {
+        let urlObject
+        if (specifier[0] === "/") {
+          urlObject = new URL(specifier.slice(1), rootDirectoryUrl)
+        } else {
+          if (isFileSystemPath(importer)) {
+            importer = fileUrlConverter.asFileUrl(importer)
+          }
+          urlObject = new URL(specifier, importer)
+        }
+        urlObject.searchParams.set("as_js_classic_library", "")
+        return { external: true, id: urlObject.href }
+      }
+      return null
+    },
     resolveId: (specifier, importer = rootDirectoryUrl) => {
       if (isFileSystemPath(importer)) {
         importer = fileUrlConverter.asFileUrl(importer)
       }
-      const url = new URL(specifier, importer).href
+      let url
+      if (specifier[0] === "/") {
+        url = new URL(specifier.slice(1), rootDirectoryUrl).href
+      } else {
+        url = new URL(specifier, importer).href
+      }
       const existingImporter = urlImporters[url]
       if (!existingImporter) {
         urlImporters[url] = importer
@@ -262,6 +297,7 @@ const buildWithRollup = async ({
 
   include,
   babelHelpersChunk,
+  preserveDynamicImport,
 }) => {
   const resultRef = { current: null }
   try {
@@ -279,6 +315,7 @@ const buildWithRollup = async ({
           sourcemaps,
           include,
           babelHelpersChunk,
+          preserveDynamicImport,
           resultRef,
         }),
       ],

package/src/plugins/bundling/jsenv_plugin_bundling.js

@@ -1,6 +1,6 @@
 import { bundleCss } from "./css/bundle_css.js"
 import { bundleJsClassicWorkers } from "./js_classic_workers/bundle_js_classic_workers.js"
-import { bundleJsModule } from "./js_module/bundle_js_module.js"
+import { bundleJsModules } from "./js_module/bundle_js_modules.js"
 
 export const jsenvPluginBundling = (bundling) => {
   if (typeof bundling === "boolean") {
@@ -40,7 +40,7 @@ export const jsenvPluginBundling = (bundling) => {
         : undefined,
       js_module: bundling.js_module
         ? (jsModuleUrlInfos, context) => {
-            return bundleJsModule({
+            return bundleJsModules({
               jsModuleUrlInfos,
               context,
               options: bundling.js_module,

package/src/plugins/import_meta_hot/jsenv_plugin_import_meta_hot.js

@@ -25,6 +25,17 @@ export const jsenvPluginImportMetaHot = () => {
         htmlUrlInfo.data.hotAcceptSelf = false
         htmlUrlInfo.data.hotAcceptDependencies = hotReferences.map(
           ({ type, specifier }) => {
+            const existingReference = context.referenceUtils.find(
+              (existingReference) => {
+                return (
+                  existingReference.type === type &&
+                  existingReference.specifier === specifier
+                )
+              },
+            )
+            if (existingReference) {
+              return existingReference.url
+            }
             const [reference] = context.referenceUtils.found({
               type,
               specifier,