@checkly/playwright-core 1.48.22 → 1.51.11-beta.1

package/lib/utils/isomorphic/ariaSnapshot.js

@@ -0,0 +1,392 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParserError = exports.KeyParser = void 0;
+exports.parseAriaSnapshot = parseAriaSnapshot;
+exports.parseAriaSnapshotUnsafe = parseAriaSnapshotUnsafe;
+exports.valueOrRegex = valueOrRegex;
+/**
+ * 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.
+ */
+
+// https://www.w3.org/TR/wai-aria-1.2/#role_definitions
+
+// We pass parsed template between worlds using JSON, make it easy.
+
+function parseAriaSnapshotUnsafe(yaml, text) {
+  const result = parseAriaSnapshot(yaml, text);
+  if (result.errors.length) throw new Error(result.errors[0].message);
+  return result.fragment;
+}
+function parseAriaSnapshot(yaml, text, options = {}) {
+  var _fragment$children;
+  const lineCounter = new yaml.LineCounter();
+  const parseOptions = {
+    keepSourceTokens: true,
+    lineCounter,
+    ...options
+  };
+  const yamlDoc = yaml.parseDocument(text, parseOptions);
+  const errors = [];
+  const convertRange = range => {
+    return [lineCounter.linePos(range[0]), lineCounter.linePos(range[1])];
+  };
+  const addError = error => {
+    errors.push({
+      message: error.message,
+      range: [lineCounter.linePos(error.pos[0]), lineCounter.linePos(error.pos[1])]
+    });
+  };
+  const convertSeq = (container, seq) => {
+    for (const item of seq.items) {
+      const itemIsString = item instanceof yaml.Scalar && typeof item.value === 'string';
+      if (itemIsString) {
+        const childNode = KeyParser.parse(item, parseOptions, errors);
+        if (childNode) {
+          container.children = container.children || [];
+          container.children.push(childNode);
+        }
+        continue;
+      }
+      const itemIsMap = item instanceof yaml.YAMLMap;
+      if (itemIsMap) {
+        convertMap(container, item);
+        continue;
+      }
+      errors.push({
+        message: 'Sequence items should be strings or maps',
+        range: convertRange(item.range || seq.range)
+      });
+    }
+  };
+  const convertMap = (container, map) => {
+    for (const entry of map.items) {
+      container.children = container.children || [];
+      // Key must by a string
+      const keyIsString = entry.key instanceof yaml.Scalar && typeof entry.key.value === 'string';
+      if (!keyIsString) {
+        errors.push({
+          message: 'Only string keys are supported',
+          range: convertRange(entry.key.range || map.range)
+        });
+        continue;
+      }
+      const key = entry.key;
+      const value = entry.value;
+
+      // - text: "text"
+      if (key.value === 'text') {
+        const valueIsString = value instanceof yaml.Scalar && typeof value.value === 'string';
+        if (!valueIsString) {
+          errors.push({
+            message: 'Text value should be a string',
+            range: convertRange(entry.value.range || map.range)
+          });
+          continue;
+        }
+        container.children.push({
+          kind: 'text',
+          text: valueOrRegex(value.value)
+        });
+        continue;
+      }
+
+      // role "name": ...
+      const childNode = KeyParser.parse(key, parseOptions, errors);
+      if (!childNode) continue;
+
+      // - role "name": "text"
+      const valueIsScalar = value instanceof yaml.Scalar;
+      if (valueIsScalar) {
+        const type = typeof value.value;
+        if (type !== 'string' && type !== 'number' && type !== 'boolean') {
+          errors.push({
+            message: 'Node value should be a string or a sequence',
+            range: convertRange(entry.value.range || map.range)
+          });
+          continue;
+        }
+        container.children.push({
+          ...childNode,
+          children: [{
+            kind: 'text',
+            text: valueOrRegex(String(value.value))
+          }]
+        });
+        continue;
+      }
+
+      // - role "name":
+      //   - child
+      const valueIsSequence = value instanceof yaml.YAMLSeq;
+      if (valueIsSequence) {
+        container.children.push(childNode);
+        convertSeq(childNode, value);
+        continue;
+      }
+      errors.push({
+        message: 'Map values should be strings or sequences',
+        range: convertRange(entry.value.range || map.range)
+      });
+    }
+  };
+  const fragment = {
+    kind: 'role',
+    role: 'fragment'
+  };
+  yamlDoc.errors.forEach(addError);
+  if (errors.length) return {
+    errors,
+    fragment
+  };
+  if (!(yamlDoc.contents instanceof yaml.YAMLSeq)) {
+    errors.push({
+      message: 'Aria snapshot must be a YAML sequence, elements starting with " -"',
+      range: yamlDoc.contents ? convertRange(yamlDoc.contents.range) : [{
+        line: 0,
+        col: 0
+      }, {
+        line: 0,
+        col: 0
+      }]
+    });
+  }
+  if (errors.length) return {
+    errors,
+    fragment
+  };
+  convertSeq(fragment, yamlDoc.contents);
+  if (errors.length) return {
+    errors,
+    fragment: emptyFragment
+  };
+  if (((_fragment$children = fragment.children) === null || _fragment$children === void 0 ? void 0 : _fragment$children.length) === 1) return {
+    fragment: fragment.children[0],
+    errors
+  };
+  return {
+    fragment,
+    errors
+  };
+}
+const emptyFragment = {
+  kind: 'role',
+  role: 'fragment'
+};
+function normalizeWhitespace(text) {
+  // TODO: why is this different from normalizeWhitespace in stringUtils.ts?
+  return text.replace(/[\u200b\u00ad]/g, '').replace(/[\r\n\s\t]+/g, ' ').trim();
+}
+function valueOrRegex(value) {
+  return value.startsWith('/') && value.endsWith('/') && value.length > 1 ? {
+    pattern: value.slice(1, -1)
+  } : normalizeWhitespace(value);
+}
+class KeyParser {
+  static parse(text, options, errors) {
+    try {
+      return new KeyParser(text.value)._parse();
+    } catch (e) {
+      if (e instanceof ParserError) {
+        const message = options.prettyErrors === false ? e.message : e.message + ':\n\n' + text.value + '\n' + ' '.repeat(e.pos) + '^\n';
+        errors.push({
+          message,
+          range: [options.lineCounter.linePos(text.range[0]), options.lineCounter.linePos(text.range[0] + e.pos)]
+        });
+        return null;
+      }
+      throw e;
+    }
+  }
+  constructor(input) {
+    this._input = void 0;
+    this._pos = void 0;
+    this._length = void 0;
+    this._input = input;
+    this._pos = 0;
+    this._length = input.length;
+  }
+  _peek() {
+    return this._input[this._pos] || '';
+  }
+  _next() {
+    if (this._pos < this._length) return this._input[this._pos++];
+    return null;
+  }
+  _eof() {
+    return this._pos >= this._length;
+  }
+  _isWhitespace() {
+    return !this._eof() && /\s/.test(this._peek());
+  }
+  _skipWhitespace() {
+    while (this._isWhitespace()) this._pos++;
+  }
+  _readIdentifier(type) {
+    if (this._eof()) this._throwError(`Unexpected end of input when expecting ${type}`);
+    const start = this._pos;
+    while (!this._eof() && /[a-zA-Z]/.test(this._peek())) this._pos++;
+    return this._input.slice(start, this._pos);
+  }
+  _readString() {
+    let result = '';
+    let escaped = false;
+    while (!this._eof()) {
+      const ch = this._next();
+      if (escaped) {
+        result += ch;
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === '"') {
+        return result;
+      } else {
+        result += ch;
+      }
+    }
+    this._throwError('Unterminated string');
+  }
+  _throwError(message, offset = 0) {
+    throw new ParserError(message, offset || this._pos);
+  }
+  _readRegex() {
+    let result = '';
+    let escaped = false;
+    let insideClass = false;
+    while (!this._eof()) {
+      const ch = this._next();
+      if (escaped) {
+        result += ch;
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+        result += ch;
+      } else if (ch === '/' && !insideClass) {
+        return {
+          pattern: result
+        };
+      } else if (ch === '[') {
+        insideClass = true;
+        result += ch;
+      } else if (ch === ']' && insideClass) {
+        result += ch;
+        insideClass = false;
+      } else {
+        result += ch;
+      }
+    }
+    this._throwError('Unterminated regex');
+  }
+  _readStringOrRegex() {
+    const ch = this._peek();
+    if (ch === '"') {
+      this._next();
+      return normalizeWhitespace(this._readString());
+    }
+    if (ch === '/') {
+      this._next();
+      return this._readRegex();
+    }
+    return null;
+  }
+  _readAttributes(result) {
+    let errorPos = this._pos;
+    while (true) {
+      this._skipWhitespace();
+      if (this._peek() === '[') {
+        this._next();
+        this._skipWhitespace();
+        errorPos = this._pos;
+        const flagName = this._readIdentifier('attribute');
+        this._skipWhitespace();
+        let flagValue = '';
+        if (this._peek() === '=') {
+          this._next();
+          this._skipWhitespace();
+          errorPos = this._pos;
+          while (this._peek() !== ']' && !this._isWhitespace() && !this._eof()) flagValue += this._next();
+        }
+        this._skipWhitespace();
+        if (this._peek() !== ']') this._throwError('Expected ]');
+        this._next(); // Consume ']'
+        this._applyAttribute(result, flagName, flagValue || 'true', errorPos);
+      } else {
+        break;
+      }
+    }
+  }
+  _parse() {
+    this._skipWhitespace();
+    const role = this._readIdentifier('role');
+    this._skipWhitespace();
+    const name = this._readStringOrRegex() || '';
+    const result = {
+      kind: 'role',
+      role,
+      name
+    };
+    this._readAttributes(result);
+    this._skipWhitespace();
+    if (!this._eof()) this._throwError('Unexpected input');
+    return result;
+  }
+  _applyAttribute(node, key, value, errorPos) {
+    if (key === 'checked') {
+      this._assert(value === 'true' || value === 'false' || value === 'mixed', 'Value of "checked\" attribute must be a boolean or "mixed"', errorPos);
+      node.checked = value === 'true' ? true : value === 'false' ? false : 'mixed';
+      return;
+    }
+    if (key === 'disabled') {
+      this._assert(value === 'true' || value === 'false', 'Value of "disabled" attribute must be a boolean', errorPos);
+      node.disabled = value === 'true';
+      return;
+    }
+    if (key === 'expanded') {
+      this._assert(value === 'true' || value === 'false', 'Value of "expanded" attribute must be a boolean', errorPos);
+      node.expanded = value === 'true';
+      return;
+    }
+    if (key === 'level') {
+      this._assert(!isNaN(Number(value)), 'Value of "level" attribute must be a number', errorPos);
+      node.level = Number(value);
+      return;
+    }
+    if (key === 'pressed') {
+      this._assert(value === 'true' || value === 'false' || value === 'mixed', 'Value of "pressed" attribute must be a boolean or "mixed"', errorPos);
+      node.pressed = value === 'true' ? true : value === 'false' ? false : 'mixed';
+      return;
+    }
+    if (key === 'selected') {
+      this._assert(value === 'true' || value === 'false', 'Value of "selected" attribute must be a boolean', errorPos);
+      node.selected = value === 'true';
+      return;
+    }
+    this._assert(false, `Unsupported attribute [${key}]`, errorPos);
+  }
+  _assert(value, message, valuePos) {
+    if (!value) this._throwError(message || 'Assertion error', valuePos);
+  }
+}
+exports.KeyParser = KeyParser;
+class ParserError extends Error {
+  constructor(message, pos) {
+    super(message);
+    this.pos = void 0;
+    this.pos = pos;
+  }
+}
+exports.ParserError = ParserError;

