WebviewJS Shared Types, Interfaces, and Enums Reference

import { ControlFlow } from '@webviewjs/webview';

const app = new Application({ controlFlow: ControlFlow.Wait });

import { CursorType } from '@webviewjs/webview';

win.setCursor(CursorType.Hand);

import { FullscreenType } from '@webviewjs/webview';

win.setFullscreen(FullscreenType.Borderless);

import { ProgressBarState } from '@webviewjs/webview';

win.setProgressBar({ state: ProgressBarState.Normal, progress: 42 });

interface AndroidContentRect {
  left:   number;
  top:    number;
  right:  number;
  bottom: number;
}

// autoRun: true (default) — app.run() is called automatically after the promise resolves
{ autoRun?: true;  interval?: number; ref?: boolean }

// autoRun: false — you are responsible for calling app.run() yourself
{ autoRun: false }

interface Dimensions { width: number; height: number; }

interface HeaderData { key: string; value?: string; }

interface NativeNotificationAction { action: string; title: string; icon?: string; }

interface Position { x: number; y: number; }

interface WebviewBounds { x: number; y: number; width: number; height: number; }

interface WebviewPageLoadEvent      { event: number; url?: string; }
interface WebviewTitleChangedEvent  { event: number; title?: string; }
interface WebviewDownloadEvent      { event: number; url?: string; success?: boolean; }
interface WebviewDownloadStartedEvent extends WebviewDownloadEvent {}
interface WebviewNavigationEvent    { event: number; url?: string; }
interface WebviewNewWindowEvent     { event: number; url?: string; }

interface WindowBaseEvent   { event: number; }
interface WindowMoveEvent   { event: number; x: number; y: number; }
interface WindowResizeEvent { event: number; width: number; height: number; }

interface WindowMouseEvent  {
  event: number;
  x: number;
  y: number;
  button?: number;    // 0=left, 1=middle, 2=right
  modifiers?: number; // bitmask: 1=Shift, 2=Ctrl, 4=Alt, 8=Meta
}

interface WindowScrollEvent { event: number; deltaX: number; deltaY: number; }

interface WindowKeyEvent {
  event: number;
  key?: string;       // DOM KeyboardEvent.key, e.g. "a", "Enter", "ArrowLeft"
  code?: string;      // DOM KeyboardEvent.code, e.g. "KeyA", "ArrowLeft"
  modifiers?: number;
  isRepeat?: boolean;
}

interface WindowFileEvent   { event: number; files?: string[]; }
interface WindowScaleEvent  { event: number; scaleFactor: number; }
interface WindowThemeEvent  { event: number; text: 'light' | 'dark'; }

interface WindowImeEvent {
  event: number;
  text?: string;
  phase: 'enabled' | 'preedit' | 'commit' | 'disabled';
}

interface WindowTouchEvent {
  event: number;
  x: number;
  y: number;
  touchId: number;
  phase: 'started' | 'moved' | 'ended' | 'cancelled';
}

type JsonValue =
  | null
  | boolean
  | number
  | string
  | JsonValue[]
  | { [key: string]: JsonValue };

type ExposedTarget = Record<
  string,
  JsonValue | ((...args: any[]) => unknown | Promise<unknown>)
>;

type EventListener<TPayload> = (payload: TPayload) => void;

interface TypedEventEmitter<TEventMap extends object> {
  on(event: keyof TEventMap, listener: EventListener<...>): this;
  once(event: keyof TEventMap, listener: EventListener<...>): this;
  off(event: keyof TEventMap, listener: EventListener<...>): this;
  addListener(event: keyof TEventMap, listener: EventListener<...>): this;
  removeListener(event: keyof TEventMap, listener: EventListener<...>): this;
  removeAllListeners(event?: string | symbol): this;
  listenerCount(event: keyof TEventMap, listener?: EventListener<...>): number;
  listeners(event: keyof TEventMap): Array<EventListener<...>>;
  rawListeners(event: keyof TEventMap): Array<EventListener<...>>;
  emit(event: keyof TEventMap, payload: ...): boolean;
  eventNames(): Array<keyof TEventMap | string | symbol>;
}

class SerializationError extends Error {
  name: 'SerializationError';
}

interface BrowserWindowEventMap {
  move:                  WindowMoveEvent;
  resize:                WindowResizeEvent;
  close:                 WindowBaseEvent;
  focus:                 WindowBaseEvent;
  blur:                  WindowBaseEvent;
  'mouse-enter':         WindowMouseEvent;
  'mouse-leave':         WindowBaseEvent;
  'mouse-move':          WindowMouseEvent;
  'mouse-down':          WindowMouseEvent;
  'mouse-up':            WindowMouseEvent;
  scroll:                WindowScrollEvent;
  'key-down':            WindowKeyEvent;
  'key-up':              WindowKeyEvent;
  'file-drop':           WindowFileEvent;
  'file-hover':          WindowFileEvent;
  'file-hover-cancelled': WindowBaseEvent;
  'scale-factor-changed': WindowScaleEvent;
  'theme-changed':        WindowThemeEvent;
  ime:                   WindowImeEvent;
  touch:                 WindowTouchEvent;
}

interface ApplicationEventMap {
  'window-close-requested':      ApplicationEvent;
  'application-close-requested': ApplicationEvent;
  'custom-menu-click':           ApplicationEvent;
  'ready':                       ApplicationEvent;
}

interface TrayEventMap {
  click:        TrayEventPayload;
  'double-click': TrayEventPayload;
  enter:        TrayEventPayload;
  move:         TrayEventPayload;
  leave:        TrayEventPayload;
}

function getWebviewVersion(): string

import { getWebviewVersion } from '@webviewjs/webview';

console.log(getWebviewVersion()); // e.g. "0.44.0"

const VERSION: string

import { VERSION } from '@webviewjs/webview';

console.log(VERSION); // e.g. "0.4.2"