@tstdl/base 0.87.13 → 0.88.0-alpha1

package/browser/element-controller.js

@@ -1,255 +1,234 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var element_controller_exports = {};
-__export(element_controller_exports, {
-  ElementController: () => ElementController
-});
-module.exports = __toCommonJS(element_controller_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_value_or_provider = require("../utils/value-or-provider.js");
-var import_utils = require("./utils.js");
-const requiresLocatorBasedController = "Requires a locator based controller";
-class ElementController {
-  locatorOrHandle;
-  options;
-  constructor(locatorOrHandle, options = {}) {
-    this.locatorOrHandle = locatorOrHandle;
-    this.options = options;
-  }
-  async getAll() {
-    if (!(0, import_utils.isLocator)(this.locatorOrHandle)) {
-      throw new Error("getAll only works with Locator");
-    }
-    const locators = await this.locatorOrHandle.all();
-    return locators.map((locator) => new ElementController(locator));
-  }
-  async getAllHandles() {
-    if (!(0, import_utils.isLocator)(this.locatorOrHandle)) {
-      throw new Error("getAllHandles only works with Locator");
-    }
-    const handles = await this.locatorOrHandle.elementHandles();
-    return handles.map((handle) => new ElementController(handle));
-  }
-  /**
-   * Get an controller with elements contained in this and the provided controller.
-   * Requires locator based controller
-   * @param elementController
-   */
-  and(elementController) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
-    (0, import_utils.assertLocator)(elementController.locatorOrHandle, requiresLocatorBasedController);
-    const locator = this.locatorOrHandle.and(elementController.locatorOrHandle);
-    return new ElementController(locator, this.options);
-  }
-  /**
-   * Get an controller with elements contained in this and the provided controller.
-   * Requires locator based controller
-   * @param elementController
-   */
-  or(elementController) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
-    (0, import_utils.assertLocator)(elementController.locatorOrHandle, requiresLocatorBasedController);
-    const locator = this.locatorOrHandle.or(elementController.locatorOrHandle);
-    return new ElementController(locator, this.options);
-  }
-  /**
-   * Filter out elements with by provided filter.
-   * Requires locator based controller.
-   */
-  filter(filter) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
-    const locator = this.locatorOrHandle.filter(convertFilter(filter));
-    return new ElementController(locator, this.options);
-  }
-  /**
-   * Locate elements in subtree with provided selector/controller and filter.
-   * Requires locator based controller.
-   */
-  locate(selectorOrController, filter) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
-    const selector = (0, import_type_guards.isString)(selectorOrController) ? selectorOrController : (0, import_utils.assertLocatorPass)(selectorOrController.locatorOrHandle, requiresLocatorBasedController);
-    const convertedFilter = (0, import_type_guards.isDefined)(filter) ? convertFilter(filter) : void 0;
-    const locator = this.locatorOrHandle.locator(selector, convertedFilter);
-    return new ElementController(locator, this.options);
-  }
-  first() {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
-    const locator = this.locatorOrHandle.first();
-    return new ElementController(locator, this.options);
-  }
-  last() {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
-    const locator = this.locatorOrHandle.last();
-    return new ElementController(locator, this.options);
-  }
-  nth(index) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
-    const locator = this.locatorOrHandle.nth(index);
-    return new ElementController(locator, this.options);
-  }
-  async evaluate(fn, argument) {
-    if ((0, import_utils.isLocator)(this.locatorOrHandle)) {
-      return this.locatorOrHandle.evaluate(fn, argument);
-    }
-    return this.locatorOrHandle.evaluate(fn, argument);
-  }
-  /**
-   * Wait for element state
-   * @param state some states may only be usable for either locator or handle
-   * @param options options
-   */
-  async waitFor(state = "visible", options) {
-    if ((0, import_utils.isLocator)(this.locatorOrHandle)) {
-      return this.locatorOrHandle.waitFor({ state, ...options });
-    }
-    return this.locatorOrHandle.waitForElementState(state, options);
-  }
-  async boundingBox(options) {
-    return this.locatorOrHandle.boundingBox({ timeout: options?.timeout ?? 1e3 });
-  }
-  async scrollIntoViewIfNeeded(options) {
-    await this.locatorOrHandle.scrollIntoViewIfNeeded({ timeout: options?.timeout ?? 1e3 });
-  }
-  /**
-   * Counts matching elements for locator based or returns 1 for handle based.
-   */
-  async count() {
-    return (0, import_utils.isLocator)(this.locatorOrHandle) ? this.locatorOrHandle.count() : 1;
-  }
-  /**
-   * Check if element exists
-   * @param options.state which state is required in order to be deemed existing
-   * @param options.timeout how long to wait for the element before being deemed not existing (default: 250ms)
-   */
-  async exists(options) {
-    try {
-      await this.waitFor(options?.state ?? "visible", { timeout: options?.timeout ?? 1e3 });
-      return true;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("violation")) {
-        throw error;
-      }
-      return false;
-    }
-  }
-  async isVisible() {
-    return this.locatorOrHandle.isVisible();
-  }
-  async isHidden() {
-    return this.locatorOrHandle.isHidden();
-  }
-  async isEnabled() {
-    return this.locatorOrHandle.isEnabled();
-  }
-  async isDisabled() {
-    return this.locatorOrHandle.isDisabled();
-  }
-  async isChecked() {
-    return this.locatorOrHandle.isChecked();
-  }
-  async isEditable() {
-    return this.locatorOrHandle.isEditable();
-  }
-  async clear(options) {
-    (0, import_utils.assertLocator)(this.locatorOrHandle, requiresLocatorBasedController);
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.clear(options);
-  }
-  async fill(text, options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.fill(text, options);
-  }
-  async type(text, options) {
-    await (0, import_utils.prepareAction)(options);
-    if ((0, import_type_guards.isUndefined)(this.options.typeDelay)) {
-      await this.locatorOrHandle.type(text, options);
-    } else {
-      for (const char of text) {
-        await this.locatorOrHandle.type(char, options);
-        await (0, import_utils.delay)(options?.typeDelay ?? this.options.typeDelay);
-      }
-    }
-  }
-  async press(key, options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.press(key, options);
-  }
-  async check(options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.check(options);
-  }
-  async uncheck(options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.uncheck(options);
-  }
-  async setChecked(checked, options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.setChecked(checked, options);
-  }
-  async selectOption(option, options) {
-    await (0, import_utils.prepareAction)(options);
-    const selectedOptions = await this.locatorOrHandle.selectOption(option, options);
-    return selectedOptions;
-  }
-  async setInputFiles(files, options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.setInputFiles(files, options);
-  }
-  async click(options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.click({
-      ...options,
-      delay: (0, import_value_or_provider.resolveValueOrProvider)(options?.clickDelay)
-    });
-  }
-  async dblclick(options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.dblclick({
-      ...options,
-      delay: (0, import_value_or_provider.resolveValueOrProvider)(options?.clickDelay)
-    });
-  }
-  async hover(options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.hover(options);
-  }
-  async focus(options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.focus(options);
-  }
-  async tap(options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.tap(options);
-  }
-  async selectText(options) {
-    await (0, import_utils.prepareAction)(options);
-    await this.locatorOrHandle.selectText(options);
-  }
-  async inputValue(options) {
-    return this.locatorOrHandle.inputValue(options);
-  }
+import { isDefined, isString, isUndefined } from '../utils/type-guards.js';
+import { resolveValueOrProvider } from '../utils/value-or-provider.js';
+import { assertLocator, assertLocatorPass, delay, isLocator, prepareAction } from './utils.js';
+const requiresLocatorBasedController = 'Requires a locator based controller';
+export class ElementController {
+    locatorOrHandle;
+    options;
+    constructor(locatorOrHandle, options = {}) {
+        this.locatorOrHandle = locatorOrHandle;
+        this.options = options;
+    }
+    async getAll() {
+        if (!isLocator(this.locatorOrHandle)) {
+            throw new Error('getAll only works with Locator');
+        }
+        const locators = await this.locatorOrHandle.all();
+        return locators.map((locator) => new ElementController(locator));
+    }
+    async getAllHandles() {
+        if (!isLocator(this.locatorOrHandle)) {
+            throw new Error('getAllHandles only works with Locator');
+        }
+        const handles = await this.locatorOrHandle.elementHandles();
+        return handles.map((handle) => new ElementController(handle));
+    }
+    /**
+     * Get an controller with elements contained in this and the provided controller.
+     * Requires locator based controller
+     * @param elementController
+     */
+    and(elementController) {
+        assertLocator(this.locatorOrHandle, requiresLocatorBasedController);
+        assertLocator(elementController.locatorOrHandle, requiresLocatorBasedController);
+        const locator = this.locatorOrHandle.and(elementController.locatorOrHandle);
+        return new ElementController(locator, this.options);
+    }
+    /**
+     * Get an controller with elements contained in this and the provided controller.
+     * Requires locator based controller
+     * @param elementController
+     */
+    or(elementController) {
+        assertLocator(this.locatorOrHandle, requiresLocatorBasedController);
+        assertLocator(elementController.locatorOrHandle, requiresLocatorBasedController);
+        const locator = this.locatorOrHandle.or(elementController.locatorOrHandle);
+        return new ElementController(locator, this.options);
+    }
+    /**
+     * Filter out elements with by provided filter.
+     * Requires locator based controller.
+     */
+    filter(filter) {
+        assertLocator(this.locatorOrHandle, requiresLocatorBasedController);
+        const locator = this.locatorOrHandle.filter(convertFilter(filter));
+        return new ElementController(locator, this.options);
+    }
+    /**
+     * Locate elements in subtree with provided selector/controller and filter.
+     * Requires locator based controller.
+     */
+    locate(selectorOrController, filter) {
+        assertLocator(this.locatorOrHandle, requiresLocatorBasedController);
+        const selector = isString(selectorOrController) ? selectorOrController : assertLocatorPass(selectorOrController.locatorOrHandle, requiresLocatorBasedController);
+        const convertedFilter = isDefined(filter) ? convertFilter(filter) : undefined;
+        const locator = this.locatorOrHandle.locator(selector, convertedFilter);
+        return new ElementController(locator, this.options);
+    }
+    first() {
+        assertLocator(this.locatorOrHandle, requiresLocatorBasedController);
+        const locator = this.locatorOrHandle.first();
+        return new ElementController(locator, this.options);
+    }
+    last() {
+        assertLocator(this.locatorOrHandle, requiresLocatorBasedController);
+        const locator = this.locatorOrHandle.last();
+        return new ElementController(locator, this.options);
+    }
+    nth(index) {
+        assertLocator(this.locatorOrHandle, requiresLocatorBasedController);
+        const locator = this.locatorOrHandle.nth(index);
+        return new ElementController(locator, this.options);
+    }
+    async evaluate(fn, argument) {
+        if (isLocator(this.locatorOrHandle)) {
+            return this.locatorOrHandle.evaluate(fn, argument);
+        }
+        return this.locatorOrHandle.evaluate(fn, argument);
+    }
+    /**
+     * Wait for element state
+     * @param state some states may only be usable for either locator or handle
+     * @param options options
+     */
+    async waitFor(state = 'visible', options) {
+        if (isLocator(this.locatorOrHandle)) {
+            return this.locatorOrHandle.waitFor({ state: state, ...options });
+        }
+        return this.locatorOrHandle.waitForElementState(state, options);
+    }
+    async boundingBox(options) {
+        return this.locatorOrHandle.boundingBox({ timeout: options?.timeout ?? 1000 });
+    }
+    async scrollIntoViewIfNeeded(options) {
+        await this.locatorOrHandle.scrollIntoViewIfNeeded({ timeout: options?.timeout ?? 1000 });
+    }
+    /**
+     * Counts matching elements for locator based or returns 1 for handle based.
+     */
+    async count() {
+        return isLocator(this.locatorOrHandle) ? this.locatorOrHandle.count() : 1;
+    }
+    /**
+     * Check if element exists
+     * @param options.state which state is required in order to be deemed existing
+     * @param options.timeout how long to wait for the element before being deemed not existing (default: 250ms)
+     */
+    async exists(options) {
+        try {
+            await this.waitFor(options?.state ?? 'visible', { timeout: options?.timeout ?? 1000 });
+            return true;
+        }
+        catch (error) {
+            if ((error instanceof Error) && error.message.includes('violation')) {
+                throw error;
+            }
+            return false;
+        }
+    }
+    async isVisible() {
+        return this.locatorOrHandle.isVisible();
+    }
+    async isHidden() {
+        return this.locatorOrHandle.isHidden();
+    }
+    async isEnabled() {
+        return this.locatorOrHandle.isEnabled();
+    }
+    async isDisabled() {
+        return this.locatorOrHandle.isDisabled();
+    }
+    async isChecked() {
+        return this.locatorOrHandle.isChecked();
+    }
+    async isEditable() {
+        return this.locatorOrHandle.isEditable();
+    }
+    async clear(options) {
+        assertLocator(this.locatorOrHandle, requiresLocatorBasedController);
+        await prepareAction(options);
+        await this.locatorOrHandle.clear(options);
+    }
+    async fill(text, options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.fill(text, options);
+    }
+    async type(text, options) {
+        await prepareAction(options);
+        if (isUndefined(this.options.typeDelay)) {
+            await this.locatorOrHandle.type(text, options);
+        }
+        else {
+            for (const char of text) {
+                await this.locatorOrHandle.type(char, options);
+                await delay(options?.typeDelay ?? this.options.typeDelay);
+            }
+        }
+    }
+    async press(key, options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.press(key, options);
+    }
+    async check(options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.check(options);
+    }
+    async uncheck(options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.uncheck(options);
+    }
+    async setChecked(checked, options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.setChecked(checked, options);
+    }
+    async selectOption(option, options) {
+        await prepareAction(options);
+        const selectedOptions = await this.locatorOrHandle.selectOption(option, options);
+        return selectedOptions;
+    }
+    async setInputFiles(files, options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.setInputFiles(files, options);
+    }
+    async click(options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.click({
+            ...options,
+            delay: resolveValueOrProvider(options?.clickDelay)
+        });
+    }
+    async dblclick(options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.dblclick({
+            ...options,
+            delay: resolveValueOrProvider(options?.clickDelay)
+        });
+    }
+    async hover(options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.hover(options);
+    }
+    async focus(options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.focus(options);
+    }
+    async tap(options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.tap(options);
+    }
+    async selectText(options) {
+        await prepareAction(options);
+        await this.locatorOrHandle.selectText(options);
+    }
+    async inputValue(options) {
+        return this.locatorOrHandle.inputValue(options);
+    }
 }
 function convertFilter(filter) {
-  return {
-    has: (0, import_type_guards.isDefined)(filter.has) ? (0, import_utils.assertLocatorPass)(filter.has.locatorOrHandle, requiresLocatorBasedController) : void 0,
-    hasNot: (0, import_type_guards.isDefined)(filter.hasNot) ? (0, import_utils.assertLocatorPass)(filter.hasNot.locatorOrHandle, requiresLocatorBasedController) : void 0,
-    hasText: filter.hasText,
-    hasNotText: filter.hasNotText
-  };
+    return {
+        has: isDefined(filter.has) ? assertLocatorPass(filter.has.locatorOrHandle, requiresLocatorBasedController) : undefined,
+        hasNot: isDefined(filter.hasNot) ? assertLocatorPass(filter.hasNot.locatorOrHandle, requiresLocatorBasedController) : undefined,
+        hasText: filter.hasText,
+        hasNotText: filter.hasNotText
+    };
 }