package/lib/utils/isomorphic/assert.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assert = assert;
+/**
+ * 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.
+ */
+
+function assert(value, message) {
+  if (!value) throw new Error(message || 'Assertion error');
+}

package/lib/utils/isomorphic/colors.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.webColors = exports.noColors = void 0;
+/**
+ * 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.
+ */
+
+const webColors = exports.webColors = {
+  enabled: true,
+  reset: text => applyStyle(0, 0, text),
+  bold: text => applyStyle(1, 22, text),
+  dim: text => applyStyle(2, 22, text),
+  italic: text => applyStyle(3, 23, text),
+  underline: text => applyStyle(4, 24, text),
+  inverse: text => applyStyle(7, 27, text),
+  hidden: text => applyStyle(8, 28, text),
+  strikethrough: text => applyStyle(9, 29, text),
+  black: text => applyStyle(30, 39, text),
+  red: text => applyStyle(31, 39, text),
+  green: text => applyStyle(32, 39, text),
+  yellow: text => applyStyle(33, 39, text),
+  blue: text => applyStyle(34, 39, text),
+  magenta: text => applyStyle(35, 39, text),
+  cyan: text => applyStyle(36, 39, text),
+  white: text => applyStyle(37, 39, text),
+  gray: text => applyStyle(90, 39, text),
+  grey: text => applyStyle(90, 39, text)
+};
+const noColors = exports.noColors = {
+  enabled: false,
+  reset: t => t,
+  bold: t => t,
+  dim: t => t,
+  italic: t => t,
+  underline: t => t,
+  inverse: t => t,
+  hidden: t => t,
+  strikethrough: t => t,
+  black: t => t,
+  red: t => t,
+  green: t => t,
+  yellow: t => t,
+  blue: t => t,
+  magenta: t => t,
+  cyan: t => t,
+  white: t => t,
+  gray: t => t,
+  grey: t => t
+};
+const applyStyle = (open, close, text) => `\u001b[${open}m${text}\u001b[${close}m`;

