Skip to content

chore: pass markTargets explicitly into action methods #40705

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
dgozman wants to merge 1 commit into
base: main
Choose a base branch
from
+123 −116
Open

chore: pass markTargets explicitly into action methods #40705

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
13 changes: 7 additions & 6 deletions packages/injected/src/injectedScript.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -49,6 +49,7 @@ export type FrameExpectParams = Omit<channels.FrameExpectParams, 'expectedValue'
expectedValue?: any;
timeoutForLogs?: number;
noAutoWaiting?: boolean;
markTargets?: string;
};

export type ElementState = 'visible' | 'hidden' | 'enabled' | 'disabled' | 'editable' | 'checked' | 'unchecked' | 'indeterminate' | 'stable';
Expand Down Expand Up @@ -93,7 +94,7 @@ export class InjectedScript {
readonly isUnderTest: boolean;
private _sdkLanguage: Language;
private _testIdAttributeNameForStrictErrorAndConsoleCodegen: string = 'data-testid';
private _markedElements?: { callId: string, elements: Set<Element> };
private _markedElements?: { markTargets: string, elements: Set<Element> };
readonly window: Window & typeof globalThis;
readonly document: Document;
readonly consoleApi: ConsoleAPI;
Expand Down Expand Up @@ -1379,15 +1380,15 @@ export class InjectedScript {
}
}

