effect-playwright 0.1.0 → 0.1.2

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { a as NewPageOptions, c as PlaywrightPageService, i as NewContextOptions, l as PlaywrightLocator, n as PlaywrightService, o as PlaywrightBrowser, r as LaunchOptions, s as PlaywrightPage, t as Playwright, u as PlaywrightLocatorService } from "./index-aR0Fa_4Y.mjs";
-export { LaunchOptions, NewContextOptions, NewPageOptions, Playwright, PlaywrightBrowser, PlaywrightLocator, PlaywrightLocatorService, PlaywrightPage, PlaywrightPageService, PlaywrightService };
+import { S as PlaywrightErrorReason, _ as PlaywrightFrame, a as NewPageOptions, b as PlaywrightWorker, c as PlaywrightBrowserContext, d as PlaywrightPageService, f as PlaywrightLocator, g as PlaywrightFileChooser, h as PlaywrightDownload, i as NewContextOptions, l as PlaywrightBrowserContextService, m as PlaywrightDialog, n as PlaywrightService, o as PlaywrightBrowser, p as PlaywrightLocatorService, r as LaunchOptions, s as PlaywrightBrowserService, t as Playwright, u as PlaywrightPage, v as PlaywrightRequest, x as PlaywrightError, y as PlaywrightResponse } from "./index-BTxElyN5.mjs";
+export { LaunchOptions, NewContextOptions, NewPageOptions, Playwright, PlaywrightBrowser, PlaywrightBrowserContext, PlaywrightBrowserContextService, PlaywrightBrowserService, PlaywrightDialog, PlaywrightDownload, PlaywrightError, PlaywrightErrorReason, PlaywrightFileChooser, PlaywrightFrame, PlaywrightLocator, PlaywrightLocatorService, PlaywrightPage, PlaywrightPageService, PlaywrightRequest, PlaywrightResponse, PlaywrightService, PlaywrightWorker };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { i as PlaywrightLocator, n as PlaywrightBrowser, r as PlaywrightPage, t as Playwright } from "./src-DveiwW4g.mjs";
+import { a as PlaywrightDownload, c as PlaywrightRequest, d as PlaywrightPage, f as PlaywrightLocator, i as PlaywrightDialog, l as PlaywrightResponse, n as PlaywrightBrowser, o as PlaywrightFileChooser, p as PlaywrightError, r as PlaywrightBrowserContext, s as PlaywrightFrame, t as Playwright, u as PlaywrightWorker } from "./src-D0uXY5ik.mjs";
 
-export { Playwright, PlaywrightBrowser, PlaywrightLocator, PlaywrightPage };
+export { Playwright, PlaywrightBrowser, PlaywrightBrowserContext, PlaywrightDialog, PlaywrightDownload, PlaywrightError, PlaywrightFileChooser, PlaywrightFrame, PlaywrightLocator, PlaywrightPage, PlaywrightRequest, PlaywrightResponse, PlaywrightWorker };

package/dist/src-D0uXY5ik.mjs

