@vitejs/devtools 0.1.8 → 0.1.10

package/dist/{server-DhChc9gv.js → context-BWju7fup.js}

@@ -1,12 +1,12 @@
-import { n as ansis_default, r as __commonJSMin, t as MARK_INFO } from "./constants-DfEeYo9W.js";
+import { i as __exportAll, n as ansis_default, r as __commonJSMin, t as MARK_INFO } from "./constants-DfEeYo9W.js";
 import { n as createStorage, t as getInternalContext } from "./context-internal-DZpoJjMz.js";
-import { a as refreshTempAuthToken, i as getTempAuthToken, o as setPendingAuth, r as abortPendingAuth, t as createDevToolsMiddleware } from "./server-BuWZ1h8p.js";
+import { a as setPendingAuth, i as refreshTempAuthToken, r as getTempAuthToken, t as abortPendingAuth } from "./auth-state-DXCxEqSd.js";
 import { t as isObject } from "./utils-HWI9S6d-.js";
 import { createDebug } from "obug";
 import { debounce } from "perfect-debounce";
 import { toDataURL } from "mlly";
-import { DEFAULT_STATE_USER_SETTINGS, DEVTOOLS_DOCK_IMPORTS_VIRTUAL_ID, DEVTOOLS_MOUNT_PATH } from "@vitejs/devtools-kit/constants";
 import { createEventEmitter } from "@vitejs/devtools-kit/utils/events";
+import { DEFAULT_STATE_USER_SETTINGS } from "@vitejs/devtools-kit/constants";
 import { join } from "pathe";
 import { existsSync } from "node:fs";
 import { createSharedState } from "@vitejs/devtools-kit/utils/shared-state";
@@ -28,6 +28,61 @@ const ContextUtils = { createSimpleClientScript(fn) {
 	};
 } };
 //#endregion
