deps: remove deprecated content-scope-utils

integration-test/helpers/mocks.android.js

@@ -197,7 +197,6 @@ export function createAndroidMocks () {
                     },
                     storeFormData (request) {
                         /** @type {MockCall} */
-                        // @ts-expect-error
                         const call = ['storeFormData', request, mocks.getAutofillData]
                         window.__playwright_autofill.mocks.calls.push(JSON.parse(JSON.stringify(call)))
                     }

integration-test/helpers/pages.js

@@ -31,7 +31,7 @@
             await expect(getCallToAction()).toBeHidden()
         }
         async getEmailProtection () {
             (await getCallToAction()).click({timeout: 500})
         }
         async dismissTooltipWith (text) {
             const dismissTooltipButton = await page.locator(`text=${text}`)
@@ -39,7 +39,7 @@
         }
         async closeTooltip () {
             const dismissTooltipButton = await page.locator(`[aria-label=Close]`)
             await dismissTooltipButton.click({timeout: 500})
         }
         async clickDirectlyOnDax () {
             const input = page.locator(selectors.identity)
@@ -170,7 +170,7 @@
             const [, generatedPassword] = passwordButtonText.split('\n')
 
             if (!generatedPassword.trim()) {
                 throw new Error('unreachable - password must not be empty')
             }
 
             await passwordBtn.click({ force: true })
@@ -283,7 +283,6 @@
             const calls = await mockedCalls(page, { names: ['storeFormData'] })
             expect(calls.length).toBeGreaterThanOrEqual(1)
             const [, sent] = calls[0]
-            // @ts-expect-error
             expect(sent.Data.credentials).toEqual(credentials)
         }
         /**
@@ -306,7 +305,7 @@
             expect(await emailStyleAttr()).toBeFalsy()
         }
         async assertPasswordHasNoIcon () {
             expect(await passwordStyleAttr()).toBeFalsy()
         }
     }
 
@@ -481,7 +480,6 @@
          */
         async assertParentOpened () {
             const credsCalls = await mockedCalls(page, { names: ['getSelectedCredentials'] })
-            // @ts-expect-error
             const hasSucceeded = credsCalls.some((call) => call[2]?.some(({type}) => type === 'ok'))
             expect(hasSucceeded).toBe(true)
         }

package.json

@@ -36,7 +36,6 @@
     "@babel/eslint-parser": "^7.18.2",
     "@babel/preset-env": "^7.16.11",
     "@duckduckgo/content-scope-scripts": "github:duckduckgo/content-scope-scripts#1.3.0",
-    "@duckduckgo/content-scope-utils": "github:duckduckgo/content-scope-utils#1.0.1",
     "@playwright/test": "^1.32.0",
     "@types/jest": "^27.4.1",
     "@types/node": "^16.11.36",

packages/messaging/messaging.js

