@jsenv/core 26.0.0 → 26.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "26.0.0",
+  "version": "26.0.1",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {

package/readme.md

@@ -291,11 +291,6 @@ _jsenv.config.mjs_ is meant to share configuration, other files will simply impo
 import { buildProject } from '@jsenv/core'
 
 + import { projectDirectoryUrl } from "./jsenv.config.mjs"
-
-await buildProject({
--  projectDirectoryUrl: new URL('./', import.meta.url)
-+  projectDirectoryUrl
-})
 ```
 
 > We recommend to use ".mjs" extension when a file is written for Node.js but you can name the file as you want, "jsenv.config.js" is fine too.
@@ -324,10 +319,10 @@ Jsenv relies on **standard web features**. Each standard listed below is potenti
 
 - `<script type="module">`
 - `<script type="importmap">`
-- top level await
-- import.meta.url
 - dynamic imports
+- import.meta.url
 - import assertions
+- top level await
 
 ## When to use it?
 

package/src/internal/compile_server/compile_file.js

@@ -14,6 +14,7 @@ export const compileFile = async ({
   logger,
 
   projectDirectoryUrl,
+  jsenvDirectory,
   jsenvRemoteDirectory,
   originalFileUrl,
   compiledFileUrl,
@@ -103,6 +104,7 @@ export const compileFile = async ({
       // when serving sourcemap files
       await updateCompileCache({
         logger,
+        jsenvDirectory,
         meta,
         compileResult,
         compileResultStatus,

package/src/internal/compile_server/compiled_file_service.js

@@ -138,6 +138,7 @@ export const createCompiledFileService = ({
       logger,
 
       projectDirectoryUrl,
+      jsenvDirectory,
       jsenvRemoteDirectory,
       originalFileUrl,
       compiledFileUrl,

package/src/internal/compile_server/jsenv_directory/jsenv_directory.js

@@ -38,6 +38,7 @@ export const setupJsenvDirectory = async ({
     )
   }
 
+  const compiledFileWriteSignal = { onwrite: () => {} }
   if (compileServerCanWriteOnFilesystem) {
     if (jsenvDirectoryClean) {
       await ensureEmptyDirectory(jsenvDirectoryUrl)
@@ -46,9 +47,15 @@ export const setupJsenvDirectory = async ({
       logger,
       jsenvDirectoryUrl,
       jsenvDirectoryMetaFileUrl,
-      writeMetaFile,
       jsenvDirectoryMeta,
     })
+    // We want ".jsenv" directory to appear on the filesystem only
+    // if there is a compiled file inside (and not immediatly when compile server starts)
+    // To do this we wait for a file to be written to write "__jsenv_meta__.json" file
+    compiledFileWriteSignal.onwrite = async () => {
+      compiledFileWriteSignal.onwrite = () => {}
+      await writeMetaFile()
+    }
   }
 
   /*
@@ -88,7 +95,7 @@ export const setupJsenvDirectory = async ({
       }
       return existingCompileId
     }
-    const compileIdBase = generateCompileId({ compileProfile })
+    const compileIdBase = generateCompileId({ compileProfile, runtime })
     let compileId = compileIdBase
     let integer = 1
     while (existingCompileIds.includes(compileId)) {
@@ -106,13 +113,20 @@ export const setupJsenvDirectory = async ({
   return {
     compileDirectories,
     getOrCreateCompileId,
+    compiledFileWriteSignal,
   }
 }
 
-const generateCompileId = ({ compileProfile }) => {
+const generateCompileId = ({ compileProfile, runtime }) => {
+  if (runtime.name === "jsenv_build") {
+    return `out_build`
+  }
   if (compileProfile.missingFeatures["transform-instrument"]) {
     return `out_instrumented`
   }
+  if (compileProfile.moduleOutFormat === "systemjs") {
+    return `out_system`
+  }
   return `out`
 }
 
@@ -121,7 +135,6 @@ const applyFileSystemEffects = async ({
   jsenvDirectoryUrl,
   jsenvDirectoryMetaFileUrl,
   jsenvDirectoryMeta,
-  writeMetaFile,
 }) => {
   try {
     const source = await readFile(jsenvDirectoryMetaFileUrl)
@@ -130,7 +143,6 @@ const applyFileSystemEffects = async ({
         `${jsenvDirectoryMetaFileUrl} is empty -> clean ${jsenvDirectoryUrl} directory`,
       )
       await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
       return
     }
     const jsenvDirectoryMetaPrevious = JSON.parse(source)
@@ -144,7 +156,6 @@ const applyFileSystemEffects = async ({
         `compile context has changed -> clean ${jsenvDirectoryUrl} directory`,
       )
       await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
       return
     }
     // reuse existing compile directories
@@ -158,7 +169,6 @@ const applyFileSystemEffects = async ({
         `${jsenvDirectoryMetaFileUrl} not found -> clean ${jsenvDirectoryUrl} directory`,
       )
       await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
       return
     }
     if (e.name === "SyntaxError") {
@@ -166,7 +176,6 @@ const applyFileSystemEffects = async ({
         `${jsenvDirectoryMetaFileUrl} syntax error -> clean ${jsenvDirectoryUrl} directory`,
       )
       await ensureEmptyDirectory(jsenvDirectoryUrl)
-      await writeMetaFile()
       return
     }
     throw e

package/src/internal/compile_server/jsenv_directory/update_compile_cache.js

@@ -10,6 +10,7 @@ import { getMetaJsonFileUrl } from "./compile_asset.js"
 
 export const updateCompileCache = async ({
   logger,
+  jsenvDirectory,
   meta,
   compiledFileUrl,
   compileResult,
@@ -17,6 +18,9 @@ export const updateCompileCache = async ({
 }) => {
   const isNew = compileResultStatus === "created"
   const isUpdated = compileResultStatus === "updated"
+  if (!isNew && !isUpdated) {
+    return
+  }
   const {
     compiledSource,
     contentType,
@@ -26,125 +30,102 @@ export const updateCompileCache = async ({
     assetsContent,
     dependencies,
   } = compileResult
-
   const promises = []
-  if (isNew || isUpdated) {
-    // ensure source that does not leads to concrete files are not capable to invalidate the cache
-    const sourcesToRemove = sources.filter((sourceFileUrl) => {
-      return (
-        sourceFileUrl.startsWith("file://") && !testFilePresence(sourceFileUrl)
-      )
-    })
-    const sourceNotFoundCount = sourcesToRemove.length
-    if (sourceNotFoundCount > 0) {
-      logger.warn(`SOURCE_META_NOT_FOUND: ${sourceNotFoundCount} source file(s) not found.
+  // ensure source that does not leads to concrete files are not capable to invalidate the cache
+  const sourcesToRemove = sources.filter((sourceFileUrl) => {
+    return (
+      sourceFileUrl.startsWith("file://") && !testFilePresence(sourceFileUrl)
+    )
+  })
+  const sourceNotFoundCount = sourcesToRemove.length
+  if (sourceNotFoundCount > 0) {
+    logger.warn(`SOURCE_META_NOT_FOUND: ${sourceNotFoundCount} source file(s) not found.
 --- consequence ---
 cache will be reused even if one of the source file is modified
 --- source files not found ---
 ${sourcesToRemove.join(`\n`)}`)
-      sourcesToRemove.forEach((url) => {
-        const sourceIndex = sources.indexOf(url)
-        if (sourceIndex) {
-          sources.splice(sourceIndex, 1)
-          sourcesContent.splice(sourceIndex, 1)
-        }
-      })
-    }
-
-    const { writeCompiledSourceFile = true, writeAssetsFile = true } =
-      compileResult
-
-    if (writeCompiledSourceFile) {
-      logger.debug(
-        `write compiled file at ${urlToFileSystemPath(compiledFileUrl)}`,
-      )
-      promises.push(
-        writeFileContent(compiledFileUrl, compiledSource, {
-          fileLikelyNotFound: isNew,
-        }).then(() => {
-          const mtime = compileResult.compiledMtime
-          // when compileResult.compiledMtime do not exists it means
-          // the client is not interested in it so
-          // -> moment we write the file is not important
-          // -> There is no need to update mtime
-          if (mtime) {
-            utimesSync(
-              urlToFileSystemPath(compiledFileUrl),
-              new Date(mtime),
-              new Date(mtime),
-            )
-          }
-        }),
-      )
-    }
-
-    if (writeAssetsFile) {
-      promises.push(
-        ...assets.map((assetFileUrl, index) => {
-          logger.debug(
-            `write compiled file asset at ${urlToFileSystemPath(assetFileUrl)}`,
-          )
-          return writeFileContent(assetFileUrl, assetsContent[index], {
-            fileLikelyNotFound: isNew,
-          })
-        }),
-      )
-    }
-  }
-
-  const metaJsonFileUrl = getMetaJsonFileUrl(compiledFileUrl)
-
-  if (isNew || isUpdated) {
-    let latestMeta
-
-    const sourceAndAssetProps = {
-      sources: sources.map((source) =>
-        urlToRelativeUrl(source, metaJsonFileUrl),
-      ),
-      sourcesEtag: sourcesContent.map((sourceContent) =>
-        bufferToEtag(Buffer.from(sourceContent)),
-      ),
-      assets: assets.map((asset) => urlToRelativeUrl(asset, metaJsonFileUrl)),
-      assetsEtag: assetsContent.map((assetContent) =>
-        bufferToEtag(Buffer.from(assetContent)),
-      ),
-      dependencies: dependencies.filter((dep) => {
-        return !dep.startsWith("data:")
-      }),
-    }
-
-    if (isNew) {
-      latestMeta = {
-        contentType,
-        ...sourceAndAssetProps,
-        createdMs: Number(Date.now()),
-        lastModifiedMs: Number(Date.now()),
-      }
-    } else if (isUpdated) {
-      latestMeta = {
-        ...meta,
-        ...sourceAndAssetProps,
-        lastModifiedMs: Number(Date.now()),
-      }
-    } else {
-      latestMeta = {
-        ...meta,
+    sourcesToRemove.forEach((url) => {
+      const sourceIndex = sources.indexOf(url)
+      if (sourceIndex) {
+        sources.splice(sourceIndex, 1)
+        sourcesContent.splice(sourceIndex, 1)
       }
-    }
-
+    })
+  }
+  const { writeCompiledSourceFile = true, writeAssetsFile = true } =
+    compileResult
+  if (writeCompiledSourceFile) {
     logger.debug(
-      `write compiled file meta at ${urlToFileSystemPath(metaJsonFileUrl)}`,
+      `write compiled file at ${urlToFileSystemPath(compiledFileUrl)}`,
+    )
+    promises.push(
+      writeFileContent(compiledFileUrl, compiledSource, {
+        fileLikelyNotFound: isNew,
+      }).then(() => {
+        const mtime = compileResult.compiledMtime
+        // when compileResult.compiledMtime do not exists it means
+        // the client is not interested in it so
+        // -> moment we write the file is not important
+        // -> There is no need to update mtime
+        if (mtime) {
+          utimesSync(
+            urlToFileSystemPath(compiledFileUrl),
+            new Date(mtime),
+            new Date(mtime),
+          )
+        }
+      }),
     )
+  }
+  if (writeAssetsFile) {
     promises.push(
-      writeFileContent(
-        metaJsonFileUrl,
-        JSON.stringify(latestMeta, null, "  "),
-        {
+      ...assets.map((assetFileUrl, index) => {
+        logger.debug(
+          `write compiled file asset at ${urlToFileSystemPath(assetFileUrl)}`,
+        )
+        return writeFileContent(assetFileUrl, assetsContent[index], {
           fileLikelyNotFound: isNew,
-        },
-      ),
+        })
+      }),
     )
   }
-
-  return Promise.all(promises)
+  const metaJsonFileUrl = getMetaJsonFileUrl(compiledFileUrl)
+  let latestMeta
+  const sourceAndAssetProps = {
+    sources: sources.map((source) => urlToRelativeUrl(source, metaJsonFileUrl)),
+    sourcesEtag: sourcesContent.map((sourceContent) =>
+      bufferToEtag(Buffer.from(sourceContent)),
+    ),
+    assets: assets.map((asset) => urlToRelativeUrl(asset, metaJsonFileUrl)),
+    assetsEtag: assetsContent.map((assetContent) =>
+      bufferToEtag(Buffer.from(assetContent)),
+    ),
+    dependencies: dependencies.filter((dep) => {
+      return !dep.startsWith("data:")
+    }),
+  }
+  if (isNew) {
+    latestMeta = {
+      contentType,
+      ...sourceAndAssetProps,
+      createdMs: Number(Date.now()),
+      lastModifiedMs: Number(Date.now()),
+    }
+  } else if (isUpdated) {
+    latestMeta = {
+      ...meta,
+      ...sourceAndAssetProps,
+      lastModifiedMs: Number(Date.now()),
+    }
+  }
+  logger.debug(
+    `write compiled file meta at ${urlToFileSystemPath(metaJsonFileUrl)}`,
+  )
+  promises.push(
+    writeFileContent(metaJsonFileUrl, JSON.stringify(latestMeta, null, "  "), {
+      fileLikelyNotFound: isNew,
+    }),
+  )
+  promises.push(jsenvDirectory.compiledFileWriteSignal.onwrite())
+  await Promise.all(promises)
 }