Class DirectIpcRenderer<TMessageMap, TInvokeMap, TIdentifierStrings>

Readonlythrottled

// High-frequency position updates (throttled)
directIpc.throttled.sendToIdentifier('output', 'position-update', x, y)

// Important events (not throttled)
directIpc.sendToIdentifier('output', 'button-clicked')
Copy

closeAllPorts

• closeAllPorts(): void

  Close all cached ports

  Returns void

invoke

• invoke<T extends string | number | symbol>(
      target: Omit<
          TargetSelector<TIdentifierStrings>,
          "allIdentifiers" | "allUrls",
      >,
      channel: T,
      ...args: [
          ...params: (TInvokeMap[T] extends (...args: P) => any ? P : never)[],
          options?: InvokeOptions,
      ],
  ): Promise<
      TInvokeMap[T] extends (...args: any[]) => R ? Awaited<R> : unknown,
  >

  Invoke a handler on a remote renderer using a TargetSelector Note: Only single-target selectors are supported (not allIdentifiers/allUrls)

  Type Parameters

  • T extends string | number | symbol

  Parameters

  • target: Omit<TargetSelector<TIdentifierStrings>, "allIdentifiers" | "allUrls">
  • channel: T
  • ...args: [
        ...params: (TInvokeMap[T] extends (...args: P) => any ? P : never)[],
        options?: InvokeOptions,
    ]

  Returns Promise<TInvokeMap[T] extends (...args: any[]) => R ? Awaited<R> : unknown>

  Example

  // Invoke on specific webContentsId
  const result = await directIpc.invoke({ webContentsId: 123 }, 'get-data', arg1, arg2)
  
  // Invoke on identifier (throws if multiple matches)
  const result = await directIpc.invoke({ identifier: 'output' }, 'get-data', arg1, arg2)
  
  // Invoke on URL pattern (throws if multiple matches)
  const result = await directIpc.invoke({ url: /^https://example/ }, 'get-data', arg1, arg2)
  
  // With timeout option
  const result = await directIpc.invoke({ identifier: 'output' }, 'get-data', arg1, { timeout: 5000 })
  Copy

refreshMap

• refreshMap(): Promise<DirectIpcTarget[]>

  Manually refresh the map from main process

  Returns Promise<DirectIpcTarget[]>

resolveTargetToWebContentsId

• resolveTargetToWebContentsId(
      target: {
          identifier?: RegExp | TIdentifierStrings;
          url?: string | RegExp;
          webContentsId?: number;
      },
  ): number
  | undefined

  Resolve a target to its webContentsId using the local map

  Parameters

  • target: {
        identifier?: RegExp | TIdentifierStrings;
        url?: string | RegExp;
        webContentsId?: number;
    }

  Returns number | undefined

  Deprecated

  Use resolveTargetToProcessId instead

send

• send<T extends string | number | symbol>(
      target: TargetSelector<TIdentifierStrings>,
      message: T,
      ...args: TMessageMap[T] extends (...args: P) => any ? P : never,
  ): Promise<void>

  Send a message to target renderer(s) using a TargetSelector

  Type Parameters

  • T extends string | number | symbol

  Parameters

  • target: TargetSelector<TIdentifierStrings>
  • message: T
  • ...args: TMessageMap[T] extends (...args: P) => any ? P : never

  Returns Promise<void>

  Example

  // Send to specific webContentsId
  await directIpc.send({ webContentsId: 123 }, 'my-message', arg1, arg2)
  
  // Send to single identifier (throws if multiple matches)
  await directIpc.send({ identifier: 'output' }, 'my-message', arg1, arg2)
  
  // Send to single URL pattern (throws if multiple matches)
  await directIpc.send({ url: /^https://example/ }, 'my-message', arg1, arg2)
  
  // Send to all matching identifiers
  await directIpc.send({ allIdentifiers: /^output/ }, 'my-message', arg1, arg2)
  
  // Send to all matching URLs
  await directIpc.send({ allUrls: 'https://example.com' }, 'my-message', arg1, arg2)
  Copy

setIdentifier

• setIdentifier(identifier: TIdentifierStrings): Promise<void>

  Set or update this renderer's identifier

  Parameters

  • identifier: TIdentifierStrings

    The identifier string to set (must be one of TIdentifierStrings)

  Returns Promise<void>

Staticinstance

• instance<
      TMessageMap extends EventMap = EventMap,
      TInvokeMap extends InvokeMap = InvokeMap,
      TProcessIdentifier extends string = string,
  >(
      options?: DirectIpcRendererOptions<TProcessIdentifier>,
  ): DirectIpcRenderer<TMessageMap, TInvokeMap, TProcessIdentifier>

  Get the singleton instance If identifier is provided, sets/updates the identifier

  Type Parameters

  • TMessageMap extends EventMap = EventMap

    Map of message channels to their handler function signatures

  • TInvokeMap extends InvokeMap = InvokeMap

    Map of invoke channels to their handler function signatures

  • TProcessIdentifier extends string = string

    Union of allowed identifier strings for type-safe identifier usage

  Parameters

  • Optionaloptions: DirectIpcRendererOptions<TProcessIdentifier>

  Returns DirectIpcRenderer<TMessageMap, TInvokeMap, TProcessIdentifier>