@nuxt/devtools-kit 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-PRESENT Nuxt Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client-api-34a84dad.d.ts

@@ -0,0 +1,64 @@
+import { AppConfig } from 'nuxt/schema';
+import { NuxtApp } from 'nuxt/dist/app/nuxt';
+import { Hookable } from 'hookable';
+import { BirpcReturn } from 'birpc';
+import { u as VueInspectorData, V as VueInspectorClient, H as HookInfo, p as PluginMetric, E as ServerFunctions } from './rpc-5ab26945.js';
+
+interface NuxtDevtoolsClientHooks {
+    /**
+     * When the devtools navigates, used for persisting the current tab
+     */
+    'devtools:navigate': (path: string) => void;
+    /**
+     * Event emitted when the component inspector is updated
+     */
+    'host:inspector:update': (data: VueInspectorData) => void;
+    /**
+     * Event emitted when the component inspector is clicked
+     */
+    'host:inspector:click': (baseUrl: string, file: string, line: number, column: number) => void;
+    /**
+     * Event to close the component inspector
+     */
+    'host:inspector:close': () => void;
+    /**
+     * Triggers reactivity manually, since Vue won't be reactive across frames)
+     */
+    'host:update:reactivity': () => void;
+}
+/**
+ * Host client from the App
+ */
+interface NuxtDevtoolsHostClient {
+    nuxt: NuxtApp;
+    appConfig: AppConfig;
+    hooks: Hookable<NuxtDevtoolsClientHooks>;
+    inspector?: {
+        instance?: VueInspectorClient;
+        enable: () => void;
+        disable: () => void;
+    };
+    getClientHooksMetrics(): HookInfo[];
+    getClientPluginMetrics(): PluginMetric[];
+    reloadPage(): void;
+    closeDevTools(): void;
+}
+interface NuxtDevtoolsClient {
+    rpc: BirpcReturn<ServerFunctions>;
+    renderCodeHighlight: (code: string, lang: string, lines?: boolean, theme?: string) => {
+        code: string;
+        supported: boolean;
+    };
+    renderMarkdown: (markdown: string) => string;
+    colorMode: string;
+    extendClientRpc: <ServerFunctions = {}, ClientFunctions = {}>(name: string, functions: ClientFunctions) => BirpcReturn<ServerFunctions, ClientFunctions>;
+}
+interface NuxtDevtoolsIframeClient {
+    host: NuxtDevtoolsHostClient;
+    devtools: NuxtDevtoolsClient;
+}
+interface NuxtDevtoolsGlobal {
+    setClient(client: NuxtDevtoolsHostClient): void;
+}
+
+export { NuxtDevtoolsClientHooks as N, NuxtDevtoolsHostClient as a, NuxtDevtoolsClient as b, NuxtDevtoolsIframeClient as c, NuxtDevtoolsGlobal as d };

package/dist/hooks-db1f6518.d.ts

