@allwright.dev/core 0.0.32 → 0.0.34

package/dist/browser.d.ts

@@ -0,0 +1,24 @@
+import type { Browser, BrowserInfo, BrowserKind, BrowserLaunchState, BrowserType, CommandOptions, LaunchOptions, Page } from "./types.js";
+export declare class BrowserTypeImpl implements BrowserType {
+    #private;
+    constructor(browserKind?: BrowserKind);
+    launch(options?: LaunchOptions): Promise<Browser>;
+}
+export declare class BrowserImpl implements Browser {
+    #private;
+    constructor(state: BrowserLaunchState);
+    readonly sessionId: string;
+    readonly browserName: string;
+    readonly launchNote: string;
+    readonly cdpWebSocketURL: string;
+    readonly userDataDir: string;
+    page(): Page;
+    initialPage(): Page;
+    pages(): Page[];
+    newPage(options?: CommandOptions): Promise<Page>;
+    close(): Promise<void>;
+    ping(message?: string): Promise<string>;
+    browserInfo(): BrowserInfo;
+    initialTab(): Page;
+    newTab(options?: CommandOptions): Promise<Page>;
+}

package/dist/browser.js

@@ -0,0 +1,137 @@
+import { PageImpl } from "./page.js";
+export class BrowserTypeImpl {
+    #browserKind;
+    constructor(browserKind = "chromium") {
+        this.#browserKind = browserKind;
+    }
+    async launch(options = {}) {
+        const { launchBrowser } = await import("./index.js");
+        return launchBrowser(this.#browserKind, options);
+    }
+}
+export class BrowserImpl {
+    #closed = false;
+    #runtime;
+    #stream;
+    #queue;
+    #pages = new Map();
+    #initialPage;
+    constructor(state) {
+        const browserInfo = {
+            sessionId: state.sessionId,
+            browserName: state.launched.browser ?? "",
+            launchNote: state.launched.note ?? "",
+            cdpWebSocketURL: "",
+            userDataDir: state.launched.userDataDir ?? "",
+        };
+        this.#runtime = state.runtime;
+        this.#stream = state.stream;
+        this.#queue = state.queue;
+        this.sessionId = browserInfo.sessionId;
+        this.browserName = browserInfo.browserName;
+        this.launchNote = browserInfo.launchNote;
+        this.cdpWebSocketURL = browserInfo.cdpWebSocketURL;
+        this.userDataDir = browserInfo.userDataDir;
+        this.#initialPage = this.#createPage(state.launched.initialTabSessionId ?? "");
+    }
+    sessionId;
+    browserName;
+    launchNote;
+    cdpWebSocketURL;
+    userDataDir;
+    page() {
+        return this.#initialPage;
+    }
+    initialPage() {
+        return this.#initialPage;
+    }
+    pages() {
+        return [...this.#pages.values()];
+    }
+    async newPage(options = {}) {
+        this.#ensureOpen();
+        this.#stream.write({
+            openTab: {
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await this.#queue.next();
+            if (event.tabOpened?.tabSessionId) {
+                return this.#createPage(event.tabOpened.tabSessionId);
+            }
+            if (event.error?.message) {
+                throw new Error(`browser session error while opening tab: ${event.error.message}`);
+            }
+        }
+    }
+    async close() {
+        if (this.#closed) {
+            return;
+        }
+        this.#stream.write({
+            close: {},
+        });
+        while (true) {
+            const event = await this.#queue.next();
+            if (event.closed) {
+                this.#closed = true;
+                this.#stream.end();
+                return;
+            }
+            if (event.error?.message) {
+                throw new Error(`browser session error while closing: ${event.error.message}`);
+            }
+        }
+    }
+    async ping(message = "ping") {
+        this.#ensureOpen();
+        this.#stream.write({
+            ping: {
+                message,
+            },
+        });
+        while (true) {
+            const event = await this.#queue.next();
+            if (event.pong?.message) {
+                return event.pong.message;
+            }
+            if (event.error?.message) {
+                throw new Error(`browser session error while pinging: ${event.error.message}`);
+            }
+        }
+    }
+    browserInfo() {
+        return {
+            sessionId: this.sessionId,
+            browserName: this.browserName,
+            launchNote: this.launchNote,
+            cdpWebSocketURL: this.cdpWebSocketURL,
+            userDataDir: this.userDataDir,
+        };
+    }
+    initialTab() {
+        return this.initialPage();
+    }
+    async newTab(options = {}) {
+        return this.newPage(options);
+    }
+    #createPage(sessionId) {
+        const existing = this.#pages.get(sessionId);
+        if (existing) {
+            return existing;
+        }
+        const page = new PageImpl({
+            runtime: this.#runtime,
+            browserSessionId: this.sessionId,
+            sessionId,
+        });
+        this.#pages.set(sessionId, page);
+        return page;
+    }
+    #ensureOpen() {
+        if (this.#closed) {
+            throw new Error(`browser session ${this.sessionId} is closed`);
+        }
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { AllwrightConfig, ResolveConfigOptions, ResolvedAllwrightConfig } from "./types.js";
+export declare function findConfigFile(startDir?: string): string | null;
+export declare function loadConfigFile(configFile: string): AllwrightConfig;
+export declare function resolveConfig(options?: ResolveConfigOptions): ResolvedAllwrightConfig;

