@vitejs/devtools-kit 0.0.0-alpha.8 → 0.1.0

package/dist/index-Bl6l5FTi.d.ts

@@ -0,0 +1,642 @@
+import { t as EventEmitter } from "./events-B41U-zeg.js";
+import { o as SharedState } from "./shared-state-BFKKxNt1.js";
+import { RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcFunctionsCollector, RpcFunctionsCollectorBase } from "@vitejs/devtools-rpc";
+import { WebSocketRpcClientOptions } from "@vitejs/devtools-rpc/presets/ws/client";
+import { DevToolsNodeRpcSessionMeta } from "@vitejs/devtools-rpc/presets/ws/server";
+import { BirpcOptions, BirpcReturn } from "birpc";
+import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
+import { ChildProcess } from "node:child_process";
+
+//#region src/types/logs.d.ts
+type DevToolsLogLevel = 'info' | 'warn' | 'error' | 'success' | 'debug';
+type DevToolsLogEntryFrom = 'server' | 'browser';
+interface DevToolsLogElementPosition {
+  /** CSS selector for the element */
+  selector?: string;
+  /** Bounding box of the element */
+  boundingBox?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  /** Human-readable description of the element */
+  description?: string;
+}
+interface DevToolsLogFilePosition {
+  /** Absolute or relative file path */
+  file: string;
+  /** Line number (1-based) */
+  line?: number;
+  /** Column number (1-based) */
+  column?: number;
+}
+interface DevToolsLogEntry {
+  /**
+   * Unique identifier for this log entry (auto-generated if not provided)
+   */
+  id: string;
+  /**
+   * Short title or summary of the log
+   */
+  message: string;
+  /**
+   * Optional detailed description or explanation
+   */
+  description?: string;
+  /**
+   * Severity level, determines color and icon
+   */
+  level: DevToolsLogLevel;
+  /**
+   * Optional stack trace string
+   */
+  stacktrace?: string;
+  /**
+   * Optional DOM element position info (e.g., for a11y issues)
+   */
+  elementPosition?: DevToolsLogElementPosition;
+  /**
+   * Optional source file position info (e.g., for lint errors)
+   */
+  filePosition?: DevToolsLogFilePosition;
+  /**
+   * Whether this log should also appear as a toast notification
+   */
+  notify?: boolean;
+  /**
+   * Origin of the log entry, automatically set by the context
+   */
+  from: DevToolsLogEntryFrom;
+  /**
+   * Grouping category (e.g., 'a11y', 'lint', 'runtime', 'test')
+   */
+  category?: string;
+  /**
+   * Optional tags/labels for filtering
+   */
+  labels?: string[];
+  /**
+   * Time in ms to auto-dismiss the toast notification (client-side)
+   */
+  autoDismiss?: number;
+  /**
+   * Time in ms to auto-delete this log entry (server-side)
+   */
+  autoDelete?: number;
+  /**
+   * Timestamp when the log was created (auto-generated if not provided)
+   */
+  timestamp: number;
+  /**
+   * Status of the log entry (e.g., 'loading' while an operation is in progress).
+   * Defaults to 'idle' when not specified.
+   */
+  status?: 'loading' | 'idle';
+}
+/**
+ * Input type for creating a log entry.
+ * `id`, `timestamp`, and `source` are auto-filled by the host.
+ */
+type DevToolsLogEntryInput = Omit<DevToolsLogEntry, 'id' | 'timestamp' | 'from'> & {
+  id?: string;
+  timestamp?: number;
+};
+interface DevToolsLogHandle {
+  /** The underlying log entry data */
+  readonly entry: DevToolsLogEntry;
+  /** Shortcut to entry.id */
+  readonly id: string;
+  /** Partial update of this log entry */
+  update: (patch: Partial<DevToolsLogEntryInput>) => Promise<DevToolsLogEntry | undefined>;
+  /** Remove this log entry */
+  dismiss: () => Promise<void>;
+}
+interface DevToolsLogsClient {
+  /**
+   * Add a log entry. Returns a Promise resolving to a handle for subsequent updates/dismissal.
+   * Can be used without `await` for fire-and-forget usage.
+   */
+  add: (input: DevToolsLogEntryInput) => Promise<DevToolsLogHandle>;
+  /** Remove a log entry by id */
+  remove: (id: string) => Promise<void>;
+  /** Clear all log entries */
+  clear: () => Promise<void>;
+}
+interface DevToolsLogsHost {
+  readonly entries: Map<string, DevToolsLogEntry>;
+  readonly events: EventEmitter<{
+    'log:added': (entry: DevToolsLogEntry) => void;
+    'log:updated': (entry: DevToolsLogEntry) => void;
+    'log:removed': (id: string) => void;
+    'log:cleared': () => void;
+  }>;
+  /**
+   * Add a new log entry. If an entry with the same `id` already exists, it will be updated instead.
+   * Returns a handle for subsequent updates/dismissal. Can be used without `await` for fire-and-forget.
+   */
+  add: (entry: DevToolsLogEntryInput) => Promise<DevToolsLogHandle>;
+  /**
+   * Update an existing log entry by id (partial update)
+   */
+  update: (id: string, patch: Partial<DevToolsLogEntryInput>) => Promise<DevToolsLogEntry | undefined>;
+  /**
+   * Remove a log entry by id
+   */
+  remove: (id: string) => Promise<void>;
+  /**
+   * Clear all log entries
+   */
+  clear: () => Promise<void>;
+}
+//#endregion
+//#region 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: (options?: {
+    includeBuiltin?: boolean;
+  }) => DevToolsDockEntry[];
+}
+type DevToolsDockEntryCategory = 'app' | 'framework' | 'web' | 'advanced' | 'default' | '~viteplus' | '~builtin';
+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;
+  /**
+   * Badge text to display on the dock icon (e.g., unread count)
+   */
+  badge?: string;
+}
+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' | '~client-auth-notice' | '~settings' | '~popup';
+}
+type DevToolsDockUserEntry = DevToolsViewIframe | DevToolsViewAction | DevToolsViewCustomRender | DevToolsViewLauncher;
+type DevToolsDockEntry = DevToolsDockUserEntry | DevToolsViewBuiltin;
+type DevToolsDockEntriesGrouped = [category: string, entries: DevToolsDockEntry[]][];
+//#endregion
+//#region src/types/rpc-augments.d.ts
+/**
+ * To be extended
+ */
+interface DevToolsRpcClientFunctions {}
+/**
+ * To be extended
+ */
+interface DevToolsRpcServerFunctions {}
+/**
+ * To be extended
+ */
+interface DevToolsRpcSharedStates {}
+//#endregion
+//#region 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 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 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 {
+  /**
+   * Workspace root directory of Vite DevTools
+   */
+  readonly workspaceRoot: string;
+  /**
+   * Current working directory of Vite DevTools
+   */
+  readonly cwd: string;
+  /**
+   * Current mode of Vite DevTools
+   * - 'dev' - when Vite DevTools is running in dev mode
+   * - 'build' - when Vite DevTools is running in build mode (no server)
+   */
+  readonly mode: 'dev' | 'build';
+  /**
+   * Resolved Vite configuration
+   */
+  readonly viteConfig: ResolvedConfig;
+  /**
+   * Vite dev server instance (only available in dev mode)
+   */
+  readonly viteServer?: ViteDevServer;
+  /**
+   * RPC functions host, for registering server-side RPC functions and calling client-side RPC functions
+   */
+  rpc: RpcFunctionsHost;
+  /**
+   * Docks host, for registering dock entries
+   */
+  docks: DevToolsDockHost;
+  /**
+   * Views host, for registering static views
+   */
+  views: DevToolsViewHost;
+  /**
+   * Utils for the node context
+   */
+  utils: DevToolsNodeUtils;
+  /**
+   * Terminals host, for registering terminal sessions and streaming terminal output
+   */
+  terminals: DevToolsTerminalHost;
+  /**
+   * Logs host, for emitting and managing structured log entries
+   */
+  logs: DevToolsLogsHost;
+}
+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 src/types/rpc.d.ts
+interface DevToolsNodeRpcSession {
+  meta: DevToolsNodeRpcSessionMeta;
+  rpc: BirpcReturn<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, false>;
+}
+interface RpcBroadcastOptions<METHOD, Args extends any[]> {
+  method: METHOD;
+  args: Args;
+  optional?: boolean;
+  event?: boolean;
+  filter?: (client: BirpcReturn<DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, false>) => boolean | void;
+}
+type RpcFunctionsHost = RpcFunctionsCollectorBase<DevToolsRpcServerFunctions, DevToolsNodeContext> & {
+  /**
+   * Invoke a locally registered server RPC function directly.
+   *
+   * This bypasses transport and is useful for server-side cross-function calls.
+   */
+  invokeLocal: <T extends keyof DevToolsRpcServerFunctions, Args extends Parameters<DevToolsRpcServerFunctions[T]>>(method: T, ...args: Args) => Promise<Awaited<ReturnType<DevToolsRpcServerFunctions[T]>>>;
+  /**
+   * Broadcast a message to all connected clients
+   */
+  broadcast: <T extends keyof DevToolsRpcClientFunctions, Args extends Parameters<DevToolsRpcClientFunctions[T]>>(options: RpcBroadcastOptions<T, Args>) => Promise<void>;
+  /**
+   * Get the current RPC client
+   *
+   * Available in RPC functions to get the current RPC client
+   */
+  getCurrentRpcSession: () => DevToolsNodeRpcSession | undefined;
+  /**
+   * The shared state host
+   */
+  sharedState: RpcSharedStateHost;
+};
+interface RpcSharedStateGetOptions<T> {
+  sharedState?: SharedState<T>;
+  initialValue?: T;
+}
+interface RpcSharedStateHost {
+  get: <T extends keyof DevToolsRpcSharedStates>(key: T, options?: RpcSharedStateGetOptions<DevToolsRpcSharedStates[T]>) => Promise<SharedState<DevToolsRpcSharedStates[T]>>;
+  keys: () => string[];
+}
+//#endregion
+//#region src/types/settings.d.ts
+interface DevToolsDocksUserSettings {
+  docksHidden: string[];
+  docksCategoriesHidden: string[];
+  docksPinned: string[];
+  docksCustomOrder: Record<string, number>;
+  showIframeAddressBar: boolean;
+  closeOnOutsideClick: boolean;
+}
+//#endregion
+//#region 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] };
+type PartialWithoutId<T extends {
+  id: string;
+}> = Partial<Omit<T, 'id'>> & {
+  id: string;
+};
+//#endregion
+//#region src/types/vite-augment.d.ts
+declare module 'vite' {
+  interface Plugin {
+    devtools?: DevToolsPluginOptions;
+  }
+}
+interface PluginWithDevTools extends Plugin {
+  devtools?: DevToolsPluginOptions;
+}
+//#endregion
+//#region src/client/rpc.d.ts
+interface DevToolsRpcClientOptions {
+  connectionMeta?: ConnectionMeta;
+  baseURL?: string | string[];
+  /**
+   * The auth id to use for the client
+   */
+  authId?: string;
+  wsOptions?: Partial<WebSocketRpcClientOptions>;
+  rpcOptions?: Partial<BirpcOptions<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions, boolean>>;
+}
+type DevToolsRpcClientCall = BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$call'];
+type DevToolsRpcClientCallEvent = BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$callEvent'];
+type DevToolsRpcClientCallOptional = BirpcReturn<DevToolsRpcServerFunctions, DevToolsRpcClientFunctions>['$callOptional'];
+interface DevToolsRpcClient {
+  /**
+   * The events of the client
+   */
+  events: EventEmitter<RpcClientEvents>;
+  /**
+   * Whether the client is trusted
+   */
+  readonly isTrusted: boolean | null;
+  /**
+   * The connection meta
+   */
+  readonly connectionMeta: ConnectionMeta;
+  /**
+   * Return a promise that resolves when the client is trusted
+   *
+   * Rejects with an error if the timeout is reached
+   *
+   * @param timeout - The timeout in milliseconds, default to 60 seconds
+   */
+  ensureTrusted: (timeout?: number) => Promise<boolean>;
+  /**
+   * Request trust from the server
+   */
+  requestTrust: () => Promise<boolean>;
+  /**
+   * Call a RPC function on the server
+   */
+  call: DevToolsRpcClientCall;
+  /**
+   * Call a RPC event on the server, and does not expect a response
+   */
+  callEvent: DevToolsRpcClientCallEvent;
+  /**
+   * Call a RPC optional function on the server
+   */
+  callOptional: DevToolsRpcClientCallOptional;
+  /**
+   * The client RPC host
+   */
+  client: DevToolsClientRpcHost;
+  /**
+   * The shared state host
+   */
+  sharedState: RpcSharedStateHost;
+}
+interface DevToolsRpcClientMode {
+  readonly isTrusted: boolean;
+  ensureTrusted: DevToolsRpcClient['ensureTrusted'];
+  requestTrust: DevToolsRpcClient['requestTrust'];
+  call: DevToolsRpcClient['call'];
+  callEvent: DevToolsRpcClient['callEvent'];
+  callOptional: DevToolsRpcClient['callOptional'];
+}
+declare function getDevToolsRpcClient(options?: DevToolsRpcClientOptions): Promise<DevToolsRpcClient>;
+//#endregion
+//#region src/client/docks.d.ts
+interface DockPanelStorage {
+  width: number;
+  height: number;
+  top: number;
+  left: number;
+  position: 'left' | 'right' | 'bottom' | 'top';
+  open: boolean;
+  inactiveTimeout: number;
+}
+type DockClientType = 'embedded' | 'standalone';
+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>;
+  groupedEntries: DevToolsDockEntriesGrouped;
+  settings: SharedState<DevToolsDocksUserSettings>;
+  /**
+   * 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>;
+  /**
+   * Toggle the selected dock entry
+   *
+   * @returns Whether the selection was changed successfully
+   */
+  toggleEntry: (id: string) => Promise<boolean>;
+}
+interface DockEntryState {
+  entryMeta: DevToolsDockEntry;
+  readonly isActive: boolean;
+  domElements: {
+    iframe?: HTMLIFrameElement | null;
+    panel?: HTMLDivElement | null;
+  };
+  events: 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 {
+  'rpc:is-trusted:updated': (isTrusted: boolean) => void;
+}
+//#endregion
+//#region 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;
+  /**
+   * Logs client scoped to this dock entry's source
+   */
+  logs: DevToolsLogsClient;
+}
+//#endregion
+export { DevToolsDockEntryIcon as $, RpcSharedStateGetOptions as A, DevToolsTerminalHost as B, PartialWithoutId as C, DevToolsNodeRpcSessionMeta as D, DevToolsNodeRpcSession as E, DevToolsNodeUtils as F, DevToolsRpcClientFunctions as G, DevToolsTerminalSessionBase as H, DevToolsPluginOptions as I, ClientScriptEntry as J, DevToolsRpcServerFunctions as K, DevToolsViewHost as L, ConnectionMeta as M, DevToolsCapabilities as N, RpcBroadcastOptions as O, DevToolsNodeContext as P, DevToolsDockEntryCategory as Q, DevToolsChildProcessExecuteOptions as R, EntriesToObject as S, DevToolsDocksUserSettings as T, DevToolsTerminalSessionStreamChunkEvent as U, DevToolsTerminalSession as V, DevToolsTerminalStatus as W, DevToolsDockEntry as X, DevToolsDockEntriesGrouped as Y, DevToolsDockEntryBase as Z, DevToolsRpcClientOptions as _, DockEntryState as a, DevToolsViewIframe as at, RpcDefinitionsToFunctions as b, DocksContext as c, DevToolsLogElementPosition as ct, RpcClientEvents as d, DevToolsLogEntryInput as dt, DevToolsDockHost as et, DevToolsRpcClient as f, DevToolsLogFilePosition as ft, DevToolsRpcClientMode as g, DevToolsLogsHost as gt, DevToolsRpcClientCallOptional as h, DevToolsLogsClient as ht, DockClientType as i, DevToolsViewCustomRender as it, RpcSharedStateHost as j, RpcFunctionsHost as k, DocksEntriesContext as l, DevToolsLogEntry as lt, DevToolsRpcClientCallEvent as m, DevToolsLogLevel as mt, DevToolsClientContext as n, DevToolsViewAction as nt, DockEntryStateEvents as o, DevToolsViewLauncher as ot, DevToolsRpcClientCall as p, DevToolsLogHandle as pt, DevToolsRpcSharedStates as q, DevToolsClientRpcHost as r, DevToolsViewBuiltin as rt, DockPanelStorage as s, DevToolsViewLauncherStatus as st, DockClientScriptContext as t, DevToolsDockUserEntry as tt, DocksPanelContext as u, DevToolsLogEntryFrom as ut, getDevToolsRpcClient as v, Thenable as w, PluginWithDevTools as x, RpcDefinitionsFilter as y, DevToolsChildProcessTerminalSession as z };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { C as DevToolsViewWebComponent, D as DevToolsRpcServerFunctions, E as DevToolsRpcClientFunctions, S as DevToolsViewIframe, T as Thenable, _ as DevToolsDockEntryBase, a as RpcDefinitionsToFunctions, b as DevToolsViewCustomRender, c as RpcFunctionType, d as DevToolsCapabilities, f as DevToolsNodeContext, g as DevToolsDockEntry, h as ClientScriptEntry, i as RpcDefinitionsFilter, l as RpcFunctionsHost, m as DevToolsPluginOptions, n as BirpcFn, o as RpcFunctionDefinition, p as DevToolsNodeUtils, r as BirpcReturn, s as RpcFunctionSetupResult, t as PluginWithDevTools, u as ConnectionMeta, v as DevToolsDockHost, w as EntriesToObject, x as DevToolsViewHost, y as DevToolsViewAction } from "./index-BtaHil_c.js";
+import { n as EventUnsubscribe, r as EventsMap, t as EventEmitter } from "./events-B41U-zeg.js";
+import { $ as DevToolsDockEntryIcon, A as RpcSharedStateGetOptions, B as DevToolsTerminalHost, C as PartialWithoutId, D as DevToolsNodeRpcSessionMeta, E as DevToolsNodeRpcSession, F as DevToolsNodeUtils, G as DevToolsRpcClientFunctions, H as DevToolsTerminalSessionBase, I as DevToolsPluginOptions, J as ClientScriptEntry, K as DevToolsRpcServerFunctions, L as DevToolsViewHost, M as ConnectionMeta, N as DevToolsCapabilities, O as RpcBroadcastOptions, P as DevToolsNodeContext, Q as DevToolsDockEntryCategory, R as DevToolsChildProcessExecuteOptions, S as EntriesToObject, T as DevToolsDocksUserSettings, U as DevToolsTerminalSessionStreamChunkEvent, V as DevToolsTerminalSession, W as DevToolsTerminalStatus, X as DevToolsDockEntry, Y as DevToolsDockEntriesGrouped, Z as DevToolsDockEntryBase, at as DevToolsViewIframe, b as RpcDefinitionsToFunctions, ct as DevToolsLogElementPosition, dt as DevToolsLogEntryInput, et as DevToolsDockHost, ft as DevToolsLogFilePosition, gt as DevToolsLogsHost, ht as DevToolsLogsClient, it as DevToolsViewCustomRender, j as RpcSharedStateHost, k as RpcFunctionsHost, lt as DevToolsLogEntry, mt as DevToolsLogLevel, nt as DevToolsViewAction, ot as DevToolsViewLauncher, pt as DevToolsLogHandle, q as DevToolsRpcSharedStates, rt as DevToolsViewBuiltin, st as DevToolsViewLauncherStatus, tt as DevToolsDockUserEntry, ut as DevToolsLogEntryFrom, w as Thenable, x as PluginWithDevTools, y as RpcDefinitionsFilter, z as DevToolsChildProcessTerminalSession } from "./index-Bl6l5FTi.js";
+import * as _vitejs_devtools_rpc0 from "@vitejs/devtools-rpc";
 
