@vitejs/devtools 0.0.0-alpha.16 → 0.0.0-alpha.18

package/dist/{index-CG5vL1Rm.d.ts → index-Dt5HYF60.d.ts}

@@ -1,54 +1,26 @@
-import { RpcFunctionsCollectorBase } from "birpc-x";
+import { RpcDefinitionsToFunctions, RpcFunctionsCollector, RpcFunctionsCollectorBase } from "birpc-x";
 import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
 import { Emitter } from "nanoevents";
 import { Raw } from "vue";
-import { BirpcReturn } from "birpc";
+import { BirpcGroup, BirpcReturn } from "birpc";
 import "@vitejs/devtools-rpc/presets/ws/client";
 
-//#region ../kit/src/types/rpc-augments.d.ts
-/**
- * To be extended
- */
-interface DevToolsRpcClientFunctions {}
-/**
- * To be extended
- */
-interface DevToolsRpcServerFunctions {}
-//#endregion
-//#region ../kit/src/types/utils.d.ts
-type Thenable<T> = T | Promise<T>;
-type EntriesToObject<T extends readonly [string, any][]> = { [K in T[number] as K[0]]: K[1] };
-//#endregion
-//#region ../kit/src/types/views.d.ts
+//#region ../kit/src/types/docks.d.ts
 interface DevToolsDockHost {
   views: Map<string, DevToolsDockEntry>;
   register: (entry: DevToolsDockEntry) => void;
   update: (entry: DevToolsDockEntry) => void;
   values: () => DevToolsDockEntry[];
 }
-interface DevToolsViewHost {
-  /**
-   * @internal
-   */
-  buildStaticDirs: {
-    baseUrl: string;
-    distDir: string;
-  }[];
-  /**
-   * Helper to host static files
-   * - In `dev` mode, it will register middleware to `viteServer.middlewares` to host the static files
-   * - In `build` mode, it will copy the static files to the dist directory
-   */
-  hostStatic: (baseUrl: string, distDir: string) => void;
-}
 type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default';
+type DevToolsDockEntryIcon = string | {
+  light: string;
+  dark: string;
+};
 interface DevToolsDockEntryBase {
   id: string;
   title: string;
-  icon: string | {
-    light: string;
-    dark: string;
-  };
+  icon: DevToolsDockEntryIcon;
   /**
    * The default order of the entry in the dock.
    * The higher the number the earlier it appears.
@@ -87,6 +59,20 @@ interface DevToolsViewIframe extends DevToolsDockEntryBase {
    */
   clientScript?: ClientScriptEntry;
 }
