@tstdl/base 0.84.27 → 0.84.29

package/browser/element-controller.d.ts

@@ -16,7 +16,8 @@ export type ElementControllerOptions = {
     typeDelay?: Delay;
 };
 type LocatorOptions<K extends keyof Locator, I extends keyof Parameters<Locator[K]>> = NonUndefinable<Parameters<Locator[K]>[I]>;
-export declare class ElementController<T extends Locator | ElementHandle = Locator | ElementHandle> {
+type Methods = 'isVisible' | 'isHidden' | 'isEnabled' | 'isDisabled' | 'isChecked' | 'isEditable' | 'fill' | 'type' | 'press' | 'check' | 'uncheck' | 'setChecked' | 'selectOption' | 'setInputFiles' | 'click' | 'hover' | 'focus' | 'tap' | 'selectText' | 'inputValue';
+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);
@@ -43,9 +44,19 @@ export declare class ElementController<T extends Locator | ElementHandle = Locat
     isEditable(): Promise<boolean>;
     fill(text: string, options?: Merge<LocatorOptions<'fill', 1>, ActionDelayOptions>): Promise<void>;
     type(text: string, options?: Merge<TypedOmit<LocatorOptions<'type', 1>, 'delay'>, ActionDelayOptions & TypeDelayOptions>): Promise<void>;
-    selectOption(value: string | string[], options?: Merge<LocatorOptions<'selectOption', 1>, ActionDelayOptions>): Promise<void>;
+    press(key: string, options?: Merge<LocatorOptions<'press', 1>, ActionDelayOptions>): Promise<void>;
+    check(options?: Merge<LocatorOptions<'check', 1>, ActionDelayOptions>): Promise<void>;
+    uncheck(options?: Merge<LocatorOptions<'uncheck', 1>, ActionDelayOptions>): Promise<void>;
+    setChecked(checked: boolean, options?: Merge<LocatorOptions<'setChecked', 1>, ActionDelayOptions>): Promise<void>;
+    selectOption(option: string | string[], options?: Merge<LocatorOptions<'selectOption', 1>, ActionDelayOptions>): Promise<string[]>;
+    setInputFiles(files: LocatorOptions<'setInputFiles', 0>, options?: Merge<LocatorOptions<'setInputFiles', 1>, ActionDelayOptions>): Promise<void>;
     click(options?: Merge<TypedOmit<LocatorOptions<'click', 0>, 'delay'>, ActionDelayOptions & ClickDelayOptions>): Promise<void>;
-    getValue(options?: LocatorOptions<'inputValue', 0>): Promise<string>;
+    dblclick(options?: Merge<TypedOmit<LocatorOptions<'click', 0>, 'delay'>, ActionDelayOptions & ClickDelayOptions>): Promise<void>;
+    hover(options?: Merge<LocatorOptions<'hover', 1>, ActionDelayOptions>): Promise<void>;
+    focus(options?: Merge<LocatorOptions<'focus', 1>, ActionDelayOptions>): Promise<void>;
+    tap(options?: Merge<LocatorOptions<'tap', 1>, ActionDelayOptions>): Promise<void>;
+    selectText(options?: Merge<LocatorOptions<'selectText', 1>, ActionDelayOptions>): Promise<void>;
+    inputValue(options?: LocatorOptions<'inputValue', 0>): Promise<string>;
     private prepareAction;
 }
 export {};

package/browser/element-controller.js

@@ -89,9 +89,30 @@ class ElementController {
       }
     }
   }
-  async selectOption(value, options) {
+  async press(key, options) {
     await this.prepareAction(options);
-    await this.locatorOrHandle.selectOption(value, 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);
@@ -100,11 +121,38 @@ class ElementController {
       delay: (0, import_value_or_provider.resolveValueOrProvider)(options?.clickDelay)
     });
   }