package/lib/utils/isomorphic/cssParser.js

@@ -9,7 +9,7 @@ exports.parseCSS = parseCSS;
 exports.serializeSelector = serializeSelector;
 var css = _interopRequireWildcard(require("./cssTokenizer"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -46,7 +46,7 @@ function parseCSS(selector, customNames) {
     tokens = css.tokenize(selector);
     if (!(tokens[tokens.length - 1] instanceof css.EOFToken)) tokens.push(new css.EOFToken());
   } catch (e) {
-    const newMessage = e.message + ` while parsing selector "${selector}"`;
+    const newMessage = e.message + ` while parsing css selector "${selector}". Did you mean to CSS.escape it?`;
     const index = (e.stack || '').indexOf(e.message);
     if (index !== -1) e.stack = e.stack.substring(0, index) + newMessage + e.stack.substring(index + e.message.length);
     e.message = newMessage;
@@ -61,11 +61,11 @@ function parseCSS(selector, customNames) {
     // TODO: Consider treating these as strings?
     token instanceof css.URLToken || token instanceof css.PercentageToken;
   });
-  if (unsupportedToken) throw new InvalidSelectorError(`Unsupported token "${unsupportedToken.toSource()}" while parsing selector "${selector}"`);
+  if (unsupportedToken) throw new InvalidSelectorError(`Unsupported token "${unsupportedToken.toSource()}" while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
   let pos = 0;
   const names = new Set();
   function unexpected() {
-    return new InvalidSelectorError(`Unexpected token "${tokens[pos].toSource()}" while parsing selector "${selector}"`);
+    return new InvalidSelectorError(`Unexpected token "${tokens[pos].toSource()}" while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
   }
   function skipWhitespace() {
     while (tokens[pos] instanceof css.WhitespaceToken) pos++;
@@ -227,7 +227,7 @@ function parseCSS(selector, customNames) {
   }
   const result = consumeFunctionArguments();
   if (!isEOF()) throw unexpected();
-  if (result.some(arg => typeof arg !== 'object' || !('simples' in arg))) throw new InvalidSelectorError(`Error while parsing selector "${selector}"`);
+  if (result.some(arg => typeof arg !== 'object' || !('simples' in arg))) throw new InvalidSelectorError(`Error while parsing css selector "${selector}". Did you mean to CSS.escape it?`);
   return {
     selector: result,
     names: Array.from(names)

package/lib/utils/isomorphic/headers.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.headersArrayToObject = headersArrayToObject;
+exports.headersObjectToArray = headersObjectToArray;
+/**
+ * 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.
+ */
+
+function headersObjectToArray(headers, separator, setCookieSeparator) {
+  if (!setCookieSeparator) setCookieSeparator = separator;
+  const result = [];
+  for (const name in headers) {
+    const values = headers[name];
+    if (values === undefined) continue;
+    if (separator) {
+      const sep = name.toLowerCase() === 'set-cookie' ? setCookieSeparator : separator;
+      for (const value of values.split(sep)) result.push({
+        name,
+        value: value.trim()
+      });
+    } else {
+      result.push({
+        name,
+        value: values
+      });
+    }
+  }
+  return result;
+}
+function headersArrayToObject(headers, lowerCase) {
+  const result = {};
+  for (const {
+    name,
+    value
+  } of headers) result[lowerCase ? name.toLowerCase() : name] = value;
+  return result;
+}