playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright_api/browser_type.rb

@@ -1,105 +1,101 @@
 module Playwright
+  #
   # BrowserType provides methods to launch a specific browser instance or connect to an existing one. The following is a
   # typical example of using Playwright to drive automation:
-  # 
   #
-  # ```js
-  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();
-  #   const page = await browser.newPage();
-  #   await page.goto('https://example.com');
-  #   // other actions...
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def run(playwright):
-  #     chromium = playwright.chromium
-  #     browser = await chromium.launch()
-  #     page = await browser.new_page()
-  #     await page.goto("https://example.com")
-  #     # other actions...
-  #     await browser.close()
-  # 
-  # async def main():
-  #     async with async_playwright() as playwright:
-  #         await run(playwright)
-  # asyncio.run(main())
-  # ```
-  # 
   # ```python sync
-  # from playwright.sync_api import sync_playwright
-  # 
-  # def run(playwright):
+  # from playwright.sync_api import sync_playwright, Playwright
+  #
+  # def run(playwright: Playwright):
   #     chromium = playwright.chromium
   #     browser = chromium.launch()
   #     page = browser.new_page()
   #     page.goto("https://example.com")
   #     # other actions...
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
   class BrowserType < PlaywrightApi
 
-    # This methods attaches Playwright to an existing browser instance.
-    def connect(params)
+    #
+    # This method attaches Playwright to an existing browser instance created via `BrowserType.launchServer` in Node.js.
+    #
+    # **NOTE**: The major and minor version of the Playwright instance that connects needs to match the version of Playwright that launches the browser (1.2.3 → is compatible with 1.2.x).
+    def connect(
+          wsEndpoint,
+          exposeNetwork: nil,
+          headers: nil,
+          slowMo: nil,
+          timeout: nil)
       raise NotImplementedError.new('connect is not implemented yet.')
     end
 