+//#region src/node/host-commands.ts
+var DevToolsCommandsHost = class {
+	commands = /* @__PURE__ */ new Map();
+	events = createEventEmitter();
+	constructor(context) {
+		this.context = context;
+	}
+	register(command) {
+		if (this.commands.has(command.id)) throw new Error(`Command "${command.id}" is already registered`);
+		this.commands.set(command.id, command);
+		this.events.emit("command:registered", this.toSerializable(command));
+		return {
+			id: command.id,
+			update: (patch) => {
+				if ("id" in patch) throw new Error(`Cannot change the id of a command. Use register() to add new commands.`);
+				const existing = this.commands.get(command.id);
+				if (!existing) throw new Error(`Command "${command.id}" is not registered`);
+				Object.assign(existing, patch);
+				this.events.emit("command:registered", this.toSerializable(existing));
+			},
+			unregister: () => this.unregister(command.id)
+		};
+	}
+	unregister(id) {
+		const deleted = this.commands.delete(id);
+		if (deleted) this.events.emit("command:unregistered", id);
+		return deleted;
+	}
+	async execute(id, ...args) {
+		const found = this.findCommand(id);
+		if (!found) throw new Error(`Command "${id}" is not registered`);
+		if (!found.handler) throw new Error(`Command "${id}" has no handler (group-only command)`);
+		return found.handler(...args);
+	}
+	list() {
+		return Array.from(this.commands.values()).map((cmd) => this.toSerializable(cmd));
+	}
+	findCommand(id) {
+		const topLevel = this.commands.get(id);
+		if (topLevel) return topLevel;
+		for (const cmd of this.commands.values()) if (cmd.children) {
+			const child = cmd.children.find((c) => c.id === id);
+			if (child) return child;
+		}
+	}
+	toSerializable(cmd) {
+		const { handler: _, children, ...rest } = cmd;
+		return {
+			...rest,
+			source: "server",
+			...children ? { children: children.map((c) => this.toSerializable(c)) } : {}
+		};
+	}
+};
+//#endregion
 //#region src/node/host-docks.ts
 var DevToolsDockHost = class {
 	views = /* @__PURE__ */ new Map();
@@ -51,8 +106,8 @@ var DevToolsDockHost = class {
 				title: "Terminals",
 				icon: "ph:terminal-duotone",
 				category: "~builtin",
-				get isHidden() {
-					return context.terminals.sessions.size === 0;
+				get when() {
+					return context.terminals.sessions.size === 0 ? "false" : void 0;
 				}
 			},
 			{
@@ -1251,6 +1306,28 @@ const anonymousAuth = defineRpcFunction({
 	}
 });
 //#endregion
+//#region src/node/rpc/internal/commands-execute.ts
+const commandsExecute = defineRpcFunction({
+	name: "devtoolskit:internal:commands:execute",
+	type: "action",
+	setup: (context) => {
+		return { async handler(id, ...args) {
+			return context.commands.execute(id, ...args);
+		} };
+	}
+});
+//#endregion
+//#region src/node/rpc/internal/commands-list.ts
+const commandsList = defineRpcFunction({
+	name: "devtoolskit:internal:commands:list",
+	type: "static",
+	setup: (context) => {
+		return { async handler() {
+			return context.commands.list();
+		} };
+	}
+});
+//#endregion
 //#region src/node/rpc/internal/docks-on-launch.ts
 const docksOnLaunch = defineRpcFunction({
 	name: "devtoolskit:internal:docks:on-launch",
@@ -1395,6 +1472,7 @@ const sharedStateGet = defineRpcFunction({
 	},
 	setup: (context) => {
 		return { handler: async (key) => {
+			if (!context.rpc.sharedState.keys().includes(key)) return void 0;
 			return (await context.rpc.sharedState.get(key)).value();
 		} };
 	}
@@ -1406,6 +1484,7 @@ const sharedStatePatch = defineRpcFunction({
 	type: "query",
 	setup: (context) => {
 		return { handler: async (key, patches, syncId) => {
+			if (!context.rpc.sharedState.keys().includes(key)) return;
 			(await context.rpc.sharedState.get(key)).patch(patches, syncId);
 		} };
 	}
@@ -1417,7 +1496,7 @@ const sharedStateSet = defineRpcFunction({
 	type: "query",
 	setup: (context) => {
 		return { handler: async (key, value, syncId) => {
-			(await context.rpc.sharedState.get(key)).mutate(() => value, syncId);
+			(await context.rpc.sharedState.get(key, { initialValue: value })).mutate(() => value, syncId);
 		} };
 	}
 });
@@ -1494,6 +1573,8 @@ const builtinPublicRpcDeclarations = [defineRpcFunction({
 })];
 const builtinAnonymousRpcDeclarations = [anonymousAuth];
 const builtinInternalRpcDeclarations = [
+	commandsExecute,
+	commandsList,
 	docksOnLaunch,
 	logsAdd,
 	logsClear,
@@ -1515,6 +1596,7 @@ const builtinRpcDeclarations = [
 ];
 //#endregion
 //#region src/node/context.ts
+var context_exports = /* @__PURE__ */ __exportAll({ createDevToolsContext: () => createDevToolsContext });
 const debugSetup = createDebug("vite:devtools:context:setup");
 function shouldSkipSetupByCapabilities(plugin, mode) {
 	const modeCapabilities = plugin.devtools?.capabilities?.[mode];
@@ -1537,6 +1619,7 @@ async function createDevToolsContext(viteConfig, viteServer) {
 		utils: ContextUtils,
 		terminals: void 0,
 		logs: void 0,
+		commands: void 0,
 		createJsonRenderer: void 0
 	};
 	const rpcHost = new RpcFunctionsHost(context);
@@ -1544,14 +1627,16 @@ async function createDevToolsContext(viteConfig, viteServer) {
 	const viewsHost = new DevToolsViewHost(context);
 	const terminalsHost = new DevToolsTerminalHost(context);
 	const logsHost = new DevToolsLogsHost(context);
+	const commandsHost = new DevToolsCommandsHost(context);
 	context.rpc = rpcHost;
 	context.docks = docksHost;
 	context.views = viewsHost;
 	context.terminals = terminalsHost;
 	context.logs = logsHost;
+	context.commands = commandsHost;
 	let jrCounter = 0;
 	context.createJsonRenderer = (initialSpec) => {
-		const stateKey = `__jr:${jrCounter++}`;
+		const stateKey = `devtoolskit:internal:json-render:${jrCounter++}`;
 		const statePromise = rpcHost.sharedState.get(stateKey, { initialValue: initialSpec });
 		return {
 			_stateKey: stateKey,
@@ -1598,6 +1683,28 @@ async function createDevToolsContext(viteConfig, viteServer) {
 	logsHost.events.on("log:updated", () => debouncedLogsUpdate());
 	logsHost.events.on("log:removed", () => debouncedLogsUpdate());
 	logsHost.events.on("log:cleared", () => debouncedLogsUpdate());
+	const commandsSharedState = await rpcHost.sharedState.get("devtoolskit:internal:commands", { initialValue: [] });
+	const debouncedCommandsSync = debounce(() => {
+		commandsSharedState.mutate(() => commandsHost.list());
+	}, context.mode === "build" ? 0 : 10);
+	commandsHost.events.on("command:registered", () => debouncedCommandsSync());
+	commandsHost.events.on("command:unregistered", () => debouncedCommandsSync());
+	commandsHost.register({
+		id: "vite:open-in-editor",
+		title: "Open in Editor",
+		icon: "ph:pencil-duotone",
+		category: "editor",
+		showInPalette: false,
+		handler: (path) => rpcHost.invokeLocal("vite:core:open-in-editor", path)
+	});
+	commandsHost.register({
+		id: "vite:open-in-finder",
+		title: "Open in Finder",
+		icon: "ph:folder-open-duotone",
+		category: "editor",
+		showInPalette: false,
+		handler: (path) => rpcHost.invokeLocal("vite:core:open-in-finder", path)
+	});
 	const plugins = viteConfig.plugins.filter((plugin) => "devtools" in plugin);
 	for (const plugin of plugins) {
 		if (!plugin.devtools?.setup) continue;
@@ -1616,50 +1723,4 @@ async function createDevToolsContext(viteConfig, viteServer) {
 	return context;
 }
 //#endregion
-//#region src/node/plugins/server.ts
-/**
-* Core plugin for enabling Vite DevTools
-*/
-function renderDockImportsMap(docks) {
-	const map = /* @__PURE__ */ new Map();
-	for (const dock of docks) {
-		const id = `${dock.type}:${dock.id}`;
-		if (dock.type === "action") map.set(id, dock.action);
-		else if (dock.type === "custom-render") map.set(id, dock.renderer);
-		else if (dock.type === "iframe" && dock.clientScript) map.set(id, dock.clientScript);
-	}
-	return [
-		`export const importsMap = {`,
-		...[...map.entries()].filter(([, entry]) => entry != null).map(([id, { importFrom, importName }]) => `  [${JSON.stringify(id)}]: () => import(${JSON.stringify(importFrom)}).then(r => r[${JSON.stringify(importName ?? "default")}]),`),
-		"}"
-	].join("\n");
-}
-function DevToolsServer() {
-	let context;
-	return {
-		name: "vite:devtools:server",
-		enforce: "post",
-		apply: "serve",
-		async configureServer(viteDevServer) {
-			context = await createDevToolsContext(viteDevServer.config, viteDevServer);
-			const host = viteDevServer.config.server.host === true ? "0.0.0.0" : viteDevServer.config.server.host || "localhost";
-			const { middleware } = await createDevToolsMiddleware({
-				cwd: viteDevServer.config.root,
-				hostWebSocket: host,
-				context
-			});
-			viteDevServer.middlewares.use(DEVTOOLS_MOUNT_PATH, middleware);
-		},
-		resolveId(id) {
-			if (id === DEVTOOLS_DOCK_IMPORTS_VIRTUAL_ID) return id;
-		},
-		load(id) {
-			if (id === DEVTOOLS_DOCK_IMPORTS_VIRTUAL_ID) {
-				if (!context) throw new Error("DevTools context is not initialized");
-				return renderDockImportsMap(context.docks.values());
-			}
-		}
-	};
-}
-//#endregion
-export { renderDockImportsMap as n, createDevToolsContext as r, DevToolsServer as t };
+export { createDevToolsContext as n, context_exports as t };

package/dist/{dist-CBtGbo90.js → dist-CCdqIez-.js}

@@ -576,6 +576,17 @@ function getHandlers() {
 function getSSRHandler(key, fallback) {
 	return handlers[key] || fallback;
 }
+/**
+* Reactive dark theme preference.
+*
+* @see https://vueuse.org/usePreferredDark
+* @param [options]
+*
+* @__NO_SIDE_EFFECTS__
+*/
+function usePreferredDark(options) {
+	return useMediaQuery("(prefers-color-scheme: dark)", options);
+}
 function guessSerializerType(rawInit) {
 	return rawInit == null ? "any" : rawInit instanceof Set ? "set" : rawInit instanceof Map ? "map" : rawInit instanceof Date ? "date" : typeof rawInit === "boolean" ? "boolean" : typeof rawInit === "string" ? "string" : typeof rawInit === "object" ? "object" : !Number.isNaN(rawInit) ? "number" : "any";
 }
@@ -730,6 +741,86 @@ function useStorage(key, defaults$1, storage, options = {}) {
 	}
 	return data;
 }
+const CSS_DISABLE_TRANS = "*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}";
+/**
+* Reactive color mode with auto data persistence.
+*
+* @see https://vueuse.org/useColorMode
+* @param options
+*/
+function useColorMode(options = {}) {
+	const { selector = "html", attribute = "class", initialValue = "auto", window: window$1 = defaultWindow, storage, storageKey = "vueuse-color-scheme", listenToStorageChanges = true, storageRef, emitAuto, disableTransition = true } = options;
+	const modes = {
+		auto: "",
+		light: "light",
+		dark: "dark",
+		...options.modes || {}
+	};
+	const preferredDark = usePreferredDark({ window: window$1 });
+	const system = computed(() => preferredDark.value ? "dark" : "light");
+	const store = storageRef || (storageKey == null ? toRef$1(initialValue) : useStorage(storageKey, initialValue, storage, {
+		window: window$1,
+		listenToStorageChanges
+	}));
+	const state = computed(() => store.value === "auto" ? system.value : store.value);
+	const updateHTMLAttrs = getSSRHandler("updateHTMLAttrs", (selector$1, attribute$1, value) => {
+		const el = typeof selector$1 === "string" ? window$1 === null || window$1 === void 0 ? void 0 : window$1.document.querySelector(selector$1) : unrefElement(selector$1);
+		if (!el) return;
+		const classesToAdd = /* @__PURE__ */ new Set();
+		const classesToRemove = /* @__PURE__ */ new Set();
+		let attributeToChange = null;
+		if (attribute$1 === "class") {
+			const current = value.split(/\s/g);
+			Object.values(modes).flatMap((i) => (i || "").split(/\s/g)).filter(Boolean).forEach((v) => {
+				if (current.includes(v)) classesToAdd.add(v);
+				else classesToRemove.add(v);
+			});
+		} else attributeToChange = {
+			key: attribute$1,
+			value
+		};
+		if (classesToAdd.size === 0 && classesToRemove.size === 0 && attributeToChange === null) return;
+		let style;
+		if (disableTransition) {
+			style = window$1.document.createElement("style");
+			style.appendChild(document.createTextNode(CSS_DISABLE_TRANS));
+			window$1.document.head.appendChild(style);
+		}
+		for (const c of classesToAdd) el.classList.add(c);
+		for (const c of classesToRemove) el.classList.remove(c);
+		if (attributeToChange) el.setAttribute(attributeToChange.key, attributeToChange.value);
+		if (disableTransition) {
+			window$1.getComputedStyle(style).opacity;
+			document.head.removeChild(style);
+		}
+	});
+	function defaultOnChanged(mode) {
+		var _modes$mode;
+		updateHTMLAttrs(selector, attribute, (_modes$mode = modes[mode]) !== null && _modes$mode !== void 0 ? _modes$mode : mode);
+	}
+	function onChanged(mode) {
+		if (options.onChanged) options.onChanged(mode, defaultOnChanged);
+		else defaultOnChanged(mode);
+	}
+	watch(state, onChanged, {
+		flush: "post",
+		immediate: true
+	});
+	tryOnMounted(() => onChanged(state.value));
+	const auto = computed({
+		get() {
+			return emitAuto ? store.value : state.value;
+		},
+		set(v) {
+			store.value = v;
+		}
+	});
+	return Object.assign(auto, {
+		store,
+		system,
+		state
+	});
+}
 /**
 * Manipulate CSS variables.
 *
@@ -769,6 +860,38 @@ function useCssVar(prop, target, options = {}) {
 	return variable;
 }
 /**
+* Reactive dark mode with auto data persistence.
+*
+* @see https://vueuse.org/useDark
+* @param options
+*/
+function useDark(options = {}) {
+	const { valueDark = "dark", valueLight = "" } = options;
+	const mode = useColorMode({
+		...options,
+		onChanged: (mode$1, defaultHandler) => {
+			var _options$onChanged;
+			if (options.onChanged) (_options$onChanged = options.onChanged) === null || _options$onChanged === void 0 || _options$onChanged.call(options, mode$1 === "dark", defaultHandler, mode$1);
+			else defaultHandler(mode$1);
+		},
+		modes: {
+			dark: valueDark,
+			light: valueLight
+		}
+	});
+	const system = computed(() => mode.system.value);
+	return computed({
+		get() {
+			return mode.value === "dark";
+		},
+		set(v) {
+			const modeVal = v ? "dark" : "light";
+			if (system.value === modeVal) mode.value = "auto";
+			else mode.value = modeVal;
+		}
+	});
+}
+/**
 * Reports changes to the dimensions of an Element's content or the border-box
 *
 * @see https://vueuse.org/useResizeObserver
@@ -1110,4 +1233,4 @@ function useWindowSize(options = {}) {
 	};
 }
 //#endregion
-export { useScreenSafeArea as a, useDebounceFn as c, useLocalStorage as i, watchDebounced as l, useElementBounding as n, useTimeAgo as o, useEventListener as r, useWindowSize as s, onClickOutside as t, watchImmediate as u };
+export { useLocalStorage as a, useWindowSize as c, watchImmediate as d, useEventListener as i, useDebounceFn as l, useDark as n, useScreenSafeArea as o, useElementBounding as r, useTimeAgo as s, onClickOutside as t, watchDebounced as u };

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { n as InternalAnonymousAuthStorage, t as DevToolsInternalContext } from "./context-internal-BA4ba-FN.js";
+import { n as InternalAnonymousAuthStorage, t as DevToolsInternalContext } from "./context-internal-Ys7Zu3q3.js";
 import { SharedStatePatch } from "@vitejs/devtools-kit/utils/shared-state";
 import * as _vitejs_devtools_rpc0 from "@vitejs/devtools-rpc";
 import { RpcFunctionsCollectorBase } from "@vitejs/devtools-rpc";
 import * as _vitejs_devtools_kit0 from "@vitejs/devtools-kit";
-import { DevToolsDockEntry, DevToolsDocksUserSettings, DevToolsLogEntry, DevToolsNodeContext, DevToolsTerminalSessionStreamChunkEvent, RpcDefinitionsToFunctions } from "@vitejs/devtools-kit";
+import { DevToolsDockEntry, DevToolsDocksUserSettings, DevToolsLogEntry, DevToolsNodeContext, DevToolsServerCommandEntry, DevToolsTerminalSessionStreamChunkEvent, RpcDefinitionsToFunctions } from "@vitejs/devtools-kit";
 import * as h3 from "h3";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
@@ -64,6 +64,28 @@ declare const builtinRpcDeclarations: readonly [{
   dump?: _vitejs_devtools_rpc0.RpcDump<[query: DevToolsAuthInput], Promise<DevToolsAuthReturn>, _vitejs_devtools_kit0.DevToolsNodeContext> | undefined;
   __resolved?: _vitejs_devtools_rpc0.RpcFunctionSetupResult<[query: DevToolsAuthInput], Promise<DevToolsAuthReturn>> | undefined;
   __promise?: _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[query: DevToolsAuthInput], Promise<DevToolsAuthReturn>>> | undefined;
+}, {
+  name: "devtoolskit:internal:commands:execute";
+  type?: "action" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  setup?: ((context: _vitejs_devtools_kit0.DevToolsNodeContext) => _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[id: string, ...args: any[]], Promise<unknown>>>) | undefined;
+  handler?: ((id: string, ...args: any[]) => Promise<unknown>) | undefined;
+  dump?: _vitejs_devtools_rpc0.RpcDump<[id: string, ...args: any[]], Promise<unknown>, _vitejs_devtools_kit0.DevToolsNodeContext> | undefined;
+  __resolved?: _vitejs_devtools_rpc0.RpcFunctionSetupResult<[id: string, ...args: any[]], Promise<unknown>> | undefined;
+  __promise?: _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[id: string, ...args: any[]], Promise<unknown>>> | undefined;
+}, {
+  name: "devtoolskit:internal:commands:list";
+  type?: "static" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  setup?: ((context: _vitejs_devtools_kit0.DevToolsNodeContext) => _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[], Promise<DevToolsServerCommandEntry[]>>>) | undefined;
+  handler?: (() => Promise<DevToolsServerCommandEntry[]>) | undefined;
+  dump?: _vitejs_devtools_rpc0.RpcDump<[], Promise<DevToolsServerCommandEntry[]>, _vitejs_devtools_kit0.DevToolsNodeContext> | undefined;
+  __resolved?: _vitejs_devtools_rpc0.RpcFunctionSetupResult<[], Promise<DevToolsServerCommandEntry[]>> | undefined;
+  __promise?: _vitejs_devtools_rpc0.Thenable<_vitejs_devtools_rpc0.RpcFunctionSetupResult<[], Promise<DevToolsServerCommandEntry[]>>> | undefined;
 }, {
   name: "devtoolskit:internal:docks:on-launch";
   type?: "action" | undefined;
@@ -255,6 +277,7 @@ declare module '@vitejs/devtools-kit' {
     'devtoolskit:internal:terminals:updated': () => Promise<void>;
   }
   interface DevToolsRpcSharedStates {
+    'devtoolskit:internal:commands': DevToolsServerCommandEntry[];
     'devtoolskit:internal:docks': DevToolsDockEntry[];
     'devtoolskit:internal:user-settings': DevToolsDocksUserSettings;
   }
@@ -268,6 +291,22 @@ interface DevToolsOptions {
    * @default true
    */
   builtinDevTools?: boolean;
+  /**
+   * Options for building static DevTools output alongside `vite build`.
+   */
+  build?: {
+    /**
+     * Automatically build DevTools when running `vite build`.
+     *
+     * @default false
+     */
+    withApp?: boolean;
+    /**
+     * Output directory for the DevTools build (relative to root).
+     * Defaults to Vite's `build.outDir`.
+     */
+    outDir?: string;
+  };
 }
 declare function DevTools(options?: DevToolsOptions): Promise<Plugin[]>;
 //#endregion

package/dist/index.js

@@ -1,5 +1,4 @@
-import { r as createDevToolsContext } from "./server-DhChc9gv.js";
-import { t as createDevToolsMiddleware } from "./server-BuWZ1h8p.js";
-import { t as DevTools } from "./plugins-DfC1vp4w.js";
-import "./dist-DpLy3ojW.js";
+import { n as createDevToolsContext } from "./context-BWju7fup.js";
+import { t as DevTools } from "./plugins-Dhpm6Ql_.js";
+import { t as createDevToolsMiddleware } from "./server-DSh-GQIq.js";
 export { DevTools, createDevToolsContext, createDevToolsMiddleware };

package/dist/internal.d.ts

@@ -1,2 +1,2 @@
-import { n as InternalAnonymousAuthStorage, r as getInternalContext, t as DevToolsInternalContext } from "./context-internal-BA4ba-FN.js";
+import { n as InternalAnonymousAuthStorage, r as getInternalContext, t as DevToolsInternalContext } from "./context-internal-Ys7Zu3q3.js";
 export { type DevToolsInternalContext, type InternalAnonymousAuthStorage, getInternalContext };

package/dist/plugins-Dhpm6Ql_.js

@@ -0,0 +1,59 @@
+import { n as ansis_default } from "./constants-DfEeYo9W.js";
+import { dirDist } from "./dirs.js";
+import { t as DevToolsServer } from "./server-ZWEvQMOm.js";
+import { join, normalize, resolve } from "pathe";
+import process from "node:process";
+//#region src/node/plugins/build.ts
+function DevToolsBuild(options = {}) {
+	let context;
+	let resolvedConfig;
+	return {
+		name: "vite:devtools:build",
+		apply: "build",
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+		async buildStart() {
+			const { createDevToolsContext } = await import("./context-BWju7fup.js").then((n) => n.t);
+			context = await createDevToolsContext(resolvedConfig);
+		},
+		async closeBundle() {
+			console.log(ansis_default.cyan`${"⬢"} Building static Vite DevTools...`);
+			const outDir = options.outDir ? resolve(resolvedConfig.root, options.outDir) : resolve(resolvedConfig.root, resolvedConfig.build.outDir);
+			const { buildStaticDevTools } = await import("./build-static-Cb3vKjJS.js");
+			await buildStaticDevTools({
+				context,
+				outDir
+			});
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/injection.ts
+function DevToolsInjection() {
+	return {
+		name: "vite:devtools:injection",
+		enforce: "post",
+		transformIndexHtml() {
+			return [{
+				tag: "script",
+				attrs: {
+					src: `/@fs/${process.env.VITE_DEVTOOLS_LOCAL_DEV ? normalize(join(dirDist, "..", "src/client/inject/index.ts")) : normalize(join(dirDist, "client/inject.js"))}`,
+					type: "module"
+				},
+				injectTo: "body"
+			}];
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/index.ts
+async function DevTools(options = {}) {
+	const { builtinDevTools = true, build } = options;
+	const plugins = [DevToolsInjection(), DevToolsServer()];
+	if (build?.withApp) plugins.push(DevToolsBuild({ outDir: build.outDir }));
+	if (builtinDevTools) plugins.push(await import("@vitejs/devtools-rolldown").then((m) => m.DevToolsRolldownUI()));
+	return plugins;
+}
+//#endregion
+export { DevTools as t };