@checkly/playwright-core 1.41.2-beta.0

package/lib/server/dispatchers/browserDispatcher.js

@@ -0,0 +1,170 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConnectedBrowserDispatcher = exports.BrowserDispatcher = void 0;
+var _browser = require("../browser");
+var _browserContextDispatcher = require("./browserContextDispatcher");
+var _cdpSessionDispatcher = require("./cdpSessionDispatcher");
+var _dispatcher = require("./dispatcher");
+var _browserContext = require("../browserContext");
+var _selectors = require("../selectors");
+var _artifactDispatcher = require("./artifactDispatcher");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class BrowserDispatcher extends _dispatcher.Dispatcher {
+  constructor(scope, browser) {
+    super(scope, browser, 'Browser', {
+      version: browser.version(),
+      name: browser.options.name
+    });
+    this._type_Browser = true;
+    this.addObjectListener(_browser.Browser.Events.Disconnected, () => this._didClose());
+  }
+  _didClose() {
+    this._dispatchEvent('close');
+    this._dispose();
+  }
+  async newContext(params, metadata) {
+    const context = await this._object.newContext(metadata, params);
+    return {
+      context: new _browserContextDispatcher.BrowserContextDispatcher(this, context)
+    };
+  }
+  async newContextForReuse(params, metadata) {
+    return await newContextForReuse(this._object, this, params, null, metadata);
+  }
+  async stopPendingOperations(params, metadata) {
+    await this._object.stopPendingOperations(params.reason);
+  }
+  async close(params, metadata) {
+    metadata.potentiallyClosesScope = true;
+    await this._object.close(params);
+  }
+  async killForTests(_, metadata) {
+    metadata.potentiallyClosesScope = true;
+    await this._object.killForTests();
+  }
+  async defaultUserAgentForTest() {
+    return {
+      userAgent: this._object.userAgent()
+    };
+  }
+  async newBrowserCDPSession() {
+    if (!this._object.options.isChromium) throw new Error(`CDP session is only available in Chromium`);
+    const crBrowser = this._object;
+    return {
+      session: new _cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowser.newBrowserCDPSession())
+    };
+  }
+  async startTracing(params) {
+    if (!this._object.options.isChromium) throw new Error(`Tracing is only available in Chromium`);
+    const crBrowser = this._object;
+    await crBrowser.startTracing(params.page ? params.page._object : undefined, params);
+  }
+  async stopTracing() {
+    if (!this._object.options.isChromium) throw new Error(`Tracing is only available in Chromium`);
+    const crBrowser = this._object;
+    return {
+      artifact: _artifactDispatcher.ArtifactDispatcher.from(this, await crBrowser.stopTracing())
+    };
+  }
+}
+
+// This class implements multiplexing browser dispatchers over a single Browser instance.
+exports.BrowserDispatcher = BrowserDispatcher;
+class ConnectedBrowserDispatcher extends _dispatcher.Dispatcher {
+  constructor(scope, browser) {
+    super(scope, browser, 'Browser', {
+      version: browser.version(),
+      name: browser.options.name
+    });
+    // When we have a remotely-connected browser, each client gets a fresh Selector instance,
+    // so that two clients do not interfere between each other.
+    this._type_Browser = true;
+    this._contexts = new Set();
+    this.selectors = void 0;
+    this.selectors = new _selectors.Selectors();
+  }
+  async newContext(params, metadata) {
+    if (params.recordVideo) params.recordVideo.dir = this._object.options.artifactsDir;
+    const context = await this._object.newContext(metadata, params);
+    this._contexts.add(context);
+    context.setSelectors(this.selectors);
+    context.on(_browserContext.BrowserContext.Events.Close, () => this._contexts.delete(context));
+    return {
+      context: new _browserContextDispatcher.BrowserContextDispatcher(this, context)
+    };
+  }
+  async newContextForReuse(params, metadata) {
+    return await newContextForReuse(this._object, this, params, this.selectors, metadata);
+  }
+  async stopPendingOperations(params, metadata) {
+    await this._object.stopPendingOperations(params.reason);
+  }
+  async close() {
+    // Client should not send us Browser.close.
+  }
+  async killForTests() {
+    // Client should not send us Browser.killForTests.
+  }
+  async defaultUserAgentForTest() {
+    throw new Error('Client should not send us Browser.defaultUserAgentForTest');
+  }
+  async newBrowserCDPSession() {
+    if (!this._object.options.isChromium) throw new Error(`CDP session is only available in Chromium`);
+    const crBrowser = this._object;
+    return {
+      session: new _cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowser.newBrowserCDPSession())
+    };
+  }
+  async startTracing(params) {
+    if (!this._object.options.isChromium) throw new Error(`Tracing is only available in Chromium`);
+    const crBrowser = this._object;
+    await crBrowser.startTracing(params.page ? params.page._object : undefined, params);
+  }
+  async stopTracing() {
+    if (!this._object.options.isChromium) throw new Error(`Tracing is only available in Chromium`);
+    const crBrowser = this._object;
+    return {
+      artifact: _artifactDispatcher.ArtifactDispatcher.from(this, await crBrowser.stopTracing())
+    };
+  }
+  async cleanupContexts() {
+    await Promise.all(Array.from(this._contexts).map(context => context.close({
+      reason: 'Global context cleanup (connection terminated)'
+    })));
+  }
+}
+exports.ConnectedBrowserDispatcher = ConnectedBrowserDispatcher;
+async function newContextForReuse(browser, scope, params, selectors, metadata) {
+  const {
+    context,
+    needsReset
+  } = await browser.newContextForReuse(params, metadata);
+  if (needsReset) {
+    const oldContextDispatcher = (0, _dispatcher.existingDispatcher)(context);
+    if (oldContextDispatcher) oldContextDispatcher._dispose();
+    await context.resetForReuse(metadata, params);
+  }
+  if (selectors) context.setSelectors(selectors);
+  const contextDispatcher = new _browserContextDispatcher.BrowserContextDispatcher(scope, context);
+  return {
+    context: contextDispatcher
+  };
+}