@@ -0,0 +1,164 @@
+import { M as ModuleCustomTab, F as ClientFunctions, E as ServerFunctions, T as TerminalState } from './rpc-5ab26945.js';
+import { BirpcGroup } from 'birpc';
+import { Nuxt } from 'nuxt/schema';
+
+interface ModuleOptions {
+    /**
+     * Enable DevTools
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Custom tabs
+     *
+     * This is in static format, for dynamic injection, call `nuxt.hook('devtools:customTabs')` instead
+     */
+    customTabs?: ModuleCustomTab[];
+    /**
+     * VS Code Server integration options.
+     */
+    vscode?: VSCodeIntegrationOptions;
+    /**
+     * Enable Vue Component Inspector
+     *
+     * @default true
+     */
+    componentInspector?: boolean;
+    /**
+     * Enable vite-plugin-inspect
+     *
+     * @default true
+     */
+    viteInspect?: boolean;
+}
+interface ModuleGlobalOptions {
+    /**
+     * List of projects to enable devtools for. Only works when devtools is installed globally.
+     */
+    projects?: string[];
+}
+interface VSCodeIntegrationOptions {
+    /**
+     * Enable VS Code Server integration
+     */
+    enabled?: boolean;
+    /**
+     * Start VS Code Server on boot
+     *
+     * @default false
+     */
+    startOnBoot?: boolean;
+    /**
+     * Port to start VS Code Server
+     *
+     * @default 3080
+     */
+    port?: number;
+    /**
+     * Reuse existing server if available (same port)
+     */
+    reuseExistingServer?: boolean;
+    /**
+     * Determine whether to use code-server or vs code tunnel
+     *
+     * @default 'local-serve'
+     */
+    mode?: 'local-serve' | 'tunnel';
+    /**
+     * Options for VS Code tunnel
+     */
+    tunnel?: VSCodeTunnelOptions;
+}
+interface VSCodeTunnelOptions {
+    /**
+     * the machine name for port forwarding service
+     *
+     * default: device hostname
+     */
+    name?: string;
+}
+
+/**
+ * @internal
+ */
+interface NuxtDevtoolsServerContext {
+    nuxt: Nuxt;
+    options: ModuleOptions;
+    rpc: BirpcGroup<ClientFunctions, ServerFunctions>;
+    /**
+     * Invalidate client cache for a function and ask for re-fetching
+     */
+    refresh: (event: keyof ServerFunctions) => void;
+    extendServerRpc: <ClientFunctions = {}, ServerFunctions = {}>(name: string, functions: ServerFunctions) => BirpcGroup<ClientFunctions, ServerFunctions>;
+}
+interface NuxtDevtoolsInfo {
+    version: string;
+    packagePath: string;
+    isGlobalInstall: boolean;
+}
+
+declare module '@nuxt/schema' {
+    interface NuxtHooks {
+        /**
+         * Called before devtools starts. Useful to detect if devtools is enabled.
+         */
+        'devtools:before': () => void;
+        /**
+         * Called after devtools is initialized.
+         */
+        'devtools:initialized': (info: NuxtDevtoolsInfo) => void;
+        /**
+         * Hooks to extend devtools tabs.
+         */
+        'devtools:customTabs': (tabs: ModuleCustomTab[]) => void;
+        /**
+         * Retrigger update for custom tabs, `devtools:customTabs` will be called again.
+         */
+        'devtools:customTabs:refresh': () => void;
+        /**
+         * Register a terminal.
+         */
+        'devtools:terminal:register': (terminal: TerminalState) => void;
+        /**
+         * Write to a terminal.
+         *
+         * Returns true if terminal is found.
+         */
+        'devtools:terminal:write': (_: {
+            id: string;
+            data: string;
+        }) => void;
+        /**
+         * Remove a terminal from devtools.
+         *
+         * Returns true if terminal is found and deleted.
+         */
+        'devtools:terminal:remove': (_: {
+            id: string;
+        }) => void;
+        /**
+         * Mark a terminal as terminated.
+         */
+        'devtools:terminal:exit': (_: {
+            id: string;
+            code?: number;
+        }) => void;
+    }
+}
+declare module '@nuxt/schema' {
+    /**
+     * Runtime Hooks
+     */
+    interface RuntimeNuxtHooks {
+        /**
+         * On terminal data.
+         */
+        'devtools:terminal:data': (payload: {
+            id: string;
+            data: string;
+        }) => void;
+    }
+}
+
+export { ModuleOptions as M, NuxtDevtoolsInfo as N, VSCodeIntegrationOptions as V, NuxtDevtoolsServerContext as a, ModuleGlobalOptions as b, VSCodeTunnelOptions as c };

package/dist/iframe-client.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const vue = require('vue');
+
+let clientRef;
+const fns = [];
+function onDevtoolsClientConnected(fn) {
+  fns.push(fn);
+  if (window.__NUXT_DEVTOOLS__) {
+    fns.forEach((fn2) => fn2(window.__NUXT_DEVTOOLS__));
+  }
+  Object.defineProperty(window, "__NUXT_DEVTOOLS__", {
+    set(value) {
+      if (value)
+        fns.forEach((fn2) => fn2(value));
+    },
+    get() {
+      return clientRef.value;
+    },
+    configurable: true
+  });
+  return () => {
+    fns.splice(fns.indexOf(fn), 1);
+  };
+}
+function useDevtoolsClient() {
+  if (!clientRef) {
+    clientRef = vue.shallowRef();
+    onDevtoolsClientConnected(setup);
+  }
+  function setup(client) {
+    clientRef.value = client;
+    if (client.host) {
+      client.host.hooks.hook("host:update:reactivity", () => {
+        vue.triggerRef(clientRef);
+      });
+    }
+  }
+  return clientRef;
+}
+
+exports.onDevtoolsClientConnected = onDevtoolsClientConnected;
+exports.useDevtoolsClient = useDevtoolsClient;

