@nuxt/devtools 0.6.6 → 0.7.0

package/dist/chunks/module-main.mjs

@@ -1,15 +1,16 @@
-import fs, { existsSync } from 'node:fs';
+import fs$1, { existsSync } from 'node:fs';
 import { resolve, join as join$1, dirname } from 'pathe';
 import { logger, useNuxt, addPlugin, addVitePlugin } from '@nuxt/kit';
 import { searchForWorkspaceRoot } from 'vite';
 import sirv from 'sirv';
 import c from 'picocolors';
 import { createBirpcGroup } from 'birpc';
-import { R as ROUTE_AUTH, W as WS_EVENT_NAME, a as ROUTE_ANALYZE, b as ROUTE_CLIENT, c as ROUTE_AUTH_VERIFY } from '../shared/devtools.7ab40af4.mjs';
+import { R as ROUTE_AUTH, d as defaultTabOptions, W as WS_EVENT_NAME, a as ROUTE_ANALYZE, b as ROUTE_CLIENT, c as ROUTE_AUTH_VERIFY } from '../shared/devtools.d198e7a9.mjs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import fsp from 'node:fs/promises';
+import fs from 'node:fs/promises';
 import { imageMeta } from 'image-meta';
+import { debounce } from 'perfect-debounce';
 import fg from 'fast-glob';
 import { startSubprocess } from '@nuxt/devtools-kit';
 import isInstalledGlobally from 'is-installed-globally';
@@ -22,7 +23,6 @@ import semver from 'semver';
 import { getPackageInfo } from 'local-pkg';
 import { resolveBuiltinPresets } from 'unimport';
 import boxen from 'boxen';
-import { debounce } from 'perfect-debounce';
 import require$$0$1 from 'fs';
 import require$$1 from 'tty';
 import require$$1$1 from 'util';
@@ -30,7 +30,7 @@ import require$$0 from 'os';
 import { spawn } from 'child_process';
 import { runtimeDir, clientDir, packageDir, isGlobalInstall } from '../dirs.mjs';
 
-const version = "0.6.6";
+const version = "0.7.0";
 
 /*! (c) 2020 Andrea Giammarchi */
 
@@ -142,11 +142,11 @@ async function getDevAuthToken() {
   const dir = join(home, ".nuxt/devtools");
   const filepath = join(dir, "dev-auth-token.txt");
   if (existsSync(filepath))
-    token = (await fsp.readFile(filepath, "utf-8")).trim();
+    token = (await fs.readFile(filepath, "utf-8")).trim();
   if (!token)
     token = randomStr(32);
-  await fsp.mkdir(dir, { recursive: true });
-  await fsp.writeFile(filepath, token, "utf-8");
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(filepath, token, "utf-8");
   return token;
 }
 
@@ -216,47 +216,62 @@ function setupStorageRPC({
   };
 }
 
