Release build 4.38.0 [ci release]

Author: shakyShane

Sources/ContentScopeScripts/dist/contentScope.js

@@ -867,6 +867,207 @@
     };
   }
 
+  // ../messaging/lib/android.js
+  var AndroidMessagingTransport = class {
+    /**
+     * @param {AndroidMessagingConfig} config
+     * @param {import('../index.js').MessagingContext} messagingContext
+     * @internal
+     */
+    constructor(config, messagingContext) {
+      this.messagingContext = messagingContext;
+      this.config = config;
+    }
+    /**
+     * @param {import('../index.js').NotificationMessage} msg
+     */
+    notify(msg) {
+      try {
+        this.config.sendMessageThrows?.(JSON.stringify(msg));
+      } catch (e) {
+        console.error(".notify failed", e);
+      }
+    }
+    /**
+     * @param {import('../index.js').RequestMessage} msg
+     * @return {Promise<any>}
+     */
+    request(msg) {
+      return new Promise((resolve, reject) => {
+        const unsub = this.config.subscribe(msg.id, handler);
+        try {
+          this.config.sendMessageThrows?.(JSON.stringify(msg));
+        } catch (e) {
+          unsub();
+          reject(new Error("request failed to send: " + e.message || "unknown error"));
+        }
+        function handler(data) {
+          if (isResponseFor(msg, data)) {
+            if (data.result) {
+              resolve(data.result || {});
+              return unsub();
+            }
+            if (data.error) {
+              reject(new Error(data.error.message));
+              return unsub();
+            }
+            unsub();
+            throw new Error("unreachable: must have `result` or `error` key by this point");
+          }
+        }
+      });
+    }
+    /**
+     * @param {import('../index.js').Subscription} msg
+     * @param {(value: unknown | undefined) => void} callback
+     */
+    subscribe(msg, callback) {
+      const unsub = this.config.subscribe(msg.subscriptionName, (data) => {
+        if (isSubscriptionEventFor(msg, data)) {
+          callback(data.params || {});
+        }
+      });
+      return () => {
+        unsub();
+      };
+    }
+  };
+  var AndroidMessagingConfig = class {
+    /** @type {(json: string, secret: string) => void} */
+    _capturedHandler;
+    /**
+     * @param {object} params
+     * @param {Record<string, any>} params.target
+     * @param {boolean} params.debug
+     * @param {string} params.secret - a secret to ensure that messages are only
+     * processed by the correct handler
+     * @param {string} params.javascriptInterface - the name of the javascript interface
+     * registered on the native side
+     * @param {string} params.messageCallback - the name of the callback that the native
+     * side will use to send messages back to the javascript side
+     */
+    constructor(params) {
+      this.target = params.target;
+      this.debug = params.debug;
+      this.javascriptInterface = params.javascriptInterface;
+      this.secret = params.secret;
+      this.messageCallback = params.messageCallback;
+      this.listeners = new globalThis.Map();
+      this._captureGlobalHandler();
+      this._assignHandlerMethod();
+    }
+    /**
+     * The transport can call this to transmit a JSON payload along with a secret
+     * to the native Android handler.
+     *
+     * Note: This can throw - it's up to the transport to handle the error.
+     *
+     * @type {(json: string) => void}
+     * @throws
+     * @internal
+     */
+    sendMessageThrows(json) {
+      this._capturedHandler(json, this.secret);
+    }
+    /**
+     * A subscription on Android is just a named listener. All messages from
+     * android -> are delivered through a single function, and this mapping is used
+     * to route the messages to the correct listener.
+     *
+     * Note: Use this to implement request->response by unsubscribing after the first
+     * response.
+     *
+     * @param {string} id
+     * @param {(msg: MessageResponse | SubscriptionEvent) => void} callback
+     * @returns {() => void}
+     * @internal
+     */
+    subscribe(id, callback) {
+      this.listeners.set(id, callback);
+      return () => {
+        this.listeners.delete(id);
+      };
+    }
+    /**
+     * Accept incoming messages and try to deliver it to a registered listener.
+     *
+     * This code is defensive to prevent any single handler from affecting another if
+     * it throws (producer interference).
+     *
+     * @param {MessageResponse | SubscriptionEvent} payload
+     * @internal
+     */
+    _dispatch(payload) {
+      if (!payload)
+        return this._log("no response");
+      if ("id" in payload) {
+        if (this.listeners.has(payload.id)) {
+          this._tryCatch(() => this.listeners.get(payload.id)?.(payload));
+        } else {
+          this._log("no listeners for ", payload);
+        }
+      }
+      if ("subscriptionName" in payload) {
+        if (this.listeners.has(payload.subscriptionName)) {
+          this._tryCatch(() => this.listeners.get(payload.subscriptionName)?.(payload));
+        } else {
+          this._log("no subscription listeners for ", payload);
+        }
+      }
+    }
+    /**
+     *
+     * @param {(...args: any[]) => any} fn
+     * @param {string} [context]
+     */
+    _tryCatch(fn, context = "none") {
+      try {
+        return fn();
+      } catch (e) {
+        if (this.debug) {
+          console.error("AndroidMessagingConfig error:", context);
+          console.error(e);
+        }
+      }
+    }
+    /**
+     * @param {...any} args
+     */
+    _log(...args) {
+      if (this.debug) {
+        console.log("AndroidMessagingConfig", ...args);
+      }
+    }
+    /**
+     * Capture the global handler and remove it from the global object.
+     */
+    _captureGlobalHandler() {
+      const { target, javascriptInterface } = this;
+      if (Object.prototype.hasOwnProperty.call(target, javascriptInterface)) {
+        this._capturedHandler = target[javascriptInterface].process.bind(target[javascriptInterface]);
+        delete target[javascriptInterface];
+      } else {
+        this._capturedHandler = () => {
+          this._log("Android messaging interface not available", javascriptInterface);
+        };
+      }
+    }
+    /**
+     * Assign the incoming handler method to the global object.
+     * This is the method that Android will call to deliver messages.
+     */
+    _assignHandlerMethod() {
+      const responseHandler = (providedSecret, response) => {
+        if (providedSecret === this.secret) {
+          this._dispatch(response);
+        }
+      };
+      Object.defineProperty(this.target, this.messageCallback, {
+        value: responseHandler
+      });
+    }
+  };
+
   // ../messaging/index.js
   var MessagingContext = class {
     /**
@@ -885,7 +1086,7 @@
   var Messaging = class {
     /**
      * @param {MessagingContext} messagingContext
-     * @param {WebkitMessagingConfig | WindowsMessagingConfig | TestTransportConfig} config
+     * @param {WebkitMessagingConfig | WindowsMessagingConfig | AndroidMessagingConfig | TestTransportConfig} config
      */
     constructor(messagingContext, config) {
       this.messagingContext = messagingContext;
@@ -986,6 +1187,9 @@
     if (config instanceof WindowsMessagingConfig) {
       return new WindowsMessagingTransport(config, messagingContext);
     }
+    if (config instanceof AndroidMessagingConfig) {
+      return new AndroidMessagingTransport(config, messagingContext);
+    }
     if (config instanceof TestTransportConfig) {
       return new TestTransport(config, messagingContext);
     }