package/dist/iframe-client.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { c as NuxtDevtoolsIframeClient } from './client-api-34a84dad.js';
+import 'nuxt/schema';
+import 'nuxt/dist/app/nuxt';
+import 'hookable';
+import 'birpc';
+import './rpc-5ab26945.js';
+import 'nitropack';
+import 'unstorage';
+import 'vue-router';
+import 'unimport';
+import 'execa';
+
+declare function onDevtoolsClientConnected(fn: (client: NuxtDevtoolsIframeClient) => void): (() => void) | undefined;
+declare function useDevtoolsClient(): Ref<NuxtDevtoolsIframeClient | undefined>;
+
+export { onDevtoolsClientConnected, useDevtoolsClient };

package/dist/iframe-client.mjs

@@ -0,0 +1,40 @@
+import { shallowRef, triggerRef } from 'vue';
+
+let clientRef;
+const fns = [];
+function onDevtoolsClientConnected(fn) {
+  fns.push(fn);
+  if (window.__NUXT_DEVTOOLS__) {
+    fns.forEach((fn2) => fn2(window.__NUXT_DEVTOOLS__));
+  }
+  Object.defineProperty(window, "__NUXT_DEVTOOLS__", {
+    set(value) {
+      if (value)
+        fns.forEach((fn2) => fn2(value));
+    },
+    get() {
+      return clientRef.value;
+    },
+    configurable: true
+  });
+  return () => {
+    fns.splice(fns.indexOf(fn), 1);
+  };
+}
+function useDevtoolsClient() {
+  if (!clientRef) {
+    clientRef = shallowRef();
+    onDevtoolsClientConnected(setup);
+  }
+  function setup(client) {
+    clientRef.value = client;
+    if (client.host) {
+      client.host.hooks.hook("host:update:reactivity", () => {
+        triggerRef(clientRef);
+      });
+    }
+  }
+  return clientRef;
+}
+
+export { onDevtoolsClientConnected, useDevtoolsClient };

package/dist/index.cjs

