@rvoh/psychic-spec-helpers 0.3.1-fgbeta-8 → 0.3.1

package/dist/types/src/feature/matchers/toClickLink.d.ts

@@ -1,5 +1,8 @@
-import { Page } from 'puppeteer';
-export default function toClickLink(page: Page, expectedText: string): Promise<{
-    message: () => string;
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toClickLink(page: Page, expectedText: string, opts?: WaitForSelectorOptions): Promise<{
     pass: boolean;
+    message: () => never;
+} | {
+    pass: boolean;
+    message: string;
 }>;

package/dist/types/src/feature/matchers/toClickSelector.d.ts

@@ -1,5 +1,8 @@
-import { Page } from 'puppeteer';
-export default function toClickSelector(page: Page, cssSelector: string): Promise<{
-    message: () => string;
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toClickSelector(page: Page, cssSelector: string, opts?: WaitForSelectorOptions): Promise<{
     pass: boolean;
+    message: () => never;
+} | {
+    pass: boolean;
+    message: string;
 }>;

package/dist/types/src/feature/matchers/toFill.d.ts

@@ -1,5 +1,8 @@
-import { Page } from 'puppeteer';
-export default function toFill(page: Page, cssSelector: string, text: string): Promise<{
-    message: () => string;
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toFill(page: Page, cssSelector: string, text: string, opts?: ToFillMatcherOpts): Promise<{
     pass: boolean;
+    message: () => string;
 }>;
+export type ToFillMatcherOpts = WaitForSelectorOptions & {
+    bypassInputValueReset: boolean;
+};

package/dist/types/src/feature/matchers/toHaveChecked.d.ts

@@ -1,5 +1,8 @@
-import { Page } from 'puppeteer';
-export default function toHaveChecked(page: Page, expectedText: string): Promise<{
-    message: () => string;
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toHaveChecked(page: Page, expectedText: string, opts?: WaitForSelectorOptions): Promise<{
+    pass: any;
+    message: () => never;
+} | {
     pass: boolean;
+    message: () => string;
 }>;

package/dist/types/src/feature/matchers/toHaveLink.d.ts

@@ -1,5 +1,5 @@
-import { Page } from 'puppeteer';
-export default function toHaveLink(page: Page, expectedText: string): Promise<{
-    message: () => string;
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toHaveLink(page: Page, expectedText: string, opts?: WaitForSelectorOptions): Promise<{
     pass: boolean;
+    message: () => string;
 }>;

package/dist/types/src/feature/matchers/toHaveSelector.d.ts

@@ -1,5 +1,5 @@
-import { Page } from 'puppeteer';
-export default function toHaveSelector(page: Page, selector: string): Promise<{
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toHaveSelector(page: Page, selector: string, opts?: WaitForSelectorOptions): Promise<{
     pass: boolean;
     message: () => string;
 }>;

package/dist/types/src/feature/matchers/toHaveUnchecked.d.ts

@@ -1,5 +1,5 @@
-import { Page } from 'puppeteer';
-export default function toHaveUnchecked(page: Page, expectedText: string): Promise<{
-    message: () => string;
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toHaveUnchecked(page: Page, expectedText: string, opts?: WaitForSelectorOptions): Promise<{
     pass: boolean;
+    message: () => string;
 }>;

package/dist/types/src/feature/matchers/toMatchTextContent.d.ts

@@ -1,7 +1,7 @@
-import { Page } from 'puppeteer';
+import { Page, WaitForSelectorOptions } from 'puppeteer';
 export default function toMatchTextContent(page: Page, text: string, { selector }?: {
     selector?: string;
-}): Promise<{
+} & WaitForSelectorOptions): Promise<{
     pass: boolean;
     message: () => string;
 }>;

package/dist/types/src/feature/matchers/toNotHaveSelector.d.ts

@@ -1,5 +1,5 @@
-import { Page } from 'puppeteer';
-export default function toNotHaveSelector(page: Page, expectedSelector: string): Promise<{
-    message: () => string;
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toNotHaveSelector(page: Page, selector: string, opts?: WaitForSelectorOptions): Promise<{
     pass: boolean;
+    message: () => string;
 }>;

package/dist/types/src/feature/matchers/toUncheck.d.ts

@@ -1,5 +1,11 @@
-import { Page } from 'puppeteer';
-export default function toUncheck(page: Page, expectedText: string): Promise<{
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+export default function toUncheck(page: Page, expectedText: string, opts?: WaitForSelectorOptions): Promise<{
+    pass: boolean;
     message: () => string;
+} | {
+    pass: any;
+    message: () => never;
+} | {
     pass: boolean;
+    message: string;
 }>;

package/dist/types/src/index.d.ts

@@ -1,6 +1,7 @@
 import { ExpectToEvaluateOpts } from './feature/internal/evaluateWithRetryAndTimeout.js';
 import { CustomMatcherResult } from './feature/helpers/providePuppeteerViteMatchers.js';
-import { Page } from 'puppeteer';
+import { Page, WaitForSelectorOptions } from 'puppeteer';
+import { ToFillMatcherOpts } from './feature/matchers/toFill.js';
 export { default as specRequest } from './unit/SpecRequest.js';
 export { default as createPsychicServer } from './unit/createPsychicServer.js';
 export { SpecRequest } from './unit/SpecRequest.js';
@@ -27,20 +28,20 @@ interface PuppeteerAssertions {
     toEqualCalendarDate(expected: any): CustomMatcherResult;
     toMatchTextContent(expected: any): Promise<CustomMatcherResult>;
     toNotMatchTextContent(expected: any): Promise<CustomMatcherResult>;
-    toHaveSelector(expected: any): Promise<CustomMatcherResult>;
-    toNotHaveSelector(expected: any): Promise<CustomMatcherResult>;
-    toCheck(expected: any): Promise<CustomMatcherResult>;
-    toClick(expected: any): Promise<CustomMatcherResult>;
-    toClickLink(expected: any): Promise<CustomMatcherResult>;
-    toClickButton(expected: any): Promise<CustomMatcherResult>;
-    toClickSelector(expected: any): Promise<CustomMatcherResult>;
+    toHaveSelector(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toNotHaveSelector(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toCheck(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toClick(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toClickLink(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toClickButton(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toClickSelector(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
     toHavePath(expected: any): Promise<CustomMatcherResult>;
     toHaveUrl(expected: any): Promise<CustomMatcherResult>;
-    toHaveChecked(expected: any): Promise<CustomMatcherResult>;
-    toHaveUnchecked(expected: any): Promise<CustomMatcherResult>;
-    toHaveLink(expected: any): Promise<CustomMatcherResult>;
-    toFill(cssSelector: string, text: string): Promise<CustomMatcherResult>;
-    toUncheck(expected: any): Promise<CustomMatcherResult>;
+    toHaveChecked(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toHaveUnchecked(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toHaveLink(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
+    toFill(cssSelector: string, text: string, opts?: ToFillMatcherOpts): Promise<CustomMatcherResult>;
+    toUncheck(expected: any, opts?: WaitForSelectorOptions): Promise<CustomMatcherResult>;
     toEvaluate(expected: (a: any) => boolean | Promise<boolean>, opts: ExpectToEvaluateOpts): Promise<CustomMatcherResult>;
 }
 declare const _default: {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@rvoh/psychic-spec-helpers",
-  "version": "0.3.1-fgbeta-8",
+  "version": "0.3.1",
   "description": "psychic framework spec helpers",
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
@@ -19,7 +19,6 @@
     "dist/**/*"
   ],
   "scripts": {
-    "publish": "yarn npm publish --access public",
     "build": "echo \"building psychic-spec-helpers...\" && rm -rf dist && npx tsc -p ./tsconfig.json",
     "prepack": "yarn build"
   },

package/src/feature/helpers/metaOrControlKey.ts

@@ -0,0 +1,4 @@
+export default function metaOrControlKey(): 'Meta' | 'Control' {
+  // Use 'Meta' for macOS and 'Control' for Windows/Linux
+  return process.platform === 'darwin' ? 'Meta' : 'Control'
+}

package/src/feature/helpers/providePuppeteerViteMatchers.ts

@@ -1,4 +1,4 @@
-import { Page } from 'puppeteer'
+import { Page, WaitForSelectorOptions } from 'puppeteer'
 import evaluateWithRetryAndTimeout, {
   ExpectToEvaluateOpts,
   ExpectToEvaluateReturnType,
@@ -18,44 +18,48 @@ import toHaveUrl from '../matchers/toHaveUrl.js'
 import toHaveLink from '../matchers/toHaveLink.js'
 import toHaveChecked from '../matchers/toHaveChecked.js'
 import toHaveUnchecked from '../matchers/toHaveUnchecked.js'
-import toFill from '../matchers/toFill.js'
+import toFill, { ToFillMatcherOpts } from '../matchers/toFill.js'
 
 export default function providePuppeteerViteMatchers() {
   ;((global as any).expect as any).extend({
-    async toMatchTextContent(page: Page, text: string) {
-      return await toMatchTextContent(page, text)
+    async toMatchTextContent(
+      page: Page,
+      text: string,
+      opts?: { selector?: string } & WaitForSelectorOptions
+    ) {
+      return await toMatchTextContent(page, text, opts)
     },
 
     async toNotMatchTextContent(page: Page, text: string) {
       return await toNotMatchTextContent(page, text)
     },
 
-    async toHaveSelector(page: Page, cssSelector: string) {
-      return await toHaveSelector(page, cssSelector)
+    async toHaveSelector(page: Page, cssSelector: string, opts?: WaitForSelectorOptions) {
+      return await toHaveSelector(page, cssSelector, opts)
     },
 
-    async toNotHaveSelector(page: Page, cssSelector: string) {
-      return await toNotHaveSelector(page, cssSelector)
+    async toNotHaveSelector(page: Page, cssSelector: string, opts?: WaitForSelectorOptions) {
+      return await toNotHaveSelector(page, cssSelector, opts)
     },
 
-    async toCheck(page: Page, text: string) {
-      return await toCheck(page, text)
+    async toCheck(page: Page, text: string, opts?: WaitForSelectorOptions) {
+      return await toCheck(page, text, opts)
     },
 
-    async toClick(page: Page, text: string) {
-      return await toClick(page, text)
+    async toClick(page: Page, text: string, opts?: WaitForSelectorOptions) {
+      return await toClick(page, text, opts)
     },
 
-    async toClickLink(page: Page, text: string) {
-      return await toClickLink(page, text)
+    async toClickLink(page: Page, text: string, opts?: WaitForSelectorOptions) {
+      return await toClickLink(page, text, opts)
     },
 
-    async toClickButton(page: Page, text: string) {
-      return await toClickButton(page, text)
+    async toClickButton(page: Page, text: string, opts?: WaitForSelectorOptions) {
+      return await toClickButton(page, text, opts)
     },
 
-    async toClickSelector(page: Page, cssSelector: string) {
-      return await toClickSelector(page, cssSelector)
+    async toClickSelector(page: Page, cssSelector: string, opts?: WaitForSelectorOptions) {
+      return await toClickSelector(page, cssSelector, opts)
     },
 
     async toHavePath(page: Page, path: string) {
@@ -66,24 +70,24 @@ export default function providePuppeteerViteMatchers() {
       return await toHaveUrl(page, url)
     },
 
-    async toHaveChecked(page: Page, text: string) {
-      return await toHaveChecked(page, text)
+    async toHaveChecked(page: Page, text: string, opts?: WaitForSelectorOptions) {
+      return await toHaveChecked(page, text, opts)
     },
 
-    async toHaveUnchecked(page: Page, checked: string) {
-      return await toHaveUnchecked(page, checked)
+    async toHaveUnchecked(page: Page, checked: string, opts?: WaitForSelectorOptions) {
+      return await toHaveUnchecked(page, checked, opts)
     },
 
-    async toHaveLink(page: Page, text: string) {
-      return await toHaveLink(page, text)
+    async toHaveLink(page: Page, text: string, opts?: WaitForSelectorOptions) {
+      return await toHaveLink(page, text, opts)
     },
 
-    async toFill(page: Page, cssSelector: string, text: string) {
-      return await toFill(page, cssSelector, text)
+    async toFill(page: Page, cssSelector: string, text: string, opts?: ToFillMatcherOpts) {
+      return await toFill(page, cssSelector, text, opts)
     },
 
-    async toUncheck(page: Page, text: string) {
-      return await toUncheck(page, text)
+    async toUncheck(page: Page, text: string, opts?: WaitForSelectorOptions) {
+      return await toUncheck(page, text, opts)
     },
 
     async toEvaluate(

package/src/feature/helpers/visit.ts

@@ -3,5 +3,4 @@ export default async function visit(
   { baseUrl = 'http://localhost:3000' }: { baseUrl?: string } = {}
 ) {
   await page.goto(`${baseUrl}/${path.replace(/^\//, '')}`)
-  return page
 }

package/src/feature/matchers/toCheck.ts

@@ -1,34 +1,24 @@
-import { Page } from 'puppeteer'
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
-import evaluationFailure from '../internal/evaluationFailure.js'
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
+import { Page, WaitForSelectorOptions } from 'puppeteer'
 
-export default async function toCheck(page: Page, expectedText: string) {
-  return await evaluateWithRetryAndTimeout(
-    page,
-    async () => {
-      requirePuppeteerPage(page)
+export default async function toCheck(
+  page: Page,
+  expectedText: string,
+  opts?: WaitForSelectorOptions
+) {
+  try {
+    const el = await page.waitForSelector(`label::-p-text(${expectedText}`, opts)
+    await el!.click()
 
-      const checkbox = await page.$(`input[type="checkbox"][value="${expectedText}"]`)
-      if (!checkbox) return evaluationFailure(`A checkbox was not found with "${expectedText}"`)
-
-      const isChecked = await page.evaluate(checkbox => checkbox.checked, checkbox)
-      if (isChecked)
-        return evaluationFailure(
-          `A checkbox was found with "${expectedText}", but it is already checked`
-        )
-
-      await checkbox.click()
-      const isCheckedNow = await page.evaluate(checkbox => checkbox.checked, checkbox)
-
-      return {
-        pass: isCheckedNow,
-        actual: expectedText,
-      }
-    },
-    {
-      successText: r => `Expected page to have checkable checkbox with text: "${expectedText}"`,
-      failureText: r => `Expected page not to have checkable checkbox with text: "${expectedText}"`,
+    return {
+      pass: true,
+      message: () => {
+        throw new Error('Cannot negate toCheck')
+      },
+    }
+  } catch (error) {
+    return {
+      pass: false,
+      message: `Expected page to have checkable element with text: "${expectedText}"`,
     }
-  )
+  }
 }

package/src/feature/matchers/toClick.ts

@@ -1,29 +1,24 @@
-import { Page, TimeoutError } from 'puppeteer'
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
-import evaluationFailure from '../internal/evaluationFailure.js'
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
+import { Page, WaitForSelectorOptions } from 'puppeteer'
 
-export default async function toClick(page: Page, expectedText: string) {
-  return await evaluateWithRetryAndTimeout(
-    page,
-    async () => {
-      requirePuppeteerPage(page)
+export default async function toClick(
+  page: Page,
+  expectedText: string,
+  opts?: WaitForSelectorOptions
+) {
+  try {
+    const el = await page.waitForSelector(`*::-p-text(${expectedText})`, opts)
+    await el!.click()
 
-      try {
-        ;(await page.$(`*::-p-text(${expectedText})`))!.click()
-      } catch (err) {
-        if (err instanceof TimeoutError) return evaluationFailure(expectedText)
-        throw err
-      }
-
-      return {
-        pass: true,
-        actual: expectedText,
-      }
-    },
-    {
-      successText: () => `Expected page to have clickable element with text: "${expectedText}"`,
-      failureText: () => `Expected page not to have clickable element with text: "${expectedText}"`,
+    return {
+      pass: true,
+      message: () => {
+        throw new Error('Cannot negate toClick')
+      },
+    }
+  } catch (error) {
+    return {
+      pass: false,
+      message: `Expected page to have clickable element with text: "${expectedText}"`,
     }
-  )
+  }
 }

package/src/feature/matchers/toClickButton.ts

@@ -1,29 +1,24 @@
-import { Page, TimeoutError } from 'puppeteer'
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
-import evaluationFailure from '../internal/evaluationFailure.js'
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
+import { Page, WaitForSelectorOptions } from 'puppeteer'
 
-export default async function toClickButton(page: Page, expectedText: string) {
-  return await evaluateWithRetryAndTimeout(
-    page,
-    async () => {
-      requirePuppeteerPage(page)
+export default async function toClickButton(
+  page: Page,
+  expectedText: string,
+  opts?: WaitForSelectorOptions
+) {
+  try {
+    const el = await page.waitForSelector('button::-p-text(Submit)', opts)
+    await el!.click()
 
-      try {
-        ;(await page.$('button::-p-text(Submit)'))!.click()
-      } catch (err) {
-        if (err instanceof TimeoutError) return evaluationFailure(expectedText)
-        throw err
-      }
-
-      return {
-        pass: true,
-        actual: expectedText,
-      }
-    },
-    {
-      successText: () => `Expected page to have clickable button with text: "${expectedText}"`,
-      failureText: () => `Expected page not to have clickable button with text: "${expectedText}"`,
+    return {
+      pass: true,
+      message: () => {
+        throw new Error('Cannot negate toClickLink')
+      },
+    }
+  } catch (error) {
+    return {
+      pass: false,
+      message: `Expected page to have clickable link with matching text: "${expectedText}"`,
     }
-  )
+  }
 }

package/src/feature/matchers/toClickLink.ts

@@ -1,29 +1,24 @@
-import { Page, TimeoutError } from 'puppeteer'
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
-import evaluationFailure from '../internal/evaluationFailure.js'
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
+import { Page, WaitForSelectorOptions } from 'puppeteer'
 
-export default async function toClickLink(page: Page, expectedText: string) {
-  return await evaluateWithRetryAndTimeout(
-    page,
-    async () => {
-      requirePuppeteerPage(page)
+export default async function toClickLink(
+  page: Page,
+  expectedText: string,
+  opts?: WaitForSelectorOptions
+) {
+  try {
+    const el = await page.waitForSelector(`a ::-p-text(${expectedText})`, opts)
+    await el!.click()
 
-      try {
-        ;(await page.$(`a ::-p-text(${expectedText})`))!.click()
-      } catch (err) {
-        if (err instanceof TimeoutError) return evaluationFailure(expectedText)
-        throw err
-      }
-
-      return {
-        pass: true,
-        actual: expectedText,
-      }
-    },
-    {
-      successText: () => `Expected page to have clickable link with text: "${expectedText}"`,
-      failureText: () => `Expected page not to have clickable link with text: "${expectedText}"`,
+    return {
+      pass: true,
+      message: () => {
+        throw new Error('Cannot negate toClickLink')
+      },
+    }
+  } catch (error) {
+    return {
+      pass: false,
+      message: `Expected page to have clickable link with matching text: "${expectedText}"`,
     }
-  )
+  }
 }

package/src/feature/matchers/toClickSelector.ts

@@ -1,29 +1,24 @@
-import { Page, TimeoutError } from 'puppeteer'
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
-import evaluationFailure from '../internal/evaluationFailure.js'
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
+import { Page, WaitForSelectorOptions } from 'puppeteer'
 
-export default async function toClickSelector(page: Page, cssSelector: string) {
-  return await evaluateWithRetryAndTimeout(
-    page,
-    async () => {
-      requirePuppeteerPage(page)
+export default async function toClickSelector(
+  page: Page,
+  cssSelector: string,
+  opts?: WaitForSelectorOptions
+) {
+  try {
+    const el = await page.waitForSelector(cssSelector, opts)
+    await el!.click()
 
-      try {
-        ;(await page.$(cssSelector))!.click()
-      } catch (err) {
-        if (err instanceof TimeoutError) return evaluationFailure(cssSelector)
-        throw err
-      }
-
-      return {
-        pass: true,
-        actual: cssSelector,
-      }
-    },
-    {
-      successText: () => `Expected page to have clickable selector with text: "${cssSelector}"`,
-      failureText: () => `Expected page not to have clickable selector with text: "${cssSelector}"`,
+    return {
+      pass: true,
+      message: () => {
+        throw new Error('Cannot negate toNotMatchTextContent, use toMatchTextContent instead')
+      },
+    }
+  } catch (error) {
+    return {
+      pass: false,
+      message: `Expected page to have clickable element with matching selector: "${cssSelector}"`,
     }
-  )
+  }
 }

package/src/feature/matchers/toFill.ts

@@ -1,28 +1,41 @@
-import { Page } from 'puppeteer'
-import evaluateWithRetryAndTimeout from '../internal/evaluateWithRetryAndTimeout.js'
-import evaluationFailure from '../internal/evaluationFailure.js'
-import requirePuppeteerPage from '../internal/requirePuppeteerPage.js'
+import { Page, WaitForSelectorOptions } from 'puppeteer'
+import metaOrControlKey from '../helpers/metaOrControlKey.js'
 
-export default async function toFill(page: Page, cssSelector: string, text: string) {
-  return await evaluateWithRetryAndTimeout(
-    page,
-    async () => {
-      requirePuppeteerPage(page)
+export default async function toFill(
+  page: Page,
+  cssSelector: string,
+  text: string,
+  opts?: ToFillMatcherOpts
+) {
+  try {
+    await page.waitForSelector(cssSelector, opts)
 
-      try {
-        await page.type(cssSelector, text)
-      } catch {
-        return evaluationFailure(text)
-      }
+    // unless the user opts out, clear the input
+    // before typing into it, since most of the
+    // time this is what people will expect to
+    // happen.
+    if (!opts?.bypassInputValueReset) {
+      await page.focus(cssSelector)
+      await page.keyboard.down(metaOrControlKey())
+      await page.keyboard.press('A')
+      await page.keyboard.up(metaOrControlKey())
+      await page.keyboard.press('Backspace')
+    }
+
+    await page.type(cssSelector, text)
 
-      return {
-        pass: true,
-        actual: text,
-      }
-    },
-    {
-      successText: () => `Expected page to have clickable link with text: "${text}"`,
-      failureText: () => `Expected page not to have clickable link with text: "${text}"`,
+    return {
+      pass: true,
+      message: () => {
+        throw new Error('cannot negate toFill')
+      },
     }
-  )
+  } catch {
+    return {
+      pass: false,
+      message: () => `failed to fill input matching selector ${cssSelector} with text "text"`,
+    }
+  }
 }
+
+export type ToFillMatcherOpts = WaitForSelectorOptions & { bypassInputValueReset: boolean }