@vitejs/devtools 0.0.0-alpha.2 → 0.0.0-alpha.20

package/dist/index-C5iw-7QZ.d.ts

@@ -0,0 +1,401 @@
+import { RpcDefinitionsToFunctions, RpcFunctionsCollector, RpcFunctionsCollectorBase } from "birpc-x";
+import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
+import { Raw } from "vue";
+import { ChildProcess } from "node:child_process";
+import { BirpcReturn } from "birpc";
+
+//#region ../kit/src/types/events.d.ts
+interface EventsMap {
+  [event: string]: any;
+}
+interface EventUnsubscribe {
+  (): void;
+}
+interface EventEmitter<Events extends EventsMap> {
+  /**
+   * Calls each of the listeners registered for a given event.
+   *
+   * ```js
+   * ee.emit('tick', tickType, tickDuration)
+   * ```
+   *
+   * @param event The event name.
+   * @param args The arguments for listeners.
+   */
+  emit: <K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) => void;
+  /**
+   * Calls the listeners for a given event once and then removes the listener.
+   *
+   * @param event The event name.
+   * @param args The arguments for listeners.
+   */
+  emitOnce: <K extends keyof Events>(event: K, ...args: Parameters<Events[K]>) => void;
+  /**
+   * Event names in keys and arrays with listeners in values.
+   *
+   * @internal
+   */
+  _listeners: Partial<{ [E in keyof Events]: Events[E][] }>;
+  /**
+   * Add a listener for a given event.
+   *
+   * ```js
+   * const unbind = ee.on('tick', (tickType, tickDuration) => {
+   *   count += 1
+   * })
+   *
+   * disable () {
+   *   unbind()
+   * }
+   * ```
+   *
+   * @param event The event name.
+   * @param cb The listener function.
+   * @returns Unbind listener from event.
+   */
+  on: <K extends keyof Events>(event: K, cb: Events[K]) => EventUnsubscribe;
+  /**
+   * Add a listener for a given event once.
+   *
+   * ```js
+   * const unbind = ee.once('tick', (tickType, tickDuration) => {
+   *   count += 1
+   * })
+   *
+   * disable () {
+   *   unbind()
+   * }
+   * ```
+   *
+   * @param event The event name.
+   * @param cb The listener function.
+   * @returns Unbind listener from event.
+   */
+  once: <K extends keyof Events>(event: K, cb: Events[K]) => EventUnsubscribe;
+}
+//#endregion
+//#region ../kit/src/types/docks.d.ts
+interface DevToolsDockHost {
+  readonly views: Map<string, DevToolsDockUserEntry>;
+  readonly events: EventEmitter<{
+    'dock:entry:updated': (entry: DevToolsDockUserEntry) => void;
+  }>;
+  register: <T extends DevToolsDockUserEntry>(entry: T, force?: boolean) => {
+    update: (patch: Partial<T>) => void;
+  };
+  update: (entry: DevToolsDockUserEntry) => void;
+  values: () => DevToolsDockUserEntry[];
+}
+type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default';
+type DevToolsDockEntryIcon = string | {
+  light: string;
+  dark: string;
+};
+interface DevToolsDockEntryBase {
+  id: string;
+  title: string;
+  icon: DevToolsDockEntryIcon;
+  /**
+   * The default order of the entry in the dock.
+   * The higher the number the earlier it appears.
+   * @default 0
+   */
+  defaultOrder?: number;
+  /**
+   * The category of the entry
+   * @default 'default'
+   */
+  category?: DevToolsDockEntryCategory;
+  /**
+   * Whether the entry should be hidden from the user.
+   * @default false
+   */
+  isHidden?: boolean;
+}
+interface ClientScriptEntry {
+  /**
+   * The filepath or module name to import from
+   */
+  importFrom: string;
+  /**
+   * The name to import the module as
+   *
+   * @default 'default'
+   */
+  importName?: string;
+}
+interface DevToolsViewIframe extends DevToolsDockEntryBase {
+  type: 'iframe';
+  url: string;
+  /**
+   * The id of the iframe, if multiple tabs is assigned with the same id, the iframe will be shared.
+   *
+   * When not provided, it would be treated as a unique frame.
+   */
+  frameId?: string;
+  /**
+   * Optional client script to import into the iframe
+   */
+  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;
+}
+interface DevToolsViewCustomRender extends DevToolsDockEntryBase {
+  type: 'custom-render';
+  renderer: ClientScriptEntry;
+}
+interface DevToolsViewBuiltin extends DevToolsDockEntryBase {
+  type: '~builtin';
+  id: '~terminals' | '~logs';
+}
+type DevToolsDockUserEntry = DevToolsViewIframe | DevToolsViewAction | DevToolsViewCustomRender | DevToolsViewLauncher;
+type DevToolsDockEntry = DevToolsDockUserEntry | DevToolsViewBuiltin;
+//#endregion
+//#region ../kit/src/types/rpc-augments.d.ts
+/**
+ * To be extended
+ */
+interface DevToolsRpcClientFunctions {}
+/**
+ * To be extended
+ */
+interface DevToolsRpcServerFunctions {}
+//#endregion
+//#region ../kit/src/types/terminals.d.ts
+interface DevToolsTerminalSessionStreamChunkEvent {
+  id: string;
+  chunks: string[];
+  ts: number;
+}
+interface DevToolsTerminalHost {
+  readonly sessions: Map<string, DevToolsTerminalSession>;
+  readonly events: EventEmitter<{
+    'terminal:session:updated': (session: DevToolsTerminalSession) => void;
+    'terminal:session:stream-chunk': (data: DevToolsTerminalSessionStreamChunkEvent) => void;
+  }>;
+  register: (session: DevToolsTerminalSession) => DevToolsTerminalSession;
+  update: (session: DevToolsTerminalSession) => void;
+  startChildProcess: (executeOptions: DevToolsChildProcessExecuteOptions, terminal: Omit<DevToolsTerminalSessionBase, 'status'>) => Promise<DevToolsChildProcessTerminalSession>;
+}
+type DevToolsTerminalStatus = 'running' | 'stopped' | 'error';
+interface DevToolsTerminalSessionBase {
+  id: string;
+  title: string;
+  description?: string;
+  status: DevToolsTerminalStatus;
+  icon?: DevToolsDockEntryIcon;
+}
+interface DevToolsTerminalSession extends DevToolsTerminalSessionBase {
+  buffer?: string[];
+  stream?: ReadableStream<string>;
+}
+interface DevToolsChildProcessExecuteOptions {
+  command: string;
+  args: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+}
+interface DevToolsChildProcessTerminalSession extends DevToolsTerminalSession {
+  type: 'child-process';
+  executeOptions: DevToolsChildProcessExecuteOptions;
+  getChildProcess: () => ChildProcess | undefined;
+  terminate: () => Promise<void>;
+  restart: () => Promise<void>;
+}
+//#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 {
+  rpc?: boolean;
+  views?: boolean;
+}
+interface DevToolsPluginOptions {
+  capabilities?: {
+    dev?: DevToolsCapabilities | boolean;
+    build?: DevToolsCapabilities | boolean;
+  };
+  setup: (context: DevToolsNodeContext) => void | Promise<void>;
+}
+interface DevToolsNodeContext {
+  readonly cwd: string;
+  readonly mode: 'dev' | 'build';
+  readonly viteConfig: ResolvedConfig;
+  readonly viteServer?: ViteDevServer;
+  rpc: RpcFunctionsHost;
+  docks: DevToolsDockHost;
+  views: DevToolsViewHost;
+  utils: DevToolsNodeUtils;
+  terminals: DevToolsTerminalHost;
+}
+interface DevToolsNodeUtils {
+  /**
+   * Create a simple client script from a function or stringified code
+   *
+   * @deprecated DO NOT USE. This is mostly for testing only. Please use a proper importable module instead.
+   * @experimental
+   */
+  createSimpleClientScript: (fn: string | ((ctx: DockClientScriptContext) => void)) => ClientScriptEntry;
+}
+interface ConnectionMeta {
+  backend: 'websocket' | 'static';
+  websocket?: number | string;
+}
+//#endregion
+//#region ../kit/src/types/rpc.d.ts
+type RpcFunctionsHost = RpcFunctionsCollectorBase<DevToolsRpcServerFunctions, DevToolsNodeContext> & {
+  boardcast: <T extends keyof DevToolsRpcClientFunctions, Args extends Parameters<DevToolsRpcClientFunctions[T]>>(name: T, ...args: Args) => Promise<(Awaited<ReturnType<DevToolsRpcClientFunctions[T]>> | undefined)[]>;
+};
+//#endregion
+//#region ../kit/src/types/vite-augment.d.ts
+declare module 'vite' {
+  interface Plugin {
+    devtools?: DevToolsPluginOptions;
+  }
+}
+//#endregion
+//#region ../kit/src/client/rpc.d.ts
+interface DevToolsRpcClient {
+  /**
+   * The events of the client
+   */
+  events: EventEmitter<RpcClientEvents>;
+  /**
+   * The connection meta
+   */
+  readonly connectionMeta: ConnectionMeta;
+  /**
+   * Call a RPC function on the server
+   */
+  call: BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$call'];
+  /**
+   * Call a RPC event on the server, and does not expect a response
+   */
+  callEvent: BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$callEvent'];
+  /**
+   * Call a RPC optional function on the server
+   */
+  callOptional: BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$callOptional'];
+  /**
+   * The client RPC host
+   */
+  client: DevToolsClientRpcHost;
+}
+//#endregion
+//#region ../kit/src/client/docks.d.ts
+interface DockPanelStorage {
+  width: number;
+  height: number;
+  top: number;
+  left: number;
+  position: 'left' | 'right' | 'bottom' | 'top';
+  open: boolean;
+  inactiveTimeout: number;
+}
+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 standalone window (no user app)
+   */
+  readonly clientType: 'embedded' | 'standalone';
+  /**
+   * The panel context
+   */
+  readonly panel: DocksPanelContext;
+  /**
+   * The docks entries context
+   */
+  readonly docks: DocksEntriesContext;
+}
+type DevToolsClientRpcHost = RpcFunctionsCollector<DevToolsRpcClientFunctions, DevToolsClientContext>;
+interface DocksPanelContext {
+  store: DockPanelStorage;
+  isDragging: boolean;
+  isResizing: boolean;
+  readonly isVertical: boolean;
+}
+interface DocksEntriesContext {
+  selectedId: string | null;
+  readonly selected: DevToolsDockEntry | null;
+  entries: DevToolsDockEntry[];
+  entryToStateMap: Map<string, DockEntryState>;
+  /**
+   * Get the state of a dock entry by its ID
+   */
+  getStateById: (id: string) => DockEntryState | undefined;
+  /**
+   * Switch to the selected dock entry, pass `null` to clear the selection
+   *
+   * @returns Whether the selection was changed successfully
+   */
+  switchEntry: (id?: string | null) => Promise<boolean>;
+}
+interface DockEntryState {
+  entryMeta: DevToolsDockEntry;
+  readonly isActive: boolean;
+  domElements: {
+    iframe?: HTMLIFrameElement | null;
+    panel?: HTMLDivElement | null;
+  };
+  events: Raw<EventEmitter<DockEntryStateEvents>>;
+}
+interface DockEntryStateEvents {
+  'entry:activated': () => void;
+  'entry:deactivated': () => void;
+  'entry:updated': (newMeta: DevToolsDockUserEntry) => void;
+  'dom:panel:mounted': (panel: HTMLDivElement) => void;
+  'dom:iframe:mounted': (iframe: HTMLIFrameElement) => void;
+}
+interface RpcClientEvents {}
+//#endregion
+//#region ../kit/src/client/client-script.d.ts
+/**
+ * Context for client scripts running in dock entries
+ */
+interface DockClientScriptContext extends DocksContext {
+  /**
+   * The state of the current dock entry
+   */
+  current: DockEntryState;
+}
+//#endregion
+export { RpcDefinitionsToFunctions as a, DevToolsTerminalSessionBase as c, DevToolsRpcServerFunctions as d, DevToolsDockEntry as f, DevToolsRpcClient as i, DevToolsTerminalSessionStreamChunkEvent as l, DockPanelStorage as n, ConnectionMeta as o, DocksContext as r, DevToolsNodeContext as s, DockEntryState as t, DevToolsRpcClientFunctions as u };