@@ -0,0 +1,109 @@
+'use strict';
+
+const kit = require('@nuxt/kit');
+const execa = require('execa');
+
+function addCustomTab(tab, nuxt = kit.useNuxt()) {
+  nuxt.hook("devtools:customTabs", async (tabs) => {
+    if (typeof tab === "function")
+      tab = await tab();
+    tabs.push(tab);
+  });
+}
+function refreshCustomTabs(nuxt = kit.useNuxt()) {
+  return nuxt.callHook("devtools:customTabs:refresh");
+}
+function startSubprocess(execaOptions, tabOptions, nuxt = kit.useNuxt()) {
+  const id = tabOptions.id;
+  let restarting = false;
+  function start() {
+    const process2 = execa.execa(
+      execaOptions.command,
+      execaOptions.args,
+      {
+        ...execaOptions,
+        env: {
+          COLORS: "true",
+          FORCE_COLOR: "true",
+          ...execaOptions.env
+        }
+      }
+    );
+    nuxt.callHook("devtools:terminal:write", { id, data: `> ${[execaOptions.command, ...execaOptions.args || []].join(" ")}
+
+` });
+    process2.stdout.on("data", (data) => {
+      nuxt.callHook("devtools:terminal:write", { id, data: data.toString() });
+    });
+    process2.stderr.on("data", (data) => {
+      nuxt.callHook("devtools:terminal:write", { id, data: data.toString() });
+    });
+    process2.on("exit", (code) => {
+      if (!restarting) {
+        nuxt.callHook("devtools:terminal:write", { id, data: `
+> process terminalated with ${code}
+` });
+        nuxt.callHook("devtools:terminal:exit", { id, code: code || 0 });
+      }
+    });
+    return process2;
+  }
+  register();
+  nuxt.hook("close", () => {
+    terminate();
+  });
+  let process = start();
+  function restart() {
+    restarting = true;
+    process?.kill();
+    clear();
+    process = start();
+    restarting = false;
+  }
+  function clear() {
+    tabOptions.buffer = "";
+    register();
+  }
+  function terminate() {
+    restarting = false;
+    try {
+      process?.kill();
+    } catch (e) {
+    }
+    nuxt.callHook("devtools:terminal:remove", { id });
+  }
+  function register() {
+    nuxt.callHook("devtools:terminal:register", {
+      onActionRestart: tabOptions.restartable === false ? void 0 : restart,
+      onActionTerminate: tabOptions.terminatable === false ? void 0 : terminate,
+      isTerminated: false,
+      ...tabOptions
+    });
+  }
+  return {
+    getProcess() {
+      return process;
+    },
+    terminate,
+    restart,
+    clear
+  };
+}
+function extendServerRpc(namespace, functions, nuxt = kit.useNuxt()) {
+  const ctx = _getContext(nuxt);
+  if (!ctx)
+    throw new Error("Failed to get devtools context.");
+  return ctx.extendServerRpc(namespace, functions);
+}
+function onDevToolsInitialized(fn, nuxt = kit.useNuxt()) {
+  nuxt.hook("devtools:initialized", fn);
+}
+function _getContext(nuxt = kit.useNuxt()) {
+  return nuxt?.devtools;
+}
+
+exports.addCustomTab = addCustomTab;
+exports.extendServerRpc = extendServerRpc;
+exports.onDevToolsInitialized = onDevToolsInitialized;
+exports.refreshCustomTabs = refreshCustomTabs;
+exports.startSubprocess = startSubprocess;

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import * as execa from 'execa';
+import * as _nuxt_schema from '@nuxt/schema';
+import { BirpcGroup } from 'birpc';
+import { N as NuxtDevtoolsInfo } from './hooks-db1f6518.js';
+import { M as ModuleCustomTab, S as SubprocessOptions, T as TerminalState } from './rpc-5ab26945.js';
+import 'nuxt/schema';
+import 'nitropack';
+import 'unstorage';
+import 'vue';
+import 'vue-router';
+import 'unimport';
+
+/**
+ * Hooks to extend a custom tab in devtools.
+ *
+ * Provide a function to pass a factory that can be updated dynamically.
+ */
+declare function addCustomTab(tab: ModuleCustomTab | (() => ModuleCustomTab | Promise<ModuleCustomTab>), nuxt?: _nuxt_schema.Nuxt): void;
+/**
+ * Retrigger update for custom tabs, `devtools:customTabs` will be called again.
+ */
+declare function refreshCustomTabs(nuxt?: _nuxt_schema.Nuxt): Promise<any>;
+/**
+ * Create a subprocess that handled by the DevTools.
+ */
+declare function startSubprocess(execaOptions: SubprocessOptions, tabOptions: TerminalState, nuxt?: _nuxt_schema.Nuxt): {
+    getProcess(): execa.ExecaChildProcess<string>;
+    terminate: () => void;
+    restart: () => void;
+    clear: () => void;
+};
+declare function extendServerRpc<ClientFunctions = {}, ServerFunctions = {}>(namespace: string, functions: ServerFunctions, nuxt?: _nuxt_schema.Nuxt): BirpcGroup<ClientFunctions, ServerFunctions>;
+declare function onDevToolsInitialized(fn: (info: NuxtDevtoolsInfo) => void, nuxt?: _nuxt_schema.Nuxt): void;
+
+export { addCustomTab, extendServerRpc, onDevToolsInitialized, refreshCustomTabs, startSubprocess };

package/dist/index.mjs