-  async getValue(options) {
+  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) {
-    await delay(options?.actionDelay ?? this.options.actionDelay);
+    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);
+    }
   }
 }
 async function delay(milliseconds) {

package/container/token.d.ts

@@ -11,6 +11,7 @@ export declare class ReifyingInjectionToken<T = any, A = any> {
     private readonly [argument];
     readonly description: string;
     constructor(description: string);
+    toString(): string;
 }
 export declare function injectionToken<T, A = any>(description: string): InjectionToken<T, A>;
 export declare function getTokenName(token: InjectionToken | undefined): string;

package/container/token.js

@@ -29,6 +29,9 @@ class ReifyingInjectionToken {
   constructor(description) {
     this.description = description;
   }
+  toString() {
+    return `InjectionToken["${this.description}"]`;
+  }
 }
 function injectionToken(description) {
   return new ReifyingInjectionToken(description);

package/json-path/json-path.d.ts

@@ -31,8 +31,11 @@ export type JsonPathOptions = {
     treatArrayAsObject?: boolean;
     /** encode as ['foo'] instead of .foo */
     forceBrackets?: boolean;
-    /** dont prepend $ */
-    noDollar?: boolean;
+    /**
+     * Prepend $
+     * @default true
+     */
+    dollar?: boolean;
 };
 export type JsonPathContext = {
     /** if path contains symbols, they are required in order to be mapped, otherwise they are created from global symbol registry */

package/json-path/json-path.js

@@ -35,7 +35,7 @@ class JsonPath {
   /** json path as encoded string */
   get path() {
     if ((0, import_type_guards.isUndefined)(this._path)) {
-      this._path = encodeJsonPath(this._nodes);
+      this._path = encodeJsonPath(this._nodes, this._options);
     }
     return this._path;
   }
@@ -55,6 +55,9 @@ class JsonPath {
       this._path = pathOrNodesOrOptions;
     } else if ((0, import_type_guards.isArray)(pathOrNodesOrOptions)) {
       this._nodes = pathOrNodesOrOptions;
+    } else if (pathOrNodesOrOptions instanceof JsonPath) {
+      this._nodes = pathOrNodesOrOptions._nodes;
+      this._path = pathOrNodesOrOptions._path;
     } else if ((0, import_is_iterable.isIterable)(pathOrNodesOrOptions)) {
       this._nodes = [...pathOrNodesOrOptions];
     } else {
@@ -88,7 +91,7 @@ function isJsonPath(path) {
   return parsePattern.test(path);
 }
 function encodeJsonPath(nodes, options = {}) {
-  const { treatArrayAsObject = false, forceBrackets = false, noDollar = false } = options;
+  const { treatArrayAsObject = false, forceBrackets = false, dollar = true } = options;
   let path = "";
   for (const node of nodes) {
     const nodeIsSymbol = (0, import_type_guards.isSymbol)(node);
@@ -105,13 +108,13 @@ function encodeJsonPath(nodes, options = {}) {
       }
     }
   }
-  if (noDollar) {
-    if (path.startsWith("[")) {
-      return path;
-    }
-    return path.slice(1);
+  if (dollar) {
+    return `$${path}`;
+  }
+  if (path.startsWith("[")) {
+    return path;
   }
-  return `$${path}`;
+  return path.slice(1);
 }
 function decodeJsonPath(path, context = {}) {
   const matches = path.trim().matchAll(parsePattern);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.27",
+  "version": "0.84.29",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -23,7 +23,7 @@
     "luxon": "^3.3",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
-    "type-fest": "^3.11"
+    "type-fest": "^3.12"
   },
   "devDependencies": {
     "@types/chroma-js": "2.4",

package/theme/adapters/tailwind-adapter.d.ts

@@ -11,6 +11,7 @@ export type TailwindPalette = {
     700: string;
     800: string;
     900: string;
+    950: string;
 };
 export declare function generateTailwindColorsFromTheme(theme: Theme, tailwindNamePrefix?: string): Record<string, TailwindPalette>;
 export declare function generateTailwindColorsFromThemeColors(colors: readonly string[], tailwindNamePrefix?: string): Record<string, TailwindPalette>;

package/theme/adapters/tailwind-adapter.js

@@ -48,7 +48,8 @@ function generateTailwindPalette(color) {
     600: `rgb(var(--theme-${color}-600-rgb) / <alpha-value>)`,
     700: `rgb(var(--theme-${color}-700-rgb) / <alpha-value>)`,
     800: `rgb(var(--theme-${color}-800-rgb) / <alpha-value>)`,
-    900: `rgb(var(--theme-${color}-900-rgb) / <alpha-value>)`
+    900: `rgb(var(--theme-${color}-900-rgb) / <alpha-value>)`,
+    950: `rgb(var(--theme-${color}-950-rgb) / <alpha-value>)`
     /* eslint-enable @typescript-eslint/naming-convention */
   };
 }

package/utils/crc32.d.ts

@@ -0,0 +1 @@
+export declare function crc32b(bytes: Uint8Array): Uint8Array;

package/utils/crc32.js

@@ -0,0 +1,47 @@
+"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 crc32_exports = {};
+__export(crc32_exports, {
+  crc32b: () => crc32b
+});
+module.exports = __toCommonJS(crc32_exports);
+let crcTable;
+function crc32b(bytes) {
+  crcTable ??= generateCrc32Table();
+  let crc = 0 ^ -1;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = crc >>> 8 ^ crcTable[crc & 255 ^ bytes[i]];
+  }
+  crc = (crc ^ -1) >>> 0;
+  const buffer = new ArrayBuffer(4);
+  const dataView = new DataView(buffer);
+  dataView.setUint32(0, crc, false);
+  return new Uint8Array(buffer);
+}
+function generateCrc32Table() {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[i] = c;
+  }
+  return table;
+}

package/utils/cryptography.js

@@ -114,7 +114,7 @@ async function importEcdsaKey(curve, key, extractable = false) {
 }
 async function importPbkdf2Key(key, extractable = false) {
   const binaryKey = (0, import_type_guards.isString)(key) ? (0, import_encoding.encodeUtf8)(key) : key;
-  return subtle.importKey("raw", binaryKey, { name: "PBKDF2" }, extractable, ["deriveKey", "deriveBits"]);
+  return globalThis.crypto.subtle.importKey("raw", binaryKey, { name: "PBKDF2" }, extractable, ["deriveKey", "deriveBits"]);
 }
 async function generateEcdsaKey(curve, extractable = false, usages = ["sign", "verify"]) {
   return subtle.generateKey({ name: "ECDSA", namedCurve: curve }, extractable, usages);