package/dist/index.d.ts

@@ -1,12 +1,32 @@
-import { DevToolsNodeContext } from "@vitejs/devtools-kit";
-import "@vitejs/devtools-vite";
+import { a as RpcDefinitionsToFunctions, c as DevToolsTerminalSessionBase, d as DevToolsRpcServerFunctions, f as DevToolsDockEntry, l as DevToolsTerminalSessionStreamChunkEvent, o as ConnectionMeta, s as DevToolsNodeContext, u as DevToolsRpcClientFunctions } from "./index-C5iw-7QZ.js";
+import * as birpc_x0 from "birpc-x";
+import { RpcFunctionsCollectorBase } from "birpc-x";
 import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
-import * as h30 from "h3";
 import * as birpc0 from "birpc";
+import * as h30 from "h3";
 
 //#region src/node/context.d.ts
 declare function createDevToolsContext(viteConfig: ResolvedConfig, viteServer?: ViteDevServer): Promise<DevToolsNodeContext>;
 //#endregion
+//#region src/node/rpc/index.d.ts
+declare const builtinRpcDecalrations: readonly [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:internal:docks:list", "static", [], DevToolsDockEntry[], DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:docks:on-launch", "action", [entryId: string], Promise<void>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:rpc:server:list", "static", [], Promise<{
+  [k: string]: {
+    type: any;
+  };
+}>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:terminals:list", "static", [], Promise<DevToolsTerminalSessionBase[]>, DevToolsNodeContext>, birpc_x0.RpcFunctionDefinition<"vite:internal:terminals:read", "query", [id: string], Promise<{
+  buffer: string[];
+  ts: number;
+}>, DevToolsNodeContext>];
+type BuiltinServerFunctions = RpcDefinitionsToFunctions<typeof builtinRpcDecalrations>;
+declare module '@vitejs/devtools-kit' {
+  interface DevToolsRpcServerFunctions extends BuiltinServerFunctions {}
+  interface DevToolsRpcClientFunctions {
+    'vite:internal:docks:updated': () => Promise<void>;
+    'vite:internal:terminals:stream-chunk': (data: DevToolsTerminalSessionStreamChunkEvent) => Promise<void>;
+    'vite:internal:terminals:updated': () => Promise<void>;
+  }
+}
+//#endregion
 //#region src/node/plugins/index.d.ts
 interface DevToolsOptions {
   /**
@@ -16,7 +36,7 @@ interface DevToolsOptions {
    */
   builtinDevTools?: boolean;
 }
