snapshot of https://github.com/tauri-apps/tauri.git (dev, 2026-09-23; blobs > 131072B omitted)

crates/tauri/scripts/ipc.js

@@ -0,0 +1,210 @@
+// Copyright 2019-2024 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+/**
+ * @typedef {{callback: string, error: string, data: *}} IsolationPayload - a valid isolation payload
+ */
+
+;(function () {
+  /**
+   * @type {string}
+   */
+  const pattern = window.__TAURI_INTERNALS__.__TAURI_PATTERN__.pattern
+
+  /**
+   * @type {string}
+   */
+  const isolationOrigin = __TEMPLATE_isolation_origin__
+
+  /**
+   * @type {{queue: object[], ready: boolean, frame: HTMLElement | null}}
+   */
+  const isolation = Object.create(null)
+  isolation.queue = []
+  isolation.ready = false
+  isolation.frame = null
+
+  /**
+   * Detects if a message event is a valid isolation message.
+   *
+   * @param {MessageEvent<object>} event - a message event that is expected to be an isolation message
+   * @return {boolean} - if the event was a valid isolation message
+   */
+  function isIsolationMessage(event) {
+    if (
+      typeof event.data === 'object'
+      && typeof event.data.payload === 'object'
+    ) {
+      const keys = Object.keys(event.data.payload || {})
+      return (
+        keys.length > 0
+        && keys.every(
+          (key) => key === 'contentType' || key === 'nonce' || key === 'payload'
+        )
+      )
+    }
+    return false
+  }
+
+  /**
+   * Detects if data is able to transform into an isolation payload.
+   *
+   * @param {object} data - object that is expected to contain at least a callback and error identifier
+   * @return {boolean} - if the data is able to transform into an isolation payload
+   */
+  function isIsolationPayload(data) {
+    return (
+      typeof data === 'object'
+      && 'callback' in data
+      && 'error' in data
+      && !isIsolationMessage(data)
+    )
+  }
+
+  /**
+   * Sends a properly formatted message to the isolation frame.
+   *
+   * @param {IsolationPayload} data - data that has been validated to be an isolation payload
+   */
+  function sendIsolationMessage(data) {
+    // set the frame dom element if it's not been set before
+    if (!isolation.frame) {
+      const frame = document.querySelector('iframe#__tauri_isolation__')
+      if (frame.src.startsWith(isolationOrigin)) {
+        isolation.frame = frame
+      } else {
+        console.error(
+          'Tauri IPC found an isolation iframe, but it had the wrong origin'
+        )
+      }
+    }
+
+    // ensure we have the target to send the message to
+    if (!isolation.frame || !isolation.frame.contentWindow) {
+      console.error(
+        'Tauri "Isolation" Pattern could not find the Isolation iframe window'
+      )
+      return
+    }
+
+    // `postMessage` uses `structuredClone` to serialize the data before sending it
+    // unlike `JSON.stringify`, we can't extend a type with a method similar to `toJSON`
+    // so that `structuredClone` would use, so until https://github.com/whatwg/html/issues/7428
+    // we manually call `toIPC`
+    function serializeIpcPayload(data) {
+      // if this value changes, make sure to update it in:
+      // 1. process-ipc-message-fn.js
+      // 2. core.ts
+      const SERIALIZE_TO_IPC_FN = '__TAURI_TO_IPC_KEY__'
+
+      if (
+        typeof data === 'object'
+        && data !== null
+        && 'constructor' in data
+        && data.constructor === Array
+      ) {
+        return data.map((v) => serializeIpcPayload(v))
+      }
+
+      if (
+        typeof data === 'object'
+        && data !== null
+        && SERIALIZE_TO_IPC_FN in data
+      ) {
+        return data[SERIALIZE_TO_IPC_FN]()
+      }
+
+      if (
+        typeof data === 'object'
+        && data !== null
+        && 'constructor' in data
+        && data.constructor === Object
+      ) {
+        const acc = {}
+        Object.entries(data).forEach(([k, v]) => {
+          acc[k] = serializeIpcPayload(v)
+        })
+        return acc
+      }
+
+      return data
+    }
+
+    data.payload = serializeIpcPayload(data.payload)
+
+    isolation.frame.contentWindow.postMessage(
+      data,
+      '*' /* todo: set this to the secure origin */
+    )
+  }
+
+  Object.defineProperty(window.__TAURI_INTERNALS__, 'ipc', {
+    // todo: JSDoc this function
+    value: Object.freeze((message) => {
+      switch (pattern) {
+        case 'brownfield':
+          window.__TAURI_INTERNALS__.postMessage(message)
+          break
+
+        case 'isolation':
+          if (!isIsolationPayload(message)) {
+            console.error(
+              'Tauri "Isolation" Pattern found an invalid isolation message payload',
+              message
+            )
+            break
+          }
+
+          if (isolation.ready) {
+            sendIsolationMessage(message)
+          } else {
+            isolation.queue.push(message)
+          }
+
+          break
+
+        case 'error':
+          console.error(
+            'Tauri IPC found a Tauri Pattern, but it was an error. Check for other log messages to find the cause.'
+          )
+          break
+
+        default:
+          console.error(
+            'Tauri IPC did not find a Tauri Pattern that it understood.'
+          )
+          break
+      }
+    })
+  })
+
+  /**
+   * IMPORTANT: See isolation_secure.js for the isolation frame implementation.
+   * main frame -> isolation frame = isolation payload
+   * isolation frame -> main frame = isolation message
+   */
+  if (pattern === 'isolation') {
+    window.addEventListener(
+      'message',
+      (event) => {
+        // watch for the isolation frame being ready and flush any queued messages
+        if (event.data === '__TAURI_ISOLATION_READY__') {
+          isolation.ready = true
+
+          for (const message of isolation.queue) {
+            sendIsolationMessage(message)
+          }
+
+          isolation.queue = []
+          return
+        }
+
+        if (isIsolationMessage(event)) {
+          window.__TAURI_INTERNALS__.postMessage(event.data)
+        }
+      },
+      false
+    )
+  }
+})()