@testspectra/matchers 1.1.8-rc.2 → 1.1.8-rc.21

package/src/runtime/element_proxy.ts

@@ -1,200 +1,200 @@
-/**
- * Element & collection proxy factories plus target resolution.
- *
- * Assembles action, state-inspection, and assertion methods into `SingleElementProxy` and
- * `CollectionProxy` instances that dispatch to the bound `PlatformDriverBridge`. The sibling
- * factories are read from the shared runtime context (single-scope concatenated assembly).
- */
-
-import type {
-  AssertionOptions,
-  CollectionProxy,
-  ElementTarget,
-  ScopedSelector,
-  SingleElementProxy,
-} from '@testspectra/matchers';
-
-/** Display text for error messages / debugging — the local selector only, never the full chain. */
-function selectorText(s: string | ScopedSelector): string {
-  return typeof s === 'string' ? s : s.selector;
-}
-
-/** Normalizes this element/collection's own identity into a `ScopedSelector`, for use as a
- * child's `parent` when chaining via `.get()`/`.getAll()`. */
-function toScopedSelector(selector: string | ScopedSelector, index: number | null): ScopedSelector {
-  return typeof selector === 'string' ? { selector, index, parent: undefined } : selector;
-}
-
-export function createElementProxy(
-  selector: string | ScopedSelector,
-  index: number | null = null,
-): SingleElementProxy {
-  const selectorTextValue = selectorText(selector);
-  const resolvedIndex = typeof selector === 'string' ? index : selector.index;
-  const actions = globalThis.__TS_RUNTIME__.createElementActions!(selector, index);
-  const state = globalThis.__TS_RUNTIME__.createElementState!(selector, index);
-  const assertions = globalThis.__TS_RUNTIME__.createElementAssertions!(selector, index, state);
-
-  return {
-    selector: selectorTextValue,
-    index: resolvedIndex,
-    ...actions,
-    ...state,
-    ...assertions,
-    get(childSelector: string, childIndex: number | null = null): SingleElementProxy {
-      return globalThis.__TS_RUNTIME__.createElementProxy!(
-        { selector: childSelector, index: childIndex, parent: toScopedSelector(selector, index) },
-        null,
-      );
-    },
-    getAll(childSelector: string): CollectionProxy {
-      return globalThis.__TS_RUNTIME__.createCollectionProxy!({
-        selector: childSelector,
-        index: null,
-        parent: toScopedSelector(selector, index),
-      });
-    },
-  } as SingleElementProxy;
-}
-
-export function createCollectionProxy(selector: string | ScopedSelector): CollectionProxy {
-  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
-  const selectorTextValue = selectorText(selector);
-
-  /** Builds the (selector, index) pair to hand to `createElementProxy` for first()/last()/nth(),
-   * preserving this collection's own scope (parent chain) instead of discarding it. */
-  const withIndex = (idx: number): [string | ScopedSelector, number | null] =>
-    typeof selector === 'string' ? [selector, idx] : [{ ...selector, index: idx }, null];
-
-  const collectionProxy: CollectionProxy = {
-    selector: selectorTextValue,
-    async count(): Promise<number> {
-      return await driver().count(selector);
-    },
-    get length(): Promise<number> {
-      return this.count();
-    },
-    first(): SingleElementProxy {
-      return globalThis.__TS_RUNTIME__.createElementProxy!(...withIndex(0));
-    },
-    last(): SingleElementProxy {
-      return globalThis.__TS_RUNTIME__.createElementProxy!(...withIndex(-1));
-    },
-    nth(index: number): SingleElementProxy {
-      return globalThis.__TS_RUNTIME__.createElementProxy!(...withIndex(index));
-    },
-    async shouldHaveLength(expected: number, options?: AssertionOptions): Promise<void> {
-      return globalThis.__TS_RUNTIME__.trackStep(
-        'assertion',
-        { type: 'assertion', key: 'have.length', target: selector, args: [expected] },
-        async () => {
-          let actual = 0;
-          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-            actual = await this.count();
-            return actual === expected;
-          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-          if (!ok) {
-            throw new Error(`Expected collection "${selectorTextValue}" count to equal ${expected}, but got ${actual}`);
-          }
-        },
-      );
-    },
-    async shouldNotHaveLength(expected: number, options?: AssertionOptions): Promise<void> {
-      return globalThis.__TS_RUNTIME__.trackStep(
-        'assertion',
-        { type: 'assertion', key: 'not.have.length', target: selector, args: [expected] },
-        async () => {
-          let actual = 0;
-          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-            actual = await this.count();
-            return actual !== expected;
-          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-          if (!ok) {
-            throw new Error(`Expected collection "${selectorTextValue}" count not to equal ${expected}`);
-          }
-        },
-      );
-    },
-    async shouldHaveLengthGreaterThan(expected: number, options?: AssertionOptions): Promise<void> {
-      return globalThis.__TS_RUNTIME__.trackStep(
-        'assertion',
-        { type: 'assertion', key: 'have.length.greaterThan', target: selector, args: [expected] },
-        async () => {
-          let actual = 0;
-          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-            actual = await this.count();
-            return actual > expected;
-          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-          if (!ok) {
-            throw new Error(
-              `Expected collection "${selectorTextValue}" count to be greater than ${expected}, but got ${actual}`,
-            );
-          }
-        },
-      );
-    },
-    async shouldHaveLengthLessThan(expected: number, options?: AssertionOptions): Promise<void> {
-      return globalThis.__TS_RUNTIME__.trackStep(
-        'assertion',
-        { type: 'assertion', key: 'have.length.lessThan', target: selector, args: [expected] },
-        async () => {
-          let actual = 0;
-          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-            actual = await this.count();
-            return actual < expected;
-          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-          if (!ok) {
-            throw new Error(`Expected collection "${selectorTextValue}" count to be less than ${expected}, but got ${actual}`);
-          }
-        },
-      );
-    },
-    async shouldBeEmpty(options?: AssertionOptions): Promise<void> {
-      return globalThis.__TS_RUNTIME__.trackStep(
-        'assertion',
-        { type: 'assertion', key: 'be.empty', target: selector, args: [] },
-        async () => {
-          let actual = 0;
-          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-            actual = await this.count();
-            return actual === 0;
-          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-          if (!ok) {
-            throw new Error(`Expected collection "${selectorTextValue}" to be empty, but got ${actual}`);
-          }
-        },
-      );
-    },
-    async shouldNotBeEmpty(options?: AssertionOptions): Promise<void> {
-      return globalThis.__TS_RUNTIME__.trackStep(
-        'assertion',
-        { type: 'assertion', key: 'not.be.empty', target: selector, args: [] },
-        async () => {
-          let actual = 0;
-          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
-            actual = await this.count();
-            return actual > 0;
-          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
-          if (!ok) {
-            throw new Error(`Expected collection "${selectorTextValue}" not to be empty`);
-          }
-        },
-      );
-    },
-  };
-  return collectionProxy;
-}
-
-export function resolveTargetProxy(target: ElementTarget): SingleElementProxy {
-  if (typeof target === 'string') {
-    return (globalThis as any).$(target);
-  }
-  if (target && typeof target === 'object' && 'selector' in target) {
-    return target as SingleElementProxy;
-  }
-  throw new Error(`Invalid element target: ${String(target)}`);
-}
-
-globalThis.__TS_RUNTIME__.createElementProxy = createElementProxy;
-globalThis.__TS_RUNTIME__.createCollectionProxy = createCollectionProxy;
-globalThis.__TS_RUNTIME__.resolveTargetProxy = resolveTargetProxy;
+/**
+ * Element & collection proxy factories plus target resolution.
+ *
+ * Assembles action, state-inspection, and assertion methods into `SingleElementProxy` and
+ * `CollectionProxy` instances that dispatch to the bound `PlatformDriverBridge`. The sibling
+ * factories are read from the shared runtime context (single-scope concatenated assembly).
+ */
+
+import type {
+  AssertionOptions,
+  CollectionProxy,
+  ElementTarget,
+  ScopedSelector,
+  SingleElementProxy,
+} from '@testspectra/matchers';
+
+/** Display text for error messages / debugging — the local selector only, never the full chain. */
+function selectorText(s: string | ScopedSelector): string {
+  return typeof s === 'string' ? s : s.selector;
+}
+
+/** Normalizes this element/collection's own identity into a `ScopedSelector`, for use as a
+ * child's `parent` when chaining via `.get()`/`.getAll()`. */
+function toScopedSelector(selector: string | ScopedSelector, index: number | null): ScopedSelector {
+  return typeof selector === 'string' ? { selector, index, parent: undefined } : selector;
+}
+
+export function createElementProxy(
+  selector: string | ScopedSelector,
+  index: number | null = null,
+): SingleElementProxy {
+  const selectorTextValue = selectorText(selector);
+  const resolvedIndex = typeof selector === 'string' ? index : selector.index;
+  const actions = globalThis.__TS_RUNTIME__.createElementActions!(selector, index);
+  const state = globalThis.__TS_RUNTIME__.createElementState!(selector, index);
+  const assertions = globalThis.__TS_RUNTIME__.createElementAssertions!(selector, index, state);
+
+  return {
+    selector: selectorTextValue,
+    index: resolvedIndex,
+    ...actions,
+    ...state,
+    ...assertions,
+    get(childSelector: string, childIndex: number | null = null): SingleElementProxy {
+      return globalThis.__TS_RUNTIME__.createElementProxy!(
+        { selector: childSelector, index: childIndex, parent: toScopedSelector(selector, index) },
+        null,
+      );
+    },
+    getAll(childSelector: string): CollectionProxy {
+      return globalThis.__TS_RUNTIME__.createCollectionProxy!({
+        selector: childSelector,
+        index: null,
+        parent: toScopedSelector(selector, index),
+      });
+    },
+  } as SingleElementProxy;
+}
+
+export function createCollectionProxy(selector: string | ScopedSelector): CollectionProxy {
+  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
+  const selectorTextValue = selectorText(selector);
+
+  /** Builds the (selector, index) pair to hand to `createElementProxy` for first()/last()/nth(),
+   * preserving this collection's own scope (parent chain) instead of discarding it. */
+  const withIndex = (idx: number): [string | ScopedSelector, number | null] =>
+    typeof selector === 'string' ? [selector, idx] : [{ ...selector, index: idx }, null];
+
+  const collectionProxy: CollectionProxy = {
+    selector: selectorTextValue,
+    async count(): Promise<number> {
+      return await driver().count(selector);
+    },
+    get length(): Promise<number> {
+      return this.count();
+    },
+    first(): SingleElementProxy {
+      return globalThis.__TS_RUNTIME__.createElementProxy!(...withIndex(0));
+    },
+    last(): SingleElementProxy {
+      return globalThis.__TS_RUNTIME__.createElementProxy!(...withIndex(-1));
+    },
+    nth(index: number): SingleElementProxy {
+      return globalThis.__TS_RUNTIME__.createElementProxy!(...withIndex(index));
+    },
+    async shouldHaveLength(expected: number, options?: AssertionOptions): Promise<void> {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        'assertion',
+        { type: 'assertion', key: 'have.length', target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual === expected;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" count to equal ${expected}, but got ${actual}`);
+          }
+        },
+      );
+    },
+    async shouldNotHaveLength(expected: number, options?: AssertionOptions): Promise<void> {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        'assertion',
+        { type: 'assertion', key: 'not.have.length', target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual !== expected;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" count not to equal ${expected}`);
+          }
+        },
+      );
+    },
+    async shouldHaveLengthGreaterThan(expected: number, options?: AssertionOptions): Promise<void> {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        'assertion',
+        { type: 'assertion', key: 'have.length.greaterThan', target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual > expected;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(
+              `Expected collection "${selectorTextValue}" count to be greater than ${expected}, but got ${actual}`,
+            );
+          }
+        },
+      );
+    },
+    async shouldHaveLengthLessThan(expected: number, options?: AssertionOptions): Promise<void> {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        'assertion',
+        { type: 'assertion', key: 'have.length.lessThan', target: selector, args: [expected] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual < expected;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" count to be less than ${expected}, but got ${actual}`);
+          }
+        },
+      );
+    },
+    async shouldBeEmpty(options?: AssertionOptions): Promise<void> {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        'assertion',
+        { type: 'assertion', key: 'be.empty', target: selector, args: [] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual === 0;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" to be empty, but got ${actual}`);
+          }
+        },
+      );
+    },
+    async shouldNotBeEmpty(options?: AssertionOptions): Promise<void> {
+      return globalThis.__TS_RUNTIME__.trackStep(
+        'assertion',
+        { type: 'assertion', key: 'not.be.empty', target: selector, args: [] },
+        async () => {
+          let actual = 0;
+          const ok = await globalThis.__TS_RUNTIME__.pollCondition(async () => {
+            actual = await this.count();
+            return actual > 0;
+          }, options?.timeoutMs ?? globalThis.__TS_RUNTIME__.getAssertionTimeoutMs());
+          if (!ok) {
+            throw new Error(`Expected collection "${selectorTextValue}" not to be empty`);
+          }
+        },
+      );
+    },
+  };
+  return collectionProxy;
+}
+
+export function resolveTargetProxy(target: ElementTarget): SingleElementProxy {
+  if (typeof target === 'string') {
+    return (globalThis as any).$(target);
+  }
+  if (target && typeof target === 'object' && 'selector' in target) {
+    return target as SingleElementProxy;
+  }
+  throw new Error(`Invalid element target: ${String(target)}`);
+}
+
+globalThis.__TS_RUNTIME__.createElementProxy = createElementProxy;
+globalThis.__TS_RUNTIME__.createCollectionProxy = createCollectionProxy;
+globalThis.__TS_RUNTIME__.resolveTargetProxy = resolveTargetProxy;