@@ -0,0 +1,103 @@
+import { useNuxt } from '@nuxt/kit';
+import { execa } from 'execa';
+
+function addCustomTab(tab, nuxt = useNuxt()) {
+  nuxt.hook("devtools:customTabs", async (tabs) => {
+    if (typeof tab === "function")
+      tab = await tab();
+    tabs.push(tab);
+  });
+}
+function refreshCustomTabs(nuxt = useNuxt()) {
+  return nuxt.callHook("devtools:customTabs:refresh");
+}
+function startSubprocess(execaOptions, tabOptions, nuxt = useNuxt()) {
+  const id = tabOptions.id;
+  let restarting = false;
+  function start() {
+    const process2 = execa(
+      execaOptions.command,
+      execaOptions.args,
+      {
+        ...execaOptions,
+        env: {
+          COLORS: "true",
+          FORCE_COLOR: "true",
+          ...execaOptions.env
+        }
+      }
+    );
+    nuxt.callHook("devtools:terminal:write", { id, data: `> ${[execaOptions.command, ...execaOptions.args || []].join(" ")}
+
+` });
+    process2.stdout.on("data", (data) => {
+      nuxt.callHook("devtools:terminal:write", { id, data: data.toString() });
+    });
+    process2.stderr.on("data", (data) => {
+      nuxt.callHook("devtools:terminal:write", { id, data: data.toString() });
+    });
+    process2.on("exit", (code) => {
+      if (!restarting) {
+        nuxt.callHook("devtools:terminal:write", { id, data: `
+> process terminalated with ${code}
+` });
+        nuxt.callHook("devtools:terminal:exit", { id, code: code || 0 });
+      }
+    });
+    return process2;
+  }
+  register();
+  nuxt.hook("close", () => {
+    terminate();
+  });
+  let process = start();
+  function restart() {
+    restarting = true;
+    process?.kill();
+    clear();
+    process = start();
+    restarting = false;
+  }
+  function clear() {
+    tabOptions.buffer = "";
+    register();
+  }
+  function terminate() {
+    restarting = false;
+    try {
+      process?.kill();
+    } catch (e) {
+    }
+    nuxt.callHook("devtools:terminal:remove", { id });
+  }
+  function register() {
+    nuxt.callHook("devtools:terminal:register", {
+      onActionRestart: tabOptions.restartable === false ? void 0 : restart,
+      onActionTerminate: tabOptions.terminatable === false ? void 0 : terminate,
+      isTerminated: false,
+      ...tabOptions
+    });
+  }
+  return {
+    getProcess() {
+      return process;
+    },
+    terminate,
+    restart,
+    clear
+  };
+}
+function extendServerRpc(namespace, functions, nuxt = useNuxt()) {
+  const ctx = _getContext(nuxt);
+  if (!ctx)
+    throw new Error("Failed to get devtools context.");
+  return ctx.extendServerRpc(namespace, functions);
+}
+function onDevToolsInitialized(fn, nuxt = useNuxt()) {
+  nuxt.hook("devtools:initialized", fn);
+}
+function _getContext(nuxt = useNuxt()) {
+  return nuxt?.devtools;
+}
+
+export { addCustomTab, extendServerRpc, onDevToolsInitialized, refreshCustomTabs, startSubprocess };

package/dist/rpc-5ab26945.d.ts

