@allwright.dev/core 0.0.31 → 0.0.33

package/dist/locator.d.ts

@@ -0,0 +1,17 @@
+import type { ClickResult, CommandOptions, CountResult, ElementResult, FillResult, HighlightOptions, HighlightResult, Locator, LocatorInfo, Page, PressOptions, PressResult, TextResult, WaitForSelectorOptions, WaitForSelectorResult } from "./types.js";
+export declare class LocatorImpl implements Locator {
+    readonly page: Page;
+    readonly selector: string;
+    constructor(input: LocatorInfo);
+    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;
+}

package/dist/locator.js

@@ -0,0 +1,45 @@
+import { chainSelectorForTransport } from "./selectors.js";
+export class LocatorImpl {
+    page;
+    selector;
+    constructor(input) {
+        this.page = input.page;
+        this.selector = input.selector;
+    }
+    async click(options = {}) {
+        return this.page.click(this.selector, options);
+    }
+    async count(options = {}) {
+        return this.page.count(this.selector, options);
+    }
+    async highlight(options = {}) {
+        return this.page.highlight(this.selector, options);
+    }
+    async focus(options = {}) {
+        return this.page.focus(this.selector, options);
+    }
+    async fill(value, options = {}) {
+        return this.page.fill(this.selector, value, options);
+    }
+    async hover(options = {}) {
+        return this.page.hover(this.selector, options);
+    }
+    async press(key, options = {}) {
+        return this.page.press(this.selector, key, options);
+    }
+    async textContent(options = {}) {
+        return this.page.textContent(this.selector, options);
+    }
+    async innerText(options = {}) {
+        return this.page.innerText(this.selector, options);
+    }
+    async waitFor(options = {}) {
+        return this.page.waitForSelector(this.selector, options);
+    }
+    locator(selector) {
+        return new LocatorImpl({
+            page: this.page,
+            selector: chainSelectorForTransport(this.selector, selector),
+        });
+    }
+}

package/dist/page.d.ts

