@jsenv/core 41.4.16 → 41.4.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "41.4.16",
+  "version": "41.4.18",
   "type": "module",
   "description": "Tool to develop, test and build js projects",
   "repository": {
@@ -72,12 +72,12 @@
     "test:snapshot_clear": "npx @jsenv/filesystem clear **/tests/**/side_effects/"
   },
   "dependencies": {
-    "@jsenv/ast": "6.9.1",
-    "@jsenv/js-module-fallback": "1.5.0",
-    "@jsenv/plugin-bundling": "2.10.16",
-    "@jsenv/plugin-minification": "1.7.8",
-    "@jsenv/plugin-supervisor": "1.8.11",
-    "@jsenv/plugin-transpilation": "1.6.0",
+    "@jsenv/ast": "6.9.2",
+    "@jsenv/js-module-fallback": "1.5.1",
+    "@jsenv/plugin-bundling": "2.10.17",
+    "@jsenv/plugin-minification": "1.7.9",
+    "@jsenv/plugin-supervisor": "1.8.13",
+    "@jsenv/plugin-transpilation": "1.6.1",
     "@jsenv/server": "17.6.1",
     "@jsenv/sourcemap": "1.4.2",
     "react-table": "7.8.0"

package/src/dev/dev_server_plugins/dev_server_plugin_serve_source_files.js

@@ -1,9 +1,8 @@
 import { bufferToEtag } from "@jsenv/filesystem";
 import { formatError } from "@jsenv/humanize";
 import { composeTwoResponses, fetchDirectory } from "@jsenv/server";
-import { URL_META } from "@jsenv/url-meta";
 import { normalizeUrl } from "@jsenv/urls";
-import { readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 
 import { watchSourceFiles } from "../../helpers/watch_source_files.js";
 import { WEB_URL_CONVERTER } from "../../helpers/web_url_converter.js";
@@ -56,11 +55,10 @@ export const devServerPluginServeSourceFiles = ({
     if (existing) {
       return existing;
     }
-    const watchAssociations = URL_META.resolveAssociations(
-      { watch: stopWatchingSourceFiles.watchPatterns },
-      sourceDirectoryUrl,
-    );
     let kitchen;
+    // per url info, the file stat under which its content was last compared
+    // with the file on disk and found identical (see isValid)
+    const fileStatValidatedMap = new WeakMap();
     clientFileChangeEventEmitter.on(({ url, event }) => {
       const urlInfo = kitchen.graph.getUrlInfo(url);
       if (urlInfo) {
@@ -101,11 +99,6 @@ export const devServerPluginServeSourceFiles = ({
       packageDirectory,
     });
     kitchen.graph.urlInfoCreatedEventEmitter.on((urlInfoCreated) => {
-      const { watch } = URL_META.applyAssociations({
-        url: urlInfoCreated.url,
-        associations: watchAssociations,
-      });
-      urlInfoCreated.isWatched = watch;
       // when an url depends on many others, we check all these (like package.json)
       urlInfoCreated.isValid = () => {
         const seenSet = new Set();
@@ -125,37 +118,64 @@ export const devServerPluginServeSourceFiles = ({
             //   was compared using etag and it has changed
             return false;
           }
-          // Watched files trust the watcher — except the ones marked
-          // revalidateOnFileSystem (package.json files, see node_esm_resolver):
-          // the watcher fires a beat AFTER a change, and what these files
-          // decide (a package version, hence the ?v= the importer embeds) is
-          // cached as immutable by the browser — a request racing the watcher
-          // must not win a stale answer it would then keep forever.
-          if (!urlInfo.isWatched || urlInfo.revalidateOnFileSystem) {
-            // check the filesystem
-            let fileContentAsBuffer;
+          // The content held in memory is the file as it was read; a request
+          // must never win a stale answer, whatever the watcher's latency,
+          // and the ?v= a package.json decides even ends up in the browser's
+          // immutable cache. So the file is checked on disk at every
+          // validation — cheaply: a stat, compared with the one taken when
+          // the content was read (or last found identical). Only a file
+          // whose stat moved is read and hashed again.
+          // Inline content (a <script> inside an html) has no file of its
+          // own: it is as fresh as the html holding it, checked by the caller.
+          if (!urlInfo.isInline) {
+            let fileStat;
             try {
-              fileContentAsBuffer = readFileSync(new URL(urlInfo.url));
-            } catch (e) {
-              if (e.code === "ENOENT") {
-                urlInfo.onModified();
-                return false;
-              }
+              fileStat = statSync(new URL(urlInfo.url), {
+                throwIfNoEntry: false,
+              });
+            } catch {
               return false;
             }
-            const fileContentEtag = bufferToEtag(fileContentAsBuffer);
-            if (fileContentEtag !== urlInfo.originalContentEtag) {
+            if (!fileStat) {
               urlInfo.onModified();
-              // restore content to be able to compare it again later
-              urlInfo.kitchen.urlInfoTransformer.setContent(
-                urlInfo,
-                String(fileContentAsBuffer),
-                {
-                  contentEtag: fileContentEtag,
-                },
-              );
               return false;
             }
+            const fileStatKnown =
+              fileStatValidatedMap.get(urlInfo) || urlInfo.data.fileStat;
+            const fileUnchanged =
+              fileStatKnown &&
+              fileStatKnown.mtimeMs === fileStat.mtimeMs &&
+              fileStatKnown.size === fileStat.size;
+            if (!fileUnchanged) {
+              let fileContentAsBuffer;
+              try {
+                fileContentAsBuffer = readFileSync(new URL(urlInfo.url));
+              } catch (e) {
+                if (e.code === "ENOENT") {
+                  urlInfo.onModified();
+                  return false;
+                }
+                return false;
+              }
+              const fileContentEtag = bufferToEtag(fileContentAsBuffer);
+              if (fileContentEtag !== urlInfo.originalContentEtag) {
+                fileStatValidatedMap.delete(urlInfo);
+                urlInfo.onModified();
+                // restore content to be able to compare it again later
+                urlInfo.kitchen.urlInfoTransformer.setContent(
+                  urlInfo,
+                  String(fileContentAsBuffer),
+                  {
+                    contentEtag: fileContentEtag,
+                  },
+                );
+                return false;
+              }
+              fileStatValidatedMap.set(urlInfo, {
+                mtimeMs: fileStat.mtimeMs,
+                size: fileStat.size,
+              });
+            }
           }
           for (const implicitUrl of urlInfo.implicitUrlSet) {
             const implicitUrlInfo = urlInfo.graph.getUrlInfo(implicitUrl);
@@ -271,6 +291,40 @@ export const devServerPluginServeSourceFiles = ({
           const ifNoneMatch = request.headers["if-none-match"];
           const inlineParentUrlInfo = urlInfo.findParentIfInline();
           const urlInfoTargetedByCache = inlineParentUrlInfo || urlInfo;
+          // The content held in memory is the response when it is finalized
+          // and still valid. Content can be defined while a cook is still in
+          // flight (a file watcher invalidation re-cooking in the background,
+          // for instance): at that point it holds the raw fetched content,
+          // transformations not applied yet. Serving that would send an html
+          // without any of the injected scripts. An inline url info (a
+          // <script> inside an html) is cooked again whenever the html
+          // containing it is cooked: its content is as fresh as the html's,
+          // so both must be valid.
+          const hasFreshContent = (urlInfo) =>
+            urlInfo.content !== undefined &&
+            urlInfo.contentFinalized &&
+            urlInfo.isValid();
+          const memoryContentIsFresh = () =>
+            inlineParentUrlInfo
+              ? hasFreshContent(urlInfo) && hasFreshContent(inlineParentUrlInfo)
+              : hasFreshContent(urlInfo);
+          // a 304 goes through the hooks too: its headers stand for the
+          // cached response's, they must say the same
+          const augmentResponse = (response) => {
+            const augmentResponseInfo = {
+              ...kitchen.context,
+              reference,
+              urlInfo,
+            };
+            kitchen.jsenvPluginsController.callHooks(
+              "augmentResponse",
+              augmentResponseInfo,
+              (returnValue) => {
+                response = composeTwoResponses(response, returnValue);
+              },
+            );
+            return response;
+          };
           const respondWithNotModified = () => {
             const headers = {
               "cache-control": `private,max-age=0,must-revalidate`,
@@ -280,23 +334,21 @@ export const devServerPluginServeSourceFiles = ({
                 headers[key] = urlInfo.headers[key];
               }
             });
-            return {
+            return augmentResponse({
               status: 304,
               headers,
-            };
+            });
           };
 
           try {
-            // an inline url info is cooked again every time the file containing it
-            // is cooked, so its content is only known after cooking; its etag is
-            // compared below, once cooked
-            if (!urlInfo.error && ifNoneMatch && !inlineParentUrlInfo) {
+            if (!urlInfo.error && ifNoneMatch) {
               const [clientOriginalContentEtag, clientContentEtag] =
                 ifNoneMatch.split("_");
               if (
-                urlInfo.originalContentEtag === clientOriginalContentEtag &&
+                urlInfoTargetedByCache.originalContentEtag ===
+                  clientOriginalContentEtag &&
                 urlInfo.contentEtag === clientContentEtag &&
-                urlInfo.isValid()
+                memoryContentIsFresh()
               ) {
                 return respondWithNotModified();
               }
@@ -314,18 +366,9 @@ export const devServerPluginServeSourceFiles = ({
             // client etag to match).
             const servableFromMemory =
               !urlInfo.error &&
-              !inlineParentUrlInfo &&
               !urlInfo.response &&
-              urlInfo.content !== undefined &&
-              // content can be defined while a cook is still in flight (a file
-              // watcher invalidation re-cooking in the background, for
-              // instance): at that point it holds the raw fetched content,
-              // transformations not applied yet. Serving that would send an
-              // html without any of the injected scripts. Only finalized
-              // content is a complete response; anything else must go through
-              // cook() below, which joins the pending cook (see debounceCook).
-              urlInfo.contentFinalized &&
               !cacheIsDisabledInResponseHeader(urlInfo) &&
+              !cacheIsDisabledInResponseHeader(urlInfoTargetedByCache) &&
               // a "?hot" request exists to bypass every cache, this one
               // included: it must be cooked, because cooking is what rewrites
               // its references so "?hot" cascades to the modified files below
@@ -344,7 +387,7 @@ export const devServerPluginServeSourceFiles = ({
               // signal registry throwing on duplicate ids). Re-cooking under
               // the normal request rewrites the references clean.
               !urlInfo.contentCookedForHotRequest &&
-              urlInfo.isValid();
+              memoryContentIsFresh();
             if (!servableFromMemory) {
               await urlInfo.cook({ request, reference });
               urlInfo.contentCookedForHotRequest =
@@ -402,19 +445,7 @@ export const devServerPluginServeSourceFiles = ({
                 ? { "served from memory cache": null }
                 : urlInfo.timing,
             };
-            const augmentResponseInfo = {
-              ...kitchen.context,
-              reference,
-              urlInfo,
-            };
-            kitchen.jsenvPluginsController.callHooks(
-              "augmentResponse",
-              augmentResponseInfo,
-              (returnValue) => {
-                response = composeTwoResponses(response, returnValue);
-              },
-            );
-            return response;
+            return augmentResponse(response);
           } catch (error) {
             const originalError = error ? error.cause || error : error;
             if (originalError.asResponse) {
@@ -492,6 +523,14 @@ export const devServerPluginServeSourceFiles = ({
                 "cache-control": "no-store",
               },
             };
+          } finally {
+            // What the request put on the url info context is for this
+            // request only: a cook happening later for another reason (the
+            // html holding an inline script is cooked again) must not see a
+            // stale "requestedUrl" and take the inline script for a direct
+            // request, which would make it pick the content of a previous
+            // reference (see jsenv:inline_content_fetcher).
+            forgetRequestFromContext(urlInfo.context);
           }
         },
       },
@@ -501,6 +540,15 @@ export const devServerPluginServeSourceFiles = ({
   return [devServerPluginRoutes, ...devServerJsenvPluginStore.allServerPlugins];
 };
 
+const forgetRequestFromContext = (context) => {
+  // own properties only: what is inherited from the owner context stays
+  for (const key of ["request", "requestedUrl", "reference"]) {
+    if (Object.hasOwn(context, key)) {
+      delete context[key];
+    }
+  }
+};
+
 const cacheIsDisabledInResponseHeader = (urlInfo) => {
   return (
     urlInfo.headers["cache-control"] === "no-store" ||

package/src/dev/start_dev_server.js

@@ -8,8 +8,13 @@ import {
   serverPluginCORS,
   startServer,
 } from "@jsenv/server";
-import { urlIsOrIsInsideOf, urlToRelativeUrl } from "@jsenv/urls";
+import {
+  urlIsOrIsInsideOf,
+  urlToFileSystemPath,
+  urlToRelativeUrl,
+} from "@jsenv/urls";
 import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 
 import { defaultRuntimeCompat } from "../build/build_params.js";
 import { createEventEmitter } from "../helpers/event_emitter.js";
@@ -50,6 +55,7 @@ const EXECUTED_BY_TEST_PLAN = process.argv.includes("--jsenv-test");
  * @param {boolean|object} [params.serverTiming={ minDuration: 0.5 }] - server-timing response headers; `minDuration` (ms) drops entries that took less (0 when run by the test plan, so tests see every entry).
  * @param {boolean|object} [params.ribbon=true] - The "ribbon" overlay marking the page as non-production. As an object: `text` (defaults to `"DEV"`), `color` (background, defaults to `"orange"`), `textColor` (defaults to dark or light depending on `color`), `href` (turns the ribbon into a link; only then does it capture clicks), `target` (defaults to `"_blank"`), `position` (`"top-right"` (default), `"top-left"`, `"bottom-right"`, `"bottom-left"` draw a diagonal corner ribbon; `"top"`, `"bottom"` draw a full width band), `htmlInclude` (defaults to `"/**\/*.html"`).
  * @param {boolean} [params.supervisor=true] - Script supervisor (better error reporting).
+ * @param {boolean} [params.modulepreload=false] - Send `Link: <url>; rel=modulepreload` response headers listing the static import graph of a page (as far as the graph knows it). Off by default, to enable once the server runs on http/2 or http/3: over http/1.1 the preloads take the 6 connections per origin ahead of the render-blocking scripts, and pages get slower (the why, with measures, in jsenv_plugin_modulepreload.js).
  * @param {boolean|object} [params.directoryListing=true] - Directory listing pages.
  * @param {object} [params.injections] - Values to inject into files, as `{ urlPattern: getInjections }`. Keys are url patterns relative to sourceDirectoryUrl (`"./index.html"`, `"**\/*.js"`), values are functions receiving `urlInfo` and returning (or resolving to) an object of placeholders to replace, named `__LIKE_THIS__` by convention. In JS the value is injected as a JS literal (a string brings its own quotes), everywhere else as-is so it can be concatenated: `href="__BACKEND_URL__/users/me"`. An html url pattern also covers what is inlined in that html, so `<script>window.backendUrl = __BACKEND_URL__;</script>` shares the value with every js file of the page. See `INJECTIONS.optional` and `INJECTIONS.global`.
  * @param {object} [params.runtimeCompat] - Target runtimes; warns when dev code wouldn't survive the build.
@@ -91,6 +97,7 @@ export const startDevServer = async ({
   sourceFilesConfig = {},
   clientAutoreload = true,
   clientAutoreloadOnServerRestart = true,
+  modulepreload = false,
   // server-timing response headers: devtools show how the time to answer is
   // spent (cook measures come from the kitchen, see urlInfo.timing). Entries
   // under minDuration are dropped so a human reads the measures that matter;
@@ -181,9 +188,12 @@ export const startDevServer = async ({
   }
 
   const logger = createLogger({ logLevel });
-  const startDevServerTask = createTaskLog("start dev server", {
-    disabled: !logger.levels.info,
-  });
+  const startDevServerTask = createTaskLog(
+    `start dev server for ${humanizeSourceDirectory(sourceDirectoryUrl)}`,
+    {
+      disabled: !logger.levels.info,
+    },
+  );
 
   const serverStopCallbackSet = new Set();
   const serverStopAbortController = new AbortController();
@@ -262,6 +272,7 @@ export const startDevServer = async ({
 
       clientAutoreload,
       clientAutoreloadOnServerRestart,
+      modulepreload,
       dependencyStatus: {
         dependencyProblemEventEmitter,
         getDependencyProblems: dependencyWatcher.getProblems,
@@ -366,3 +377,12 @@ export const startDevServer = async ({
     kitchenCache,
   };
 };
+
+// "./src/" when inside the current working directory, the full path otherwise
+const humanizeSourceDirectory = (sourceDirectoryUrl) => {
+  const cwdUrl = pathToFileURL(`${process.cwd()}/`).href;
+  if (urlIsOrIsInsideOf(sourceDirectoryUrl, cwdUrl)) {
+    return `./${urlToRelativeUrl(sourceDirectoryUrl, cwdUrl)}`;
+  }
+  return urlToFileSystemPath(sourceDirectoryUrl);
+};

package/src/helpers/watch_source_files.js

@@ -2,24 +2,27 @@ import {
   lookupPackageDirectory,
   registerDirectoryLifecycle,
 } from "@jsenv/filesystem";
-import { urlToRelativeUrl } from "@jsenv/urls";
+import { urlIsOrIsInsideOf, urlToRelativeUrl } from "@jsenv/urls";
 import { readFileSync } from "node:fs";
 
 export const getDirectoryWatchPatterns = (
   directoryUrl,
   watchedDirectoryUrl,
-  { sourceFilesConfig },
+  { sourceFilesConfig, defaultPatterns = true },
 ) => {
   const directoryUrlRelativeToWatchedDirectory = urlToRelativeUrl(
     directoryUrl,
     watchedDirectoryUrl,
   );
-  const watchPatterns = {
-    [`${directoryUrlRelativeToWatchedDirectory}**/*`]: true, // by default watch everything inside the source directory
-    [`${directoryUrlRelativeToWatchedDirectory}**/.*`]: false, // file starting with a dot -> do not watch
-    [`${directoryUrlRelativeToWatchedDirectory}**/.*/`]: false, // directory starting with a dot -> do not watch
-    [`${directoryUrlRelativeToWatchedDirectory}**/node_modules/`]: false, // node_modules directory -> do not watch
-  };
+  const watchPatterns = {};
+  if (defaultPatterns) {
+    Object.assign(watchPatterns, {
+      [`${directoryUrlRelativeToWatchedDirectory}**/*`]: true, // by default watch everything inside the source directory
+      [`${directoryUrlRelativeToWatchedDirectory}**/.*`]: false, // file starting with a dot -> do not watch
+      [`${directoryUrlRelativeToWatchedDirectory}**/.*/`]: false, // directory starting with a dot -> do not watch
+      [`${directoryUrlRelativeToWatchedDirectory}**/node_modules/`]: false, // node_modules directory -> do not watch
+    });
+  }
   for (const key of Object.keys(sourceFilesConfig)) {
     watchPatterns[`${directoryUrlRelativeToWatchedDirectory}${key}`] =
       sourceFilesConfig[key];
@@ -40,11 +43,12 @@ export const watchSourceFiles = (
   // And jsenv should not consider these as source files and watch them (to not hurt performances)
   const watchPatterns = {};
   let watchedDirectoryUrl = "";
-  const addDirectoryToWatch = (directoryUrl) => {
+  const addDirectoryToWatch = (directoryUrl, { defaultPatterns } = {}) => {
     Object.assign(
       watchPatterns,
       getDirectoryWatchPatterns(directoryUrl, watchedDirectoryUrl, {
         sourceFilesConfig,
+        defaultPatterns,
       }),
     );
   };
@@ -76,7 +80,6 @@ export const watchSourceFiles = (
         },
       },
     );
-    stopWatchingSourceFiles.watchPatterns = watchPatterns;
     return stopWatchingSourceFiles;
   };
 
@@ -96,16 +99,18 @@ export const watchSourceFiles = (
     }
     watchedDirectoryUrl = packageDirectoryUrl;
     for (const workspace of workspaces) {
-      if (workspace.endsWith("*")) {
-        const workspaceDirectoryUrl = new URL(
-          workspace.slice(0, -1),
-          packageDirectoryUrl,
-        );
-        addDirectoryToWatch(workspaceDirectoryUrl);
-      } else {
-        const workspaceRelativeUrl = new URL(workspace, packageDirectoryUrl);
-        addDirectoryToWatch(workspaceRelativeUrl);
-      }
+      const workspaceDirectoryUrl = workspace.endsWith("*")
+        ? new URL(workspace.slice(0, -1), packageDirectoryUrl)
+        : new URL(workspace, packageDirectoryUrl);
+      addDirectoryToWatch(workspaceDirectoryUrl, {
+        // The source directory patterns already cover a workspace inside it.
+        // Every pattern is tested against every file found while watching, so
+        // the same patterns rooted at each workspace only multiply that work.
+        defaultPatterns: !urlIsOrIsInsideOf(
+          workspaceDirectoryUrl,
+          sourceDirectoryUrl,
+        ),
+      });
     }
     // we are updating the root directory
     // we must make the patterns relative to source directory relative to the new root directory

package/src/kitchen/url_graph/references.js

@@ -634,20 +634,37 @@ const checkForDependencyRemovalEffects = (reference) => {
 };
 
 const traceFromUrlSite = (urlSite) => {
-  const codeFrame = urlSite.content
-    ? generateContentFrame({
-        content: urlSite.content,
-        line: urlSite.line,
-        column: urlSite.column,
-      })
-    : "";
-  return {
-    codeFrame,
-    message: stringifyUrlSite(urlSite),
-    url: urlSite.url,
-    line: urlSite.line,
-    column: urlSite.column,
+  const { url, line, column, content } = urlSite;
+  const trace = { url, line, column };
+  // A file references many urls and an error on one of them is rare: the code
+  // frame (and the message embedding it) is built the first time it is read,
+  // not for every reference found.
+  defineLazyProperty(trace, "codeFrame", () =>
+    content ? generateContentFrame({ content, line, column }) : "",
+  );
+  defineLazyProperty(trace, "message", () => stringifyUrlSite(urlSite));
+  return trace;
+};
+
+const defineLazyProperty = (object, property, compute) => {
+  const setValue = (value) => {
+    Object.defineProperty(object, property, {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value,
+    });
   };
+  Object.defineProperty(object, property, {
+    enumerable: true,
+    configurable: true,
+    get: () => {
+      const value = compute();
+      setValue(value);
+      return value;
+    },
+    set: setValue,
+  });
 };
 
 const adjustUrlSite = (urlInfo, { url, line, column }) => {

package/src/kitchen/url_graph/url_graph.js

@@ -185,7 +185,6 @@ const createUrlInfo = (url, context) => {
     dereferencedTimestamp: 0,
     originalContentEtag: null,
     contentEtag: null,
-    isWatched: false,
     isValid: () => false,
     data: {}, // plugins can put whatever they want here
     referenceToOthersSet: new Set(),

package/src/plugins/import_meta_css/jsenv_plugin_import_meta_css.js

@@ -23,7 +23,11 @@
  *
  */
 
-import { applyBabelPlugins } from "@jsenv/ast";
+import {
+  applyBabelPlugins,
+  getImportMetaPropertyName,
+  visitJsAstUntil,
+} from "@jsenv/ast";
 
 export const jsenvPluginImportMetaCss = () => {
   const importMetaCssDevClientFileUrl = import.meta
@@ -47,15 +51,10 @@ export const jsenvPluginImportMetaCss = () => {
         if (!urlInfo.content.includes("import.meta.css")) {
           return null;
         }
-        const { metadata } = await applyBabelPlugins({
-          babelPlugins: [babelPluginMetadataUsesImportMetaCss],
-          input: urlInfo.content,
-          inputIsJsModule: true,
-          inputUrl: urlInfo.originalUrl,
-          outputUrl: urlInfo.generatedUrl,
+        const importMetaCssNode = visitJsAstUntil(urlInfo.contentAst, {
+          MemberExpression: (node) => getImportMetaPropertyName(node) === "css",
         });
-        const { usesImportMetaCss } = metadata;
-        if (!usesImportMetaCss) {
+        if (!importMetaCssNode) {
           return null;
         }
         if (urlInfo.context.build) {
@@ -135,37 +134,6 @@ const babelPluginRewriteImportMetaCssAssignment = (
   };
 };
 
-const babelPluginMetadataUsesImportMetaCss = () => {
-  return {
-    name: "metadata-uses-import-meta-css",
-    visitor: {
-      Program(programPath, state) {
-        let usesImportMetaCss = false;
-        programPath.traverse({
-          MemberExpression(path) {
-            const { node } = path;
-            const { object } = node;
-            if (object.type !== "MetaProperty") {
-              return;
-            }
-            const { property: objectProperty } = object;
-            if (objectProperty.name !== "meta") {
-              return;
-            }
-            const { property } = node;
-            const { name } = property;
-            if (name === "css") {
-              usesImportMetaCss = true;
-              path.stop();
-            }
-          },
-        });
-        state.file.metadata.usesImportMetaCss = usesImportMetaCss;
-      },
-    },
-  };
-};
-
 const injectImportMetaCss = (
   urlInfo,
   { content, importFrom, importName, importAs, hot },

package/src/plugins/import_meta_hot/import_meta_hot_analysis.js

@@ -0,0 +1,70 @@
+import { getImportMetaPropertyName, visitJsAst } from "@jsenv/ast";
+
+export const analyzeImportMetaHot = (ast) => {
+  const importMetaHotNodes = [];
+  let hotDecline = false;
+  let hotAcceptSelf = false;
+  let hotAcceptSpecifiers = [];
+  visitJsAst(ast, {
+    MemberExpression: (node) => {
+      if (getImportMetaPropertyName(node) === "hot") {
+        importMetaHotNodes.push(node);
+      }
+    },
+    CallExpression: (node) => {
+      const methodName = getImportMetaHotMethodName(node);
+      if (methodName === "accept") {
+        const args = node.arguments;
+        if (args.length === 0) {
+          hotAcceptSelf = true;
+          return;
+        }
+        const [firstArg] = args;
+        if (isStringLiteral(firstArg)) {
+          hotAcceptSpecifiers = [firstArg.value];
+          return;
+        }
+        if (firstArg.type === "ArrayExpression") {
+          hotAcceptSpecifiers = firstArg.elements.map((element) => {
+            if (!isStringLiteral(element)) {
+              throw new Error(
+                `all array elements must be strings in "import.meta.hot.accept(array)"`,
+              );
+            }
+            return element.value;
+          });
+          return;
+        }
+        // accept first arg can be "anything" such as
+        // `const cb = () => {}; import.meta.hot.accept(cb)`
+        hotAcceptSelf = true;
+        return;
+      }
+      if (methodName === "decline") {
+        hotDecline = true;
+      }
+    },
+  });
+  return {
+    importMetaHotNodes,
+    hotDecline,
+    hotAcceptSelf,
+    hotAcceptSpecifiers,
+  };
+};
+
+// "import.meta.hot.<method>(...)"
+const getImportMetaHotMethodName = (callNode) => {
+  const { callee } = callNode;
+  if (callee.type !== "MemberExpression" || callee.computed) {
+    return null;
+  }
+  if (getImportMetaPropertyName(callee.object) !== "hot") {
+    return null;
+  }
+  return callee.property.name;
+};
+
+const isStringLiteral = (node) => {
+  return node.type === "Literal" && typeof node.value === "string";
+};