@@ -0,0 +1,332 @@
+import { NuxtOptions, NuxtPage, NuxtLayout } from 'nuxt/schema';
+import { StorageMounts } from 'nitropack';
+import { StorageValue } from 'unstorage';
+import { VNode, Component } from 'vue';
+import { RouteRecordNormalized } from 'vue-router';
+import { Import, UnimportMeta } from 'unimport';
+import { Options } from 'execa';
+
+interface ModuleCustomTab {
+    /**
+     * The name of the tab, must be unique
+     */
+    name: string;
+    /**
+     * Icon of the tab, support any Iconify icons, or a url to an image
+     */
+    icon?: string;
+    /**
+     * Title of the tab
+     */
+    title: string;
+    /**
+     * Main view of the tab
+     */
+    view: ModuleView;
+    /**
+     * Insert static vnode to the tab entry
+     *
+     * Advanced options. You don't usually need this.
+     */
+    extraTabVNode?: VNode;
+}
+interface ModuleLaunchView {
+    /**
+     * A view for module to lazy launch some actions
+     */
+    type: 'launch';
+    title?: string;
+    icon?: string;
+    description: string;
+    /**
+     * Action buttons
+     */
+    actions: ModuleLaunchAction[];
+}
+interface ModuleIframeView {
+    /**
+     * Iframe view
+     */
+    type: 'iframe';
+    /**
+     * Url of the iframe
+     */
+    src: string;
+    /**
+     * Persist the iframe instance even if the tab is not active
+     *
+     * @default true
+     */
+    persistent?: boolean;
+}
+interface ModuleVNodeView {
+    /**
+     * Vue's VNode view
+     */
+    type: 'vnode';
+    /**
+     * Send vnode to the client, they must be static and serializable
+     *
+     * Call `nuxt.hook('devtools:customTabs:refresh')` to trigger manual refresh
+     */
+    vnode: VNode;
+}
+interface ModuleLaunchAction {
+    /**
+     * Label of the action button
+     */
+    label: string;
+    /**
+     * Additional HTML attributes to the action button
+     */
+    attrs?: Record<string, string>;
+    /**
+     * Indicate if the action is pending, will show a loading indicator and disable the button
+     */
+    pending?: boolean;
+    /**
+     * Function to handle the action, this is executed on the server side.
+     * Will automatically refresh the tabs after the action is resolved.
+     */
+    handle?: () => void | Promise<void>;
+    /**
+     * Treat the action as a link, will open the link in a new tab
+     */
+    src?: string;
+}
+type ModuleView = ModuleIframeView | ModuleLaunchView | ModuleVNodeView;
+interface ModuleIframeTabLazyOptions {
+    description?: string;
+    onLoad?: () => Promise<void>;
+}
+interface ModuleBuiltinTab {
+    name: string;
+    icon?: string;
+    title?: string;
+    path?: string;
+    requireClient?: boolean;
+    shouldShow?: () => boolean;
+}
+type ModuleTabInfo = ModuleCustomTab | ModuleBuiltinTab;
+
+interface HookInfo {
+    name: string;
+    start: number;
+    end?: number;
+    duration?: number;
+    listeners: number;
+    executions: number[];
+}
+interface ImageMeta {
+    width: number;
+    height: number;
+    orientation?: number;
+    type?: string;
+    mimeType?: string;
+}
+interface PackageUpdateInfo {
+    name: string;
+    current: string;
+    latest: string;
+    needsUpdate: boolean;
+}
+type PackageManagerName = 'npm' | 'yarn' | 'pnpm';
+type NpmCommandType = 'install' | 'uninstall' | 'update';
+interface NpmCommandOptions {
+    dev?: boolean;
+    global?: boolean;
+}
+interface AutoImportsWithMetadata {
+    imports: Import[];
+    metadata?: UnimportMeta;
+}
+interface RouteInfo extends Pick<RouteRecordNormalized, 'name' | 'path' | 'meta' | 'props' | 'children'> {
+    file?: string;
+}
+interface Payload {
+    url: string;
+    time: number;
+    data?: Record<string, any>;
+    state?: Record<string, any>;
+    functions?: Record<string, any>;
+}
+interface PluginInfoWithMetic {
+    src: string;
+    mode?: 'client' | 'server' | 'all';
+    ssr?: boolean;
+    metric?: PluginMetric;
+}
+interface PluginMetric {
+    src: string;
+    duration: number;
+}
+interface BasicModuleInfo {
+    entryPath?: string;
+    meta?: {
+        name?: string;
+    };
+}
+interface ModuleMetric {
+    name: string;
+    description: string;
+    repo: string;
+    npm: string;
+    icon?: string;
+    github: string;
+    website: string;
+    learn_more: string;
+    category: string;
+    type: ModuleType;
+    maintainers: MaintainerInfo[];
+    contributors: GitHubContributor[];
+    compatibility: ModuleCompatibility;
+}
+interface ModuleCompatibility {
+    nuxt: string;
+    requires: {
+        bridge?: boolean | 'optional';
+    };
+}
+type CompatibilityStatus = 'working' | 'wip' | 'unknown' | 'not-working';
+type ModuleType = 'community' | 'official' | '3rd-party';
+interface MaintainerInfo {
+    name: string;
+    github: string;
+    twitter?: string;
+}
+interface GitHubContributor {
+    login: string;
+    name?: string;
+    avatar_url?: string;
+}
+interface VueInspectorClient {
+    enabled: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    linkParams: {
+        file: string;
+        line: number;
+        column: number;
+    };
+    enable: () => void;
+    disable: () => void;
+    toggleEnabled: () => void;
+    openInEditor: (baseUrl: string, file: string, line: number, column: number) => void;
+    onUpdated: () => void;
+}
+type VueInspectorData = VueInspectorClient['linkParams'] & VueInspectorClient['position'];
+type AssetType = 'image' | 'font' | 'video' | 'audio' | 'text' | 'other';
+interface AssetInfo {
+    path: string;
+    type: AssetType;
+    publicPath: string;
+    filePath: string;
+    size: number;
+    mtime: number;
+}
+interface CodeSnippet {
+    code: string;
+    lang: string;
+    name: string;
+    docs?: string;
+}
+interface ComponentRelationship {
+    id: string;
+    deps: string[];
+}
+
+interface TerminalBase {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+}
+type TerminalAction = 'restart' | 'terminate' | 'clear' | 'remove';
+interface SubprocessOptions extends Options {
+    command: string;
+    args?: string[];
+}
+interface TerminalInfo extends TerminalBase {
+    /**
+     * Whether the terminal can be restarted
+     */
+    restartable?: boolean;
+    /**
+     * Whether the terminal can be terminated
+     */
+    terminatable?: boolean;
+    /**
+     * Whether the terminal is terminated
+     */
+    isTerminated?: boolean;
+    /**
+     * Content buffer
+     */
+    buffer?: string;
+}
+interface TerminalState extends TerminalInfo {
+    /**
+     * User action to restart the terminal, when not provided, this action will be disabled
+     */
+    onActionRestart?: () => Promise<void> | void;
+    /**
+     * User action to terminate the terminal, when not provided, this action will be disabled
+     */
+    onActionTerminate?: () => Promise<void> | void;
+}
+
+interface WizardFunctions {
+    enablePages: (nuxt: any) => Promise<void>;
+}
+type WizardActions = keyof WizardFunctions;
+type GetWizardArgs<T extends WizardActions> = WizardFunctions[T] extends (nuxt: any, ...args: infer A) => any ? A : never;
+
+interface ServerFunctions {
+    getServerConfig(): NuxtOptions;
+    getComponents(): Component[];
+    getComponentsRelationships(): Promise<ComponentRelationship[]>;
+    getAutoImports(): AutoImportsWithMetadata;
+    getServerPages(): NuxtPage[];
+    getCustomTabs(): ModuleCustomTab[];
+    getServerHooks(): HookInfo[];
+    getServerLayouts(): NuxtLayout[];
+    getStaticAssets(): Promise<AssetInfo[]>;
+    checkForUpdateFor(name: string): Promise<PackageUpdateInfo | undefined>;
+    getPackageManager(): Promise<PackageManagerName>;
+    getNpmCommand(command: NpmCommandType, packageName: string, options?: NpmCommandOptions): Promise<string[] | undefined>;
+    runNpmCommand(command: NpmCommandType, packageName: string, options?: NpmCommandOptions): Promise<{
+        processId: string;
+    } | undefined>;
+    getTerminals(): TerminalInfo[];
+    getTerminalDetail(id: string): TerminalInfo | undefined;
+    runTerminalAction(id: string, action: TerminalAction): Promise<boolean>;
+    getStorageMounts(): Promise<StorageMounts>;
+    getStorageKeys(base?: string): Promise<string[]>;
+    getStorageItem(key: string): Promise<StorageValue>;
+    setStorageItem(key: string, value: StorageValue): Promise<void>;
+    removeStorageItem(key: string): Promise<void>;
+    getImageMeta(filepath: string): Promise<ImageMeta | undefined>;
+    getTextAssetContent(filepath: string, limit?: number): Promise<string | undefined>;
+    customTabAction(name: string, action: number): Promise<boolean>;
+    runWizard<T extends WizardActions>(name: T, ...args: GetWizardArgs<T>): Promise<void>;
+    openInEditor(filepath: string): void;
+    restartNuxt(hard?: boolean): Promise<void>;
+}
+interface ClientFunctions {
+    refresh(event: ClientUpdateEvent): void;
+    callHook(hook: string, ...args: any[]): Promise<void>;
+    navigateTo(path: string): void;
+    onTerminalData(_: {
+        id: string;
+        data: string;
+    }): void;
+    onTerminalExit(_: {
+        id: string;
+        code?: number;
+    }): void;
+}
+type ClientUpdateEvent = keyof ServerFunctions;
+
+export { AutoImportsWithMetadata as A, BasicModuleInfo as B, CompatibilityStatus as C, GetWizardArgs as D, ServerFunctions as E, ClientFunctions as F, GitHubContributor as G, HookInfo as H, ImageMeta as I, ClientUpdateEvent as J, ModuleCustomTab as M, NpmCommandType as N, PackageUpdateInfo as P, RouteInfo as R, SubprocessOptions as S, TerminalState as T, VueInspectorClient as V, WizardFunctions as W, ModuleLaunchView as a, ModuleIframeView as b, ModuleVNodeView as c, ModuleLaunchAction as d, ModuleView as e, ModuleIframeTabLazyOptions as f, ModuleBuiltinTab as g, ModuleTabInfo as h, TerminalBase as i, TerminalAction as j, TerminalInfo as k, PackageManagerName as l, NpmCommandOptions as m, Payload as n, PluginInfoWithMetic as o, PluginMetric as p, ModuleMetric as q, ModuleCompatibility as r, ModuleType as s, MaintainerInfo as t, VueInspectorData as u, AssetType as v, AssetInfo as w, CodeSnippet as x, ComponentRelationship as y, WizardActions as z };