package/dist/config.js

@@ -0,0 +1,177 @@
+import fs from "node:fs";
+import path from "node:path";
+const CONFIG_FILENAMES = [
+    "allwright.config.yaml",
+    "allwright.config.yml",
+    "allwright.config.json",
+    ".allwright/config.yaml",
+    ".allwright/config.yml",
+    ".allwright/config.json",
+];
+export function findConfigFile(startDir = process.cwd()) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        for (const filename of CONFIG_FILENAMES) {
+            const candidate = path.join(currentDir, filename);
+            if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+                return candidate;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+export function loadConfigFile(configFile) {
+    const resolved = path.resolve(configFile);
+    const raw = fs.readFileSync(resolved, "utf8");
+    const parsed = parseConfigContents(raw, resolved);
+    validateConfigShape(parsed, resolved);
+    return parsed;
+}
+export function resolveConfig(options = {}) {
+    const configFilePath = options.configFile ? path.resolve(options.configFile) : findConfigFile(options.cwd);
+    const fileConfig = configFilePath ? loadConfigFile(configFilePath) : {};
+    const suiteName = options.suite?.trim() || null;
+    const suiteConfig = suiteName ? fileConfig.suites?.[suiteName] : undefined;
+    if (suiteName && !suiteConfig) {
+        throw new Error(`allwright config suite "${suiteName}" was not found in ${configFilePath ?? "the resolved config file"}`);
+    }
+    const serverAddr = suiteConfig?.server?.addr ?? fileConfig.server?.addr;
+    const browserName = suiteConfig?.browser?.name ?? fileConfig.browser?.name ?? "chromium";
+    const browserBinary = suiteConfig?.browser?.binary ?? fileConfig.browser?.binary;
+    const launchOptions = mergeLaunchOptions(fileConfig.browser?.launchOptions, suiteConfig?.browser?.launchOptions);
+    const expect = {
+        ...(fileConfig.expect ?? {}),
+        ...(suiteConfig?.expect ?? {}),
+    };
+    return {
+        configFilePath,
+        suiteName,
+        serverAddr,
+        browserName,
+        browserBinary,
+        launchOptions: browserBinary ? { ...launchOptions, browserBinary } : launchOptions,
+        expect,
+    };
+}
+function mergeLaunchOptions(base, override) {
+    return {
+        ...(base ?? {}),
+        ...(override ?? {}),
+    };
+}
+function validateConfigShape(value, source) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`allwright config ${source} must contain a top-level object`);
+    }
+    const config = value;
+    if (config.schemaVersion !== undefined && config.schemaVersion !== 1) {
+        throw new Error(`allwright config ${source} has unsupported schemaVersion ${String(config.schemaVersion)}; expected 1`);
+    }
+    const browserName = config.browser?.name;
+    if (browserName !== undefined && browserName !== "chromium" && browserName !== "firefox") {
+        throw new Error(`allwright config ${source} has unsupported browser.name ${String(browserName)}; use "chromium" or "firefox"`);
+    }
+}
+function parseConfigContents(raw, source) {
+    const extension = path.extname(source).toLowerCase();
+    if (extension === ".json") {
+        return JSON.parse(raw);
+    }
+    if (extension === ".yaml" || extension === ".yml") {
+        return parseSimpleYaml(raw, source);
+    }
+    throw new Error(`unsupported allwright config file extension ${extension || "<none>"} for ${source}`);
+}
+function parseSimpleYaml(raw, source) {
+    const root = {};
+    const stack = [
+        { indent: -1, value: root },
+    ];
+    for (const [index, originalLine] of raw.split(/\r?\n/).entries()) {
+        const lineNumber = index + 1;
+        const line = stripYamlComment(originalLine);
+        if (!line.trim()) {
+            continue;
+        }
+        const indent = countLeadingSpaces(line);
+        if (indent % 2 !== 0) {
+            throw new Error(`invalid YAML indentation in ${source}:${lineNumber}; use multiples of 2 spaces`);
+        }
+        while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+            stack.pop();
+        }
+        const current = stack[stack.length - 1];
+        const trimmed = line.trim();
+        const separatorIndex = trimmed.indexOf(":");
+        if (separatorIndex <= 0) {
+            throw new Error(`invalid YAML mapping in ${source}:${lineNumber}`);
+        }
+        const key = trimmed.slice(0, separatorIndex).trim();
+        const rawValue = trimmed.slice(separatorIndex + 1).trim();
+        if (!key) {
+            throw new Error(`empty YAML key in ${source}:${lineNumber}`);
+        }
+        if (!rawValue) {
+            const child = {};
+            current.value[key] = child;
+            stack.push({ indent, value: child });
+            continue;
+        }
+        current.value[key] = parseYamlScalar(rawValue, source, lineNumber);
+    }
+    return root;
+}
+function stripYamlComment(line) {
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (char === "'" && !inDoubleQuote) {
+            inSingleQuote = !inSingleQuote;
+            continue;
+        }
+        if (char === "\"" && !inSingleQuote) {
+            inDoubleQuote = !inDoubleQuote;
+            continue;
+        }
+        if (char === "#" && !inSingleQuote && !inDoubleQuote) {
+            return line.slice(0, index);
+        }
+    }
+    return line;
+}
+function countLeadingSpaces(line) {
+    let count = 0;
+    while (count < line.length && line[count] === " ") {
+        count += 1;
+    }
+    return count;
+}
+function parseYamlScalar(value, source, lineNumber) {
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    if (value === "true") {
+        return true;
+    }
+    if (value === "false") {
+        return false;
+    }
+    if (value === "null") {
+        return null;
+    }
+    if (/^-?\d+$/.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    if (/^-?\d+\.\d+$/.test(value)) {
+        return Number.parseFloat(value);
+    }
+    if (value.startsWith("[") || value.startsWith("{")) {
+        throw new Error(`unsupported YAML collection syntax in ${source}:${lineNumber}; use nested mappings instead`);
+    }
+    return value;
+}

package/dist/index.d.ts

@@ -1,183 +1,18 @@
-export interface LaunchOptions {
-    browserBinary?: string;
-    timeoutMs?: number;
-}
-export type BrowserKind = "chromium" | "firefox";
-export interface CommandOptions {
-    timeoutMs?: number;
-}
-export interface NavigateResult {
-    url: string;
-    note: string;
-    bidiSessionId: string;
-    mapperTargetId: string;
-    mapperSessionId: string;
-    packageVersion: string;
-}
-export interface ClickResult {
-    selector: string;
-    note: string;
-    bidiSessionId: string;
-}
-export interface CountResult {
-    selector: string;
-    count: number;
-    note: string;
-}
-export interface HighlightOptions {
-    timeoutMs?: number;
-    durationMs?: number;
-}
-export interface HighlightResult {
-    selector: string;
-    count: number;
-    note: string;
-}
-export interface ElementResult {
-    selector: string;
-    note: string;
-}
-export interface FillResult {
-    selector: string;
-    value: string;
-    note: string;
-}
-export interface PressOptions {
-    timeoutMs?: number;
-    text?: string;
-}
-export interface PressResult {
-    selector: string;
-    key: string;
-    note: string;
-}
-export interface TextResult {
-    selector: string;
-    text: string;
-    note: string;
-}
-export interface WaitForSelectorOptions {
-    timeoutMs?: number;
-    visible?: boolean;
-}
-export interface WaitForSelectorResult {
-    selector: string;
-    visible: boolean;
-    note: string;
-}
-export interface BrowserInfo {
-    sessionId: string;
-    browserName: string;
-    launchNote: string;
-    cdpWebSocketURL: string;
-    userDataDir: string;
-}
-export interface PageInfo {
-    sessionId: string;
-    browserSessionId: string;
-}
-export interface LocatorInfo {
-    page: Page;
-    selector: string;
-}
-export interface BrowserType {
-    launch(options?: LaunchOptions): Promise<Browser>;
-}
-export interface Browser extends BrowserInfo {
-    page(): Page;
-    initialPage(): Page;
-    initialTab(): Page;
-    pages(): Page[];
-    newPage(options?: CommandOptions): Promise<Page>;
-    newTab(options?: CommandOptions): Promise<Page>;
-    close(): Promise<void>;
-    ping(message?: string): Promise<string>;
-    browserInfo(): BrowserInfo;
-}
-export interface Page extends PageInfo {
-    locator(selector: string): Locator;
-    goto(url: string, options?: CommandOptions): Promise<NavigateResult>;
-    navigate(url: string, options?: CommandOptions): Promise<NavigateResult>;
-    click(selector: string, options?: CommandOptions): Promise<ClickResult>;
-    count(selector: string, options?: CommandOptions): Promise<CountResult>;
-    highlight(selector: string, options?: HighlightOptions): Promise<HighlightResult>;
-    focus(selector: string, options?: CommandOptions): Promise<ElementResult>;
-    fill(selector: string, value: string, options?: CommandOptions): Promise<FillResult>;
-    hover(selector: string, options?: CommandOptions): Promise<ElementResult>;
-    press(selector: string, key: string, options?: PressOptions): Promise<PressResult>;
-    textContent(selector: string, options?: CommandOptions): Promise<TextResult>;
-    innerText(selector: string, options?: CommandOptions): Promise<TextResult>;
-    waitForSelector(selector: string, options?: WaitForSelectorOptions): Promise<WaitForSelectorResult>;
-    close(): Promise<void>;
-    ping(message?: string): Promise<string>;
-    pageInfo(): PageInfo;
-}
-export interface Locator {
-    readonly page: Page;
-    readonly selector: string;
-    click(options?: CommandOptions): Promise<ClickResult>;
-    count(options?: CommandOptions): Promise<CountResult>;
-    highlight(options?: HighlightOptions): Promise<HighlightResult>;
-    focus(options?: CommandOptions): Promise<ElementResult>;
-    fill(value: string, options?: CommandOptions): Promise<FillResult>;
-    hover(options?: CommandOptions): Promise<ElementResult>;
-    press(key: string, options?: PressOptions): Promise<PressResult>;
-    textContent(options?: CommandOptions): Promise<TextResult>;
-    innerText(options?: CommandOptions): Promise<TextResult>;
-    waitFor(options?: WaitForSelectorOptions): Promise<WaitForSelectorResult>;
-    locator(selector: string): Locator;
-}
-export interface AllwrightConfig {
-    schemaVersion?: 1;
-    server?: {
-        addr?: string;
-    };
-    browser?: {
-        name?: BrowserKind;
-        binary?: string;
-        launchOptions?: LaunchOptions;
-    };
-    expect?: RetryConfig;
-    suites?: Record<string, AllwrightSuiteConfig>;
-}
-export interface AllwrightSuiteConfig {
-    server?: {
-        addr?: string;
-    };
-    browser?: {
-        name?: BrowserKind;
-        binary?: string;
-        launchOptions?: LaunchOptions;
-    };
-    expect?: RetryConfig;
-}
-export interface RetryConfig {
-    timeoutMs?: number;
-    intervalMs?: number;
-}
-export interface ResolvedAllwrightConfig {
-    configFilePath: string | null;
-    suiteName: string | null;
-    serverAddr?: string;
-    browserName: BrowserKind;
-    browserBinary?: string;
-    launchOptions: LaunchOptions;
-    expect: RetryConfig;
-}
-export interface ResolveConfigOptions {
-    cwd?: string;
-    configFile?: string;
-    suite?: string;
-}
+import { BrowserImpl, BrowserTypeImpl } from "./browser.js";
+import { findConfigFile, loadConfigFile, resolveConfig } from "./config.js";
+import { PageImpl } from "./page.js";
+import { setServerAddr, shutdown } from "./runtime.js";
+import type { Browser, BrowserKind, BrowserType, LaunchOptions, Page, ResolveConfigOptions, ResolvedAllwrightConfig } from "./types.js";
+export { findConfigFile, loadConfigFile, resolveConfig, setServerAddr, shutdown };
+export type { AllwrightConfig, Browser, BrowserInfo, BrowserKind, BrowserType, ClickResult, CommandOptions, CountResult, ElementResult, FillResult, HighlightOptions, HighlightResult, LaunchOptions, Locator, LocatorInfo, NavigateResult, Page, PageInfo, PressOptions, PressResult, ResolveConfigOptions, ResolvedAllwrightConfig, RetryConfig, TextResult, WaitForSelectorOptions, WaitForSelectorResult, } from "./types.js";
 export declare const chromium: BrowserType;
 export declare const firefox: BrowserType;
 export type Tab = Page;
 export declare function ping(): Promise<string>;
 export declare function launchChrome(options?: LaunchOptions): Promise<Browser>;
+export declare function launchFirefox(options?: LaunchOptions): Promise<Browser>;
 export declare function launchConfiguredBrowser(config: ResolvedAllwrightConfig): Promise<Browser>;
+export declare function launchBrowser(): Promise<Browser>;
+export declare function launchBrowser(options: ResolveConfigOptions): Promise<Browser>;
 export declare function launchBrowser(browserKind: BrowserKind, options?: LaunchOptions): Promise<Browser>;
-export declare function setServerAddr(serverAddr: string): void;
-export declare function shutdown(): Promise<void>;
-export declare function findConfigFile(startDir?: string): string | null;
-export declare function loadConfigFile(configFile: string): AllwrightConfig;
-export declare function resolveConfig(options?: ResolveConfigOptions): ResolvedAllwrightConfig;
+export { BrowserImpl, BrowserTypeImpl, PageImpl };