package/lib/server/dispatchers/browserTypeDispatcher.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BrowserTypeDispatcher = void 0;
+var _browserDispatcher = require("./browserDispatcher");
+var _dispatcher = require("./dispatcher");
+var _browserContextDispatcher = require("./browserContextDispatcher");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class BrowserTypeDispatcher extends _dispatcher.Dispatcher {
+  constructor(scope, browserType) {
+    super(scope, browserType, 'BrowserType', {
+      executablePath: browserType.executablePath(),
+      name: browserType.name()
+    });
+    this._type_BrowserType = true;
+  }
+  async launch(params, metadata) {
+    const browser = await this._object.launch(metadata, params);
+    return {
+      browser: new _browserDispatcher.BrowserDispatcher(this, browser)
+    };
+  }
+  async launchPersistentContext(params, metadata) {
+    const browserContext = await this._object.launchPersistentContext(metadata, params.userDataDir, params);
+    return {
+      context: new _browserContextDispatcher.BrowserContextDispatcher(this, browserContext)
+    };
+  }
+  async connectOverCDP(params, metadata) {
+    const browser = await this._object.connectOverCDP(metadata, params.endpointURL, params, params.timeout);
+    const browserDispatcher = new _browserDispatcher.BrowserDispatcher(this, browser);
+    return {
+      browser: browserDispatcher,
+      defaultContext: browser._defaultContext ? new _browserContextDispatcher.BrowserContextDispatcher(browserDispatcher, browser._defaultContext) : undefined
+    };
+  }
+}
+exports.BrowserTypeDispatcher = BrowserTypeDispatcher;

