@tstdl/base 0.85.24 → 0.85.26

package/browser/element-controller.d.ts

@@ -17,12 +17,34 @@ export type ElementControllerOptions = {
 };
 type LocatorOptions<K extends keyof Locator, I extends keyof Parameters<Locator[K]>> = NonUndefinable<Parameters<Locator[K]>[I]>;
 type Methods = 'isVisible' | 'isHidden' | 'isEnabled' | 'isDisabled' | 'isChecked' | 'isEditable' | 'fill' | 'type' | 'press' | 'check' | 'uncheck' | 'setChecked' | 'selectOption' | 'setInputFiles' | 'click' | 'hover' | 'focus' | 'tap' | 'selectText' | 'inputValue';
+export type Filter = {
+    has?: ElementController;
+    hasNot?: ElementController;
+    hasText?: string | RegExp;
+    hasNotText?: string | RegExp;
+};
 export declare class ElementController<T extends Locator | ElementHandle = Locator | ElementHandle> implements Pick<Locator, Methods> {
     readonly locatorOrHandle: T;
     readonly options: ElementControllerOptions;
     constructor(locatorOrHandle: T, options?: ElementControllerOptions);
     getAll(): Promise<ElementController<Locator>[]>;
     getAllHandles(): Promise<ElementController<ElementHandle>[]>;
+    /**
+     * Get an controller with elements contained in this and the provided controller.
+     * Requires locator based controller
+     * @param elementController
+     */
+    and(elementController: ElementController): ElementController<Locator>;
+    /**
+     * Filter out elements with by provided filter.
+     * Requires locator based controller.
+     */
+    filter(filter: Filter): ElementController<Locator>;
+    /**
+     * Locate elements in subtree with provided selector/controller and filter.
+     * Requires locator based controller.
+     */
+    locate(selectorOrController: string | ElementController, filter?: Filter): ElementController<Locator>;
     /**
      * Wait for element state
      * @param state some states may only be usable for either locator or handle

package/browser/element-controller.js

@@ -25,6 +25,7 @@ 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");
+const filterNonLocatorErrorMessage = "Requires a locator basesd controller";
 class ElementController {
   locatorOrHandle;
   options;
@@ -46,6 +47,37 @@ class ElementController {
     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, filterNonLocatorErrorMessage);
+    (0, import_utils.assertLocator)(elementController.locatorOrHandle, filterNonLocatorErrorMessage);
+    const locator = this.locatorOrHandle.and(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, filterNonLocatorErrorMessage);
+    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, filterNonLocatorErrorMessage);
+    const selector = (0, import_type_guards.isString)(selectorOrController) ? selectorOrController : (0, import_utils.assertLocatorPass)(selectorOrController.locatorOrHandle, filterNonLocatorErrorMessage);
+    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);
+  }
   /**
    * Wait for element state
    * @param state some states may only be usable for either locator or handle
@@ -178,3 +210,11 @@ async function delay(milliseconds) {
   }
   await (0, import_timing.timeout)((0, import_value_or_provider.resolveValueOrProvider)(milliseconds));
 }
+function convertFilter(filter) {
+  return {
+    has: (0, import_type_guards.isDefined)(filter.has) ? (0, import_utils.assertLocatorPass)(filter.has.locatorOrHandle, filterNonLocatorErrorMessage) : void 0,
+    hasNot: (0, import_type_guards.isDefined)(filter.hasNot) ? (0, import_utils.assertLocatorPass)(filter.hasNot.locatorOrHandle, filterNonLocatorErrorMessage) : void 0,
+    hasText: filter.hasText,
+    hasNotText: filter.hasNotText
+  };
+}

package/browser/utils.d.ts

@@ -6,6 +6,8 @@ export declare function getLaunchOptions(options: NewBrowserOptions): LaunchOpti
 export declare function mergeNewBrowserContextOptions(a: NewBrowserContextOptions | undefined, b?: NewBrowserContextOptions, c?: NewBrowserContextOptions): NewBrowserContextOptions;
 export declare function attachLogger(loggable: Page | BrowserContext, logger: Logger): void;
 export declare function isLocator(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is Locator;
+export declare function assertLocator(locatorOrHandle: Locator | ElementHandle, message?: string): asserts locatorOrHandle is Locator;
+export declare function assertLocatorPass(locatorOrHandle: Locator | ElementHandle, message?: string): Locator;
 export declare function isElementHandle(locatorOrHandle: Locator | ElementHandle): locatorOrHandle is ElementHandle;
 export declare function isPage(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is Page;
 export declare function isFrame(pageOrFrameOrContext: Page | Frame | BrowserContext): pageOrFrameOrContext is Frame;

package/browser/utils.js

@@ -18,6 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  assertLocator: () => assertLocator,
+  assertLocatorPass: () => assertLocatorPass,
   attachLogger: () => attachLogger,
   getLaunchOptions: () => getLaunchOptions,
   isBrowserContext: () => isBrowserContext,
@@ -104,6 +106,13 @@ function attachLogger(loggable, logger) {
 function isLocator(locatorOrHandle) {
   return locatorOrHandle.constructor.name == "Locator";
 }
+function assertLocator(locatorOrHandle, message = "Locator instead of ElementHandle required") {
+  (0, import_type_guards.assert)(isLocator(locatorOrHandle), message);
+}
+function assertLocatorPass(locatorOrHandle, message = "Locator instead of ElementHandle required") {
+  assertLocator(locatorOrHandle, message);
+  return locatorOrHandle;
+}
 function isElementHandle(locatorOrHandle) {
   return locatorOrHandle.constructor.name == "ElementHandle";
 }

package/decorators/log.js

@@ -25,27 +25,31 @@ var import_log = require("../function/log.js");
 var import_utils = require("../reflection/utils.js");
 var import_object = require("../utils/object/object.js");
 var import_type_guards = require("../utils/type-guards.js");
-const isLogWrapped = Symbol("log wrapped");
-function wrapLogTagged(fn, options) {
-  const wrapped = (0, import_log.wrapLog)(fn, options);
-  wrapped[isLogWrapped] = true;
-  return wrapped;
+const wrappedStaticMethods = /* @__PURE__ */ new WeakMap();
+const wrappedInstanceMethods = /* @__PURE__ */ new WeakMap();
+function isWrapped(constructor, property, isStatic) {
+  return (isStatic ? wrappedStaticMethods : wrappedInstanceMethods).get(constructor)?.has(property) ?? false;
 }
-function isWrapped(fn) {
-  return fn[isLogWrapped] ?? false;
+function setWrapped(constructor, property, isStatic) {
+  const map = isStatic ? wrappedStaticMethods : wrappedInstanceMethods;
+  if (!map.has(constructor)) {
+    map.set(constructor, /* @__PURE__ */ new Set());
+  }
+  map.get(constructor).add(property);
 }
 function Log() {
   return (0, import_utils.createDecorator)({ class: true, method: true }, (data) => {
     if (data.type == "method") {
-      return { value: wrapLogTagged(data.descriptor.value) };
+      setWrapped(data.constructor, data.methodKey, data.static);
+      return { value: (0, import_log.wrapLog)(data.descriptor.value) };
     }
-    const staticProperties = (0, import_object.objectKeys)(data.constructor).filter((property) => property != "length" && property != "name" && property != "prototype" && (0, import_type_guards.isFunction)(data.constructor[property]) && !isWrapped(data.constructor[property]));
-    const instanceProperties = (0, import_object.objectKeys)(data.prototype).filter((property) => property != "constructor" && (0, import_type_guards.isFunction)(data.prototype[property]) && !isWrapped(data.prototype[property]));
+    const staticProperties = (0, import_object.objectKeys)(data.constructor).filter((property) => property != "length" && property != "name" && property != "prototype" && (0, import_type_guards.isFunction)(data.constructor[property]) && !isWrapped(data.constructor, property, true));
+    const instanceProperties = (0, import_object.objectKeys)(data.prototype).filter((property) => property != "constructor" && (0, import_type_guards.isFunction)(data.prototype[property]) && !isWrapped(data.constructor, property, false));
     for (const property of staticProperties) {
-      data.constructor[property] = wrapLogTagged(data.constructor[property], property);
+      data.constructor[property] = (0, import_log.wrapLog)(data.constructor[property], property);
     }
     for (const property of instanceProperties) {
-      data.prototype[property] = wrapLogTagged(data.prototype[property], property);
+      data.prototype[property] = (0, import_log.wrapLog)(data.prototype[property], property);
     }
     return void 0;
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.85.24",
+  "version": "0.85.26",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -58,7 +58,7 @@
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",
-    "mongodb": "^5.7",
+    "mongodb": "^5.8",
     "nodemailer": "^6.9",
     "playwright": "^1.37",
     "preact": "^10.17",