effect-playwright 0.1.1 → 0.1.2

package/README.md

@@ -3,6 +3,7 @@
 [![NPM Version](https://img.shields.io/npm/v/effect-playwright)](https://www.npmjs.com/package/effect-playwright)
 [![GitHub License](https://img.shields.io/github/license/Jobflow-io/effect-playwright)](https://github.com/Jobflow-io/effect-playwright/blob/main/LICENSE)
 [![Effect: yes](https://img.shields.io/badge/effect-yes-blue)](https://effect.website/)
+[![Documentation](https://img.shields.io/badge/view_documentation-purple)](https://jobflow-io.github.io/effect-playwright/modules/index.html)
 
 A Playwright wrapper for the Effect ecosystem. This library provides a set of services and layers to interact with Playwright in a type-safe way using Effect.
 
@@ -125,6 +126,41 @@ const program = Effect.gen(function* () {
 }).pipe(PlaywrightEnvironment.withBrowser);
 ```
 
+## Event Handling
+
+You can listen to Playwright events using the `eventStream` method. This returns an Effect `Stream` that emits events as they occur.
+
+> [!NOTE]
+> `eventStream` emits "Effectified" wrappers (e.g., `PlaywrightRequest`, `PlaywrightResponse`, `PlaywrightPage`) for most events. This allows you to continue using the Effect ecosystem seamlessly within your event handlers.
+
+The stream is automatically managed and will close when the underlying resource (like the Page or Browser) is closed.
+
+### Example: Monitoring Network Requests
+
+Since event streams run indefinitely until the resource closes, you often need to **fork** the resulting effect so it runs in the background without blocking your main program flow.
+
+```ts
+const program = Effect.gen(function* () {
+  const browser = yield* PlaywrightBrowser;
+  const page = yield* browser.newPage();
+
+  // Create a stream of request events
+  yield* page.eventStream("request").pipe(
+    Stream.runForEach((request) =>
+      Effect.gen(function* () {
+        const url = yield* request.url;
+        yield* Effect.log(`Request: ${url}`);
+      }),
+    ),
+
+    // Fork to run it in the background
+    Effect.fork,
+  );
+
+  yield* page.goto("https://example.com");
+}).pipe(PlaywrightEnvironment.withBrowser);
+```
+
 ## Accessing Native Playwright
 
 If you need to access functionality from the underlying Playwright objects that isn't directly exposed, you can use the `use` method available on most services/objects (browsers, pages, locators).

package/dist/experimental/index.d.mts

@@ -1,4 +1,4 @@
-import { d as PlaywrightError, o as PlaywrightBrowser } from "../index-DnbVDccF.mjs";
+import { o as PlaywrightBrowser, x as PlaywrightError } from "../index-BTxElyN5.mjs";
 import { Context, Effect, Layer } from "effect";
 import { BrowserType, LaunchOptions } from "playwright-core";
 import { Scope as Scope$1 } from "effect/Scope";
@@ -13,9 +13,9 @@ declare const PlaywrightEnvironment_base: Context.TagClass<PlaywrightEnvironment
 /**
  * Most of the time you want to use the same kind of browser and configuration every time you use Playwright.
  * `PlaywrightEnvironment` is a service that allows you to configure how browsers are launched once. You can then
- * use {@link PlaywrightEnvironment.browser} to start browsers scoped to the current lifetime. They will be closed when the scope is closed.
+ * use `PlaywrightEnvironment.browser` to start browsers scoped to the current lifetime. They will be closed when the scope is closed.
  *
- * You can use {@link PlaywrightEnvironment.withBrowser} to provide the `PlaywrightBrowser` service to the wrapped effect. This
+ * You can use {@link withBrowser} to provide the `PlaywrightBrowser` service to the wrapped effect. This
  * also allows you to re-use the same browser as many times as you want.
  *
  * @since 0.1.0
@@ -70,6 +70,7 @@ declare const layer: (browser: BrowserType, launchOptions?: LaunchOptions) => La
  * ```
  *
  * @since 0.1.0
+ * @category util
  */
 declare const withBrowser: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, PlaywrightError | E, PlaywrightEnvironment | Exclude<R, PlaywrightBrowser>>;
 //#endregion

package/dist/experimental/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "../chunk-BiucMVzj.mjs";
-import { n as PlaywrightBrowser, t as Playwright } from "../src-BGGNNney.mjs";
+import { n as PlaywrightBrowser, t as Playwright } from "../src-D0uXY5ik.mjs";
 import { Context, Effect, Layer } from "effect";
 
 //#region src/experimental/environment.ts
@@ -11,9 +11,9 @@ var environment_exports = /* @__PURE__ */ __exportAll({
 /**
 * Most of the time you want to use the same kind of browser and configuration every time you use Playwright.
 * `PlaywrightEnvironment` is a service that allows you to configure how browsers are launched once. You can then
-* use {@link PlaywrightEnvironment.browser} to start browsers scoped to the current lifetime. They will be closed when the scope is closed.
+* use `PlaywrightEnvironment.browser` to start browsers scoped to the current lifetime. They will be closed when the scope is closed.
 *
-* You can use {@link PlaywrightEnvironment.withBrowser} to provide the `PlaywrightBrowser` service to the wrapped effect. This
+* You can use {@link withBrowser} to provide the `PlaywrightBrowser` service to the wrapped effect. This
 * also allows you to re-use the same browser as many times as you want.
 *
 * @since 0.1.0
@@ -72,6 +72,7 @@ const layer = (browser, launchOptions) => {
 * ```
 *
 * @since 0.1.0
+* @category util
 */
 const withBrowser = Effect.provide(PlaywrightEnvironment.pipe(Effect.map((e) => e.browser), Effect.flatten, Layer.scoped(PlaywrightBrowser)));