xmlui 0.11.10 → 0.11.12

package/dist/lib/testing.js

@@ -1,16 +1,6 @@
 import { expect as expect$1, test as test$1 } from "@playwright/test";
 import { x as xmlUiMarkupToComponent, P as PART_START_ADORNMENT, a as PART_END_ADORNMENT, b as PART_INPUT } from "./xmlui-parser-CW8YmGjO.js";
-import chroma from "chroma-js";
-function mapObject(obj, valFn = ((val) => val), keyFn = ((val) => val)) {
-  const newObject = {};
-  Object.entries(obj).forEach(([key, value]) => {
-    newObject[keyFn(key)] = valFn(value);
-  });
-  return newObject;
-}
-function getComponentTagName(locator) {
-  return locator.evaluate((el) => el.tagName.toLowerCase());
-}
+import "chroma-js";
 function parseComponentIfNecessary(rawComponent) {
   if (typeof rawComponent === "string") {
     return xmlUiMarkupToComponent(rawComponent);
@@ -21,62 +11,7 @@ function parseComponentIfNecessary(rawComponent) {
     erroneousCompoundComponentName: void 0
   };
 }
-function scaleByPercent(scalarOf100Percent, percentage) {
-  const parsed = parseAsNumericCss(percentage);
-  if (parsed.unit !== "%") {
-    throw new Error(`Expected percentage unit (%), got: ${parsed.unit}`);
-  }
-  return scalarOf100Percent / 100 * parsed.value;
-}
-function getBoundingRect$1(locator) {
-  return locator.evaluate((element) => element.getBoundingClientRect());
-}
-function getElementStyle$1(specifier, style) {
-  return specifier.evaluate(
-    (element, style2) => window.getComputedStyle(element).getPropertyValue(style2),
-    style
-  );
-}
-function getElementStyles$1(locator, styles = []) {
-  return locator.evaluate(
-    (element, styles2) => Object.fromEntries(
-      styles2.map((styleName) => [
-        styleName,
-        window.getComputedStyle(element).getPropertyValue(styleName)
-      ])
-    ),
-    styles
-  );
-}
-function isIndeterminate(specifier) {
-  if (specifier instanceof ComponentDriver) specifier = specifier.component;
-  return specifier.evaluate((el) => el.indeterminate);
-}
-async function overflows(locator, direction = "both") {
-  const [width, height, scrollWidth, scrollHeight] = await locator.evaluate((element) => [
-    element.clientWidth,
-    element.clientHeight,
-    element.scrollWidth,
-    element.scrollHeight
-  ]);
-  if (direction === "x") return scrollWidth > width;
-  if (direction === "y") return scrollHeight > height;
-  return scrollWidth > width && scrollHeight > height;
-}
-function getStyles(specifier, style) {
-  if (specifier instanceof ComponentDriver) specifier = specifier.component;
-  style = Array.isArray(style) ? style : [style];
-  return specifier.evaluate(
-    (element, styles) => Object.fromEntries(
-      styles.map((styleName) => [
-        styleName.trim().split("-").map((n, idx) => idx === 0 ? n : n[0].toUpperCase() + n.slice(1)).join(""),
-        window.getComputedStyle(element).getPropertyValue(styleName)
-      ])
-    ),
-    style
-  );
-}
-function getPseudoStyles(specifier, pseudoElement, style) {
+function getStyles(specifier, style, pseudoElement) {
   if (specifier instanceof ComponentDriver) specifier = specifier.component;
   style = Array.isArray(style) ? style : [style];
   return specifier.evaluate(
@@ -89,204 +24,6 @@ function getPseudoStyles(specifier, pseudoElement, style) {
     { style, pseudoElement }
   );
 }
-async function getHtmlAttributes(specifier, attributes) {
-  if (specifier instanceof ComponentDriver) specifier = specifier.component;
-  attributes = Array.isArray(attributes) ? attributes : [attributes];
-  const mapped = await Promise.all(
-    attributes.map(async (attr) => {
-      return [attr, await specifier.getAttribute(attr)];
-    })
-  );
-  return Object.fromEntries(mapped);
-}
-async function getPaddings(specifier) {
-  const paddings = mapObject(
-    await getStyles(specifier, ["padding-left", "padding-right", "padding-top", "padding-bottom"]),
-    parseAsNumericCss
-  );
-  return {
-    left: paddings.paddingLeft,
-    right: paddings.paddingRight,
-    top: paddings.paddingTop,
-    bottom: paddings.paddingBottom
-  };
-}
-async function getBorders(specifier) {
-  const borders = mapObject(
-    await getStyles(specifier, ["border-left", "border-right", "border-top", "border-bottom"]),
-    parseAsCssBorder
-  );
-  return {
-    left: borders.borderLeft,
-    right: borders.borderRight,
-    top: borders.borderTop,
-    bottom: borders.borderBottom
-  };
-}
-function getMargins(specifier) {
-  return getStyles(specifier, ["margin-left", "margin-right", "margin-top", "margin-bottom"]);
-}
-async function getBounds(specifier) {
-  if (specifier instanceof ComponentDriver) specifier = specifier.component;
-  const boundingRect = await specifier.evaluate((element) => element.getBoundingClientRect());
-  const m = mapObject(await getMargins(specifier), parseFloat);
-  const width = boundingRect.width + m.marginLeft + m.marginRight;
-  const height = boundingRect.height + m.marginTop + m.marginBottom;
-  const left = boundingRect.left - m.marginLeft;
-  const right = boundingRect.right + m.marginRight;
-  const top = boundingRect.top - m.marginTop;
-  const bottom = boundingRect.bottom + m.marginBottom;
-  return {
-    width,
-    height,
-    left,
-    right,
-    top,
-    bottom
-  };
-}
-class TestSkipReason {
-  addAnnotation(type, description) {
-    return {
-      annotation: {
-        type,
-        description: description ?? ""
-      }
-    };
-  }
-  NOT_IMPLEMENTED_XMLUI(description) {
-    return this.addAnnotation("not implemented in xmlui", description);
-  }
-  TO_BE_IMPLEMENTED(description) {
-    return this.addAnnotation("to be implemented", description);
-  }
-  XMLUI_BUG(description) {
-    return this.addAnnotation("xmlui bug", description);
-  }
-  TEST_INFRA_BUG(description) {
-    return this.addAnnotation("test infra bug", description);
-  }
-  TEST_NOT_WORKING(description) {
-    return this.addAnnotation("test not working", description);
-  }
-  TEST_INFRA_NOT_IMPLEMENTED(description) {
-    return this.addAnnotation("test infra not implemented", description);
-  }
-  REFACTOR(description) {
-    return this.addAnnotation("refactor", description);
-  }
-  // Need to specify a reason here!
-  UNSURE(description) {
-    return this.addAnnotation("unsure", description);
-  }
-}
-const SKIP_REASON = new TestSkipReason();
-function pixelStrToNum$1(pixelStr) {
-  return Number(pixelStr.replace("px", ""));
-}
-function parseAsCssBorder(str) {
-  const parts = str.split(/\s+(?=[a-z]+|\()/i);
-  if (parts.length > 3) {
-    throw new Error(`Provided value ${str} cannot be parsed as a CSS border`);
-  }
-  const style = parts.filter(isCSSBorderStyle);
-  if (style.length > 1) {
-    throw new Error(`Too many border styles provided in ${str}`);
-  }
-  const width = parts.filter(isNumericCSS);
-  if (width.length > 1) {
-    throw new Error(`Too many border widths provided in ${str}`);
-  }
-  const color = parts.filter((p) => chroma.valid(p));
-  if (color.length > 1) {
-    throw new Error(`Too many border colors provided in ${str}`);
-  }
-  const result = {
-    width: !!width[0] ? parseAsNumericCss(width[0]) : void 0,
-    style: style[0],
-    color: chroma(color[0])
-  };
-  return result;
-}
-const numericCSSRegex = /^([+-]?(?:\d+|\d*\.\d+))([a-z]*|%)$/;
-function isNumericCSS(str) {
-  const parts = str.match(numericCSSRegex);
-  if (!parts) return false;
-  if (parts.length < 3) return false;
-  if (isNaN(parseFloat(parts[1]))) return false;
-  if (!isCSSUnit(parts[2])) return false;
-  return true;
-}
-function parseAsNumericCss(str) {
-  const parts = str.match(numericCSSRegex);
-  if (!parts) {
-    throw new Error(`Provided value ${str} cannot be parsed as a numeric CSS value`);
-  }
-  if (parts.length < 3) {
-    throw new Error(`${parts[0]} is not a correct numeric CSS value`);
-  }
-  const value = parseFloat(parts[1]);
-  if (isNaN(value)) {
-    throw new Error(`${value} is not a valid number in ${str}`);
-  }
-  const unit = parts[2];
-  if (!isCSSUnit(unit)) {
-    throw new Error(`${unit} is not have a valid CSS unit in ${str}`);
-  }
-  const result = { value, unit };
-  return result;
-}
-function numericCSSToString(cssValue) {
-  return `${cssValue.value}${cssValue.unit}`;
-}
-function parseAsCSSColor(str) {
-  return chroma(str);
-}
-const CSSUnitValues = [
-  "px",
-  "em",
-  "rem",
-  "vh",
-  "vw",
-  "%",
-  "cm",
-  "mm",
-  "in",
-  "pt",
-  "pc",
-  "ex",
-  "ch",
-  "vmin",
-  "vmax"
-];
-function isCSSUnit(str) {
-  return CSSUnitValues.includes(str);
-}
-const CSSBorderStyleValues = [
-  "solid",
-  "dotted",
-  "dashed",
-  "double",
-  "none",
-  "hidden",
-  "groove",
-  "ridge",
-  "inset",
-  "outset"
-];
-function isCSSBorderStyle(str) {
-  return CSSBorderStyleValues.includes(str);
-}
-function parseAsCSSBorderStyle(str) {
-  if (!isCSSBorderStyle(str)) {
-    throw new Error(`Provided value ${str} cannot be parsed as a CSS border style`);
-  }
-  return str;
-}
-const BorderSideValues = ["top", "bottom", "left", "right"];
-function isBorderSide(str) {
-  return BorderSideValues.includes(str);
-}
 class ComponentDriver {
   constructor({ locator, page }) {
     this.click = async (options) => {
@@ -1023,7 +760,7 @@ class CodeBlockDriver extends ComponentDriver {
 class CheckboxDriver extends InputComponentDriver {
   async getIndicatorColor() {
     const specifier = this.component.getByRole("checkbox").or(this.component).last();
-    const { boxShadow } = await getPseudoStyles(specifier, "::before", "box-shadow");
+    const { boxShadow } = await getStyles(specifier, "box-shadow", "::before");
     const colorMatch = boxShadow.match(/(rgba?\([^)]+\)|hsla?\([^)]+\)|#[a-fA-F0-9]{3,8})/);
     return colorMatch ? colorMatch[1] : null;
   }
@@ -1485,307 +1222,6 @@ Received: ${this.utils.printReceived(provided)}`;
       expected,
       actual: void 0
     };
-  },
-  // ---
-  // --- NOTE: Assertations below this line are experimental and are reserved for future test cases (ex. comparison tests)
-  // ---
-  /**
-   * Asserts whether a component has the correct CSS `border-color` styling.
-   *
-   * @param expected Expected CSS color
-   * @param border Border side(s), Default: **"all"**
-   *
-   * ---
-   * **Usage**
-   *
-   * ```js
-   * await initTestBed(`<Button label="hello" />`, {
-   *    testThemeVars: { "borderLeftColor-Button": "rgb(0, 0, 0)" },
-   * });
-   * const driver = await createButtonDriver();
-   * await expect(driver.component).toHaveBorderColor("rgb(0, 0, 0)", "left");
-   * ```
-   */
-  async toHaveBorderColor(locator, expected, border = "all") {
-    const assertionName = "toHaveBorder";
-    let expectedBorderColor;
-    try {
-      expectedBorderColor = parseAsCSSColor(expected);
-      if (Object.values(expectedBorderColor).length === 0) {
-        throw new Error("Empty color!");
-      }
-    } catch (e) {
-      return {
-        message: () => "In " + this.utils.matcherHint(assertionName, locator, expected, { isNot: this.isNot }) + ":\n" + (e instanceof Error ? e.message : String(e)) + `
-
-Expected: Correct CSS border color to expect (e.g. "red", "rgb(0, 0, 0)", "#AA0011")
-Received: ${this.utils.printReceived(expected)}`,
-        pass: false,
-        name: assertionName,
-        expected,
-        actual: void 0
-      };
-    }
-    let _border = [];
-    if (typeof border === "string") {
-      if (border === "all") {
-        _border = ["top", "bottom", "left", "right"];
-      } else {
-        _border = [border];
-      }
-    } else {
-      _border = Array.from(new Set(border)).filter(isBorderSide);
-    }
-    let pass = true;
-    let matcherResult;
-    const colorStr = `rgb(${expectedBorderColor.rgb().join(", ")})`;
-    try {
-      for (let b of _border) {
-        await expect$1(locator).toHaveCSS(`border-${b}-color`, colorStr);
-      }
-    } catch (e) {
-      matcherResult = e.matcherResult;
-      pass = false;
-    }
-    const message = pass ? () => this.utils.matcherHint(assertionName, void 0, void 0, { isNot: this.isNot }) + `
-
-Expected: not ${this.utils.printExpected(expected)}
-` + (matcherResult ? `Received: ${this.utils.printReceived(matcherResult.actual)}` : "") : () => this.utils.matcherHint(assertionName, void 0, void 0, { isNot: this.isNot }) + `
-
-Expected: ${this.utils.printExpected(expected)}
-` + (matcherResult ? `Received: ${this.utils.printReceived(matcherResult.actual)}` : "");
-    return {
-      message,
-      pass,
-      name: assertionName,
-      expected,
-      actual: matcherResult?.actual
-    };
-  },
-  /**
-   * Asserts whether a component has the correct CSS `border-width` styling.
-   *
-   * @param expected Expected CSS size
-   * @param border Border side(s), Default: **"all"**
-   *
-   * ---
-   * **Usage**
-   *
-   * ```js
-   * await initTestBed(`<Button label="hello" />`, {
-   *    testThemeVars: { "borderLeftWidth-Button": "12px" },
-   * });
-   * const driver = await createButtonDriver();
-   * await expect(driver.component).toHaveBorderWidth("12px", "left");
-   * ```
-   */
-  async toHaveBorderWidth(locator, expected, border = "all") {
-    const assertionName = "toHaveBorder";
-    let expectedBorderWidth;
-    try {
-      expectedBorderWidth = parseAsNumericCss(expected);
-      if (Object.values(expectedBorderWidth).length === 0) {
-        throw new Error("Empty width!");
-      }
-    } catch (e) {
-      return {
-        message: () => "In " + this.utils.matcherHint(assertionName, locator, expected, { isNot: this.isNot }) + ":\n" + (e instanceof Error ? e.message : String(e)) + `
-
-Expected: Correct CSS border width to expect (e.g. "1px", "2rem")
-Received: ${this.utils.printReceived(expected)}`,
-        pass: false,
-        name: assertionName,
-        expected,
-        actual: void 0
-      };
-    }
-    let _border = [];
-    if (typeof border === "string") {
-      if (border === "all") {
-        _border = ["top", "bottom", "left", "right"];
-      } else {
-        _border = [border];
-      }
-    } else {
-      _border = Array.from(new Set(border)).filter(isBorderSide);
-    }
-    let pass = true;
-    let matcherResult;
-    const widthStr = numericCSSToString(expectedBorderWidth);
-    try {
-      for (let b of _border) {
-        await expect$1(locator).toHaveCSS(`border-${b}-width`, widthStr);
-      }
-    } catch (e) {
-      matcherResult = e.matcherResult;
-      pass = false;
-    }
-    const message = pass ? () => this.utils.matcherHint(assertionName, void 0, void 0, { isNot: this.isNot }) + `
-
-Expected: not ${this.utils.printExpected(expected)}
-` + (matcherResult ? `Received: ${this.utils.printReceived(matcherResult.actual)}` : "") : () => this.utils.matcherHint(assertionName, void 0, void 0, { isNot: this.isNot }) + `
-
-Expected: ${this.utils.printExpected(expected)}
-` + (matcherResult ? `Received: ${this.utils.printReceived(matcherResult.actual)}` : "");
-    return {
-      message,
-      pass,
-      name: assertionName,
-      expected,
-      actual: matcherResult?.actual
-    };
-  },
-  /**
-   * Asserts whether a component has the correct CSS `border-style` styling.
-   *
-   * @param expected Expected CSS border style
-   * @param border Border side(s), default: **"all"**
-   *
-   * ---
-   * **Usage**
-   *
-   * ```js
-   * await initTestBed(`<Button label="hello" />`, {
-   *    testThemeVars: { "borderLeftStyle-Button": "dotted" },
-   * });
-   * const driver = await createButtonDriver();
-   * await expect(driver.component).toHaveBorderStyle("dotted", "left");
-   * ```
-   */
-  async toHaveBorderStyle(locator, expected, border = "all") {
-    const assertionName = "toHaveBorder";
-    let expectedBorderStyle;
-    try {
-      expectedBorderStyle = parseAsCSSBorderStyle(expected);
-      if (Object.values(expectedBorderStyle).length === 0) {
-        throw new Error("Empty border style!");
-      }
-    } catch (e) {
-      return {
-        message: () => "In " + this.utils.matcherHint(assertionName, locator, expected, { isNot: this.isNot }) + ":\n" + (e instanceof Error ? e.message : String(e)) + `
-
-Expected: Correct CSS border style to expect (e.g. "1px solid black")
-Received: ${this.utils.printReceived(expected)}`,
-        pass: false,
-        name: assertionName,
-        expected,
-        actual: void 0
-      };
-    }
-    let _border = [];
-    if (typeof border === "string") {
-      if (border === "all") {
-        _border = ["top", "bottom", "left", "right"];
-      } else {
-        _border = [border];
-      }
-    } else {
-      _border = Array.from(new Set(border)).filter(isBorderSide);
-    }
-    let pass = true;
-    let matcherResult;
-    try {
-      for (let b of _border) {
-        await expect$1(locator).toHaveCSS(`border-${b}-style`, expectedBorderStyle);
-      }
-    } catch (e) {
-      matcherResult = e.matcherResult;
-      pass = false;
-    }
-    const message = pass ? () => this.utils.matcherHint(assertionName, void 0, void 0, { isNot: this.isNot }) + `
-
-Expected: not ${this.utils.printExpected(expected)}
-` + (matcherResult ? `Received: ${this.utils.printReceived(matcherResult.actual)}` : "") : () => this.utils.matcherHint(assertionName, void 0, void 0, { isNot: this.isNot }) + `
-
-Expected: ${this.utils.printExpected(expected)}
-` + (matcherResult ? `Received: ${this.utils.printReceived(matcherResult.actual)}` : "");
-    return {
-      message,
-      pass,
-      name: assertionName,
-      expected,
-      actual: matcherResult?.actual
-    };
-  },
-  /**
-   * Asserts whether a component has the correct CSS `border` shorthand set:
-   * `color`, `width`, `style`.
-   *
-   * @param expected Expected string label
-   * @param border Border side(s), Default: **"all"**
-   *
-   * ---
-   * **Usage**
-   *
-   * ```js
-   * await initTestBed(`<Button label="hello" />`, {
-   *    testThemeVars: { "borderLeft-Button": "1px solid black" },
-   * });
-   * const driver = await createButtonDriver();
-   * await expect(driver.component).toHaveBorder("1px solid black", "left");
-   * ```
-   */
-  async toHaveBorder(locator, expected, border = "all") {
-    const assertionName = "toHaveBorder";
-    let expectedBorder;
-    try {
-      expectedBorder = parseAsCssBorder(expected);
-      if (Object.values(expectedBorder).length === 0) {
-        throw new Error("Empty style!");
-      }
-    } catch (e) {
-      return {
-        message: () => "In " + this.utils.matcherHint(assertionName, locator, expected, { isNot: this.isNot }) + ":\n" + (e instanceof Error ? e.message : String(e)) + `
-
-Expected: Correct CSS border style to expect (e.g. "1px solid black")
-Received: ${this.utils.printReceived(expected)}`,
-        pass: false,
-        name: assertionName,
-        expected,
-        actual: void 0
-      };
-    }
-    let _border = [];
-    if (typeof border === "string") {
-      if (border === "all") {
-        _border = ["top", "bottom", "left", "right"];
-      } else {
-        _border = [border];
-      }
-    } else {
-      _border = Array.from(new Set(border)).filter(isBorderSide);
-    }
-    let pass = true;
-    let matcherResult;
-    try {
-      if (expectedBorder?.color) {
-        const colorStr = `rgb(${expectedBorder.color.rgb().join(", ")})`;
-        await expect(locator).toHaveBorderColor(colorStr, _border);
-      }
-      if (expectedBorder?.width) {
-        await expect(locator).toHaveBorderWidth(numericCSSToString(expectedBorder.width), _border);
-      }
-      if (expectedBorder?.style) {
-        await expect(locator).toHaveBorderStyle(expectedBorder.style, _border);
-      }
-    } catch (e) {
-      matcherResult = e.matcherResult;
-      pass = false;
-    }
-    const message = pass ? () => this.utils.matcherHint(assertionName, void 0, void 0, { isNot: this.isNot }) + `
-
-Expected: not ${this.utils.printExpected(expected)}
-` + (matcherResult ? `Received: ${this.utils.printReceived(matcherResult.actual)}` : "") : () => this.utils.matcherHint(assertionName, void 0, void 0, { isNot: this.isNot }) + `
-
-Expected: ${this.utils.printExpected(expected)}
-` + (matcherResult ? `Received: ${this.utils.printReceived(matcherResult.actual)}` : "");
-    return {
-      message,
-      pass,
-      name: assertionName,
-      expected,
-      actual: matcherResult?.actual
-    };
   }
 });
 const isCI = process?.env?.CI === "true";
@@ -2243,141 +1679,7 @@ const test = test$1.extend({
     });
   }
 });
-function parseComponent(entryPoint) {
-  if (typeof entryPoint === "string") {
-    return xmlUiMarkupToComponent(entryPoint).component;
-  }
-  return entryPoint;
-}
-async function initApp(page, appDescription, url = "/", resources = {}) {
-  const { entryPoint, components } = appDescription;
-  const _appDescription = {
-    ...appDescription,
-    name: appDescription.name || "Test App",
-    entryPoint: parseComponent(entryPoint),
-    resources,
-    components: !components ? void 0 : Array.isArray(components) ? components.map((comp) => parseComponent(comp)) : [parseComponent(components)]
-  };
-  await page.addInitScript((app) => {
-    window.TEST_ENV = app;
-  }, _appDescription);
-  await page.goto(url);
-}
-async function prepPage(co, appDesc, url = "/") {
-  const context = co;
-  const page = await context.newPage();
-  await initApp(page, appDesc, url);
-  return page;
-}
-async function initThemedApp(page, entryPoint, theme) {
-  theme.id ?? (theme.id = "testTheme");
-  theme.name ?? (theme.name = "Custom Test theme");
-  await initApp(page, { entryPoint, defaultTheme: theme.id, themes: [theme] });
-}
-function scalePercentBy(scalarOf100Percent, percentage) {
-  if (!percentage.endsWith("%")) {
-    throw new Error("argument doesn't end with % sign");
-  }
-  const percentageNum = Number(percentage.slice(0, -1));
-  return scalarOf100Percent / 100 * percentageNum;
-}
-function getBoundingRect(locator) {
-  return locator.evaluate((element) => element.getBoundingClientRect());
-}
-async function getFullRectangle(locator) {
-  const boundingRect = await locator.evaluate((element) => element.getBoundingClientRect());
-  const margins = await getElementStyles(locator, [
-    "margin-left",
-    "margin-right",
-    "margin-top",
-    "margin-bottom"
-  ]);
-  const marginLeft = parseFloat(margins["margin-left"]);
-  const marginRight = parseFloat(margins["margin-right"]);
-  const marginTop = parseFloat(margins["margin-top"]);
-  const marginBottom = parseFloat(margins["margin-bottom"]);
-  const width = boundingRect.width + marginLeft + marginRight;
-  const height = boundingRect.height + marginTop + marginBottom;
-  const left = boundingRect.left - marginLeft;
-  const right = boundingRect.right + marginRight;
-  const top = boundingRect.top - marginTop;
-  const bottom = boundingRect.bottom + marginBottom;
-  return { width, height, left, right, top, bottom };
-}
-async function isElementOverflown(locator, direction = "both") {
-  const [width, height, scrollWidth, scrollHeight] = await locator.evaluate((element) => [
-    element.clientWidth,
-    element.clientHeight,
-    element.scrollWidth,
-    element.scrollHeight
-  ]);
-  if (direction === "x") return scrollWidth > width;
-  if (direction === "y") return scrollHeight > height;
-  return scrollWidth > width && scrollHeight > height;
-}
-function pixelStrToNum(pixelStr) {
-  return Number(pixelStr.replace("px", ""));
-}
-function getElementStyle(locator, style) {
-  return locator.evaluate(
-    (element, style2) => window.getComputedStyle(element).getPropertyValue(style2),
-    style
-  );
-}
-function getElementStyles(locator, styles = []) {
-  return locator.evaluate(
-    (element, styles2) => Object.fromEntries(
-      styles2.map((styleName) => [
-        styleName,
-        window.getComputedStyle(element).getPropertyValue(styleName)
-      ])
-    ),
-    styles
-  );
-}
-async function getStyle(page, testId, style) {
-  const locator = page.getByTestId(testId);
-  return await getElementStyle(locator, style);
-}
 export {
-  ComponentDriver,
-  DateInputDriver,
-  SKIP_REASON,
-  TimeInputDriver,
-  TimerDriver,
   expect,
-  getBorders,
-  getBoundingRect$1 as getBoundingRect,
-  getBounds,
-  getComponentTagName,
-  getElementStyle$1 as getElementStyle,
-  getElementStyles$1 as getElementStyles,
-  getFullRectangle,
-  getHtmlAttributes,
-  getMargins,
-  getPaddings,
-  getPseudoStyles,
-  getStyles,
-  getBoundingRect as getThemedBoundingRect,
-  getElementStyle as getThemedElementStyle,
-  getElementStyles as getThemedElementStyles,
-  getStyle as getThemedStyle,
-  initApp,
-  initThemedApp,
-  isIndeterminate,
-  mapObject,
-  numericCSSToString,
-  overflows,
-  parseAsCSSBorderStyle,
-  parseAsCSSColor,
-  parseAsCssBorder,
-  parseAsNumericCss,
-  parseComponentIfNecessary,
-  pixelStrToNum$1 as pixelStrToNum,
-  prepPage,
-  scaleByPercent,
-  scalePercentBy,
-  test,
-  isElementOverflown as themedOverflows,
-  pixelStrToNum as themedPixelStrToNum
+  test
 };