markTargetElements(markedElements: Set<Element>, callId: string) {
if (this._markedElements?.callId !== callId)
markTargetElements(markedElements: Set<Element>, markTargets: string) {
if (this._markedElements?.markTargets !== markTargets)
this._markedElements = undefined;
const previous = this._markedElements?.elements || new Set();

const unmarkEvent = new CustomEvent('__playwright_unmark_target__', {
bubbles: true,
cancelable: true,
detail: callId,
detail: markTargets,
composed: true,
});
for (const element of previous) {
Expand All @@ -1398,15 +1399,15 @@ export class InjectedScript {
const markEvent = new CustomEvent('__playwright_mark_target__', {
bubbles: true,
cancelable: true,
detail: callId,
detail: markTargets,
composed: true,
});
for (const element of markedElements) {
if (!previous.has(element))
element.dispatchEvent(markEvent);
}

this._markedElements = { callId, elements: markedElements };
this._markedElements = { markTargets, elements: markedElements };
}

private _setupGlobalListenersRemovalDetection() {
Expand Down
48 changes: 24 additions & 24 deletions packages/playwright-core/src/server/dispatchers/elementHandlerDispatcher.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -66,111 +66,111 @@ export class ElementHandleDispatcher extends JSHandleDispatcher<FrameDispatcher>
}

async getAttribute(params: channels.ElementHandleGetAttributeParams, progress: Progress): Promise<channels.ElementHandleGetAttributeResult> {
const value = await this._elementHandle.getAttribute(progress, params.name);
const value = await this._elementHandle.getAttribute(progress, params.name, { markTargets: progress.metadata.id });
Copy link
Copy Markdown
Member

@pavelfeldman pavelfeldman May 7, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This does not make much sense to me! Why are you passing this?

return { value: value === null ? undefined : value };
}

async inputValue(params: channels.ElementHandleInputValueParams, progress: Progress): Promise<channels.ElementHandleInputValueResult> {
const value = await this._elementHandle.inputValue(progress);
const value = await this._elementHandle.inputValue(progress, { markTargets: progress.metadata.id });
return { value };
}

async textContent(params: channels.ElementHandleTextContentParams, progress: Progress): Promise<channels.ElementHandleTextContentResult> {
const value = await this._elementHandle.textContent(progress);
const value = await this._elementHandle.textContent(progress, { markTargets: progress.metadata.id });
return { value: value === null ? undefined : value };
}

async innerText(params: channels.ElementHandleInnerTextParams, progress: Progress): Promise<channels.ElementHandleInnerTextResult> {
return { value: await this._elementHandle.innerText(progress) };
return { value: await this._elementHandle.innerText(progress, { markTargets: progress.metadata.id }) };
}

async innerHTML(params: channels.ElementHandleInnerHTMLParams, progress: Progress): Promise<channels.ElementHandleInnerHTMLResult> {
return { value: await this._elementHandle.innerHTML(progress) };
return { value: await this._elementHandle.innerHTML(progress, { markTargets: progress.metadata.id }) };
}

async isChecked(params: channels.ElementHandleIsCheckedParams, progress: Progress): Promise<channels.ElementHandleIsCheckedResult> {
return { value: await this._elementHandle.isChecked(progress) };
return { value: await this._elementHandle.isChecked(progress, { markTargets: progress.metadata.id }) };
}

async isDisabled(params: channels.ElementHandleIsDisabledParams, progress: Progress): Promise<channels.ElementHandleIsDisabledResult> {
return { value: await this._elementHandle.isDisabled(progress) };
return { value: await this._elementHandle.isDisabled(progress, { markTargets: progress.metadata.id }) };
}

async isEditable(params: channels.ElementHandleIsEditableParams, progress: Progress): Promise<channels.ElementHandleIsEditableResult> {
return { value: await this._elementHandle.isEditable(progress) };
return { value: await this._elementHandle.isEditable(progress, { markTargets: progress.metadata.id }) };
}

async isEnabled(params: channels.ElementHandleIsEnabledParams, progress: Progress): Promise<channels.ElementHandleIsEnabledResult> {
return { value: await this._elementHandle.isEnabled(progress) };
return { value: await this._elementHandle.isEnabled(progress, { markTargets: progress.metadata.id }) };
}

async isHidden(params: channels.ElementHandleIsHiddenParams, progress: Progress): Promise<channels.ElementHandleIsHiddenResult> {
return { value: await this._elementHandle.isHidden(progress) };
return { value: await this._elementHandle.isHidden(progress, { markTargets: progress.metadata.id }) };
}

async isVisible(params: channels.ElementHandleIsVisibleParams, progress: Progress): Promise<channels.ElementHandleIsVisibleResult> {
return { value: await this._elementHandle.isVisible(progress) };
return { value: await this._elementHandle.isVisible(progress, { markTargets: progress.metadata.id }) };
}

async dispatchEvent(params: channels.ElementHandleDispatchEventParams, progress: Progress): Promise<void> {
await this._elementHandle.dispatchEvent(progress, params.type, parseArgument(params.eventInit));
await this._elementHandle.dispatchEvent(progress, params.type, parseArgument(params.eventInit), { markTargets: progress.metadata.id });
}

async scrollIntoViewIfNeeded(params: channels.ElementHandleScrollIntoViewIfNeededParams, progress: Progress): Promise<void> {
await this._elementHandle.scrollIntoViewIfNeeded(progress);
}

async hover(params: channels.ElementHandleHoverParams, progress: Progress): Promise<void> {
return await this._elementHandle.hover(progress, params);
return await this._elementHandle.hover(progress, { ...params, markTargets: progress.metadata.id });
}

async click(params: channels.ElementHandleClickParams, progress: Progress): Promise<void> {
return await this._elementHandle.click(progress, params);
return await this._elementHandle.click(progress, { ...params, markTargets: progress.metadata.id });
}

async dblclick(params: channels.ElementHandleDblclickParams, progress: Progress): Promise<void> {
return await this._elementHandle.dblclick(progress, params);
return await this._elementHandle.dblclick(progress, { ...params, markTargets: progress.metadata.id });
}

async tap(params: channels.ElementHandleTapParams, progress: Progress): Promise<void> {
return await this._elementHandle.tap(progress, params);
return await this._elementHandle.tap(progress, { ...params, markTargets: progress.metadata.id });
}

async selectOption(params: channels.ElementHandleSelectOptionParams, progress: Progress): Promise<channels.ElementHandleSelectOptionResult> {
const elements = (params.elements || []).map(e => (e as ElementHandleDispatcher)._elementHandle);
return { values: await this._elementHandle.selectOption(progress, elements, params.options || [], params) };
return { values: await this._elementHandle.selectOption(progress, elements, params.options || [], { ...params, markTargets: progress.metadata.id }) };
}

async fill(params: channels.ElementHandleFillParams, progress: Progress): Promise<void> {
return await this._elementHandle.fill(progress, params.value, params);
return await this._elementHandle.fill(progress, params.value, { ...params, markTargets: progress.metadata.id });
}

async selectText(params: channels.ElementHandleSelectTextParams, progress: Progress): Promise<void> {
await this._elementHandle.selectText(progress, params);
}

async setInputFiles(params: channels.ElementHandleSetInputFilesParams, progress: Progress): Promise<void> {
return await this._elementHandle.setInputFiles(progress, params);
return await this._elementHandle.setInputFiles(progress, { ...params, markTargets: progress.metadata.id });
}

async focus(params: channels.ElementHandleFocusParams, progress: Progress): Promise<void> {
await this._elementHandle.focus(progress);
await this._elementHandle.focus(progress, { markTargets: progress.metadata.id });
}

async type(params: channels.ElementHandleTypeParams, progress: Progress): Promise<void> {
return await this._elementHandle.type(progress, params.text, params);
return await this._elementHandle.type(progress, params.text, { ...params, markTargets: progress.metadata.id });
}

async press(params: channels.ElementHandlePressParams, progress: Progress): Promise<void> {
return await this._elementHandle.press(progress, params.key, params);
return await this._elementHandle.press(progress, params.key, { ...params, markTargets: progress.metadata.id });
}

async check(params: channels.ElementHandleCheckParams, progress: Progress): Promise<void> {
return await this._elementHandle.check(progress, params);
return await this._elementHandle.check(progress, { ...params, markTargets: progress.metadata.id });
}

async uncheck(params: channels.ElementHandleUncheckParams, progress: Progress): Promise<void> {
return await this._elementHandle.uncheck(progress, params);
return await this._elementHandle.uncheck(progress, { ...params, markTargets: progress.metadata.id });
}

async boundingBox(params: channels.ElementHandleBoundingBoxParams, progress: Progress): Promise<channels.ElementHandleBoundingBoxResult> {
Expand Down
Loading
Loading