+type DevToolsViewLauncherStatus = 'idle' | 'loading' | 'success' | 'error';
+interface DevToolsViewLauncher extends DevToolsDockEntryBase {
+  type: 'launcher';
+  launcher: {
+    icon?: DevToolsDockEntryIcon;
+    title: string;
+    status?: DevToolsViewLauncherStatus;
+    error?: string;
+    description?: string;
+    buttonStart?: string;
+    buttonLoading?: string;
+    onLaunch: () => Promise<void>;
+  };
+}
 interface DevToolsViewAction extends DevToolsDockEntryBase {
   type: 'action';
   action: ClientScriptEntry;
@@ -95,7 +81,34 @@ interface DevToolsViewCustomRender extends DevToolsDockEntryBase {
   type: 'custom-render';
   renderer: ClientScriptEntry;
 }
-type DevToolsDockEntry = DevToolsViewIframe | DevToolsViewAction | DevToolsViewCustomRender;
+type DevToolsDockEntry = DevToolsViewIframe | DevToolsViewAction | DevToolsViewCustomRender | DevToolsViewLauncher;
+//#endregion
+//#region ../kit/src/types/rpc-augments.d.ts
+/**
+ * To be extended
+ */
+interface DevToolsRpcClientFunctions {}
+/**
+ * To be extended
+ */
+interface DevToolsRpcServerFunctions {}
+//#endregion
+//#region ../kit/src/types/views.d.ts
+interface DevToolsViewHost {
+  /**
+   * @internal
+   */
+  buildStaticDirs: {
+    baseUrl: string;
+    distDir: string;
+  }[];
+  /**
+   * Helper to host static files
+   * - In `dev` mode, it will register middleware to `viteServer.middlewares` to host the static files
+   * - In `build` mode, it will copy the static files to the dist directory
+   */
+  hostStatic: (baseUrl: string, distDir: string) => void;
+}
 //#endregion
 //#region ../kit/src/types/vite-plugin.d.ts
 interface DevToolsCapabilities {
@@ -128,28 +141,15 @@ interface DevToolsNodeUtils {
    */
   createSimpleClientScript: (fn: string | ((ctx: DockClientScriptContext) => void)) => ClientScriptEntry;
 }
+interface ConnectionMeta {
+  backend: 'websocket' | 'static';
+  websocket?: number | string;
+}
 //#endregion
 //#region ../kit/src/types/rpc.d.ts
-/**
- * Type of the RPC function,
- * - static: A function that returns a static data (can be cached and dumped)
- * - action: A function that performs an action (no data returned)
- * - query: A function that queries a resource
- */
-type RpcFunctionType = 'static' | 'action' | 'query';
-type RpcFunctionsHost = RpcFunctionsCollectorBase<DevToolsRpcServerFunctions, DevToolsNodeContext>;
-interface RpcFunctionSetupResult<ARGS extends any[], RETURN = void> {
-  handler: (...args: ARGS) => RETURN;
-}
-interface RpcFunctionDefinition<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[] = [], RETURN = void> {
-  name: NAME;
-  type: TYPE;
-  setup: (context: DevToolsNodeContext) => Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
-  handler?: (...args: ARGS) => RETURN;
-  __resolved?: RpcFunctionSetupResult<ARGS, RETURN>;
-  __promise?: Thenable<RpcFunctionSetupResult<ARGS, RETURN>>;
-}
-type RpcDefinitionsToFunctions<T extends readonly RpcFunctionDefinition<any, any, any>[]> = EntriesToObject<{ [K in keyof T]: [T[K]['name'], Awaited<ReturnType<T[K]['setup']>>['handler']] }>;
+type RpcFunctionsHost = RpcFunctionsCollectorBase<DevToolsRpcServerFunctions, DevToolsNodeContext> & {
+  boardcast: BirpcGroup<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions>['broadcast'];
+};
 //#endregion
 //#region ../kit/src/types/vite-augment.d.ts
 declare module 'vite' {
@@ -160,6 +160,11 @@ declare module 'vite' {
 //#endregion
 //#region ../kit/src/client/rpc.d.ts
 type DevToolsRpcClient = BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>;
+interface ClientRpcReturn {
+  connectionMeta: ConnectionMeta;
+  rpc: DevToolsRpcClient;
+  clientRpc: DevToolsClientRpcHost;
+}
 //#endregion
 //#region ../kit/src/client/docks.d.ts
 interface DockPanelStorage {
@@ -171,27 +176,34 @@ interface DockPanelStorage {
   open: boolean;
   inactiveTimeout: number;
 }
-interface DocksContext {
+interface DevToolsClientContext {
+  /**
+   * The RPC client to interact with the server
+   */
+  readonly rpc: DevToolsRpcClient;
+}
+interface DocksContext extends DevToolsClientContext {
   /**
    * Type of the client environment
    *
    * 'embedded' - running inside an embedded floating panel
-   * 'standalone' - running inside a standlone window (no user app)
+   * 'standalone' - running inside a standalone window (no user app)
    */
   readonly clientType: 'embedded' | 'standalone';
-  /**
-   * The RPC client to interact with the server
-   */
-  readonly rpc: DevToolsRpcClient;
   /**
    * The panel context
    */
-  panel: DocksPanelContext;
+  readonly panel: DocksPanelContext;
   /**
    * The docks entries context
    */
-  docks: DocksEntriesContext;
+  readonly docks: DocksEntriesContext;
+  /**
+   * The client-side RPC functions to be called from the server
+   */
+  readonly clientRpc: DevToolsClientRpcHost;
 }
+type DevToolsClientRpcHost = RpcFunctionsCollector<DevToolsRpcClientFunctions, DevToolsClientContext>;
 interface DocksPanelContext {
   store: DockPanelStorage;
   isDragging: boolean;
@@ -199,7 +211,8 @@ interface DocksPanelContext {
   readonly isVertical: boolean;
 }
 interface DocksEntriesContext {
-  selected: DevToolsDockEntry | null;
+  selectedId: string | null;
+  readonly selected: DevToolsDockEntry | null;
   entries: DevToolsDockEntry[];
   entryToStateMap: Map<string, DockEntryState>;
   /**
@@ -241,4 +254,4 @@ interface DockClientScriptContext extends DocksContext {
   current: DockEntryState;
 }
 //#endregion
-export { DevToolsNodeContext as a, RpcDefinitionsToFunctions as i, DocksContext as n, DevToolsDockEntry as o, DevToolsRpcClient as r, DockPanelStorage as t };
+export { ConnectionMeta as a, DevToolsRpcServerFunctions as c, RpcDefinitionsToFunctions as i, DevToolsDockEntry as l, DocksContext as n, DevToolsNodeContext as o, ClientRpcReturn as r, DevToolsRpcClientFunctions as s, DockPanelStorage as t };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { a as DevToolsNodeContext, i as RpcDefinitionsToFunctions, o as DevToolsDockEntry } from "./index-CG5vL1Rm.js";
+import { a as ConnectionMeta, c as DevToolsRpcServerFunctions, i as RpcDefinitionsToFunctions, l as DevToolsDockEntry, o as DevToolsNodeContext, s as DevToolsRpcClientFunctions } from "./index-Dt5HYF60.js";
 import * as birpc_x0 from "birpc-x";
 import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
 import * as birpc0 from "birpc";
@@ -12,10 +12,13 @@ declare const builtinRpcFunctions: readonly [birpc_x0.RpcFunctionDefinition<"vit
   [k: string]: {
     type: any;
   };
-}>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:list-dock-entries", "query", [], DevToolsDockEntry[], DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:open-in-editor", "action", [path: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:open-in-finder", "action", [path: string], Promise<void>, DevToolsNodeContext>];
+}>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:list-dock-entries", "query", [], DevToolsDockEntry[], DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:open-in-editor", "action", [path: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:open-in-finder", "action", [path: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:core:on-dock-launch", "action", [entryId: string], Promise<void>, DevToolsNodeContext>];
 type ServerFunctions = RpcDefinitionsToFunctions<typeof builtinRpcFunctions>;
 declare module '@vitejs/devtools-kit' {
   interface DevToolsRpcServerFunctions extends ServerFunctions {}
+  interface DevToolsRpcClientFunctions {
+    'vite:core:list-dock-entries:updated': () => Promise<void>;
+  }
 }
 //#endregion
 //#region src/node/plugins/index.d.ts
@@ -40,8 +43,9 @@ interface CreateWsServerOptions {
 //#region src/node/server.d.ts
 declare function createDevToolsMiddleware(options: CreateWsServerOptions): Promise<{
   h3: h30.App;
+  rpc: birpc0.BirpcGroup<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions>;
   middleware: h30.NodeListener;
-  rpc: birpc0.BirpcGroup<any, any>;
+  getConnectionMeta: () => Promise<ConnectionMeta>;
 }>;
 //#endregion
 export { DevTools, createDevToolsContext, createDevToolsMiddleware };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { d as createDevToolsContext, n as createDevToolsMiddleware, t as DevTools } from "./plugins-CMhTYtP5.js";
+import { d as createDevToolsContext, n as createDevToolsMiddleware, t as DevTools } from "./plugins-LceePuMU.js";
 import "./dirs-DcSK9l9L.js";
 
 export { DevTools, createDevToolsContext, createDevToolsMiddleware };

package/dist/{plugins-CMhTYtP5.js → plugins-LceePuMU.js}

@@ -1,6 +1,7 @@
 import { n as dirDist, t as dirClientStandalone } from "./dirs-DcSK9l9L.js";
 import Debug from "debug";
 import { toDataURL } from "mlly";
+import { debounce } from "perfect-debounce";
 import { RpcFunctionsCollectorBase } from "birpc-x";
 import { existsSync } from "node:fs";
 import sirv from "sirv";
@@ -52,25 +53,32 @@ const ContextUtils = { createSimpleClientScript(fn) {
 //#region src/node/host-docks.ts
 var DevToolsDockHost = class {
 	views = /* @__PURE__ */ new Map();
+	_sendOnChange;
 	constructor(context) {
 		this.context = context;
+		this._sendOnChange = debounce(() => {
+			context.rpc?.boardcast?.$callOptional("vite:core:list-dock-entries:updated");
+		}, 10);
 	}
 	values() {
 		return Array.from(this.views.values());
 	}
-	register(view) {
-		if (this.views.has(view.id)) throw new Error(`Dock with id "${view.id}" is already registered`);
+	register(view, force) {
+		if (this.views.has(view.id) && !force) throw new Error(`Dock with id "${view.id}" is already registered`);
 		this.views.set(view.id, view);
+		this._sendOnChange();
 	}
 	update(view) {
 		if (!this.views.has(view.id)) throw new Error(`Dock with id "${view.id}" is not registered. Use register() to add new docks.`);
 		this.views.set(view.id, view);
+		this._sendOnChange();
 	}
 };
 
 //#endregion
 //#region src/node/host-functions.ts
 var RpcFunctionsHost = class extends RpcFunctionsCollectorBase {
+	boardcast = void 0;
 	constructor(context) {
 		super(context);
 	}
@@ -124,6 +132,53 @@ const listRpcFunctions = defineRpcFunction({
 	}
 });
 
+//#endregion
+//#region src/node/rpc/on-dock-launch.ts
+const onDockLaunch = defineRpcFunction({
+	name: "vite:core:on-dock-launch",
+	type: "action",
+	setup: (context) => {
+		const launchMap = /* @__PURE__ */ new Map();
+		return { handler: async (entryId) => {
+			if (launchMap.has(entryId)) return launchMap.get(entryId);
+			const entry = context.docks.values().find((entry$1) => entry$1.id === entryId);
+			if (!entry) throw new Error(`Dock entry with id "${entryId}" not found`);
+			if (entry.type !== "launcher") throw new Error(`Dock entry with id "${entryId}" is not a launcher`);
+			try {
+				context.docks.update({
+					...entry,
+					launcher: {
+						...entry.launcher,
+						status: "loading"
+					}
+				});
+				const promise = entry.launcher.onLaunch();
+				launchMap.set(entryId, promise);
+				const result = await promise;
+				const newEntry = context.docks.values().find((entry$1) => entry$1.id === entryId) || entry;
+				if (newEntry.type === "launcher") context.docks.update({
+					...newEntry,
+					launcher: {
+						...newEntry.launcher,
+						status: "success"
+					}
+				});
+				return result;
+			} catch (error) {
+				console.error(`[VITE DEVTOOLS] Error launching dock entry "${entryId}"`, error);
+				context.docks.update({
+					...entry,
+					launcher: {
+						...entry.launcher,
+						status: "error",
+						error: error instanceof Error ? error.message : String(error)
+					}
+				});
+			}
+		} };
+	}
+});
+
 //#endregion
 //#region src/node/rpc/open-in-editor.ts
 const openInEditor = defineRpcFunction({
@@ -154,7 +209,8 @@ const builtinRpcFunctions = [
 	listRpcFunctions,
 	listDockEntries,
 	openInEditor,
-	openInFinder
+	openInFinder,
+	onDockLaunch
 ];
 
 //#endregion
@@ -1249,7 +1305,8 @@ async function createWsServer(options) {
 			throw error;
 		} }
 	});
-	const getMetadata = async () => {
+	rpcHost.boardcast = rpc.broadcast;
+	const getConnectionMeta = async () => {
 		return {
 			backend: "websocket",
 			websocket: port
@@ -1258,28 +1315,29 @@ async function createWsServer(options) {
 	return {
 		port,
 		rpc,
-		functions: rpcHost,
-		getMetadata
+		rpcHost,
+		getConnectionMeta
 	};
 }
 
 //#endregion
 //#region src/node/server.ts
 async function createDevToolsMiddleware(options) {
-	const app = createApp();
-	const { rpc, getMetadata } = await createWsServer(options);
-	app.use("/.vdt-connection.json", eventHandler(async (event) => {
+	const h3 = createApp();
+	const { rpc, getConnectionMeta } = await createWsServer(options);
+	h3.use("/.vdt-connection.json", eventHandler(async (event) => {
 		event.node.res.setHeader("Content-Type", "application/json");
-		return event.node.res.end(JSON.stringify(await getMetadata()));
+		return event.node.res.end(JSON.stringify(await getConnectionMeta()));
 	}));
-	app.use(fromNodeMiddleware(sirv(dirClientStandalone, {
+	h3.use(fromNodeMiddleware(sirv(dirClientStandalone, {
 		dev: true,
 		single: true
 	})));
 	return {
-		h3: app,
-		middleware: toNodeListener(app),
-		rpc
+		h3,
+		rpc,
+		middleware: toNodeListener(h3),
+		getConnectionMeta
 	};
 }