effect-playwright 0.1.1 → 0.2.0

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,9 +1,28 @@
-import { d as PlaywrightError, o as PlaywrightBrowser } from "../index-DnbVDccF.mjs";
-import { Context, Effect, Layer } from "effect";
+import { d as PlaywrightPageService, o as PlaywrightBrowser, s as PlaywrightBrowserService, v as PlaywrightFrameService, x as PlaywrightError } from "../index-K6LNMeXC.mjs";
+import { Context, Effect, Layer, Stream } from "effect";
 import { BrowserType, LaunchOptions } from "playwright-core";
 import { Scope as Scope$1 } from "effect/Scope";
 
-//#region src/experimental/environment.d.ts
+//#region src/experimental/browser-utils.d.ts
+declare namespace browser_utils_d_exports {
+  export { allFrameNavigatedEventStream, allFrames, allPages };
+}
+/**
+ * Returns all pages in the browser from all contexts.
+ * @category util
+ */
+declare const allPages: (browser: PlaywrightBrowserService) => Effect.Effect<PlaywrightPageService[], never, never>;
+/**
+ * Returns all frames in the browser from all pages in all contexts.
+ * @category util
+ */
+declare const allFrames: (browser: PlaywrightBrowserService) => Effect.Effect<(readonly PlaywrightFrameService[])[], PlaywrightError, never>;
+/**
+ * Returns a stream of all framenavigated events for all current and future pages in the browser.
+ * In all current contexts (but not future contexts).
+ * @category util
+ */
+declare const allFrameNavigatedEventStream: (browser: PlaywrightBrowserService) => Stream.Stream<PlaywrightFrameService, never, never>;
 declare namespace environment_d_exports {
   export { PlaywrightEnvironment, layer, withBrowser };
 }
@@ -13,9 +32,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,7 +89,8 @@ 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
-export { environment_d_exports as PlaywrightEnvironment };
+export { browser_utils_d_exports as BrowserUtils, environment_d_exports as PlaywrightEnvironment };

package/dist/experimental/index.mjs

@@ -1,7 +1,36 @@
 import { t as __exportAll } from "../chunk-BiucMVzj.mjs";
-import { n as PlaywrightBrowser, t as Playwright } from "../src-BGGNNney.mjs";
-import { Context, Effect, Layer } from "effect";
+import { n as PlaywrightBrowser, t as Playwright } from "../src-Bf0XqK7M.mjs";
+import { Array, Context, Effect, Layer, Stream, pipe } from "effect";
 
+//#region src/experimental/browser-utils.ts
+var browser_utils_exports = /* @__PURE__ */ __exportAll({
+	allFrameNavigatedEventStream: () => allFrameNavigatedEventStream,
+	allFrames: () => allFrames,
+	allPages: () => allPages
+});
+/**
+* Returns all pages in the browser from all contexts.
+* @category util
+*/
+const allPages = (browser) => browser.contexts.pipe(Effect.flatMap((contexts) => Effect.all(contexts.map((context) => context.pages))), Effect.map(Array.flatten));
+/**
+* Returns all frames in the browser from all pages in all contexts.
+* @category util
+*/
+const allFrames = (browser) => allPages(browser).pipe(Effect.flatMap((pages) => Effect.all(pages.map((page) => page.frames))));
+/**
+* Returns a stream of all framenavigated events for all current and future pages in the browser.
+* In all current contexts (but not future contexts).
+* @category util
+*/
+const allFrameNavigatedEventStream = (browser) => Effect.gen(function* () {
+	const contexts = yield* browser.contexts;
+	const currentPages = (yield* pipe(contexts.map((c) => c.pages), Effect.all, Effect.map(Array.flatten))).map((page) => page.eventStream("framenavigated"));
+	const newPages = pipe(contexts.map((c) => c.eventStream("page")), Stream.mergeAll({ concurrency: "unbounded" }), Stream.flatMap((page) => page.eventStream("framenavigated"), { concurrency: "unbounded" }));
+	return Stream.mergeAll([newPages, ...currentPages], { concurrency: "unbounded" });
+}).pipe(Stream.unwrap);
+
+//#endregion
 //#region src/experimental/environment.ts
 var environment_exports = /* @__PURE__ */ __exportAll({
 	PlaywrightEnvironment: () => PlaywrightEnvironment,
@@ -11,9 +40,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,8 +101,9 @@ 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)));
 
 //#endregion
-export { environment_exports as PlaywrightEnvironment };
+export { browser_utils_exports as BrowserUtils, environment_exports as PlaywrightEnvironment };