-declare function DevTools(options?: DevToolsOptions): Plugin[];
+declare function DevTools(options?: DevToolsOptions): Promise<Plugin[]>;
 //#endregion
 //#region src/node/ws.d.ts
 interface CreateWsServerOptions {
@@ -29,8 +49,9 @@ interface CreateWsServerOptions {
 //#region src/node/server.d.ts
 declare function createDevToolsMiddleware(options: CreateWsServerOptions): Promise<{
   h3: h30.App;
+  rpc: birpc0.BirpcGroup<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, false>;
   middleware: h30.NodeListener;
-  rpc: birpc0.BirpcGroup<any, any>;
+  getConnectionMeta: () => Promise<ConnectionMeta>;
 }>;
 //#endregion
 export { DevTools, createDevToolsContext, createDevToolsMiddleware };

package/dist/index.js

@@ -1,57 +1,3 @@
-import { createDevToolsContext, createDevToolsMiddleware } from "./server-B_q0HJ88.js";
-import { dirDist } from "./dirs-B7dOX6eI.js";
-import { DevToolsViteUI } from "@vitejs/devtools-vite";
-import { join } from "node:path";
-import process from "node:process";
-import { normalizePath } from "vite";
+import { d as createDevToolsContext, n as createDevToolsMiddleware, t as DevTools } from "./plugins-DfJlAQ2j.js";
 
-//#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 ? normalizePath(join(dirDist, "..", "src/client/inject/index.ts")) : normalizePath(join(dirDist, "client/inject.js"))}`,
-					type: "module"
-				},
-				injectTo: "body"
-			}];
-		}
-	};
-}
-
-//#endregion
-//#region src/node/plugins/server.ts
-/**
-* Core plugin for enabling Vite DevTools
-*/
-function DevToolsServer() {
-	return {
-		name: "vite:devtools:server",
-		enforce: "post",
-		apply: "serve",
-		async configureServer(viteDevServer) {
-			const context = await createDevToolsContext(viteDevServer.config, viteDevServer);
-			const { middleware } = await createDevToolsMiddleware({
-				cwd: viteDevServer.config.root,
-				context
-			});
-			viteDevServer.middlewares.use("/__vite_devtools__/", middleware);
-		}
-	};
-}
-
-//#endregion
-//#region src/node/plugins/index.ts
-function DevTools(options = {}) {
-	const { builtinDevTools = true } = options;
-	const plugins = [DevToolsInjection(), DevToolsServer()];
-	if (builtinDevTools) plugins.push(DevToolsViteUI());
-	return plugins;
-}
-
-//#endregion
 export { DevTools, createDevToolsContext, createDevToolsMiddleware };