@@ -0,0 +1,154 @@
+/**
+ * @module Messaging
+ *
+ * @description
+ *
+ * An abstraction for communications between JavaScript and host platforms.
+ *
+ * 1) First you construct your platform-specific configuration (eg: {@link WebkitMessagingConfig})
+ * 2) Then use that to get an instance of the Messaging utility which allows
+ * you to send and receive data in a unified way
+ * 3) Each platform implements {@link MessagingTransport} along with its own Configuration
+ *     - For example, to learn what configuration is required for Webkit, see: {@link "Webkit Messaging".WebkitMessagingConfig}
+ *     - Or, to learn about how messages are sent and received in Webkit, see {@link "Webkit Messaging".WebkitMessagingTransport}
+ *
+ * @example Webkit Messaging
+ *
+ * ```js
+ * import { Messaging, WebkitMessagingConfig } from "@duckduckgo/content-scope-scripts/lib/messaging.js"
+ *
+ * // This config would be injected into the UserScript
+ * const injectedConfig = {
+ *   hasModernWebkitAPI: true,
+ *   webkitMessageHandlerNames: ["foo", "bar", "baz"],
+ *   secret: "dax",
+ * };
+ *
+ * // Then use that config to construct platform-specific configuration
+ * const config = new WebkitMessagingConfig(injectedConfig);
+ *
+ * // finally, get an instance of Messaging and start sending messages in a unified way 🚀
+ * const messaging = new Messaging(config);
+ * messaging.notify("hello world!", {foo: "bar"})
+ *
+ * ```
+ *
+ * @example Windows Messaging
+ *
+ * ```js
+ * import { Messaging, WindowsMessagingConfig } from "@duckduckgo/content-scope-scripts/lib/messaging.js"
+ *
+ * // Messaging on Windows is namespaced, so you can create multiple messaging instances
+ * const autofillConfig  = new WindowsMessagingConfig({ featureName: "Autofill" });
+ * const debugConfig     = new WindowsMessagingConfig({ featureName: "Debugging" });
+ *
+ * const autofillMessaging = new Messaging(autofillConfig);
+ * const debugMessaging    = new Messaging(debugConfig);
+ *
+ * // Now send messages to both features as needed 🚀
+ * autofillMessaging.notify("storeFormData", { "username": "dax" })
+ * debugMessaging.notify("pageLoad", { time: window.performance.now() })
+ * ```
+ */
+import { WebkitMessagingConfig, WebkitMessagingTransport } from './webkit.js'
+
+/**
+ * @implements {MessagingTransport}
+ */
+export class Messaging {
+    /**
+   * @param {WebkitMessagingConfig} config
+   */
+    constructor (config) {
+        this.transport = getTransport(config)
+    }
+    /**
+   * Send a 'fire-and-forget' message.
+   * @throws {Error}
+   * {@link MissingHandler}
+   *
+   * @example
+   *
+   * ```
+   * const messaging = new Messaging(config)
+   * messaging.notify("foo", {bar: "baz"})
+   * ```
+   * @param {string} name
+   * @param {Record<string, any>} [data]
+   */
+    notify (name, data = {}) {
+        this.transport.notify(name, data)
+    }
+    /**
+   * Send a request, and wait for a response
+   * @throws {Error}
+   * {@link MissingHandler}
+   *
+   * @example
+   * ```
+   * const messaging = new Messaging(config)
+   * const response = await messaging.request("foo", {bar: "baz"})
+   * ```
+   *
+   * @param {string} name
+   * @param {Record<string, any>} [data]
+   * @return {Promise<any>}
+   */
+    request (name, data = {}) {
+        return this.transport.request(name, data)
+    }
+}
+
+/**
+ * @interface
+ */
+export class MessagingTransport {
+    /**
+   * @param {string} name
+   * @param {Record<string, any>} [data]
+   * @returns {void}
+   */
+    // @ts-ignore - ignoring a no-unused ts error, this is only an interface.
+    notify (name, data = {}) {
+        throw new Error("must implement 'notify'")
+    }
+    /**
+   * @param {string} name
+   * @param {Record<string, any>} [data]
+   * @return {Promise<any>}
+   */
+    // @ts-ignore - ignoring a no-unused ts error, this is only an interface.
+    request (name, data = {}) {
+        throw new Error('must implement')
+    }
+}
+
+/**
+ * @param {WebkitMessagingConfig} config
+ * @returns {MessagingTransport}
+ */
+function getTransport (config) {
+    if (config instanceof WebkitMessagingConfig) {
+        return new WebkitMessagingTransport(config)
+    }
+    throw new Error('unreachable')
+}
+
+/**
+ * Thrown when a handler cannot be found
+ */
+export class MissingHandler extends Error {
+    /**
+   * @param {string} message
+   * @param {string} handlerName
+   */
+    constructor (message, handlerName) {
+        super(message)
+        this.handlerName = handlerName
+    }
+}
+
+/**
+ * Some re-exports for convenience
+ */
+export { WebkitMessagingConfig }