+    #
+    # This method attaches Playwright to an existing browser instance using the Chrome DevTools Protocol.
+    #
+    # The default browser context is accessible via [`method: Browser.contexts`].
+    #
+    # **NOTE**: Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.
+    #
+    # **NOTE**: This connection is significantly lower fidelity than the Playwright protocol connection via [`method: BrowserType.connect`]. If you are experiencing issues or attempting to use advanced functionality, you probably want to use [`method: BrowserType.connect`].
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # browser = playwright.chromium.connect_over_cdp("http://localhost:9222")
+    # default_context = browser.contexts[0]
+    # page = default_context.pages[0]
+    # ```
+    def connect_over_cdp(
+          endpointURL,
+          headers: nil,
+          isLocal: nil,
+          slowMo: nil,
+          timeout: nil,
+          &block)
+      wrap_impl(@impl.connect_over_cdp(unwrap_impl(endpointURL), headers: unwrap_impl(headers), isLocal: unwrap_impl(isLocal), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
+    #
     # A path where Playwright expects to find a bundled browser executable.
     def executable_path
       wrap_impl(@impl.executable_path)
     end
 
+    #
     # Returns the browser instance.
-    # 
+    #
+    # **Usage**
+    #
     # You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
-    # 
     #
-    # ```js
-    # const browser = await chromium.launch({  // Or 'firefox' or 'webkit'.
-    #   ignoreDefaultArgs: ['--mute-audio']
-    # });
-    # ```
-    # 
-    # ```python async
-    # browser = await playwright.chromium.launch( # or "firefox" or "webkit".
-    #     ignore_default_args=["--mute-audio"]
-    # )
-    # ```
-    # 
     # ```python sync
     # browser = playwright.chromium.launch( # or "firefox" or "webkit".
     #     ignore_default_args=["--mute-audio"]
     # )
     # ```
-    # 
-    # > **Chromium-only** Playwright can also be used to control the Chrome browser, but it works best with the version of
-    # Chromium it is bundled with. There is no guarantee it will work with any other version. Use `executablePath` option with
-    # extreme caution.
+    #
+    # > **Chromium-only** Playwright can also be used to control the Google Chrome or Microsoft Edge browsers, but it works best with the version of
+    # Chromium it is bundled with. There is no guarantee it will work with any other version. Use `executablePath`
+    # option with extreme caution.
+    #
     # >
+    #
     # > If Google Chrome (rather than Chromium) is preferred, a
     # [Chrome Canary](https://www.google.com/chrome/browser/canary.html) or
     # [Dev Channel](https://www.chromium.org/getting-involved/dev-channel) build is suggested.
+    #
     # >
-    # > In [`method: BrowserType.launch`] above, any mention of Chromium also applies to Chrome.
-    # >
-    # > See [`this article`](https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/) for
-    # a description of the differences between Chromium and Chrome.
-    # [`This article`](https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md)
+    #
+    # > Stock browsers like Google Chrome and Microsoft Edge are suitable for tests that require proprietary media codecs for video playback. See [this article](https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/) for other differences between Chromium and Chrome.
+    # [This article](https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md)
     # describes some differences for Linux users.
     def launch(
           args: nil,
+          channel: nil,
           chromiumSandbox: nil,
-          devtools: nil,
           downloadsPath: nil,
           env: nil,
           executablePath: nil,
@@ -109,31 +105,37 @@ module Playwright
           handleSIGTERM: nil,
           headless: nil,
           ignoreDefaultArgs: nil,
-          logger: nil,
           proxy: nil,
           slowMo: nil,
           timeout: nil,
+          tracesDir: nil,
           &block)
-      wrap_impl(@impl.launch(args: unwrap_impl(args), chromiumSandbox: unwrap_impl(chromiumSandbox), devtools: unwrap_impl(devtools), downloadsPath: unwrap_impl(downloadsPath), env: unwrap_impl(env), executablePath: unwrap_impl(executablePath), firefoxUserPrefs: unwrap_impl(firefoxUserPrefs), handleSIGHUP: unwrap_impl(handleSIGHUP), handleSIGINT: unwrap_impl(handleSIGINT), handleSIGTERM: unwrap_impl(handleSIGTERM), headless: unwrap_impl(headless), ignoreDefaultArgs: unwrap_impl(ignoreDefaultArgs), logger: unwrap_impl(logger), proxy: unwrap_impl(proxy), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+      wrap_impl(@impl.launch(args: unwrap_impl(args), channel: unwrap_impl(channel), chromiumSandbox: unwrap_impl(chromiumSandbox), downloadsPath: unwrap_impl(downloadsPath), env: unwrap_impl(env), executablePath: unwrap_impl(executablePath), firefoxUserPrefs: unwrap_impl(firefoxUserPrefs), handleSIGHUP: unwrap_impl(handleSIGHUP), handleSIGINT: unwrap_impl(handleSIGINT), handleSIGTERM: unwrap_impl(handleSIGTERM), headless: unwrap_impl(headless), ignoreDefaultArgs: unwrap_impl(ignoreDefaultArgs), proxy: unwrap_impl(proxy), slowMo: unwrap_impl(slowMo), timeout: unwrap_impl(timeout), tracesDir: unwrap_impl(tracesDir), &wrap_block_call(block)))
     end
 
+    #
     # Returns the persistent browser context instance.
-    # 
-    # Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
-    # context will automatically close the browser.
+    #
+    # Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing
+    # this context will automatically close the browser.
     def launch_persistent_context(
           userDataDir,
           acceptDownloads: nil,
           args: nil,
+          baseURL: nil,
           bypassCSP: nil,
+          channel: nil,
           chromiumSandbox: nil,
+          clientCertificates: nil,
           colorScheme: nil,
+          contrast: nil,
           deviceScaleFactor: nil,
-          devtools: nil,
           downloadsPath: nil,
           env: nil,
           executablePath: nil,
           extraHTTPHeaders: nil,
+          firefoxUserPrefs: nil,
+          forcedColors: nil,
           geolocation: nil,
           handleSIGHUP: nil,
           handleSIGINT: nil,
@@ -146,60 +148,32 @@ module Playwright
           isMobile: nil,
           javaScriptEnabled: nil,
           locale: nil,
-          logger: nil,
+          noViewport: nil,
           offline: nil,
           permissions: nil,
           proxy: nil,
-          recordHar: nil,
-          recordVideo: nil,
+          record_har_content: nil,
+          record_har_mode: nil,
+          record_har_omit_content: nil,
+          record_har_path: nil,
+          record_har_url_filter: nil,
+          record_video_dir: nil,
+          record_video_size: nil,
+          reducedMotion: nil,
+          screen: nil,
+          serviceWorkers: nil,
           slowMo: nil,
+          strictSelectors: nil,
           timeout: nil,
           timezoneId: nil,
+          tracesDir: nil,
           userAgent: nil,
-          videoSize: nil,
-          videosPath: nil,
-          viewport: nil)
-      raise NotImplementedError.new('launch_persistent_context is not implemented yet.')
-    end
-
-    # Returns the browser app instance.
-    # 
-    # Launches browser server that client can connect to. An example of launching a browser executable and connecting to it
-    # later:
-    # 
-    #
-    # ```js
-    # const { chromium } = require('playwright');  // Or 'webkit' or 'firefox'.
-    # 
-    # (async () => {
-    #   const browserServer = await chromium.launchServer();
-    #   const wsEndpoint = browserServer.wsEndpoint();
-    #   // Use web socket endpoint later to establish a connection.
-    #   const browser = await chromium.connect({ wsEndpoint });
-    #   // Close browser instance.
-    #   await browserServer.close();
-    # })();
-    # ```
-    def launch_server(
-          args: nil,
-          chromiumSandbox: nil,
-          devtools: nil,
-          downloadsPath: nil,
-          env: nil,
-          executablePath: nil,
-          firefoxUserPrefs: nil,
-          handleSIGHUP: nil,
-          handleSIGINT: nil,
-          handleSIGTERM: nil,
-          headless: nil,
-          ignoreDefaultArgs: nil,
-          logger: nil,
-          port: nil,
-          proxy: nil,
-          timeout: nil)
-      raise NotImplementedError.new('launch_server is not implemented yet.')
+          viewport: nil,
+          &block)
+      wrap_impl(@impl.launch_persistent_context(unwrap_impl(userDataDir), acceptDownloads: unwrap_impl(acceptDownloads), args: unwrap_impl(args), baseURL: unwrap_impl(baseURL), bypassCSP: unwrap_impl(bypassCSP), channel: unwrap_impl(channel), chromiumSandbox: unwrap_impl(chromiumSandbox), clientCertificates: unwrap_impl(clientCertificates), colorScheme: unwrap_impl(colorScheme), contrast: unwrap_impl(contrast), deviceScaleFactor: unwrap_impl(deviceScaleFactor), downloadsPath: unwrap_impl(downloadsPath), env: unwrap_impl(env), executablePath: unwrap_impl(executablePath), extraHTTPHeaders: unwrap_impl(extraHTTPHeaders), firefoxUserPrefs: unwrap_impl(firefoxUserPrefs), forcedColors: unwrap_impl(forcedColors), geolocation: unwrap_impl(geolocation), handleSIGHUP: unwrap_impl(handleSIGHUP), handleSIGINT: unwrap_impl(handleSIGINT), handleSIGTERM: unwrap_impl(handleSIGTERM), hasTouch: unwrap_impl(hasTouch), headless: unwrap_impl(headless), httpCredentials: unwrap_impl(httpCredentials), ignoreDefaultArgs: unwrap_impl(ignoreDefaultArgs), ignoreHTTPSErrors: unwrap_impl(ignoreHTTPSErrors), isMobile: unwrap_impl(isMobile), javaScriptEnabled: unwrap_impl(javaScriptEnabled), locale: unwrap_impl(locale), noViewport: unwrap_impl(noViewport), offline: unwrap_impl(offline), permissions: unwrap_impl(permissions), proxy: unwrap_impl(proxy), record_har_content: unwrap_impl(record_har_content), record_har_mode: unwrap_impl(record_har_mode), record_har_omit_content: unwrap_impl(record_har_omit_content), record_har_path: unwrap_impl(record_har_path), record_har_url_filter: unwrap_impl(record_har_url_filter), record_video_dir: unwrap_impl(record_video_dir), record_video_size: unwrap_impl(record_video_size), reducedMotion: unwrap_impl(reducedMotion), screen: unwrap_impl(screen), serviceWorkers: unwrap_impl(serviceWorkers), slowMo: unwrap_impl(slowMo), strictSelectors: unwrap_impl(strictSelectors), timeout: unwrap_impl(timeout), timezoneId: unwrap_impl(timezoneId), tracesDir: unwrap_impl(tracesDir), userAgent: unwrap_impl(userAgent), viewport: unwrap_impl(viewport), &wrap_block_call(block)))
     end
 
+    #
     # Returns browser name. For example: `'chromium'`, `'webkit'` or `'firefox'`.
     def name
       wrap_impl(@impl.name)
@@ -207,20 +181,24 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/lib/playwright_api/cdp_session.rb

@@ -1,59 +1,56 @@
 module Playwright
-  # - extends: [EventEmitter]
-  # 
+  #
   # The `CDPSession` instances are used to talk raw Chrome Devtools Protocol:
   # - protocol methods can be called with `session.send` method.
   # - protocol events can be subscribed to with `session.on` method.
-  # 
+  #
   # Useful links:
-  # - Documentation on DevTools Protocol can be found here:
-  #   [DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/).
-  # - Getting Started with DevTools Protocol:
-  #   https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md
-  # 
+  # - Documentation on DevTools Protocol can be found here: [DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/).
+  # - Getting Started with DevTools Protocol: https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md
   #
-  # ```js
-  # const client = await page.context().newCDPSession(page);
-  # await client.send('Animation.enable');
-  # client.on('Animation.animationCreated', () => console.log('Animation created!'));
-  # const response = await client.send('Animation.getPlaybackRate');
-  # console.log('playback rate is ' + response.playbackRate);
-  # await client.send('Animation.setPlaybackRate', {
-  #   playbackRate: response.playbackRate / 2
-  # });
-  # ```
-  # 
-  # ```python async
-  # client = await page.context().new_cdp_session(page)
-  # await client.send("animation.enable")
-  # client.on("animation.animation_created", lambda: print("animation created!"))
-  # response = await client.send("animation.get_playback_rate")
-  # print("playback rate is " + response["playback_rate"])
-  # await client.send("animation.set_playback_rate", {
-  #     playback_rate: response["playback_rate"] / 2
-  # })
-  # ```
-  # 
   # ```python sync
-  # client = page.context().new_cdp_session(page)
-  # client.send("animation.enable")
-  # client.on("animation.animation_created", lambda: print("animation created!"))
-  # response = client.send("animation.get_playback_rate")
-  # print("playback rate is " + response["playback_rate"])
-  # client.send("animation.set_playback_rate", {
-  #     playback_rate: response["playback_rate"] / 2
+  # client = page.context.new_cdp_session(page)
+  # client.send("Animation.enable")
+  # client.on("Animation.animationCreated", lambda: print("animation created!"))
+  # response = client.send("Animation.getPlaybackRate")
+  # print("playback rate is " + str(response["playbackRate"]))
+  # client.send("Animation.setPlaybackRate", {
+  #     "playbackRate": response["playbackRate"] / 2
   # })
   # ```
   class CDPSession < PlaywrightApi
 
+    #
     # Detaches the CDPSession from the target. Once detached, the CDPSession object won't emit any events and can't be used to
     # send messages.
     def detach
-      raise NotImplementedError.new('detach is not implemented yet.')
+      wrap_impl(@impl.detach)
     end
 
     def send_message(method, params: nil)
-      raise NotImplementedError.new('send_message is not implemented yet.')
+      wrap_impl(@impl.send_message(unwrap_impl(method), params: unwrap_impl(params)))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/lib/playwright_api/clock.rb

@@ -0,0 +1,121 @@
+module Playwright
+  #
+  # Accurately simulating time-dependent behavior is essential for verifying the correctness of applications. Learn more about [clock emulation](../clock.md).
+  #
+  # Note that clock is installed for the entire `BrowserContext`, so the time
+  # in all the pages and iframes is controlled by the same clock.
+  class Clock < PlaywrightApi
+
+    #
+    # Advance the clock by jumping forward in time. Only fires due timers at most once. This is equivalent to user closing the laptop lid for a while and
+    # reopening it later, after given time.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # page.clock.fast_forward(1000)
+    # page.clock.fast_forward("30:00")
+    # ```
+    def fast_forward(ticks)
+      wrap_impl(@impl.fast_forward(unwrap_impl(ticks)))
+    end
+
+    #
+    # Install fake implementations for the following time-related functions:
+    # - `Date`
+    # - `setTimeout`
+    # - `clearTimeout`
+    # - `setInterval`
+    # - `clearInterval`
+    # - `requestAnimationFrame`
+    # - `cancelAnimationFrame`
+    # - `requestIdleCallback`
+    # - `cancelIdleCallback`
+    # - `performance`
+    #
+    # Fake timers are used to manually control the flow of time in tests. They allow you to advance time, fire timers, and control the behavior of time-dependent functions. See [`method: Clock.runFor`] and [`method: Clock.fastForward`] for more information.
+    def install(time: nil)
+      wrap_impl(@impl.install(time: unwrap_impl(time)))
+    end
+
+    #
+    # Advance the clock, firing all the time-related callbacks.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # page.clock.run_for(1000);
+    # page.clock.run_for("30:00")
+    # ```
+    def run_for(ticks)
+      wrap_impl(@impl.run_for(unwrap_impl(ticks)))
+    end
+
+    #
+    # Advance the clock by jumping forward in time and pause the time. Once this method is called, no timers
+    # are fired unless [`method: Clock.runFor`], [`method: Clock.fastForward`], [`method: Clock.pauseAt`] or [`method: Clock.resume`] is called.
+    #
+    # Only fires due timers at most once.
+    # This is equivalent to user closing the laptop lid for a while and reopening it at the specified time and
+    # pausing.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # page.clock.pause_at(datetime.datetime(2020, 2, 2))
+    # page.clock.pause_at("2020-02-02")
+    # ```
+    #
+    # For best results, install the clock before navigating the page and set it to a time slightly before the intended test time. This ensures that all timers run normally during page loading, preventing the page from getting stuck. Once the page has fully loaded, you can safely use [`method: Clock.pauseAt`] to pause the clock.
+    #
+    # ```python sync
+    # # Initialize clock with some time before the test time and let the page load
+    # # naturally. `Date.now` will progress as the timers fire.
+    # page.clock.install(time=datetime.datetime(2024, 12, 10, 8, 0, 0))
+    # page.goto("http://localhost:3333")
+    # page.clock.pause_at(datetime.datetime(2024, 12, 10, 10, 0, 0))
+    # ```
+    def pause_at(time)
+      wrap_impl(@impl.pause_at(unwrap_impl(time)))
+    end
+
+    #
+    # Resumes timers. Once this method is called, time resumes flowing, timers are fired as usual.
+    def resume
+      wrap_impl(@impl.resume)
+    end
+
+    #
+    # Makes `Date.now` and `new Date()` return fixed fake time at all times,
+    # keeps all the timers running.
+    #
+    # Use this method for simple scenarios where you only need to test with a predefined time. For more advanced scenarios, use [`method: Clock.install`] instead. Read docs on [clock emulation](../clock.md) to learn more.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # page.clock.set_fixed_time(datetime.datetime.now())
+    # page.clock.set_fixed_time(datetime.datetime(2020, 2, 2))
+    # page.clock.set_fixed_time("2020-02-02")
+    # ```
+    def set_fixed_time(time)
+      wrap_impl(@impl.set_fixed_time(unwrap_impl(time)))
+    end
+    alias_method :fixed_time=, :set_fixed_time
+
+    #
+    # Sets system time, but does not trigger any timers. Use this to test how the web page reacts to a time shift, for example switching from summer to winter time, or changing time zones.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # page.clock.set_system_time(datetime.datetime.now())
+    # page.clock.set_system_time(datetime.datetime(2020, 2, 2))
+    # page.clock.set_system_time("2020-02-02")
+    # ```
+    def set_system_time(time)
+      wrap_impl(@impl.set_system_time(unwrap_impl(time)))
+    end
+    alias_method :system_time=, :set_system_time
+  end
+end

data/lib/playwright_api/console_message.rb

@@ -1,7 +1,30 @@
 module Playwright
+  #
   # `ConsoleMessage` objects are dispatched by page via the [`event: Page.console`] event.
+  # For each console message logged in the page there will be corresponding event in the Playwright
+  # context.
+  #
+  # ```python sync
+  # # Listen for all console logs
+  # page.on("console", lambda msg: print(msg.text))
+  #
+  # # Listen for all console events and handle errors
+  # page.on("console", lambda msg: print(f"error: {msg.text}") if msg.type == "error" else None)
+  #
+  # # Get the next console log
+  # with page.expect_console_message() as msg_info:
+  #     # Issue console.log inside the page
+  #     page.evaluate("console.log('hello', 42, { foo: 'bar' })")
+  # msg = msg_info.value
+  #
+  # # Deconstruct print arguments
+  # msg.args[0].json_value() # hello
+  # msg.args[1].json_value() # 42
+  # ```
   class ConsoleMessage < PlaywrightApi
 
+    #
+    # List of arguments passed to a `console` function call. See also [`event: Page.console`].
     def args
       wrap_impl(@impl.args)
     end
@@ -10,33 +33,26 @@ module Playwright
       wrap_impl(@impl.location)
     end
 
+    #
+    # The page that produced this console message, if any.
+    def page
+      wrap_impl(@impl.page)
+    end
+
+    #
+    # The text of the console message.
     def text
       wrap_impl(@impl.text)
     end
 
-    # One of the following values: `'log'`, `'debug'`, `'info'`, `'error'`, `'warning'`, `'dir'`, `'dirxml'`, `'table'`,
-    # `'trace'`, `'clear'`, `'startGroup'`, `'startGroupCollapsed'`, `'endGroup'`, `'assert'`, `'profile'`, `'profileEnd'`,
-    # `'count'`, `'timeEnd'`.
     def type
       wrap_impl(@impl.type)
     end
 
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def on(event, callback)
-      wrap_impl(@impl.on(unwrap_impl(event), unwrap_impl(callback)))
-    end
-
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def off(event, callback)
-      wrap_impl(@impl.off(unwrap_impl(event), unwrap_impl(callback)))
-    end
-
-    # -- inherited from EventEmitter --
-    # @nodoc
-    def once(event, callback)
-      wrap_impl(@impl.once(unwrap_impl(event), unwrap_impl(callback)))
+    #
+    # The web worker or service worker that produced this console message, if any. Note that console messages from web workers also have non-null [`method: ConsoleMessage.page`].
+    def worker
+      wrap_impl(@impl.worker)
     end
   end
 end