@tstdl/base 0.85.13 → 0.86.0-beta1

package/browser/document-controller.js

@@ -1,89 +1,56 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var document_controller_exports = {};
-__export(document_controller_exports, {
-  DocumentController: () => DocumentController
-});
-module.exports = __toCommonJS(document_controller_exports);
-var import_type_guards = require("../utils/type-guards.js");
-var import_element_controller = require("./element-controller.js");
-var import_locator_controller = require("./locator-controller.js");
-class DocumentController extends import_locator_controller.LocatorController {
-  forwardOptions;
-  /** @deprecated should be avoided */
-  document;
-  constructor(document, options, forwardOptions) {
-    super(document, { actionDelay: options.defaultActionDelay, typeDelay: options.defaultTypeDelay });
-    this.document = document;
-    this.forwardOptions = forwardOptions;
-  }
-  async setContent(...args) {
-    await this.document.setContent(...args);
-  }
-  async navigate(...args) {
-    await this.document.goto(...args);
-  }
-  async waitForLoadState(...args) {
-    await this.document.waitForLoadState(...args);
-  }
-  async waitForUrl(...args) {
-    await this.document.waitForURL(...args);
-  }
-  async waitForElement(selector, options) {
-    const element = await this.document.waitForSelector(selector, options);
-    if ((0, import_type_guards.isNull)(element)) {
-      throw new Error("Element not found.");
+import { isNull, isUndefined } from '../utils/type-guards.js';
+import { ElementController } from './element-controller.js';
+import { LocatorController } from './locator-controller.js';
+export class DocumentController extends LocatorController {
+    forwardOptions;
+    /** @deprecated should be avoided */
+    document;
+    constructor(document, options, forwardOptions) {
+        super(document, { actionDelay: options.defaultActionDelay, typeDelay: options.defaultTypeDelay });
+        this.document = document;
+        this.forwardOptions = forwardOptions;
     }
-    return new import_element_controller.ElementController(element, this.elementControllerOptions);
-  }
-  locateInFrame(frameSelector) {
-    const locator = this.document.frameLocator(frameSelector);
-    return new import_locator_controller.LocatorController(locator, this.elementControllerOptions);
-  }
-  async waitForFrame(selector, options) {
-    const element = await this.waitForElement(selector, options);
-    const frame = await element.locatorOrHandle.contentFrame();
-    if ((0, import_type_guards.isNull)(frame)) {
-      throw new Error("Element is not a frame.");
+    async setContent(...args) {
+        await this.document.setContent(...args);
+    }
+    async navigate(...args) {
+        await this.document.goto(...args);
+    }
+    async waitForLoadState(...args) {
+        await this.document.waitForLoadState(...args);
+    }
+    async waitForUrl(...args) {
+        await this.document.waitForURL(...args);
+    }
+    async waitForElement(selector, options) {
+        const element = await this.document.waitForSelector(selector, options);
+        if (isNull(element)) {
+            throw new Error('Element not found.');
+        }
+        return new ElementController(element, this.elementControllerOptions);
+    }
+    locateInFrame(frameSelector) {
+        const locator = this.document.frameLocator(frameSelector);
+        return new LocatorController(locator, this.elementControllerOptions);
+    }
+    async waitForFrame(selector, options) {
+        const element = await this.waitForElement(selector, options);
+        const frame = await element.locatorOrHandle.contentFrame();
+        if (isNull(frame)) {
+            throw new Error('Element is not a frame.');
+        }
+        return newFrameController(frame, this.forwardOptions.frameControllerOptions, { pageControllerOptions: this.forwardOptions.pageControllerOptions });
     }
-    return newFrameController(frame, this.forwardOptions.frameControllerOptions, { pageControllerOptions: this.forwardOptions.pageControllerOptions });
-  }
 }
 let frameControllerConstructor;
 async function newFrameController(...args) {
-  if ((0, import_type_guards.isUndefined)(frameControllerConstructor)) {
-    frameControllerConstructor = importFrameController();
-    void frameControllerConstructor.then((constructor) => frameControllerConstructor = constructor);
-  }
-  return new (await frameControllerConstructor)(...args);
+    if (isUndefined(frameControllerConstructor)) {
+        frameControllerConstructor = importFrameController();
+        void frameControllerConstructor.then((constructor) => (frameControllerConstructor = constructor));
+    }
+    return new (await frameControllerConstructor)(...args);
 }
 async function importFrameController() {
-  const module2 = await import("./frame-controller.js");
-  return module2.FrameController;
+    const module = await import('./frame-controller.js');
+    return module.FrameController;
 }

package/browser/element-controller.js

@@ -1,163 +1,142 @@
-"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_timing = require("../utils/timing.js");
-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");
-class ElementController {
-  locatorOrHandle;
-  options;
-  constructor(locatorOrHandle, options = {}) {
-    this.locatorOrHandle = locatorOrHandle;
-    this.options = options;
-  }
-  /**
-   * 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);
-  }
-  /**
-   * 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 ?? 250 });
-      return true;
-    } catch {
-      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 fill(text, options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.fill(text, options);
-  }
-  async type(text, options) {
-    await this.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 delay(options?.typeDelay ?? this.options.typeDelay);
-      }
-    }
-  }
-  async press(key, options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.press(key, options);
-  }
-  async check(options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.check(options);
-  }
-  async uncheck(options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.uncheck(options);
-  }
-  async setChecked(checked, options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.setChecked(checked, options);
-  }
-  async selectOption(option, options) {
-    await this.prepareAction(options);
-    const selectedOptions = await this.locatorOrHandle.selectOption(option, options);
-    return selectedOptions;
-  }
-  async setInputFiles(files, options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.setInputFiles(files, options);
-  }
-  async click(options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.click({
-      ...options,
-      delay: (0, import_value_or_provider.resolveValueOrProvider)(options?.clickDelay)
-    });
-  }
-  async dblclick(options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.dblclick({
-      ...options,
-      delay: (0, import_value_or_provider.resolveValueOrProvider)(options?.clickDelay)
-    });
-  }
-  async hover(options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.hover(options);
-  }
-  async focus(options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.focus(options);
-  }
-  async tap(options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.tap(options);
-  }
-  async selectText(options) {
-    await this.prepareAction(options);
-    await this.locatorOrHandle.selectText(options);
-  }
-  async inputValue(options) {
-    return this.locatorOrHandle.inputValue(options);
-  }
-  async prepareAction(options) {
-    const actionDelay = options?.actionDelay ?? this.options.actionDelay;
-    if ((0, import_type_guards.isDefined)(actionDelay)) {
-      await this.waitFor("visible", { timeout: (0, import_value_or_provider.resolveValueOrProvider)(options?.timeout) });
-      await delay(actionDelay);
-    }
-  }
+import { timeout } from '../utils/timing.js';
+import { isDefined, isUndefined } from '../utils/type-guards.js';
+import { resolveValueOrProvider } from '../utils/value-or-provider.js';
+import { isLocator } from './utils.js';
+export class ElementController {
+    locatorOrHandle;
+    options;
+    constructor(locatorOrHandle, options = {}) {
+        this.locatorOrHandle = locatorOrHandle;
+        this.options = options;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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 ?? 250 });
+            return true;
+        }
+        catch {
+            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 fill(text, options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.fill(text, options);
+    }
+    async type(text, options) {
+        await this.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 this.prepareAction(options);
+        await this.locatorOrHandle.press(key, options);
+    }
+    async check(options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.check(options);
+    }
+    async uncheck(options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.uncheck(options);
+    }
+    async setChecked(checked, options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.setChecked(checked, options);
+    }
+    async selectOption(option, options) {
+        await this.prepareAction(options);
+        const selectedOptions = await this.locatorOrHandle.selectOption(option, options);
+        return selectedOptions;
+    }
+    async setInputFiles(files, options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.setInputFiles(files, options);
+    }
+    async click(options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.click({
+            ...options,
+            delay: resolveValueOrProvider(options?.clickDelay)
+        });
+    }
+    async dblclick(options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.dblclick({
+            ...options,
+            delay: resolveValueOrProvider(options?.clickDelay)
+        });
+    }
+    async hover(options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.hover(options);
+    }
+    async focus(options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.focus(options);
+    }
+    async tap(options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.tap(options);
+    }
+    async selectText(options) {
+        await this.prepareAction(options);
+        await this.locatorOrHandle.selectText(options);
+    }
+    async inputValue(options) {
+        return this.locatorOrHandle.inputValue(options);
+    }
+    async prepareAction(options) {
+        const actionDelay = options?.actionDelay ?? this.options.actionDelay;
+        if (isDefined(actionDelay)) {
+            await this.waitFor('visible', { timeout: resolveValueOrProvider(options?.timeout) });
+            await delay(actionDelay);
+        }
+    }
 }
 async function delay(milliseconds) {
-  if ((0, import_type_guards.isUndefined)(milliseconds)) {
-    return;
-  }
-  await (0, import_timing.timeout)((0, import_value_or_provider.resolveValueOrProvider)(milliseconds));
+    if (isUndefined(milliseconds)) {
+        return;
+    }
+    await timeout(resolveValueOrProvider(milliseconds));
 }

package/browser/frame-controller.js

@@ -1,52 +1,29 @@
-"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");
-var import_page_controller = require("./page-controller.js");
-class FrameController extends import_document_controller.DocumentController {
-  frameControllerForwardOptions;
-  /** @deprecated should be avoided */
-  frame;
-  options;
-  constructor(frame, options, forwardOptions) {
-    super(frame, options, { frameControllerOptions: options, pageControllerOptions: forwardOptions.pageControllerOptions });
-    this.options = options;
-    this.frameControllerForwardOptions = forwardOptions;
-  }
-  /** Get the page containing this frame */
-  getPage() {
-    return new import_page_controller.PageController(this.frame.page(), this.frameControllerForwardOptions.pageControllerOptions);
-  }
-  /**
-   * @param frameSelector frame name, url or url predicate
-   * @returns
-   */
-  getFrame(frameSelector) {
-    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';
+import { PageController } from './page-controller.js';
+export class FrameController extends DocumentController {
+    frameControllerForwardOptions;
+    /** @deprecated should be avoided */
+    frame;
+    options;
+    constructor(frame, options, forwardOptions) {
+        super(frame, options, { frameControllerOptions: options, pageControllerOptions: forwardOptions.pageControllerOptions });
+        this.options = options;
+        this.frameControllerForwardOptions = forwardOptions;
+    }
+    /** Get the page containing this frame */
+    getPage() {
+        return new PageController(this.frame.page(), this.frameControllerForwardOptions.pageControllerOptions);
+    }
+    /**
+     * @param frameSelector frame name, url or url predicate
+     * @returns
+     */
+    getFrame(frameSelector) {
+        const frame = this.frame.page().frame(frameSelector);
+        if (isNull(frame)) {
+            throw new Error('Frame not found.');
+        }
+        return new FrameController(frame, this.options, this.frameControllerForwardOptions);
     }
-    return new FrameController(frame, this.options, this.frameControllerForwardOptions);
-  }
 }

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';