@checkly/playwright-core 1.41.2-beta.0

package/lib/server/formData.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MultipartFormData = void 0;
+var _utilsBundle = require("../utilsBundle");
+/**
+ * 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 MultipartFormData {
+  constructor() {
+    this._boundary = void 0;
+    this._chunks = [];
+    this._boundary = generateUniqueBoundaryString();
+  }
+  contentTypeHeader() {
+    return `multipart/form-data; boundary=${this._boundary}`;
+  }
+  addField(name, value) {
+    this._beginMultiPartHeader(name);
+    this._finishMultiPartHeader();
+    this._chunks.push(Buffer.from(value));
+    this._finishMultiPartField();
+  }
+  addFileField(name, value) {
+    this._beginMultiPartHeader(name);
+    this._chunks.push(Buffer.from(`; filename="${value.name}"`));
+    this._chunks.push(Buffer.from(`\r\ncontent-type: ${value.mimeType || _utilsBundle.mime.getType(value.name) || 'application/octet-stream'}`));
+    this._finishMultiPartHeader();
+    this._chunks.push(value.buffer);
+    this._finishMultiPartField();
+  }
+  finish() {
+    this._addBoundary(true);
+    return Buffer.concat(this._chunks);
+  }
+  _beginMultiPartHeader(name) {
+    this._addBoundary();
+    this._chunks.push(Buffer.from(`content-disposition: form-data; name="${name}"`));
+  }
+  _finishMultiPartHeader() {
+    this._chunks.push(Buffer.from(`\r\n\r\n`));
+  }
+  _finishMultiPartField() {
+    this._chunks.push(Buffer.from(`\r\n`));
+  }
+  _addBoundary(isLastBoundary) {
+    this._chunks.push(Buffer.from('--' + this._boundary));
+    if (isLastBoundary) this._chunks.push(Buffer.from('--'));
+    this._chunks.push(Buffer.from('\r\n'));
+  }
+}
+exports.MultipartFormData = MultipartFormData;
+const alphaNumericEncodingMap = [0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42];
+
+// See generateUniqueBoundaryString() in WebKit
+function generateUniqueBoundaryString() {
+  const charCodes = [];
+  for (let i = 0; i < 16; i++) charCodes.push(alphaNumericEncodingMap[Math.floor(Math.random() * alphaNumericEncodingMap.length)]);
+  return '----WebKitFormBoundary' + String.fromCharCode(...charCodes);
+}

package/lib/server/frameSelectors.js

@@ -0,0 +1,171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FrameSelectors = void 0;
+var _selectorParser = require("../utils/isomorphic/selectorParser");
+var _locatorGenerators = require("../utils/isomorphic/locatorGenerators");
+/**
+ * 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 FrameSelectors {
+  constructor(frame) {
+    this.frame = void 0;
+    this.frame = frame;
+  }
+  _parseSelector(selector, options) {
+    const strict = typeof (options === null || options === void 0 ? void 0 : options.strict) === 'boolean' ? options.strict : !!this.frame._page.context()._options.strictSelectors;
+    return this.frame._page.context().selectors().parseSelector(selector, strict);
+  }
+  async query(selector, options, scope) {
+    const resolved = await this.resolveInjectedForSelector(selector, options, scope);
+    // Be careful, |this.frame| can be different from |resolved.frame|.
+    if (!resolved) return null;
+    const handle = await resolved.injected.evaluateHandle((injected, {
+      info,
+      scope
+    }) => {
+      return injected.querySelector(info.parsed, scope || document, info.strict);
+    }, {
+      info: resolved.info,
+      scope: resolved.scope
+    });
+    const elementHandle = handle.asElement();
+    if (!elementHandle) {
+      handle.dispose();
+      return null;
+    }
+    return adoptIfNeeded(elementHandle, await resolved.frame._mainContext());
+  }
+  async queryArrayInMainWorld(selector, scope) {
+    const resolved = await this.resolveInjectedForSelector(selector, {
+      mainWorld: true
+    }, scope);
+    // Be careful, |this.frame| can be different from |resolved.frame|.
+    if (!resolved) throw new Error(`Failed to find frame for selector "${selector}"`);
+    return await resolved.injected.evaluateHandle((injected, {
+      info,
+      scope
+    }) => {
+      return injected.querySelectorAll(info.parsed, scope || document);
+    }, {
+      info: resolved.info,
+      scope: resolved.scope
+    });
+  }
+  async queryCount(selector) {
+    const resolved = await this.resolveInjectedForSelector(selector);
+    // Be careful, |this.frame| can be different from |resolved.frame|.
+    if (!resolved) throw new Error(`Failed to find frame for selector "${selector}"`);
+    return await resolved.injected.evaluate((injected, {
+      info
+    }) => {
+      return injected.querySelectorAll(info.parsed, document).length;
+    }, {
+      info: resolved.info
+    });
+  }
+  async queryAll(selector, scope) {
+    const resolved = await this.resolveInjectedForSelector(selector, {}, scope);
+    // Be careful, |this.frame| can be different from |resolved.frame|.
+    if (!resolved) return [];
+    const arrayHandle = await resolved.injected.evaluateHandle((injected, {
+      info,
+      scope
+    }) => {
+      return injected.querySelectorAll(info.parsed, scope || document);
+    }, {
+      info: resolved.info,
+      scope: resolved.scope
+    });
+    const properties = await arrayHandle.getProperties();
+    arrayHandle.dispose();
+
+    // Note: adopting elements one by one may be slow. If we encounter the issue here,
+    // we might introduce 'useMainContext' option or similar to speed things up.
+    const targetContext = await resolved.frame._mainContext();
+    const result = [];
+    for (const property of properties.values()) {
+      const elementHandle = property.asElement();
+      if (elementHandle) result.push(adoptIfNeeded(elementHandle, targetContext));else property.dispose();
+    }
+    return Promise.all(result);
+  }
+  async resolveFrameForSelector(selector, options = {}, scope) {
+    let frame = this.frame;
+    const frameChunks = (0, _selectorParser.splitSelectorByFrame)(selector);
+    for (const chunk of frameChunks) {
+      (0, _selectorParser.visitAllSelectorParts)(chunk, (part, nested) => {
+        if (nested && part.name === 'internal:control' && part.body === 'enter-frame') {
+          const locator = (0, _locatorGenerators.asLocator)(this.frame._page.attribution.playwright.options.sdkLanguage, selector);
+          throw new _selectorParser.InvalidSelectorError(`Frame locators are not allowed inside composite locators, while querying "${locator}"`);
+        }
+      });
+    }
+    for (let i = 0; i < frameChunks.length - 1; ++i) {
+      const info = this._parseSelector(frameChunks[i], options);
+      const context = await frame._context(info.world);
+      const injectedScript = await context.injectedScript();
+      const handle = await injectedScript.evaluateHandle((injected, {
+        info,
+        scope,
+        selectorString
+      }) => {
+        const element = injected.querySelector(info.parsed, scope || document, info.strict);
+        if (element && element.nodeName !== 'IFRAME' && element.nodeName !== 'FRAME') throw injected.createStacklessError(`Selector "${selectorString}" resolved to ${injected.previewNode(element)}, <iframe> was expected`);
+        return element;
+      }, {
+        info,
+        scope: i === 0 ? scope : undefined,
+        selectorString: (0, _selectorParser.stringifySelector)(info.parsed)
+      });
+      const element = handle.asElement();
+      if (!element) return null;
+      const maybeFrame = await frame._page._delegate.getContentFrame(element);
+      element.dispose();
+      if (!maybeFrame) return null;
+      frame = maybeFrame;
+    }
+    // If we end up in the different frame, we should start from the frame root, so throw away the scope.
+    if (frame !== this.frame) scope = undefined;
+    return {
+      frame,
+      info: frame.selectors._parseSelector(frameChunks[frameChunks.length - 1], options),
+      scope
+    };
+  }
+  async resolveInjectedForSelector(selector, options, scope) {
+    const resolved = await this.resolveFrameForSelector(selector, options, scope);
+    // Be careful, |this.frame| can be different from |resolved.frame|.
+    if (!resolved) return;
+    const context = await resolved.frame._context(options !== null && options !== void 0 && options.mainWorld ? 'main' : resolved.info.world);
+    const injected = await context.injectedScript();
+    return {
+      injected,
+      info: resolved.info,
+      frame: resolved.frame,
+      scope: resolved.scope
+    };
+  }
+}
+exports.FrameSelectors = FrameSelectors;
+async function adoptIfNeeded(handle, context) {
+  if (handle._context === context) return handle;
+  const adopted = handle._page._delegate.adoptElementHandle(handle, context);
+  handle.dispose();
+  return adopted;
+}