-//#region src/utils/rpc.d.ts
-declare function defineRpcFunction<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN>): RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN>;
-declare function getRpcHandler<NAME extends string, TYPE extends RpcFunctionType, ARGS extends any[], RETURN = void>(definition: RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN>, context: DevToolsNodeContext): Promise<(...args: ARGS) => RETURN>;
+//#region src/utils/define.d.ts
+declare const defineRpcFunction: <NAME extends string, TYPE extends _vitejs_devtools_rpc0.RpcFunctionType, ARGS extends any[], RETURN = void, const AS extends _vitejs_devtools_rpc0.RpcArgsSchema | undefined = undefined, const RS extends _vitejs_devtools_rpc0.RpcReturnSchema | undefined = undefined>(definition: _vitejs_devtools_rpc0.RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevToolsNodeContext>) => _vitejs_devtools_rpc0.RpcFunctionDefinition<NAME, TYPE, ARGS, RETURN, AS, RS, DevToolsNodeContext>;
 //#endregion
-export { BirpcFn, BirpcReturn, ClientScriptEntry, ConnectionMeta, DevToolsCapabilities, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockHost, DevToolsNodeContext, DevToolsNodeUtils, DevToolsPluginOptions, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsViewAction, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewWebComponent, EntriesToObject, PluginWithDevTools, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcFunctionDefinition, RpcFunctionSetupResult, RpcFunctionType, RpcFunctionsHost, Thenable, defineRpcFunction, getRpcHandler };
+export { ClientScriptEntry, ConnectionMeta, DevToolsCapabilities, DevToolsChildProcessExecuteOptions, DevToolsChildProcessTerminalSession, DevToolsDockEntriesGrouped, DevToolsDockEntry, DevToolsDockEntryBase, DevToolsDockEntryCategory, DevToolsDockEntryIcon, DevToolsDockHost, DevToolsDockUserEntry, DevToolsDocksUserSettings, DevToolsLogElementPosition, DevToolsLogEntry, DevToolsLogEntryFrom, DevToolsLogEntryInput, DevToolsLogFilePosition, DevToolsLogHandle, DevToolsLogLevel, DevToolsLogsClient, DevToolsLogsHost, DevToolsNodeContext, DevToolsNodeRpcSession, DevToolsNodeRpcSessionMeta, DevToolsNodeUtils, DevToolsPluginOptions, DevToolsRpcClientFunctions, DevToolsRpcServerFunctions, DevToolsRpcSharedStates, DevToolsTerminalHost, DevToolsTerminalSession, DevToolsTerminalSessionBase, DevToolsTerminalSessionStreamChunkEvent, DevToolsTerminalStatus, DevToolsViewAction, DevToolsViewBuiltin, DevToolsViewCustomRender, DevToolsViewHost, DevToolsViewIframe, DevToolsViewLauncher, DevToolsViewLauncherStatus, EntriesToObject, EventEmitter, EventUnsubscribe, EventsMap, PartialWithoutId, PluginWithDevTools, RpcBroadcastOptions, RpcDefinitionsFilter, RpcDefinitionsToFunctions, RpcFunctionsHost, RpcSharedStateGetOptions, RpcSharedStateHost, Thenable, defineRpcFunction };

package/dist/index.js

@@ -1,17 +1,5 @@
-//#region src/utils/rpc.ts
-function defineRpcFunction(definition) {
-	return definition;
-}
-async function getRpcHandler(definition, context) {
-	if (definition.handler) return definition.handler;
-	if (definition.__resolved?.handler) return definition.__resolved.handler;
-	definition.__promise ??= Promise.resolve(definition.setup(context)).then((r) => {
-		definition.__resolved = r;
-		definition.__promise = void 0;
-		return r;
-	});
-	return (definition.__resolved ??= await definition.__promise).handler;
-}
-
+import { createDefineWrapperWithContext } from "@vitejs/devtools-rpc";
+//#region src/utils/define.ts
+const defineRpcFunction = createDefineWrapperWithContext();
 //#endregion
-export { defineRpcFunction, getRpcHandler };
+export { defineRpcFunction };