-function setupAssetsRPC({ nuxt, ensureDevAuthToken }) {
+function setupAssetsRPC({ nuxt, ensureDevAuthToken, refresh }) {
   const _imageMetaCache = /* @__PURE__ */ new Map();
+  let cache = null;
+  const publicDir = resolve(nuxt.options.srcDir, nuxt.options.dir.public);
+  const refreshDebounced = debounce(() => {
+    cache = null;
+    refresh("getStaticAssets");
+  }, 500);
+  nuxt.hook("builder:watch", (event, key) => {
+    if (key.startsWith(publicDir) && (event === "add" || event === "unlink"))
+      refreshDebounced();
+  });
+  async function scan() {
+    if (cache)
+      return cache;
+    const baseURL = nuxt.options.app.baseURL;
+    const files = await fg(["**/*"], {
+      cwd: publicDir,
+      onlyFiles: true
+    });
+    function guessType(path) {
+      if (/\.(png|jpe?g|jxl|gif|svg|webp|avif|ico|bmp|tiff?)$/i.test(path))
+        return "image";
+      if (/\.(mp4|webm|ogv|mov|avi|flv|wmv|mpg|mpeg|mkv|3gp|3g2|ts|mts|m2ts|vob|ogm|ogx|rm|rmvb|asf|amv|divx|m4v|svi|viv|f4v|f4p|f4a|f4b)$/i.test(path))
+        return "video";
+      if (/\.(mp3|wav|ogg|flac|aac|wma|alac|ape|ac3|dts|tta|opus|amr|aiff|au|mid|midi|ra|rm|wv|weba|dss|spx|vox|tak|dsf|dff|dsd|cda)$/i.test(path))
+        return "audio";
+      if (/\.(woff2?|eot|ttf|otf|ttc|pfa|pfb|pfm|afm)/i.test(path))
+        return "font";
+      if (/\.(json[5c]?|te?xt|[mc]?[jt]sx?|md[cx]?|markdown)/i.test(path))
+        return "text";
+      return "other";
+    }
+    cache = await Promise.all(files.map(async (path) => {
+      const filePath = resolve(publicDir, path);
+      const stat = await fs.lstat(filePath);
+      return {
+        path,
+        publicPath: join$1(baseURL, path),
+        filePath,
+        type: guessType(path),
+        size: stat.size,
+        mtime: stat.mtimeMs
+      };
+    }));
+    return cache;
+  }
   return {
     async getStaticAssets() {
-      const dir = resolve(nuxt.options.srcDir, nuxt.options.dir.public);
-      const baseURL = nuxt.options.app.baseURL;
-      const files = await fg(["**/*"], {
-        cwd: dir,
-        onlyFiles: true
-      });
-      function guessType(path) {
-        if (/\.(png|jpe?g|gif|svg|webp|avif|ico|bmp|tiff?)$/i.test(path))
-          return "image";
-        if (/\.(mp4|webm|ogv|mov|avi|flv|wmv|mpg|mpeg|mkv|3gp|3g2|ts|mts|m2ts|vob|ogm|ogx|rm|rmvb|asf|amv|divx|m4v|svi|viv|f4v|f4p|f4a|f4b)$/i.test(path))
-          return "video";
-        if (/\.(mp3|wav|ogg|flac|aac|wma|alac|ape|ac3|dts|tta|opus|amr|aiff|au|mid|midi|ra|rm|wv|weba|dss|spx|vox|tak|dsf|dff|dsd|cda)$/i.test(path))
-          return "audio";
-        if (/\.(woff2?|eot|ttf|otf|ttc|pfa|pfb|pfm|afm)/i.test(path))
-          return "font";
-        if (/\.(json[5c]?|te?xt|[mc]?[jt]sx?|md[cx]?|markdown)/i.test(path))
-          return "text";
-        return "other";
-      }
-      return await Promise.all(files.map(async (path) => {
-        const filePath = resolve(dir, path);
-        const stat = await fsp.lstat(filePath);
-        return {
-          path,
-          publicPath: join$1(baseURL, path),
-          filePath,
-          type: guessType(path),
-          size: stat.size,
-          mtime: stat.mtimeMs
-        };
-      }));
+      return await scan();
     },
     async getImageMeta(filepath) {
       if (_imageMetaCache.has(filepath))
         return _imageMetaCache.get(filepath);
       try {
-        const meta = imageMeta(await fsp.readFile(filepath));
+        const meta = imageMeta(await fs.readFile(filepath));
         _imageMetaCache.set(filepath, meta);
         return meta;
       } catch (e) {
@@ -267,7 +282,7 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken }) {
     },
     async getTextAssetContent(filepath, limit = 300) {
       try {
-        const content = await fsp.readFile(filepath, "utf-8");
+        const content = await fs.readFile(filepath, "utf-8");
         return content.slice(0, limit);
       } catch (e) {
         console.error(e);
@@ -281,16 +296,16 @@ function setupAssetsRPC({ nuxt, ensureDevAuthToken }) {
         files.map(async ({ name, data }) => {
           let dir = resolve(baseDir, name);
           try {
-            await fsp.stat(dir);
+            await fs.stat(dir);
             const ext = dir.split(".").pop();
             const base = dir.slice(0, dir.length - ext.length - 1);
             let i = 1;
-            while (await fsp.access(`${base}-${i}.${ext}`).then(() => true).catch(() => false))
+            while (await fs.access(`${base}-${i}.${ext}`).then(() => true).catch(() => false))
               i++;
             dir = `${base}-${i}.${ext}`;
           } catch (err) {
           }
-          await fsp.writeFile(dir, data, "base64");
+          await fs.writeFile(dir, data, "base64");
           return dir;
         })
       );
@@ -359,6 +374,8 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
       processId
     };
   }
+  const installSet = /* @__PURE__ */ new Set();
+  let latestGenerated = null;
   return {
     checkForUpdateFor(name) {
       if (!updatesPromise.has(name))
@@ -375,12 +392,16 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
       await ensureDevAuthToken(token);
       const commands = await getNpmCommand("install", name, { dev: true });
       const filepath = nuxt.options._nuxtConfigFile;
-      const source = await fsp.readFile(filepath, "utf-8");
-      const mod = await parseModule(source, { sourceFileName: filepath });
+      let source = latestGenerated;
+      if (source == null)
+        source = await fs.readFile(filepath, "utf-8");
+      const mod = parseModule(source, { sourceFileName: filepath });
       addNuxtModule(mod, name);
       const generated = mod.generate().code;
       const processId = `nuxt:add-module:${name}`;
       if (!dry) {
+        latestGenerated = generated;
+        installSet.add(name);
         const process = startSubprocess({
           command: commands[0],
           args: commands.slice(1)
@@ -393,12 +414,16 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
         const execa = process.getProcess();
         const result = await execa;
         await Promise.resolve();
+        installSet.delete(name);
         const code = result.exitCode;
         if (code !== 0) {
           console.error(result.stderr);
           throw new Error(`Failed to install module, process exited with ${code}`);
         }
-        await fsp.writeFile(filepath, generated, "utf-8");
+        if (installSet.size === 0) {
+          latestGenerated = null;
+          await fs.writeFile(filepath, generated, "utf-8");
+        }
       }
       return {
         configOriginal: source,
@@ -411,7 +436,7 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
       await ensureDevAuthToken(token);
       const commands = await getNpmCommand("uninstall", name);
       const filepath = nuxt.options._nuxtConfigFile;
-      const source = await fsp.readFile(filepath, "utf-8");
+      const source = await fs.readFile(filepath, "utf-8");
       const mod = parseModule(source, { sourceFileName: filepath });
       const config = getDefaultExportOptions(mod);
       config.modules || (config.modules = []);
@@ -441,7 +466,7 @@ function setupNpmRPC({ nuxt, ensureDevAuthToken }) {
           console.error(result.stderr);
           throw new Error(`Failed to uninstall module', process exited with ${code}`);
         }
-        await fsp.writeFile(filepath, generated, "utf-8");
+        await fs.writeFile(filepath, generated, "utf-8");
       }
       return {
         configOriginal: source,
@@ -667,7 +692,7 @@ function setupGeneralRPC({ nuxt, options, refresh, openInEditorHooks }) {
         c.bold(info),
         "",
         "Please open the following URL in the browser:",
-        c.bold(c.green(`http://localhost:${nuxt.options.devServer.port}${ROUTE_AUTH}?token=${token}`)),
+        c.bold(c.green(`${nuxt.options.devServer.https ? "https" : "http"}://${nuxt.options.devServer.host || "localhost"}:${nuxt.options.devServer.port}${ROUTE_AUTH}?token=${token}`)),
         "",
         "Or manually copy and paste the following token:",
         c.bold(c.cyan(token))
@@ -702,16 +727,16 @@ const route = useRoute()
 async function enablePages(nuxt) {
   const pathApp = join$1(nuxt.options.srcDir, "app.vue");
   const pathPageIndex = join$1(nuxt.options.srcDir, "pages/index.vue");
-  if (fs.existsSync(pathPageIndex)) {
+  if (fs$1.existsSync(pathPageIndex)) {
     logger.warn("pages/index.vue already exists, skipping");
     return;
   }
-  let appContent = fs.existsSync(pathApp) ? await fsp.readFile(pathApp, "utf-8") : void 0;
-  await fsp.mkdir(dirname(pathPageIndex), { recursive: true });
-  await fsp.writeFile(pathPageIndex, pagesIndexTemplate, "utf-8");
+  let appContent = fs$1.existsSync(pathApp) ? await fs.readFile(pathApp, "utf-8") : void 0;
+  await fs.mkdir(dirname(pathPageIndex), { recursive: true });
+  await fs.writeFile(pathPageIndex, pagesIndexTemplate, "utf-8");
   if (appContent && !appContent.includes("<NuxtPage")) {
     appContent = appContent.replace("</template>", "  <NuxtPage />\n</template>").replace(/<NuxtWelcome\s*\/>/, "");
-    await fsp.writeFile(pathApp, appContent, "utf-8");
+    await fs.writeFile(pathApp, appContent, "utf-8");
   }
   logger.success("Routing creation wizard completed");
 }
@@ -6212,27 +6237,31 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
     const files = await fg("*/meta.json", { cwd: analyzeDir, onlyFiles: true, absolute: true });
     builds = await Promise.all(files.map(async (file) => {
       const dir = dirname(file);
-      const json = JSON.parse(await fsp.readFile(file, "utf-8"));
+      const json = JSON.parse(await fs.readFile(file, "utf-8"));
       return {
         ...json,
         features: {
-          bundleClient: fs.existsSync(join$1(dir, "client.html")),
-          bundleNitro: fs.existsSync(join$1(dir, "nitro.html")),
-          viteInspect: fs.existsSync(join$1(dir, ".vite-inspect"))
+          bundleClient: fs$1.existsSync(join$1(dir, "client.html")),
+          bundleNitro: fs$1.existsSync(join$1(dir, "nitro.html")),
+          viteInspect: fs$1.existsSync(join$1(dir, ".vite-inspect"))
         }
       };
     }));
     return builds.sort((a, b) => b.endTime - a.endTime);
   }
   async function generateAnalyzeBuildName() {
-    const git = esm_default(nuxt.options.rootDir);
-    const branch = await git.branch();
-    const branchName = branch.current || "head";
-    const sha = await git.revparse(["--short", "HEAD"]);
-    const isWorkingTreeClean = (await git.status()).isClean();
-    if (isWorkingTreeClean)
-      return `${branchName}#${sha}`;
-    return `${branchName}#${sha}-dirty`;
+    try {
+      const git = esm_default(nuxt.options.rootDir);
+      const branch = await git.branch();
+      const branchName = branch.current || "head";
+      const sha = await git.revparse(["--short", "HEAD"]);
+      const isWorkingTreeClean = (await git.status()).isClean();
+      if (isWorkingTreeClean)
+        return `${branchName}#${sha}`;
+      return `${branchName}#${sha}-dirty`;
+    } catch (e) {
+      return (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+    }
   }
   return {
     async getAnalyzeBuildInfo() {
@@ -6247,10 +6276,10 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
     async clearAnalyzeBuilds(token, names) {
       await ensureDevAuthToken(token);
       if (!names) {
-        await fsp.rm(analyzeDir, { recursive: true, force: true });
+        await fs.rm(analyzeDir, { recursive: true, force: true });
       } else {
         const targets = builds.filter((build) => names.includes(build.name));
-        await Promise.all(targets.map((target) => fsp.rm(join$1(analyzeDir, target.slug), { recursive: true, force: true })));
+        await Promise.all(targets.map((target) => fs.rm(join$1(analyzeDir, target.slug), { recursive: true, force: true })));
       }
       initalized = readBuildInfo();
       refresh("getAnalyzeBuildInfo");
@@ -6263,7 +6292,7 @@ function setupAnalyzeBuildRPC({ nuxt, refresh, ensureDevAuthToken }) {
   };
 }
 
-const defaults$1 = {
+const defaults = {
   ignoreUnknown: false,
   respectType: false,
   respectFunctionNames: false,
@@ -6273,7 +6302,7 @@ const defaults$1 = {
   unorderedSets: false
 };
 function objectHash(object, options = {}) {
-  options = { ...defaults$1, ...options };
+  options = { ...defaults, ...options };
   const hasher = createHasher(options);
   hasher.dispatch(object);
   return hasher.toString();
@@ -6836,62 +6865,94 @@ function hash(object, options = {}) {
   return sha256base64(hashed).slice(0, 10);
 }
 
-const defaults = {
-  componentsView: "list",
-  componentsGraphShowNodeModules: false,
-  componentsGraphShowGlobalComponents: true,
-  componentsGraphShowPages: false,
-  componentsGraphShowLayouts: false,
-  componentsGraphShowWorkspace: true,
-  interactionCloseOnOutsideClick: false,
-  showExperimentalFeatures: false,
-  showHelpButtons: true,
-  scale: 1,
-  hiddenTabs: [],
-  hiddenTabCategories: []
-};
-function setupUIOptionsRPC({ nuxt }) {
-  const home = homedir();
-  const projectHash = hash(nuxt.options.rootDir);
-  const dir = join$1(home, ".nuxt/devtools");
-  const filepath = join$1(dir, `${projectHash}.json`);
-  let settings;
-  async function getUIOptions() {
-    if (!settings)
-      await read();
-    return settings;
-  }
-  async function read() {
-    if (existsSync(filepath)) {
-      settings = {
-        ...defaults,
-        ...JSON.parse(await fsp.readFile(filepath, "utf-8")).settings || {}
-      };
-    } else {
-      settings = { ...defaults };
+async function readOptions(defaults, options) {
+  let hashedKey;
+  if (options.key)
+    hashedKey = hash(`${options.root}:${options.key}`);
+  else
+    hashedKey = hash(options.root);
+  const filePath = join$1(homedir(), ".nuxt/devtools", `${hashedKey}.json`);
+  if (existsSync(filePath)) {
+    const options2 = {
+      ...defaults,
+      ...JSON.parse(await fs.readFile(filePath, "utf-8")).settings || {}
+    };
+    return options2;
+  } else {
+    return { ...defaults };
+  }
+}
+async function writeOptions(settings, options) {
+  const dir = join$1(homedir(), ".nuxt/devtools");
+  if (!existsSync(dir))
+    await fs.mkdir(dir, { recursive: true });
+  let hashedKey;
+  if (options.key)
+    hashedKey = hash(`${options.root}:${options.key}`);
+  else
+    hashedKey = hash(options.root);
+  const filePath = join$1(dir, `${hashedKey}.json`);
+  await fs.writeFile(
+    filePath,
+    JSON.stringify(
+      {
+        root: options.root,
+        hash: hashedKey,
+        settings
+      },
+      null,
+      2
+    ),
+    "utf-8"
+  );
+}
+
+function setupOptionsRPC({ nuxt }) {
+  let options;
+  async function getOptions(tab) {
+    if (!options || options[tab]) {
+      options = defaultTabOptions;
+      await read(tab);
     }
-    return settings;
-  }
-  async function write(settings2) {
-    if (!existsSync(dir))
-      await fsp.mkdir(dir, { recursive: true });
-    await fsp.writeFile(
-      filepath,
-      JSON.stringify({
-        root: nuxt.options.rootDir,
-        hash: projectHash,
-        settings: settings2
-      }, null, 2),
-      "utf-8"
-    );
+    return options[tab];
+  }
+  async function read(tab) {
+    options[tab] = await readOptions(defaultTabOptions[tab], {
+      root: nuxt.options.rootDir,
+      key: tab !== "ui" && tab
+    });
+    return options;
   }
   return {
-    async updateUIOptions(_settings) {
-      const settings2 = await getUIOptions();
-      Object.assign(settings2, _settings);
-      await write(settings2);
+    async updateOptions(tab, _settings) {
+      const settings = await getOptions(tab);
+      Object.assign(settings, _settings);
+      await writeOptions({ ...settings }, {
+        root: nuxt.options.rootDir,
+        key: tab !== "ui" && tab
+      });
     },
-    getUIOptions
+    getOptions
+  };
+}
+
+function setupTimelineRPC({ nuxt }) {
+  return {
+    async enableTimeline(dry) {
+      const filepath = nuxt.options._nuxtConfigFile;
+      const source = await fs.readFile(filepath, "utf-8");
+      const mod = await parseModule(source, { sourceFileName: filepath });
+      const options = getDefaultExportOptions(mod);
+      options.devtools = options.devtools || {};
+      options.devtools.timeline = options.devtools.timeline || {};
+      options.devtools.timeline.enabled = true;
+      const generated = mod.generate().code;
+      if (!dry) {
+        await fs.writeFile(filepath, generated, "utf-8");
+        await nuxt.callHook("restart", { hard: true });
+      }
+      return [source, generated];
+    }
   };
 }
 
@@ -6956,7 +7017,8 @@ function setupRPC(nuxt, options) {
     ...setupTerminalRPC(ctx),
     ...setupServerRoutesRPC(ctx),
     ...setupAnalyzeBuildRPC(ctx),
-    ...setupUIOptionsRPC(ctx)
+    ...setupOptionsRPC(ctx),
+    ...setupTimelineRPC(ctx)
   });
   const wsClients = /* @__PURE__ */ new Set();
   const vitePlugin = {
@@ -7089,7 +7151,8 @@ window.__NUXT_DEVTOOLS_TIME_METRIC__.appInit = Date.now()
     import('./plugin-metrics.mjs').then(({ setup }) => setup(ctx)),
     options.viteInspect !== false ? import('./vite-inspect.mjs').then(({ setup }) => setup(ctx)) : null,
     options.componentInspector !== false ? import('./vue-inspector.mjs').then(({ setup }) => setup(ctx)) : null,
-    options.vscode?.enabled ? import('./vscode.mjs').then(({ setup }) => setup(ctx)) : null
+    options.vscode?.enabled ? import('./vscode.mjs').then(({ setup }) => setup(ctx)) : null,
+    options.experimental?.timeline || options.timeline?.enabled ? import('./timeline.mjs').then(({ setup }) => setup(ctx)) : null
   ];
   await Promise.all(integrations);
   await nuxt.callHook("devtools:initialized", {

package/dist/chunks/plugin-metrics.mjs

@@ -18,18 +18,21 @@ function ${WRAPPER_KEY} (plugin, src) {
   if (!plugin)
     return plugin
 
-  return defineNuxtPlugin(async function (...args) {
-    const start = performance.now()
-    const result = await plugin.apply(this, args)
-    const end = performance.now()
-    globalThis.${PAYLOAD_KEY}.push({
-      src,
-      start,
-      end,
-      duration: end - start,
-    })
-    return result
-  }, plugin.meta)
+  return defineNuxtPlugin({
+    ...plugin,
+    async setup (...args) {
+      const start = performance.now()
+      const result = await plugin.apply(this, args)
+      const end = performance.now()
+      globalThis.${PAYLOAD_KEY}.push({
+        src,
+        start,
+        end,
+        duration: end - start,
+      })
+      return result
+    }
+  })
 }
 `;
         const imports = Array.from(content.matchAll(/(?:\n|^)import (.*) from ['"](.*)['"]/g)).map(([, name, path]) => ({ name, path }));

package/dist/chunks/timeline.mjs

@@ -0,0 +1,69 @@
+import { resolve } from 'pathe';
+import semver from 'semver';
+import { runtimeDir } from '../dirs.mjs';
+import 'node:path';
+import 'node:url';
+import 'is-installed-globally';
+
+async function setup({ nuxt, options }) {
+  const helperPath = resolve(runtimeDir, "function-metrics-helpers");
+  const includeFrom = options.timeline?.functions?.includeFrom || [
+    "#app",
+    "@unhead/vue"
+  ];
+  const include = options.timeline?.functions?.include || [
+    (i) => includeFrom.includes(i.from),
+    (i) => i.from.includes("composables")
+  ];
+  const exclude = options.timeline?.functions?.exclude || [
+    /^define[A-Z]/
+  ];
+  function filter(item) {
+    if (item.type)
+      return false;
+    const name = item.as || item.name;
+    if (!include.some((f) => typeof f === "function" ? f(item) : typeof f === "string" ? name === f : f.test(name)))
+      return false;
+    if (exclude.some((f) => typeof f === "function" ? f(item) : typeof f === "string" ? name === f : f.test(name)))
+      return false;
+    return true;
+  }
+  nuxt.hook("imports:context", (unimport) => {
+    const ctx = unimport.getInternalContext();
+    if (!ctx.version || !semver.gte(ctx.version, "3.1.0"))
+      throw new Error(`[Nuxt DevTools] The timeline feature requires \`unimport\` >= v3.1.0, but got \`${ctx.version || "(unknown)"}\`. Please upgrade using \`nuxi upgrade --force\`.`);
+    ctx.addons.push(
+      {
+        injectImportsResolved(imports) {
+          return imports.map((i) => {
+            if (!filter(i))
+              return i;
+            const name = i.as || i.name;
+            return {
+              ...i,
+              meta: {
+                wrapperOriginalAs: name
+              },
+              as: `_$__${name}`
+            };
+          });
+        },
+        injectImportsStringified(str, imports, s) {
+          const code = s.toString();
+          const injected = imports.filter((i) => i.meta?.wrapperOriginalAs);
+          if (injected.length) {
+            const result = [
+              str,
+              code.includes("__nuxtTimelineWrap") ? "" : `import { __nuxtTimelineWrap } from ${JSON.stringify(helperPath)}`,
+              ...injected.map((i) => `const ${i.meta.wrapperOriginalAs} = __nuxtTimelineWrap(${JSON.stringify(i.name)}, ${i.as})`),
+              ""
+            ].join(";");
+            return result;
+          }
+        }
+      }
+    );
+  });
+}
+
+export { setup };

package/dist/chunks/vscode.mjs

@@ -1,6 +1,6 @@
 import { hostname } from 'node:os';
 import { resolve } from 'node:path';
-import fsp from 'node:fs/promises';
+import fs from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { logger } from '@nuxt/kit';
 import { execa } from 'execa';
@@ -14,11 +14,12 @@ import 'vite';
 import 'sirv';
 import 'picocolors';
 import 'birpc';
-import '../shared/devtools.7ab40af4.mjs';
+import '../shared/devtools.d198e7a9.mjs';
 import '../dirs.mjs';
 import 'node:url';
 import 'is-installed-globally';
 import 'image-meta';
+import 'perfect-debounce';
 import 'fast-glob';
 import 'nypm';
 import 'magicast';
@@ -29,7 +30,6 @@ import 'semver';
 import 'local-pkg';
 import 'unimport';
 import 'boxen';
-import 'perfect-debounce';
 import 'fs';
 import 'tty';
 import 'util';
@@ -51,7 +51,7 @@ async function setup({ nuxt, options, openInEditorHooks, rpc }) {
     if (!existsSync(vscodeServerControllerFile))
       return false;
     try {
-      const { port: port2 } = JSON.parse(await fsp.readFile(vscodeServerControllerFile, "utf-8"));
+      const { port: port2 } = JSON.parse(await fs.readFile(vscodeServerControllerFile, "utf-8"));
       const url2 = `http://localhost:${port2}/open?path=${encodeURIComponent(file)}`;
       await fetch(url2);
       rpc.broadcast.navigateTo("/modules/custom-builtin-vscode");
@@ -64,7 +64,7 @@ async function setup({ nuxt, options, openInEditorHooks, rpc }) {
   });
   async function startCodeServer() {
     if (existsSync(vscodeServerControllerFile))
-      await fsp.rm(vscodeServerControllerFile, { force: true });
+      await fs.rm(vscodeServerControllerFile, { force: true });
     if (vsOptions?.reuseExistingServer && !await checkPort(port)) {
       loaded = true;
       url = `http://localhost:${port}/?folder=${encodeURIComponent(root)}`;