package/dist/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+export { b as ModuleGlobalOptions, M as ModuleOptions, N as NuxtDevtoolsInfo, a as NuxtDevtoolsServerContext, V as VSCodeIntegrationOptions, c as VSCodeTunnelOptions } from './hooks-db1f6518.js';
+export { w as AssetInfo, v as AssetType, A as AutoImportsWithMetadata, B as BasicModuleInfo, F as ClientFunctions, J as ClientUpdateEvent, x as CodeSnippet, C as CompatibilityStatus, y as ComponentRelationship, D as GetWizardArgs, G as GitHubContributor, H as HookInfo, I as ImageMeta, t as MaintainerInfo, g as ModuleBuiltinTab, r as ModuleCompatibility, M as ModuleCustomTab, f as ModuleIframeTabLazyOptions, b as ModuleIframeView, d as ModuleLaunchAction, a as ModuleLaunchView, q as ModuleMetric, h as ModuleTabInfo, s as ModuleType, c as ModuleVNodeView, e as ModuleView, m as NpmCommandOptions, N as NpmCommandType, l as PackageManagerName, P as PackageUpdateInfo, n as Payload, o as PluginInfoWithMetic, p as PluginMetric, R as RouteInfo, E as ServerFunctions, S as SubprocessOptions, j as TerminalAction, i as TerminalBase, k as TerminalInfo, T as TerminalState, V as VueInspectorClient, u as VueInspectorData, z as WizardActions, W as WizardFunctions } from './rpc-5ab26945.js';
+export { b as NuxtDevtoolsClient, N as NuxtDevtoolsClientHooks, d as NuxtDevtoolsGlobal, a as NuxtDevtoolsHostClient, c as NuxtDevtoolsIframeClient } from './client-api-34a84dad.js';
+import 'birpc';
+import 'nuxt/schema';
+import 'nitropack';
+import 'unstorage';
+import 'vue';
+import 'vue-router';
+import 'unimport';
+import 'execa';
+import 'nuxt/dist/app/nuxt';
+import 'hookable';