package/src/runtime/element_state.ts

@@ -1,94 +1,94 @@
-/**
- * Element state-inspection methods for `SingleElementProxy`.
- *
- * Thin delegations to the bound `PlatformDriverBridge`. No platform branching here.
- */
-
-import type { ScopedSelector } from '@testspectra/matchers';
-
-export function createElementState(selector: string | ScopedSelector, index: number | null): Record<string, any> {
-  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
-  const selectorText = typeof selector === 'string' ? selector : selector.selector;
-
-  async function getText(): Promise<string> {
-    return await driver().getText(selector, index);
-  }
-
-  async function getValue(): Promise<string> {
-    return await driver().getValue(selector, index);
-  }
-
-  async function isDisplayed(): Promise<boolean> {
-    return await driver().isDisplayed(selector, index);
-  }
-
-  async function isVisible(): Promise<boolean> {
-    return await isDisplayed();
-  }
-
-  async function isExisting(): Promise<boolean> {
-    return await driver().isExisting(selector, index);
-  }
-
-  async function isEnabled(): Promise<boolean> {
-    return await driver().isEnabled(selector, index);
-  }
-
-  async function isSelected(): Promise<boolean> {
-    return await driver().isSelected(selector, index);
-  }
-
-  async function isChecked(): Promise<boolean> {
-    return await isSelected();
-  }
-
-  async function isFocused(): Promise<boolean> {
-    return await driver().isFocused(selector, index);
-  }
-
-  async function getAttribute(name: string): Promise<string | null> {
-    return await driver().getAttribute(selector, name, index);
-  }
-
-  async function getCSSProperty(name: string): Promise<{ value: string }> {
-    return await driver().getCSSProperty(selector, name, index);
-  }
-
-  async function waitForElement(timeoutMs?: number): Promise<boolean> {
-    const waitTimeout = timeoutMs ?? globalThis.__TS_RUNTIME__.getImplicitWaitMs();
-    const ok = await globalThis.__TS_RUNTIME__.pollCondition(
-      async () => driver().isExisting(selector, index),
-      waitTimeout,
-    );
-    if (ok) return true;
-    throw new Error('Element not found: ' + JSON.stringify(selectorText));
-  }
-
-  async function waitForDisplayed(opts: { timeout?: number } = {}): Promise<boolean> {
-    const timeout = opts.timeout || 5000;
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      if (await driver().isDisplayed(selector, index)) return true;
-      await new Promise((r) => setTimeout(r, 20));
-    }
-    throw new Error(`Element ${selectorText} not displayed after ${timeout}ms`);
-  }
-
-  return {
-    getText,
-    getValue,
-    isDisplayed,
-    isVisible,
-    isExisting,
-    isEnabled,
-    isSelected,
-    isChecked,
-    isFocused,
-    getAttribute,
-    getCSSProperty,
-    waitForElement,
-    waitForDisplayed,
-  };
-}
-
-globalThis.__TS_RUNTIME__.createElementState = createElementState;
+/**
+ * Element state-inspection methods for `SingleElementProxy`.
+ *
+ * Thin delegations to the bound `PlatformDriverBridge`. No platform branching here.
+ */
+
+import type { ScopedSelector } from '@testspectra/matchers';
+
+export function createElementState(selector: string | ScopedSelector, index: number | null): Record<string, any> {
+  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
+  const selectorText = typeof selector === 'string' ? selector : selector.selector;
+
+  async function getText(): Promise<string> {
+    return await driver().getText(selector, index);
+  }
+
+  async function getValue(): Promise<string> {
+    return await driver().getValue(selector, index);
+  }
+
+  async function isDisplayed(): Promise<boolean> {
+    return await driver().isDisplayed(selector, index);
+  }
+
+  async function isVisible(): Promise<boolean> {
+    return await isDisplayed();
+  }
+
+  async function isExisting(): Promise<boolean> {
+    return await driver().isExisting(selector, index);
+  }
+
+  async function isEnabled(): Promise<boolean> {
+    return await driver().isEnabled(selector, index);
+  }
+
+  async function isSelected(): Promise<boolean> {
+    return await driver().isSelected(selector, index);
+  }
+
+  async function isChecked(): Promise<boolean> {
+    return await isSelected();
+  }
+
+  async function isFocused(): Promise<boolean> {
+    return await driver().isFocused(selector, index);
+  }
+
+  async function getAttribute(name: string): Promise<string | null> {
+    return await driver().getAttribute(selector, name, index);
+  }
+
+  async function getCSSProperty(name: string): Promise<{ value: string }> {
+    return await driver().getCSSProperty(selector, name, index);
+  }
+
+  async function waitForElement(timeoutMs?: number): Promise<boolean> {
+    const waitTimeout = timeoutMs ?? globalThis.__TS_RUNTIME__.getImplicitWaitMs();
+    const ok = await globalThis.__TS_RUNTIME__.pollCondition(
+      async () => driver().isExisting(selector, index),
+      waitTimeout,
+    );
+    if (ok) return true;
+    throw new Error('Element not found: ' + JSON.stringify(selectorText));
+  }
+
+  async function waitForDisplayed(opts: { timeout?: number } = {}): Promise<boolean> {
+    const timeout = opts.timeout || 5000;
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      if (await driver().isDisplayed(selector, index)) return true;
+      await new Promise((r) => setTimeout(r, 20));
+    }
+    throw new Error(`Element ${selectorText} not displayed after ${timeout}ms`);
+  }
+
+  return {
+    getText,
+    getValue,
+    isDisplayed,
+    isVisible,
+    isExisting,
+    isEnabled,
+    isSelected,
+    isChecked,
+    isFocused,
+    getAttribute,
+    getCSSProperty,
+    waitForElement,
+    waitForDisplayed,
+  };
+}
+
+globalThis.__TS_RUNTIME__.createElementState = createElementState;