@@ -0,0 +1,25 @@
+import type { ClickResult, CommandOptions, CountResult, ElementResult, FillResult, HighlightOptions, HighlightResult, Locator, NavigateResult, Page, PageInfo, PressOptions, PressResult, RuntimeClient, TextResult, WaitForSelectorOptions, WaitForSelectorResult } from "./types.js";
+export declare class PageImpl implements Page {
+    #private;
+    constructor(input: PageInfo & {
+        runtime: RuntimeClient;
+    });
+    readonly sessionId: string;
+    readonly browserSessionId: string;
+    locator(selector: string): Locator;
+    goto(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;
+    navigate(url: string, options?: CommandOptions): Promise<NavigateResult>;
+}

package/dist/page.js

@@ -0,0 +1,418 @@
+import { LocatorImpl } from "./locator.js";
+import { normalizeSelectorForTransport } from "./selectors.js";
+import { createPageHandle } from "./runtime.js";
+export class PageImpl {
+    #runtime;
+    #handlePromise = null;
+    constructor(input) {
+        this.#runtime = input.runtime;
+        this.sessionId = input.sessionId;
+        this.browserSessionId = input.browserSessionId;
+    }
+    sessionId;
+    browserSessionId;
+    locator(selector) {
+        return new LocatorImpl({ page: this, selector: normalizeSelectorForTransport(selector) });
+    }
+    async goto(url, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            navigate: {
+                url,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        let navigated = null;
+        let injection = null;
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.navigated) {
+                navigated = event.navigated;
+            }
+            if (event.chromiumBidiInjection) {
+                injection = event.chromiumBidiInjection;
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while navigating: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while navigating`);
+            }
+            if (navigated && injection) {
+                return {
+                    url: navigated.url ?? "",
+                    note: navigated.note ?? "",
+                    bidiSessionId: injection.bidiSessionId ?? "",
+                    mapperTargetId: injection.mapperTargetId ?? "",
+                    mapperSessionId: injection.mapperSessionId ?? "",
+                    packageVersion: injection.packageVersion ?? "",
+                };
+            }
+        }
+    }
+    async click(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            clickElement: {
+                cssSelector: transportSelector,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementClicked) {
+                return {
+                    selector: event.elementClicked.cssSelector ?? "",
+                    note: event.elementClicked.note ?? "",
+                    bidiSessionId: event.elementClicked.bidiSessionId ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while clicking: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for click result`);
+            }
+        }
+    }
+    async count(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            countElements: {
+                cssSelector: transportSelector,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementCounted) {
+                return {
+                    selector: event.elementCounted.cssSelector ?? "",
+                    count: event.elementCounted.count ?? 0,
+                    note: event.elementCounted.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while counting elements: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for count result`);
+            }
+        }
+    }
+    async highlight(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            highlightElements: {
+                cssSelector: transportSelector,
+                durationMs: options.durationMs,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementsHighlighted) {
+                return {
+                    selector: event.elementsHighlighted.cssSelector ?? "",
+                    count: event.elementsHighlighted.count ?? 0,
+                    note: event.elementsHighlighted.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while highlighting elements: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for highlight result`);
+            }
+        }
+    }
+    async focus(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            focusElement: {
+                cssSelector: transportSelector,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementFocused) {
+                return {
+                    selector: event.elementFocused.cssSelector ?? "",
+                    note: event.elementFocused.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while focusing: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for focus result`);
+            }
+        }
+    }
+    async fill(selector, value, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            fillElement: {
+                cssSelector: transportSelector,
+                value,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementFilled) {
+                return {
+                    selector: event.elementFilled.cssSelector ?? "",
+                    value: event.elementFilled.value ?? "",
+                    note: event.elementFilled.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while filling: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for fill result`);
+            }
+        }
+    }
+    async hover(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            hoverElement: {
+                cssSelector: transportSelector,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.elementHovered) {
+                return {
+                    selector: event.elementHovered.cssSelector ?? "",
+                    note: event.elementHovered.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while hovering: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for hover result`);
+            }
+        }
+    }
+    async press(selector, key, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            pressKey: {
+                cssSelector: transportSelector,
+                key,
+                text: options.text,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.keyPressed) {
+                return {
+                    selector: event.keyPressed.cssSelector ?? "",
+                    key: event.keyPressed.key ?? "",
+                    note: event.keyPressed.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while pressing key: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for press result`);
+            }
+        }
+    }
+    async textContent(selector, options = {}) {
+        return this.#readText(selector, options, true);
+    }
+    async innerText(selector, options = {}) {
+        return this.#readText(selector, options, false);
+    }
+    async waitForSelector(selector, options = {}) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            waitForSelector: {
+                cssSelector: transportSelector,
+                visible: options.visible,
+                retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.selectorWaitSatisfied) {
+                return {
+                    selector: event.selectorWaitSatisfied.cssSelector ?? "",
+                    visible: event.selectorWaitSatisfied.visible ?? false,
+                    note: event.selectorWaitSatisfied.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while waiting for selector: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for selector result`);
+            }
+        }
+    }
+    async close() {
+        const handle = await this.#getHandle();
+        if (handle.closed) {
+            return;
+        }
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            close: {},
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.closed) {
+                handle.closed = true;
+                handle.stream.end();
+                return;
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while closing: ${event.error.message}`);
+            }
+        }
+    }
+    async ping(message = "ping") {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        handle.stream.write({
+            browserSessionId: this.browserSessionId,
+            tabSessionId: this.sessionId,
+            ping: {
+                message,
+            },
+        });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.pong?.message) {
+                return event.pong.message;
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while pinging: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for pong`);
+            }
+        }
+    }
+    pageInfo() {
+        return {
+            sessionId: this.sessionId,
+            browserSessionId: this.browserSessionId,
+        };
+    }
+    async navigate(url, options = {}) {
+        return this.goto(url, options);
+    }
+    async #readText(selector, options, textContent) {
+        const handle = await this.#getHandle();
+        this.#ensureOpen(handle);
+        const transportSelector = normalizeSelectorForTransport(selector);
+        handle.stream.write(textContent
+            ? {
+                browserSessionId: this.browserSessionId,
+                tabSessionId: this.sessionId,
+                getTextContent: {
+                    cssSelector: transportSelector,
+                    retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+                },
+            }
+            : {
+                browserSessionId: this.browserSessionId,
+                tabSessionId: this.sessionId,
+                getInnerText: {
+                    cssSelector: transportSelector,
+                    retryOptions: options.timeoutMs ? { timeoutMs: options.timeoutMs } : undefined,
+                },
+            });
+        while (true) {
+            const event = await handle.queue.next();
+            if (event.textContentResolved) {
+                return {
+                    selector: event.textContentResolved.cssSelector ?? "",
+                    text: event.textContentResolved.text ?? "",
+                    note: event.textContentResolved.note ?? "",
+                };
+            }
+            if (event.innerTextResolved) {
+                return {
+                    selector: event.innerTextResolved.cssSelector ?? "",
+                    text: event.innerTextResolved.text ?? "",
+                    note: event.innerTextResolved.note ?? "",
+                };
+            }
+            if (event.error?.message) {
+                throw new Error(`page session error while reading text: ${event.error.message}`);
+            }
+            if (event.closed) {
+                handle.closed = true;
+                throw new Error(`page session ${this.sessionId} closed while waiting for text result`);
+            }
+        }
+    }
+    #ensureOpen(handle) {
+        if (handle.closed) {
+            throw new Error(`page session ${this.sessionId} is closed`);
+        }
+    }
+    async #getHandle() {
+        if (!this.#handlePromise) {
+            this.#handlePromise = createPageHandle(this.#runtime);
+        }
+        return this.#handlePromise;
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,14 @@
+import { EventQueue } from "./types.js";
+import type { BrowserSessionEvent, BrowserSessionStream, Browser, BrowserKind, LaunchOptions, PageHandle, ResolveConfigOptions, ResolvedAllwrightConfig, RuntimeClient } from "./types.js";
+export declare function setServerAddr(serverAddr: string): void;
+export declare function shutdown(): Promise<void>;
+export declare function ping(): Promise<string>;
+export declare function getRuntime(): Promise<RuntimeClient>;
+export declare function createPageHandle(runtime: RuntimeClient): Promise<PageHandle>;
+export declare function createBrowserSessionHandle(runtime: RuntimeClient): Promise<{
+    stream: BrowserSessionStream;
+    queue: EventQueue<BrowserSessionEvent>;
+}>;
+export declare function launchConfiguredBrowser(config: ResolvedAllwrightConfig, launchBrowserKind: (browserKind: BrowserKind, options?: LaunchOptions) => Promise<Browser>): Promise<Browser>;
+export declare function normalizeServerAddr(raw: string): string;
+export declare function resolveLaunchBrowserArgs(browserKindOrOptions: BrowserKind | ResolveConfigOptions | undefined): browserKindOrOptions is undefined | ResolveConfigOptions;

package/dist/runtime.js

@@ -0,0 +1,107 @@
+import { fileURLToPath } from "node:url";
+import grpc from "@grpc/grpc-js";
+import protoLoader from "@grpc/proto-loader";
+import { EventQueue } from "./types.js";
+const DEFAULT_SERVER_ADDR = "127.0.0.1:50051";
+const SERVER_ADDR_ENV_VAR = "ALLWRIGHT_SERVER_ADDR";
+const PROTO_ROOT = fileURLToPath(new URL("../proto/", import.meta.url));
+const ENGINE_PROTO_PATH = fileURLToPath(new URL("../proto/engine/v1/engine.proto", import.meta.url));
+let runtimePromise = null;
+let serverAddrOverride = null;
+export function setServerAddr(serverAddr) {
+    serverAddrOverride = normalizeServerAddr(serverAddr);
+    runtimePromise = null;
+}
+export async function shutdown() {
+    if (!runtimePromise) {
+        return;
+    }
+    const runtime = await runtimePromise;
+    runtime.client.close();
+    runtimePromise = null;
+}
+export async function ping() {
+    const runtime = await getRuntime();
+    return new Promise((resolve, reject) => {
+        runtime.client.Ping({}, (error, response) => {
+            if (error) {
+                reject(new Error(`ping engine server: ${error.message}`));
+                return;
+            }
+            resolve(response.message ?? "");
+        });
+    });
+}
+export async function getRuntime() {
+    if (!runtimePromise) {
+        runtimePromise = Promise.resolve(createRuntime());
+    }
+    return runtimePromise;
+}
+export async function createPageHandle(runtime) {
+    const stream = runtime.client.TabSession();
+    const queue = bindStreamQueue(stream);
+    return {
+        stream,
+        queue,
+        closed: false,
+    };
+}
+export async function createBrowserSessionHandle(runtime) {
+    const stream = runtime.client.BrowserSession();
+    const queue = bindStreamQueue(stream);
+    return { stream, queue };
+}
+export async function launchConfiguredBrowser(config, launchBrowserKind) {
+    return launchBrowserKind(config.browserName, {
+        ...config.launchOptions,
+        browserBinary: config.browserBinary ?? config.launchOptions.browserBinary,
+    });
+}
+export function normalizeServerAddr(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("dns:") || trimmed.startsWith("unix:")) {
+        return trimmed;
+    }
+    if (trimmed.includes("://")) {
+        const parsed = new URL(trimmed);
+        return parsed.host;
+    }
+    return trimmed;
+}
+export function resolveLaunchBrowserArgs(browserKindOrOptions) {
+    return browserKindOrOptions === undefined || typeof browserKindOrOptions !== "string";
+}
+function createRuntime() {
+    const loaded = protoLoader.loadSync(ENGINE_PROTO_PATH, {
+        includeDirs: [PROTO_ROOT],
+        keepCase: false,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true,
+    });
+    const proto = grpc.loadPackageDefinition(loaded);
+    const ClientCtor = proto.allwright.engine.v1.EngineService;
+    const client = new ClientCtor(configuredServerAddr(), grpc.credentials.createInsecure());
+    return { client };
+}
+function configuredServerAddr() {
+    if (serverAddrOverride) {
+        return serverAddrOverride;
+    }
+    return normalizeServerAddr(process.env[SERVER_ADDR_ENV_VAR] ?? DEFAULT_SERVER_ADDR);
+}
+function bindStreamQueue(stream) {
+    const queue = new EventQueue();
+    stream.on("data", (event) => {
+        queue.push(event);
+    });
+    stream.on("error", (error) => {
+        queue.fail(new Error(`grpc stream error: ${error.message}`));
+    });
+    stream.on("end", () => {
+        queue.fail(new Error("grpc stream ended"));
+    });
+    return queue;
+}

package/dist/selectors.d.ts

@@ -0,0 +1,7 @@
+export type SelectorFlavor = "css" | "xpath";
+export declare function parseSelectorForTransport(selector: string): {
+    flavor: SelectorFlavor;
+    body: string;
+};
+export declare function normalizeSelectorForTransport(selector: string): string;
+export declare function chainSelectorForTransport(parent: string, child: string): string;

package/dist/selectors.js

@@ -0,0 +1,33 @@
+export function parseSelectorForTransport(selector) {
+    const trimmed = selector.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower.startsWith("xpath=") || lower.startsWith("xpath:")) {
+        return { flavor: "xpath", body: trimmed.slice(6).trim() };
+    }
+    if (lower.startsWith("css=") || lower.startsWith("css:")) {
+        return { flavor: "css", body: trimmed.slice(4).trim() };
+    }
+    if (trimmed.startsWith("//") ||
+        trimmed.startsWith(".//") ||
+        trimmed.startsWith("../") ||
+        trimmed.startsWith("/") ||
+        trimmed.startsWith("(")) {
+        return { flavor: "xpath", body: trimmed };
+    }
+    return { flavor: "css", body: trimmed };
+}
+export function normalizeSelectorForTransport(selector) {
+    const parsed = parseSelectorForTransport(selector);
+    return `${parsed.flavor}=${JSON.stringify(parsed.body)}`;
+}
+export function chainSelectorForTransport(parent, child) {
+    const parentSelector = normalizeSelectorForTransport(parent);
+    const childSelector = normalizeSelectorForTransport(child);
+    if (!parentSelector) {
+        return childSelector;
+    }
+    if (!childSelector) {
+        return parentSelector;
+    }
+    return `${parentSelector} ${childSelector}`;
+}