package/dist/types.mjs

@@ -0,0 +1 @@
+

package/iframe-client.d.ts

@@ -0,0 +1 @@
+export * from './dist/iframe-client'

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@nuxt/devtools-kit",
+  "type": "module",
+  "version": "0.3.0",
+  "license": "MIT",
+  "repository": "nuxt/devtools",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./types": {
+      "types": "./types.d.ts",
+      "require": "./dist/types.cjs",
+      "import": "./dist/types.mjs"
+    },
+    "./iframe-client": {
+      "types": "./iframe-client.d.ts",
+      "require": "./dist/iframe-client.cjs",
+      "import": "./dist/iframe-client.mjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "*.d.ts",
+    "*.cjs",
+    "*.mjs"
+  ],
+  "peerDependencies": {
+    "nuxt": "^3.3.1",
+    "vite": "*"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^3.3.1",
+    "@nuxt/schema": "^3.3.1",
+    "execa": "^7.1.1"
+  },
+  "devDependencies": {
+    "birpc": "^0.2.10",
+    "hookable": "^5.5.1",
+    "unbuild": "^1.1.2",
+    "unimport": "^3.0.3",
+    "vue-router": "^4.1.6"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "stub": "unbuild --stub",
+    "dev:prepare": "nr stub"
+  }
+}

package/types.d.ts

@@ -0,0 +1 @@
+export * from './dist/types'