@reset-framework/sdk 0.2.0 → 1.0.1

package/src/errors.js

@@ -1,6 +1,33 @@
-export class ResetRuntimeUnavailableError extends Error {
-  constructor(message = "reset runtime is not available") {
+export class ResetRuntimeError extends Error {
+  constructor(message, options = {}) {
     super(message)
-    this.name = "ResetRuntimeUnavailableError"
+    this.name = new.target.name
+
+    if ("cause" in options) {
+      this.cause = options.cause
+    }
+  }
+}
+
+export class ResetRuntimeUnavailableError extends ResetRuntimeError {
+  constructor(message = "Reset runtime is not available in the current environment.") {
+    super(message)
+  }
+}
+
+export class ResetProtocolError extends ResetRuntimeError {
+  constructor(message, options = {}) {
+    super(message, options)
+    this.command = options.command
+  }
+}
+
+export class ResetInvocationError extends ResetRuntimeError {
+  constructor(command, message, response, options = {}) {
+    super(message, options)
+    this.command = command
+    this.code = response?.code
+    this.details = response?.details
+    this.response = response
   }
 }

package/src/events.js

@@ -0,0 +1,123 @@
+function getDefaultWindowTarget() {
+  if (typeof window === "undefined") {
+    return undefined
+  }
+
+  return window
+}
+
+function getState(target = getDefaultWindowTarget()) {
+  if (!target) {
+    return null
+  }
+
+  if (!target.__resetEventState) {
+    const listeners = new Map()
+
+    target.__resetEventState = {
+      listeners,
+      dispatch(envelope) {
+        const eventName = typeof envelope?.event === "string" ? envelope.event : ""
+        if (eventName === "") {
+          return
+        }
+
+        const handlers = listeners.get(eventName)
+        if (!handlers) {
+          return
+        }
+
+        for (const handler of [...handlers]) {
+          handler(envelope.payload)
+        }
+      }
+    }
+
+    Object.defineProperty(target, "__resetDispatchEvent", {
+      value: (envelope) => target.__resetEventState.dispatch(envelope),
+      configurable: false,
+      enumerable: false,
+      writable: false
+    })
+  }
+
+  return target.__resetEventState
+}
+
+export function listen(eventName, handler, target = getDefaultWindowTarget()) {
+  if (typeof eventName !== "string" || eventName.trim() === "") {
+    throw new TypeError("Reset event name must be a non-empty string.")
+  }
+
+  if (typeof handler !== "function") {
+    throw new TypeError("Reset event handler must be a function.")
+  }
+
+  const state = getState(target)
+  if (!state) {
+    return () => {}
+  }
+
+  const handlers = state.listeners.get(eventName) ?? new Set()
+  handlers.add(handler)
+  state.listeners.set(eventName, handlers)
+
+  return () => {
+    const current = state.listeners.get(eventName)
+    if (!current) {
+      return
+    }
+
+    current.delete(handler)
+    if (current.size === 0) {
+      state.listeners.delete(eventName)
+    }
+  }
+}
+
+export function once(eventName, handler, target = getDefaultWindowTarget()) {
+  let dispose = () => {}
+
+  dispose = listen(
+    eventName,
+    (payload) => {
+      dispose()
+      handler(payload)
+    },
+    target
+  )
+
+  return dispose
+}
+
+export function emitLocal(eventName, payload, target = getDefaultWindowTarget()) {
+  const state = getState(target)
+  if (!state) {
+    return
+  }
+
+  state.dispatch({
+    event: eventName,
+    payload
+  })
+}
+
+export function createEventApi(transport, target = getDefaultWindowTarget()) {
+  return Object.freeze({
+    listen(eventName, handler) {
+      return listen(eventName, handler, target)
+    },
+    once(eventName, handler) {
+      return once(eventName, handler, target)
+    },
+    emitLocal(eventName, payload) {
+      emitLocal(eventName, payload, target)
+    },
+    emit(eventName, payload = null) {
+      return transport.invoke("event.emit", {
+        event: eventName,
+        payload
+      })
+    }
+  })
+}

package/src/index.d.ts

@@ -6,12 +6,18 @@ export type ResetInvokeSuccess<T = unknown> = {
 export type ResetInvokeError = {
   ok: false;
   error: string;
+  code?: string;
+  details?: unknown;
 };
 
 export type ResetInvokeResponse<T = unknown> =
   | ResetInvokeSuccess<T>
   | ResetInvokeError;
 
+export type ResetPlatform = "macos" | "windows" | "linux" | "unknown";
+
+export type ResetArchitecture = "arm64" | "x64" | "x86" | "unknown";
+
 export interface ResetRuntime {
   invoke<T = unknown>(
     command: string,
@@ -21,41 +27,519 @@ export interface ResetRuntime {
 
 export interface ResetRuntimeWindow {
   reset?: ResetRuntime;
+  __resetEventState?: {
+    listeners: Map<string, Set<(payload: unknown) => void>>;
+    dispatch(envelope: { event: string; payload: unknown }): void;
+  };
+  __resetDispatchEvent?: (envelope: { event: string; payload: unknown }) => void;
+}
+
+export interface ResetRuntimeSourceOptions {
+  target?: ResetRuntimeWindow;
+  runtime?: ResetRuntime;
+  resolveRuntime?: () => ResetRuntime | undefined;
+}
+
+export type ResetRuntimeSource =
+  | ResetRuntime
+  | ResetRuntimeWindow
+  | ResetRuntimeSourceOptions
+  | (() => ResetRuntime | undefined)
+  | undefined;
+
+export interface ResetTransport {
+  isAvailable(): boolean;
+  getRuntime(): ResetRuntime;
+  invokeRaw<T = unknown>(
+    command: string,
+    payload?: unknown
+  ): Promise<ResetInvokeResponse<T>>;
+  invoke<T = unknown>(command: string, payload?: unknown): Promise<T>;
+}
+
+export interface ResetCommandApi {
+  invoke<T = unknown>(command: string, payload?: unknown): Promise<T>;
+  invokeRaw<T = unknown>(
+    command: string,
+    payload?: unknown
+  ): Promise<ResetInvokeResponse<T>>;
+}
+
+export interface ResetAppInfo {
+  id: string;
+  name: string;
+  slug: string;
+  version: string;
+  windowTitle: string;
+}
+
+export interface ResetPoint {
+  x: number;
+  y: number;
+}
+
+export interface ResetSize {
+  width: number;
+  height: number;
+}
+
+export interface ResetRect extends ResetPoint, ResetSize {}
+
+export interface ResetWindowInfo {
+  id: string;
+  title: string;
+  frame: ResetRect;
+  position: ResetPoint;
+  size: ResetSize;
+  visible: boolean;
+  focused: boolean;
+  minimized: boolean;
+  maximized: boolean;
+  resizable: boolean;
+}
+
+export interface ResetDisplayInfo {
+  id: string;
+  frame: ResetRect;
+  visibleFrame: ResetRect;
+  scaleFactor: number;
+}
+
+export interface ResetRuntimeInfo {
+  platform: ResetPlatform;
+  arch: ResetArchitecture;
+  frameworkVersion: string;
+  bridgeVersion: string;
+  debug: boolean;
+}
+
+export interface ResetCommandDescriptor {
+  command: string;
+  permission: string;
+}
+
+export interface ResetCapabilitiesInfo {
+  commands: ReadonlyArray<ResetCommandDescriptor>;
+  permissions: ReadonlyArray<string>;
+}
+
+export interface ResetAppApi {
+  getId(): Promise<string>;
+  getName(): Promise<string>;
+  getSlug(): Promise<string>;
+  getVersion(): Promise<string>;
+  getInfo(): Promise<ResetAppInfo>;
+  show(): Promise<{ visible: boolean }>;
+  hide(): Promise<{ hidden: boolean }>;
+  quit(): Promise<{ quitting: boolean }>;
+  relaunch(): Promise<{ relaunching: boolean }>;
+}
+
+export interface ResetRuntimeApi {
+  getPlatform(): Promise<ResetPlatform>;
+  getArchitecture(): Promise<ResetArchitecture>;
+  getFrameworkVersion(): Promise<string>;
+  getBridgeVersion(): Promise<string>;
+  getInfo(): Promise<ResetRuntimeInfo>;
+  getCapabilities(): Promise<ResetCapabilitiesInfo>;
+}
+
+export interface ResetWindowApi {
+  getCurrent(): Promise<ResetWindowInfo>;
+  getInfo(): Promise<ResetWindowInfo>;
+  list(): Promise<{ windows: ResetWindowInfo[] }>;
+  show(): Promise<ResetWindowInfo>;
+  hide(): Promise<ResetWindowInfo>;
+  focus(): Promise<ResetWindowInfo>;
+  close(): Promise<{ closed: boolean }>;
+  minimize(): Promise<ResetWindowInfo>;
+  maximize(): Promise<ResetWindowInfo>;
+  center(): Promise<ResetWindowInfo>;
+  setTitle(title: string): Promise<ResetWindowInfo>;
+  setSize(width: number, height: number): Promise<ResetWindowInfo>;
+  setResizable(resizable: boolean): Promise<ResetWindowInfo>;
+}
+
+export interface ResetDialogOpenFileOptions {
+  title?: string;
+  multiple?: boolean;
+  directory?: boolean;
+}
+
+export interface ResetDialogSaveFileOptions {
+  title?: string;
+  defaultPath?: string;
+}
+
+export interface ResetDialogApi {
+  openFile(options?: ResetDialogOpenFileOptions): Promise<{
+    canceled: boolean;
+    paths: string[];
+  }>;
+  saveFile(options?: ResetDialogSaveFileOptions): Promise<{
+    canceled: boolean;
+    path?: string;
+  }>;
+  message(title: string, message: string): Promise<{ confirmed: boolean }>;
+  confirm(title: string, message: string): Promise<{ confirmed: boolean }>;
+}
+
+export interface ResetDirectoryEntry {
+  name: string;
+  path: string;
+  kind: "file" | "directory" | "symlink" | "other";
+}
+
+export interface ResetFsApi {
+  readTextFile(path: string): Promise<string>;
+  writeTextFile(
+    path: string,
+    text: string,
+    options?: { createDirectories?: boolean }
+  ): Promise<{ written: boolean }>;
+  exists(path: string): Promise<boolean>;
+  mkdir(
+    path: string,
+    options?: { recursive?: boolean }
+  ): Promise<{ created: boolean }>;
+  remove(
+    path: string,
+    options?: { recursive?: boolean }
+  ): Promise<{ removed: boolean; count: number }>;
+  rename(from: string, to: string): Promise<{ renamed: boolean }>;
+  readDir(path: string): Promise<ResetDirectoryEntry[]>;
+}
+
+export interface ResetPathInfo {
+  homeDir: string;
+  tempDir: string;
+  appDataDir: string;
+  appConfigDir: string;
+  cacheDir: string;
+}
+
+export interface ResetPathApi {
+  join(...segments: string[]): Promise<string>;
+  basename(path: string): Promise<string>;
+  dirname(path: string): Promise<string>;
+  resolve(path: string, base?: string): Promise<string>;
+  getHomeDir(): Promise<string>;
+  getTempDir(): Promise<string>;
+  getAppDataDir(): Promise<string>;
+  getAppConfigDir(): Promise<string>;
+  getCacheDir(): Promise<string>;
+  getInfo(): Promise<ResetPathInfo>;
+}
+
+export interface ResetShellApi {
+  openExternal(url: string): Promise<{ opened: boolean }>;
+  openPath(path: string): Promise<{ opened: boolean }>;
+  showItemInFolder(path: string): Promise<{ shown: boolean }>;
+}
+
+export interface ResetClipboardApi {
+  readText(): Promise<string>;
+  writeText(text: string): Promise<{ written: boolean }>;
+}
+
+export interface ResetNotificationApi {
+  isSupported(): Promise<boolean>;
+  requestPermission(): Promise<{
+    supported: boolean;
+    authorized: boolean;
+    status: string;
+  }>;
+  show(options: { title: string; body?: string }): Promise<{
+    shown: boolean;
+    authorized: boolean;
+    id?: string;
+  }>;
+}
+
+export interface ResetScreenApi {
+  getCursorPosition(): Promise<ResetPoint>;
+  getPrimaryDisplay(): Promise<ResetDisplayInfo | null>;
+  getDisplays(): Promise<ResetDisplayInfo[]>;
+}
+
+export interface ResetStorageApi {
+  get<T = unknown>(key: string): Promise<T | null>;
+  set(key: string, value: unknown): Promise<{ key: string; stored: boolean }>;
+  remove(key: string): Promise<{ key: string; removed: boolean }>;
+  clear(): Promise<{ cleared: boolean }>;
+  getAll(): Promise<Record<string, unknown>>;
+}
+
+export interface ResetWebViewInfo {
+  title: string;
+  url: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  loading: boolean;
+  estimatedProgress: number;
+}
+
+export interface ResetWebViewApi {
+  getInfo(): Promise<ResetWebViewInfo>;
+  reload(): Promise<ResetWebViewInfo>;
+  goBack(): Promise<ResetWebViewInfo>;
+  goForward(): Promise<ResetWebViewInfo>;
+  navigate(options: { url?: string; path?: string }): Promise<ResetWebViewInfo>;
+  setZoomFactor(factor: number): Promise<ResetWebViewInfo>;
+}
+
+export interface ResetCryptoApi {
+  getInfo(): Promise<{
+    supported: boolean;
+    encodings: string[];
+    maxRandomBytes: number;
+  }>;
+  randomBytes(
+    size: number,
+    options?: { encoding?: "hex" | "base64url" }
+  ): Promise<{
+    size: number;
+    encoding: "hex" | "base64url";
+    value: string;
+  }>;
+  randomUuid(): Promise<string>;
+}
+
+export interface ResetProcessInfo {
+  pid: number;
+  cwd: string;
+  platform: ResetPlatform;
+  arch: ResetArchitecture;
+  debug: boolean;
+}
+
+export interface ResetProcessApi {
+  getPid(): Promise<number>;
+  getCwd(): Promise<string>;
+  getInfo(): Promise<ResetProcessInfo>;
+}
+
+export interface ResetPowerInfo {
+  supported: boolean;
+  lowPowerMode: boolean;
+  thermalState: string;
+}
+
+export interface ResetPowerApi {
+  getInfo(): Promise<ResetPowerInfo>;
+}
+
+export interface ResetSupportInfo {
+  supported: boolean;
+  module: string;
+  platform: ResetPlatform | string;
+}
+
+export interface ResetMenuInfo extends ResetSupportInfo {
+  installed: boolean;
+  topLevelCount: number;
+}
+
+export interface ResetTrayInfo extends ResetSupportInfo {
+  created: boolean;
+  title: string;
+  tooltip: string;
+  hasMenu: boolean;
+}
+
+export interface ResetMenuItem {
+  id?: string;
+  label?: string;
+  enabled?: boolean;
+  checked?: boolean;
+  separator?: boolean;
+  submenu?: ResetMenuItem[];
+}
+
+export interface ResetMenuApi {
+  getInfo(): Promise<ResetMenuInfo>;
+  setApplicationMenu(items: ResetMenuItem[]): Promise<ResetMenuInfo>;
+  clearApplicationMenu(): Promise<ResetMenuInfo>;
+}
+
+export interface ResetTrayApi {
+  getInfo(): Promise<ResetTrayInfo>;
+  create(options?: {
+    title?: string;
+    tooltip?: string;
+    items?: ResetMenuItem[];
+  }): Promise<ResetTrayInfo>;
+  setTitle(title: string): Promise<ResetTrayInfo>;
+  setTooltip(tooltip: string): Promise<ResetTrayInfo>;
+  setMenu(items: ResetMenuItem[]): Promise<ResetTrayInfo>;
+  destroy(): Promise<{ destroyed: boolean }>;
+}
+
+export interface ResetShortcutApi {
+  getInfo(): Promise<ResetSupportInfo>;
+  register(accelerator: string): Promise<unknown>;
+  unregister(accelerator: string): Promise<unknown>;
+  unregisterAll(): Promise<unknown>;
+}
+
+export interface ResetProtocolApi {
+  getInfo(): Promise<ResetSupportInfo>;
+  register(options?: {
+    scheme?: string;
+  }): Promise<unknown>;
+  unregister(options?: {
+    scheme?: string;
+  }): Promise<unknown>;
+}
+
+export interface ResetUpdaterApi {
+  getInfo(): Promise<ResetSupportInfo>;
+  check(options?: Record<string, unknown>): Promise<unknown>;
+  download(options?: Record<string, unknown>): Promise<unknown>;
+  install(options?: Record<string, unknown>): Promise<unknown>;
+}
+
+export interface ResetNetResponse {
+  url: string;
+  status: number;
+  ok: boolean;
+  headers: Record<string, string>;
+  body: string;
+  bodyEncoding: "utf8" | "base64" | string;
+}
+
+export interface ResetNetApi {
+  request(options: {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+  }): Promise<ResetNetResponse>;
+}
+
+export interface ResetClient {
+  isAvailable(): boolean;
+  getRuntime(): ResetRuntime;
+  commands: ResetCommandApi;
+  app: ResetAppApi;
+  runtime: ResetRuntimeApi;
+  events: ResetEventApi;
+  window: ResetWindowApi;
+  dialog: ResetDialogApi;
+  fs: ResetFsApi;
+  path: ResetPathApi;
+  shell: ResetShellApi;
+  clipboard: ResetClipboardApi;
+  notification: ResetNotificationApi;
+  screen: ResetScreenApi;
+  storage: ResetStorageApi;
+  webview: ResetWebViewApi;
+  crypto: ResetCryptoApi;
+  process: ResetProcessApi;
+  power: ResetPowerApi;
+  menu: ResetMenuApi;
+  tray: ResetTrayApi;
+  shortcut: ResetShortcutApi;
+  protocol: ResetProtocolApi;
+  updater: ResetUpdaterApi;
+  net: ResetNetApi;
+}
+
+export interface ResetEventApi {
+  listen<T = unknown>(
+    eventName: string,
+    handler: (payload: T) => void
+  ): () => void;
+  once<T = unknown>(
+    eventName: string,
+    handler: (payload: T) => void
+  ): () => void;
+  emitLocal<T = unknown>(eventName: string, payload: T): void;
+  emit<T = unknown>(eventName: string, payload?: T): Promise<{
+    delivered: boolean;
+    event: string;
+  }>;
 }
 
 declare global {
   interface Window extends ResetRuntimeWindow {}
 }
 
-export class ResetRuntimeUnavailableError extends Error {
+export class ResetRuntimeError extends Error {
+  cause?: unknown;
+  constructor(message?: string, options?: { cause?: unknown });
+}
+
+export class ResetRuntimeUnavailableError extends ResetRuntimeError {
   constructor(message?: string);
 }
 
+export class ResetProtocolError extends ResetRuntimeError {
+  command?: string;
+  constructor(message?: string, options?: { command?: string; cause?: unknown });
+}
+
+export class ResetInvocationError extends ResetRuntimeError {
+  command: string;
+  response: ResetInvokeError;
+  code?: string;
+  details?: unknown;
+  constructor(
+    command: string,
+    message: string,
+    response: ResetInvokeError,
+    options?: { cause?: unknown }
+  );
+}
+
 export function isResetRuntimeAvailable(
-  target?: ResetRuntimeWindow
+  source?: ResetRuntimeSource
 ): boolean;
 
 export function getResetRuntime(
-  target?: ResetRuntimeWindow
+  source?: ResetRuntimeSource
 ): ResetRuntime;
 
+export function createResetTransport(
+  source?: ResetRuntimeSource
+): ResetTransport;
+
 export function invokeRaw<T = unknown>(
   command: string,
   payload?: unknown,
-  target?: ResetRuntimeWindow
+  source?: ResetRuntimeSource
 ): Promise<ResetInvokeResponse<T>>;
 
 export function invoke<T = unknown>(
   command: string,
   payload?: unknown,
-  target?: ResetRuntimeWindow
+  source?: ResetRuntimeSource
 ): Promise<T>;
 
-export function createResetClient(target?: ResetRuntimeWindow): {
-  isAvailable(): boolean;
-  invoke<T = unknown>(command: string, payload?: unknown): Promise<T>;
-  invokeRaw<T = unknown>(
-    command: string,
-    payload?: unknown
-  ): Promise<ResetInvokeResponse<T>>;
-};
+export function createResetClient(source?: ResetRuntimeSource): ResetClient;
+
+export const reset: ResetClient;
+export const commands: ResetCommandApi;
+export const app: ResetAppApi;
+export const runtime: ResetRuntimeApi;
+export const events: ResetEventApi;
+export const window: ResetWindowApi;
+export const dialog: ResetDialogApi;
+export const fs: ResetFsApi;
+export const path: ResetPathApi;
+export const shell: ResetShellApi;
+export const clipboard: ResetClipboardApi;
+export const notification: ResetNotificationApi;
+export const screen: ResetScreenApi;
+export const storage: ResetStorageApi;
+export const webview: ResetWebViewApi;
+export const crypto: ResetCryptoApi;
+export const process: ResetProcessApi;
+export const power: ResetPowerApi;
+export const menu: ResetMenuApi;
+export const tray: ResetTrayApi;
+export const shortcut: ResetShortcutApi;
+export const protocol: ResetProtocolApi;
+export const updater: ResetUpdaterApi;
+export const net: ResetNetApi;