package/browser/frame-controller.js

@@ -1,49 +1,26 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var frame_controller_exports = {};
-__export(frame_controller_exports, {
-  FrameController: () => FrameController
-});
-module.exports = __toCommonJS(frame_controller_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_document_controller = require("./document-controller.js");
-class FrameController extends import_document_controller.DocumentController {
-  /** @deprecated should be avoided */
-  frame;
-  options;
-  constructor(frame, context, options) {
-    super(frame, context, options);
-    this.options = options;
-  }
-  /** Get the page containing this frame */
-  getPage(options) {
-    return this.context.getControllerByPage(this.frame.page(), options);
-  }
-  /**
-   * @param frameSelector frame name, url or url predicate
-   * @returns
-   */
-  getFrame(frameSelector, options) {
-    const frame = this.frame.page().frame(frameSelector);
-    if ((0, import_type_guards.isNull)(frame)) {
-      throw new Error("Frame not found.");
+import { isNull } from '../utils/type-guards.js';
+import { DocumentController } from './document-controller.js';
+export class FrameController extends DocumentController {
+    /** @deprecated should be avoided */
+    frame;
+    options;
+    constructor(frame, context, options) {
+        super(frame, context, options);
+        this.options = options;
+    }
+    /** Get the page containing this frame */
+    getPage(options) {
+        return this.context.getControllerByPage(this.frame.page(), options);
+    }
+    /**
+     * @param frameSelector frame name, url or url predicate
+     * @returns
+     */
+    getFrame(frameSelector, options) {
+        const frame = this.frame.page().frame(frameSelector);
+        if (isNull(frame)) {
+            throw new Error('Frame not found.');
+        }
+        return this.getControllerByFrame(frame, { ...this.options, ...options });
     }
-    return this.getControllerByFrame(frame, { ...this.options, ...options });
-  }
 }

package/browser/index.js

@@ -1,27 +1,10 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var browser_exports = {};
-module.exports = __toCommonJS(browser_exports);
-__reExport(browser_exports, require("./browser-context-controller.js"), module.exports);
-__reExport(browser_exports, require("./browser-controller.js"), module.exports);
-__reExport(browser_exports, require("./browser.service.js"), module.exports);
-__reExport(browser_exports, require("./document-controller.js"), module.exports);
-__reExport(browser_exports, require("./element-controller.js"), module.exports);
-__reExport(browser_exports, require("./frame-controller.js"), module.exports);
-__reExport(browser_exports, require("./locator-controller.js"), module.exports);
-__reExport(browser_exports, require("./module.js"), module.exports);
-__reExport(browser_exports, require("./page-controller.js"), module.exports);
-__reExport(browser_exports, require("./types.js"), module.exports);
+export * from './browser-context-controller.js';
+export * from './browser-controller.js';
+export * from './browser.service.js';
+export * from './document-controller.js';
+export * from './element-controller.js';
+export * from './frame-controller.js';
+export * from './locator-controller.js';
+export * from './module.js';
+export * from './page-controller.js';
+export * from './types.js';