@@ -0,0 +1,389 @@
+import { Context, Data, Effect, Layer, Option, Stream, identity } from "effect";
+import { chromium, errors } from "playwright-core";
+
+//#region src/errors.ts
+/**
+* Error type that is returned when a Playwright error occurs.
+* Reason can either be "Timeout" or "Unknown".
+*
+* Timeout errors occur when a timeout is reached. All other errors are
+* grouped under "Unknown".
+*
+* @category error
+* @since 0.1.0
+*/
+var PlaywrightError = class extends Data.TaggedError("PlaywrightError") {};
+function wrapError(error) {
+	if (error instanceof errors.TimeoutError) return new PlaywrightError({
+		reason: "Timeout",
+		cause: error
+	});
+	else return new PlaywrightError({
+		reason: "Unknown",
+		cause: error
+	});
+}
+
+//#endregion
+//#region src/utils.ts
+/** @internal */
+const useHelper = (api) => (userFunction) => Effect.tryPromise(() => userFunction(api)).pipe(Effect.mapError(wrapError));
+
+//#endregion
+//#region src/locator.ts
+/**
+* A service that provides a `PlaywrightLocator` instance.
+*
+* @since 0.1.0
+* @category tag
+*/
+var PlaywrightLocator = class PlaywrightLocator extends Context.Tag("effect-playwright/PlaywrightLocator")() {
+	/**
+	* Creates a `PlaywrightLocator` from a Playwright `Locator` instance. This is mostly for internal use.
+	* But you could use this if you have used `use` or similar to wrap the locator.
+	*
+	* @example
+	* ```ts
+	* const playwrightNativeLocator = yield* page.use((p) => p.locator("button"));
+	* const locator = PlaywrightLocator.make(playwrightNativeLocator);
+	* ```
+	*
+	* @param locator - The Playwright `Locator` instance to wrap.
+	* @since 0.1.0
+	* @category constructor
+	*/
+	static make(locator) {
+		const use = useHelper(locator);
+		return PlaywrightLocator.of({
+			click: (options) => use((l) => l.click(options)),
+			fill: (value, options) => use((l) => l.fill(value, options)),
+			getAttribute: (name, options) => use((l) => l.getAttribute(name, options)),
+			innerText: (options) => use((l) => l.innerText(options)),
+			innerHTML: (options) => use((l) => l.innerHTML(options)),
+			inputValue: (options) => use((l) => l.inputValue(options)),
+			textContent: (options) => use((l) => l.textContent(options)),
+			count: use((l) => l.count()),
+			first: () => PlaywrightLocator.make(locator.first()),
+			last: () => PlaywrightLocator.make(locator.last()),
+			nth: (index) => PlaywrightLocator.make(locator.nth(index)),
+			evaluate: (pageFunction, arg, options) => use((l) => l.evaluate(pageFunction, arg, options)),
+			use
+		});
+	}
+};
+
+//#endregion
+//#region src/page.ts
+const eventMappings$2 = {
+	close: (page) => PlaywrightPage.make(page),
+	console: identity,
+	crash: (page) => PlaywrightPage.make(page),
+	dialog: (dialog) => PlaywrightDialog.make(dialog),
+	domcontentloaded: (page) => PlaywrightPage.make(page),
+	download: (download) => PlaywrightDownload.make(download),
+	filechooser: (fileChooser) => PlaywrightFileChooser.make(fileChooser),
+	frameattached: (frame) => PlaywrightFrame.make(frame),
+	framedetached: (frame) => PlaywrightFrame.make(frame),
+	framenavigated: (frame) => PlaywrightFrame.make(frame),
+	load: (page) => PlaywrightPage.make(page),
+	pageerror: identity,
+	popup: (page) => PlaywrightPage.make(page),
+	request: (request) => PlaywrightRequest.make(request),
+	requestfailed: (request) => PlaywrightRequest.make(request),
+	requestfinished: (request) => PlaywrightRequest.make(request),
+	response: (response) => PlaywrightResponse.make(response),
+	websocket: identity,
+	worker: (worker) => PlaywrightWorker.make(worker)
+};
+/**
+* @category tag
+*/
+var PlaywrightPage = class PlaywrightPage extends Context.Tag("effect-playwright/PlaywrightPage")() {
+	/**
+	* Creates a `PlaywrightPage` from a Playwright `Page` instance.
+	*
+	* @param page - The Playwright `Page` instance to wrap.
+	* @since 0.1.0
+	*/
+	static make(page) {
+		const use = useHelper(page);
+		return PlaywrightPage.of({
+			goto: (url, options) => use((p) => p.goto(url, options)),
+			waitForURL: (url, options) => use((p) => p.waitForURL(url, options)),
+			title: use((p) => p.title()),
+			evaluate: (f, arg) => use((p) => p.evaluate(f, arg)),
+			locator: (selector, options) => PlaywrightLocator.make(page.locator(selector, options)),
+			getByRole: (role, options) => PlaywrightLocator.make(page.getByRole(role, options)),
+			getByText: (text, options) => PlaywrightLocator.make(page.getByText(text, options)),
+			getByLabel: (label, options) => PlaywrightLocator.make(page.getByLabel(label, options)),
+			getByTestId: (testId) => PlaywrightLocator.make(page.getByTestId(testId)),
+			url: Effect.sync(() => page.url()),
+			reload: use((p) => p.reload()),
+			close: use((p) => p.close()),
+			click: (selector, options) => use((p) => p.click(selector, options)),
+			eventStream: (event) => Stream.asyncPush((emit) => Effect.acquireRelease(Effect.sync(() => {
+				page.on(event, emit.single);
+				page.once("close", emit.end);
+			}), () => Effect.sync(() => {
+				page.off(event, emit.single);
+				page.off("close", emit.end);
+			}))).pipe(Stream.map((e) => {
+				const mapping = eventMappings$2[event];
+				return mapping(e);
+			})),
+			use
+		});
+	}
+};
+
+//#endregion
+//#region src/common.ts
+/**
+* @category model
+* @since 0.1.2
+*/
+var PlaywrightFrame = class PlaywrightFrame extends Data.TaggedClass("PlaywrightFrame") {
+	static make(frame) {
+		return new PlaywrightFrame({ use: useHelper(frame) });
+	}
+};
+/**
+* @category model
+* @since 0.1.2
+*/
+var PlaywrightRequest = class PlaywrightRequest extends Data.TaggedClass("PlaywrightRequest") {
+	static make(request) {
+		const use = useHelper(request);
+		return new PlaywrightRequest({
+			allHeaders: use(() => request.allHeaders()),
+			failure: Option.liftNullable(request.failure),
+			frame: Effect.sync(() => PlaywrightFrame.make(request.frame())),
+			headerValue: (name) => use(() => request.headerValue(name)).pipe(Effect.map(Option.fromNullable)),
+			headers: Effect.sync(() => request.headers()),
+			headersArray: use(() => request.headersArray()),
+			isNavigationRequest: Effect.sync(() => request.isNavigationRequest()),
+			method: Effect.sync(() => request.method()),
+			postData: Option.liftNullable(request.postData),
+			postDataBuffer: Option.liftNullable(request.postDataBuffer),
+			postDataJSON: use(() => request.postDataJSON()).pipe(Effect.map(Option.fromNullable)),
+			redirectedFrom: () => Option.fromNullable(request.redirectedFrom()).pipe(Option.map(PlaywrightRequest.make)),
+			redirectedTo: () => Option.fromNullable(request.redirectedTo()).pipe(Option.map(PlaywrightRequest.make)),
+			resourceType: Effect.sync(() => request.resourceType()),
+			response: use(() => request.response()).pipe(Effect.map(Option.fromNullable), Effect.map(Option.map(PlaywrightResponse.make))),
+			serviceWorker: () => Option.fromNullable(request.serviceWorker()).pipe(Option.map(PlaywrightWorker.make)),
+			sizes: use(() => request.sizes()),
+			timing: Effect.sync(() => request.timing()),
+			url: Effect.sync(() => request.url())
+		});
+	}
+};
+/**
+* @category model
+* @since 0.1.2
+*/
+var PlaywrightResponse = class PlaywrightResponse extends Data.TaggedClass("PlaywrightResponse") {
+	static make(response) {
+		const use = useHelper(response);
+		return new PlaywrightResponse({
+			allHeaders: use(() => response.allHeaders()),
+			body: use(() => response.body()),
+			finished: use(() => response.finished()),
+			frame: Effect.sync(() => PlaywrightFrame.make(response.frame())),
+			fromServiceWorker: Effect.sync(() => response.fromServiceWorker()),
+			headers: Effect.sync(() => response.headers()),
+			headersArray: use(() => response.headersArray()),
+			headerValue: (name) => use(() => response.headerValue(name)).pipe(Effect.map(Option.fromNullable)),
+			headerValues: (name) => use(() => response.headerValues(name)),
+			json: use(() => response.json()),
+			ok: Effect.sync(() => response.ok()),
+			request: () => PlaywrightRequest.make(response.request()),
+			securityDetails: use(() => response.securityDetails()).pipe(Effect.map(Option.fromNullable)),
+			serverAddr: use(() => response.serverAddr()).pipe(Effect.map(Option.fromNullable)),
+			status: Effect.sync(() => response.status()),
+			statusText: Effect.sync(() => response.statusText()),
+			text: use(() => response.text()),
+			url: Effect.sync(() => response.url())
+		});
+	}
+};
+/**
+* @category model
+* @since 0.1.2
+*/
+var PlaywrightWorker = class PlaywrightWorker extends Data.TaggedClass("PlaywrightWorker") {
+	static make(worker) {
+		const use = useHelper(worker);
+		return new PlaywrightWorker({
+			evaluate: (f, arg) => use((w) => w.evaluate(f, arg)),
+			url: Effect.sync(() => worker.url())
+		});
+	}
+};
+/**
+* @category model
+* @since 0.1.2
+*/
+var PlaywrightDialog = class PlaywrightDialog extends Data.TaggedClass("PlaywrightDialog") {
+	static make(dialog) {
+		const use = useHelper(dialog);
+		return new PlaywrightDialog({
+			accept: (promptText) => use(() => dialog.accept(promptText)),
+			defaultValue: Effect.sync(() => dialog.defaultValue()),
+			dismiss: use(() => dialog.dismiss()),
+			message: Effect.sync(() => dialog.message()),
+			page: () => Option.fromNullable(dialog.page()).pipe(Option.map(PlaywrightPage.make)),
+			type: Effect.sync(() => dialog.type())
+		});
+	}
+};
+/**
+* @category model
+* @since 0.1.2
+*/
+var PlaywrightFileChooser = class PlaywrightFileChooser extends Data.TaggedClass("PlaywrightFileChooser") {
+	static make(fileChooser) {
+		const use = useHelper(fileChooser);
+		return new PlaywrightFileChooser({
+			element: () => fileChooser.element(),
+			isMultiple: Effect.sync(() => fileChooser.isMultiple()),
+			page: () => PlaywrightPage.make(fileChooser.page()),
+			setFiles: (files, options) => use(() => fileChooser.setFiles(files, options))
+		});
+	}
+};
+/**
+* @category model
+* @since 0.1.2
+*/
+var PlaywrightDownload = class PlaywrightDownload extends Data.TaggedClass("PlaywrightDownload") {
+	static make(download) {
+		const use = useHelper(download);
+		return new PlaywrightDownload({
+			cancel: use(() => download.cancel()),
+			createReadStream: Stream.empty,
+			delete: use(() => download.delete()),
+			failure: use(() => download.failure()).pipe(Effect.map(Option.fromNullable)),
+			page: () => PlaywrightPage.make(download.page()),
+			path: use(() => download.path()).pipe(Effect.map(Option.fromNullable)),
+			saveAs: (path) => use(() => download.saveAs(path)),
+			suggestedFilename: Effect.sync(() => download.suggestedFilename()),
+			url: Effect.sync(() => download.url()),
+			use
+		});
+	}
+};
+
+//#endregion
+//#region src/browser-context.ts
+const eventMappings$1 = {
+	backgroundpage: (page) => PlaywrightPage.make(page),
+	close: (context) => PlaywrightBrowserContext.make(context),
+	console: identity,
+	dialog: (dialog) => PlaywrightDialog.make(dialog),
+	page: (page) => PlaywrightPage.make(page),
+	request: (request) => PlaywrightRequest.make(request),
+	requestfailed: (request) => PlaywrightRequest.make(request),
+	requestfinished: (request) => PlaywrightRequest.make(request),
+	response: (response) => PlaywrightResponse.make(response),
+	serviceworker: (worker) => PlaywrightWorker.make(worker),
+	weberror: identity
+};
+/**
+* @category tag
+*/
+var PlaywrightBrowserContext = class PlaywrightBrowserContext extends Context.Tag("effect-playwright/PlaywrightBrowserContext")() {
+	/**
+	* Creates a `PlaywrightBrowserContext` from a Playwright `BrowserContext` instance.
+	*
+	* @param context - The Playwright `BrowserContext` instance to wrap.
+	* @since 0.1.0
+	*/
+	static make(context) {
+		const use = useHelper(context);
+		return PlaywrightBrowserContext.of({
+			pages: Effect.sync(() => context.pages().map(PlaywrightPage.make)),
+			newPage: use((c) => c.newPage().then(PlaywrightPage.make)),
+			close: use((c) => c.close()),
+			eventStream: (event) => Stream.asyncPush((emit) => Effect.acquireRelease(Effect.sync(() => {
+				context.on(event, emit.single);
+				context.once("close", emit.end);
+			}), () => Effect.sync(() => {
+				context.off(event, emit.single);
+				context.off("close", emit.end);
+			}))).pipe(Stream.map((e) => {
+				const mapping = eventMappings$1[event];
+				return mapping(e);
+			}))
+		});
+	}
+};
+
+//#endregion
+//#region src/browser.ts
+const eventMappings = { disconnected: (browser) => PlaywrightBrowser.make(browser) };
+/**
+* @category tag
+*/
+var PlaywrightBrowser = class PlaywrightBrowser extends Context.Tag("effect-playwright/PlaywrightBrowser")() {
+	/**
+	* @category constructor
+	*/
+	static make(browser) {
+		const use = useHelper(browser);
+		return PlaywrightBrowser.of({
+			newPage: (options) => use((browser$1) => browser$1.newPage(options).then(PlaywrightPage.make)),
+			close: use((browser$1) => browser$1.close()),
+			contexts: Effect.sync(() => browser.contexts().map(PlaywrightBrowserContext.make)),
+			newContext: (options) => Effect.acquireRelease(use((browser$1) => browser$1.newContext(options).then(PlaywrightBrowserContext.make)), (context) => context.close.pipe(Effect.ignoreLogged)),
+			browserType: Effect.sync(() => browser.browserType()),
+			version: Effect.sync(() => browser.version()),
+			isConnected: Effect.sync(() => browser.isConnected()),
+			eventStream: (event) => Stream.asyncPush((emit) => Effect.acquireRelease(Effect.sync(() => {
+				browser.on(event, emit.single);
+				browser.once("disconnected", emit.end);
+			}), () => Effect.sync(() => {
+				browser.off(event, emit.single);
+				browser.off("disconnected", emit.end);
+			}))).pipe(Stream.map((e) => {
+				const mapping = eventMappings[event];
+				return mapping(e);
+			})),
+			use
+		});
+	}
+};
+
+//#endregion
+//#region src/playwright.ts
+const launch = Effect.fn(function* (browserType, options) {
+	const rawBrowser = yield* Effect.tryPromise({
+		try: () => browserType.launch(options),
+		catch: wrapError
+	});
+	return PlaywrightBrowser.make(rawBrowser);
+});
+const connectCDP = Effect.fn(function* (cdpUrl, options) {
+	const browser = yield* Effect.tryPromise({
+		try: () => chromium.connectOverCDP(cdpUrl, options),
+		catch: wrapError
+	});
+	return PlaywrightBrowser.make(browser);
+});
+/**
+* @category tag
+* @since 0.1.0
+*/
+var Playwright = class Playwright extends Context.Tag("effect-playwright/index/Playwright")() {
+	/**
+	* @category layer
+	*/
+	static layer = Layer.succeed(Playwright, {
+		launch,
+		launchScoped: (browserType, options) => Effect.acquireRelease(launch(browserType, options), (browser) => browser.close.pipe(Effect.ignore)),
+		connectCDP,
+		connectCDPScoped: (cdpUrl, options) => Effect.acquireRelease(connectCDP(cdpUrl, options), (browser) => browser.close.pipe(Effect.ignore))
+	});
+};
+
+//#endregion
+export { PlaywrightDownload as a, PlaywrightRequest as c, PlaywrightPage as d, PlaywrightLocator as f, PlaywrightDialog as i, PlaywrightResponse as l, PlaywrightBrowser as n, PlaywrightFileChooser as o, PlaywrightError as p, PlaywrightBrowserContext as r, PlaywrightFrame as s, Playwright as t, PlaywrightWorker as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "effect-playwright",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "An Effect-based Playwright library.",
   "author": "Jobflow GmbH",
   "license": "ISC",
@@ -37,21 +37,25 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.11",
-    "@effect/language-service": "^0.64.1",
+    "@effect/language-service": "^0.69.2",
     "@effect/platform": "^0.94.1",
     "@effect/platform-node": "^0.104.0",
     "@effect/vitest": "^0.27.0",
+    "@types/node": "^25.0.9",
     "effect": "^3.19.14",
     "playwright": "^1.57.0",
-    "tsdown": "^0.19.0",
+    "tsdown": "0.20.0-beta.3",
     "tsx": "^4.21.0",
+    "typedoc": "^0.28.16",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.17"
   },
   "types": "./dist/index.d.mts",
   "scripts": {
     "build": "tsdown",
     "test": "vitest run",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "generate-docs": "typedoc",
+    "format-fix": "biome format --fix"
   }
 }