package/lib/server/dispatchers/cdpSessionDispatcher.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CDPSessionDispatcher = void 0;
+var _crConnection = require("../chromium/crConnection");
+var _dispatcher = require("./dispatcher");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class CDPSessionDispatcher extends _dispatcher.Dispatcher {
+  constructor(scope, cdpSession) {
+    super(scope, cdpSession, 'CDPSession', {});
+    this._type_CDPSession = true;
+    this.addObjectListener(_crConnection.CDPSession.Events.Event, ({
+      method,
+      params
+    }) => this._dispatchEvent('event', {
+      method,
+      params
+    }));
+    this.addObjectListener(_crConnection.CDPSession.Events.Closed, () => this._dispose());
+  }
+  async send(params) {
+    return {
+      result: await this._object.send(params.method, params.params)
+    };
+  }
+  async detach(_, metadata) {
+    metadata.potentiallyClosesScope = true;
+    await this._object.detach();
+  }
+}
+exports.CDPSessionDispatcher = CDPSessionDispatcher;

package/lib/server/dispatchers/debugControllerDispatcher.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DebugControllerDispatcher = void 0;
+var _utils = require("../../utils");
+var _debugController = require("../debugController");
+var _dispatcher = require("./dispatcher");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class DebugControllerDispatcher extends _dispatcher.Dispatcher {
+  constructor(connection, debugController) {
+    super(connection, debugController, 'DebugController', {});
+    this._type_DebugController = void 0;
+    this._listeners = void 0;
+    this._type_DebugController = true;
+    this._listeners = [_utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.StateChanged, params => {
+      this._dispatchEvent('stateChanged', params);
+    }), _utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.InspectRequested, ({
+      selector,
+      locator
+    }) => {
+      this._dispatchEvent('inspectRequested', {
+        selector,
+        locator
+      });
+    }), _utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.SourceChanged, ({
+      text,
+      header,
+      footer,
+      actions
+    }) => {
+      this._dispatchEvent('sourceChanged', {
+        text,
+        header,
+        footer,
+        actions
+      });
+    }), _utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.Paused, ({
+      paused
+    }) => {
+      this._dispatchEvent('paused', {
+        paused
+      });
+    }), _utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.SetModeRequested, ({
+      mode
+    }) => {
+      this._dispatchEvent('setModeRequested', {
+        mode
+      });
+    })];
+  }
+  async initialize(params) {
+    this._object.initialize(params.codegenId, params.sdkLanguage);
+  }
+  async setReportStateChanged(params) {
+    this._object.setReportStateChanged(params.enabled);
+  }
+  async resetForReuse() {
+    await this._object.resetForReuse();
+  }
+  async navigate(params) {
+    await this._object.navigate(params.url);
+  }
+  async setRecorderMode(params) {
+    await this._object.setRecorderMode(params);
+  }
+  async highlight(params) {
+    await this._object.highlight(params.selector);
+  }
+  async hideHighlight() {
+    await this._object.hideHighlight();
+  }
+  async resume() {
+    await this._object.resume();
+  }
+  async kill() {
+    await this._object.kill();
+  }
+  async closeAllBrowsers() {
+    await this._object.closeAllBrowsers();
+  }
+  _onDispose() {
+    _utils.eventsHelper.removeEventListeners(this._listeners);
+    this._object.dispose();
+  }
+}
+exports.DebugControllerDispatcher = DebugControllerDispatcher;

package/lib/server/dispatchers/dialogDispatcher.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DialogDispatcher = void 0;
+var _dispatcher = require("./dispatcher");
+var _pageDispatcher = require("./pageDispatcher");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class DialogDispatcher extends _dispatcher.Dispatcher {
+  constructor(scope, dialog) {
+    const page = _pageDispatcher.PageDispatcher.fromNullable(scope, dialog.page().initializedOrUndefined());
+    // Prefer scoping to the page, unless we don't have one.
+    super(page || scope, dialog, 'Dialog', {
+      page,
+      type: dialog.type(),
+      message: dialog.message(),
+      defaultValue: dialog.defaultValue()
+    });
+    this._type_Dialog = true;
+  }
+  async accept(params) {
+    await this._object.accept(params.promptText);
+  }
+  async dismiss() {
+    await this._object.dismiss();
+  }
+}
+exports.DialogDispatcher = DialogDispatcher;