[REGRESSION]: Types for BrowserTypeLaunchOptions and BrowserContextCookies are not exported

Context:

• GOOD Playwright Version: 0.12.1
• BAD Playwright Version: 0.13.0

Code Snippet

import { BrowserContextCookies, BrowserTypeLaunchOptions } from 'playwright';

Describe the bug

These types are no longer available.

[JoelEinbinder]

For one-off use cases, you can still get the types by using TypeScript’s Parameters type.

async function myFunction(page: import('playwright').Page, options: Parameters<typeof page.goto>[1]) {
  await page.goto('https://example.com', options);
}

This has the benefit of being guaranteed to work forever, even if the signature of page.goto changes. The downside is that it looks fairly ugly.

With the previous types, we were generating and exporting all of the object types inside of the api. The upside of this is that you get everything. The downsides are that there is a lot of useless types adding noise to the API, and it options us up to introducing subtle breaking changes.

PageGotoOptions and FrameGotoOptions, are identical. If we merged them, into GotoOptions, someone might write code like:

const opt: GotoOptions = ...;
await page.goto(opt);
await frame.goto(opt);

Then, if we later added a new option foo to page.goto, but did not add foo to frame.goto, it would be a breaking change. We could solve this by having GotoOptions contain the shared options contained by page.goto and frame.goto, and then having PageGotoOptions extend GotoOptions with the same type. This makes our generating process significantly more complicated, because we would need to check not just whether types can be merged, but if and how they were merged in a previously released version of playwright.

Perhaps a bigger subtle problem with exporting all of the types was that we add the parameter name into the type name. BrowserTypeLaunchOptions ends with Options because the first argument to browserType.launch is options. If we were to rename browserType.launch(options) into browserType.launch(nameOrOptions) or browserType.launch(opt), this usually wouldn’t be a breaking change. But with the generated types it is, because the type name will change.

Ways to proceed:

1. Leave things as they are, manually pick out parameters with Parameters.
2. Put back all of the generated types. Create a system that yells when something goes wrong, and then we will manually fix problems by aliasing types.
3. Whitelist some generated types or manually add some types that feel both safe and useful.
4. Create a new endpoint, playwright/types, that contains the types. This might have a different stability contract, where we don’t consider changes here to be breaking.

What do you all think?

[ghs]

I’ve opened another issue some days ago, https://github.com/microsoft/playwright/issues/2752, but while searching another thing ended up here. Thanks for the clarification! Just in case, from historical reason from pptr, we use also: ElementHandleScreenshotOptions, PageGotoOptions, PageScreenshotOptions.

This one as well: BrowserTypeLaunchServerOptions