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

package/dist/{dirs-Z7VQHyIZ.js → dirs-BzX7rGLP.mjs}

@@ -4,4 +4,4 @@ import { fileURLToPath } from "node:url";
 const clientPublicDir = fileURLToPath(new URL("../dist/public", import.meta.url));
 
 //#endregion
-export { clientPublicDir };
+export { clientPublicDir as t };

package/dist/dirs.mjs

@@ -0,0 +1,3 @@
+import { t as clientPublicDir } from "./dirs-BzX7rGLP.mjs";
+
+export { clientPublicDir };

package/dist/index.d.mts

@@ -0,0 +1,407 @@
+import { RpcFunctionsCollector, RpcFunctionsCollectorBase } from "birpc-x";
+import { Plugin, ResolvedConfig, ViteDevServer } from "vite";
+import { Raw } from "vue";
+import { BirpcReturn } from "birpc";
+import { ChildProcess } from "node:child_process";
+
+//#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/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
+//#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;
+  }
+}
+interface PluginWithDevTools extends Plugin {
+  devtools?: DevToolsPluginOptions;
+}
+//#endregion
+//#region src/node/plugin.d.ts
+declare function DevToolsViteUI(): PluginWithDevTools;
+//#endregion
+export { DevToolsViteUI };