@testspectra/matchers 1.1.11-rc.5 → 1.1.13

package/src/runtime/element_actions.ts

@@ -1,169 +0,0 @@
-/**
- * Element action methods for `SingleElementProxy`.
- *
- * Each action delegates to the bound `PlatformDriverBridge` and wraps the invocation in a
- * semantic `trackStep('action')` log entry. There is zero platform branching here — every
- * platform-specific behavior lives inside the active driver.
- */
-
-import type { ClickOptions, ElementTarget, LongPressOptions, ScopedSelector, TypeOptions } from '@testspectra/matchers';
-
-export function createElementActions(selector: string | ScopedSelector, index: number | null): Record<string, any> {
-  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
-
-  async function click(_options?: ClickOptions): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'click', target: selector, args: [] },
-      async () => {
-        await driver().click(selector, index);
-      },
-    );
-  }
-
-  async function doubleClick(): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'doubleClick', target: selector, args: [] },
-      async () => {
-        await driver().doubleClick(selector, index);
-      },
-    );
-  }
-
-  async function rightClick(): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'rightClick', target: selector, args: [] },
-      async () => {
-        await driver().rightClick(selector, index);
-      },
-    );
-  }
-
-  async function setValue(value: unknown): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'type', target: selector, args: [value] },
-      async () => {
-        await driver().setValue(selector, value, index);
-      },
-    );
-  }
-
-  async function type(value: unknown, options?: TypeOptions): Promise<void> {
-    if (options?.clearFirst) {
-      await clearValue();
-    }
-    await setValue(value);
-  }
-
-  async function clearValue(): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'clear', target: selector, args: [] },
-      async () => {
-        await driver().clearValue(selector, index);
-      },
-    );
-  }
-
-  async function clear(): Promise<void> {
-    await clearValue();
-  }
-
-  async function select(option: string): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'select', target: selector, args: [option] },
-      async () => {
-        await driver().select(selector, option, index);
-      },
-    );
-  }
-
-  async function selectByVisibleText(text: string): Promise<void> {
-    await select(text);
-  }
-
-  async function hover(): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'hover', target: selector, args: [] },
-      async () => {
-        await driver().hover(selector, index);
-      },
-    );
-  }
-
-  async function focus(): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'focus', target: selector, args: [] },
-      async () => {
-        await driver().focus(selector, index);
-      },
-    );
-  }
-
-  async function moveTo(): Promise<void> {
-    await hover();
-  }
-
-  async function dragDrop(target: ElementTarget): Promise<void> {
-    const destSelector = typeof target === 'string' ? target : (target as any)?.selector || String(target);
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'dragDrop', target: selector, args: [destSelector] },
-      async () => {
-        await driver().dragDrop(selector, destSelector, index);
-      },
-    );
-  }
-
-  async function dragAndDrop(target: ElementTarget): Promise<void> {
-    await dragDrop(target);
-  }
-
-  async function longPress(options?: number | LongPressOptions): Promise<void> {
-    const duration = typeof options === 'number' ? options : options?.duration || 1000;
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'longPress', target: selector, args: [duration] },
-      async () => {
-        await driver().longPress(selector, duration, index);
-      },
-    );
-  }
-
-  async function scrollIntoView(): Promise<void> {
-    return globalThis.__TS_RUNTIME__.trackStep(
-      'action',
-      { type: 'action', key: 'scrollIntoView', target: selector, args: [] },
-      async () => {
-        await driver().scrollIntoView(selector, index);
-      },
-    );
-  }
-
-  return {
-    click,
-    doubleClick,
-    rightClick,
-    setValue,
-    type,
-    clearValue,
-    clear,
-    select,
-    selectByVisibleText,
-    hover,
-    focus,
-    moveTo,
-    dragDrop,
-    dragAndDrop,
-    longPress,
-    scrollIntoView,
-  };
-}
-
-globalThis.__TS_RUNTIME__.createElementActions = createElementActions;

package/src/runtime/element_proxy.ts

@@ -1,199 +0,0 @@
-/**
- * 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 +0,0 @@
-/**
- * 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;

package/src/runtime/spectra.ts

@@ -1,110 +0,0 @@
-/**
- * Builds the global `Spectra` automation object.
- *
- * All static actions delegate to the bound `PlatformDriverBridge` (browser/navigation/gestures/
- * network) or to element proxies (element actions). No platform branching here.
- */
-
-import type {
-  ClickOptions,
-  ElementTarget,
-  KeyOption,
-  LongPressOptions,
-  MockInterceptHandle,
-  ScrollOptions,
-  SpectraStatic,
-  SwipeOptions,
-  TypeOptions,
-} from '@testspectra/matchers';
-
-export function buildSpectra(): SpectraStatic {
-  const driver = () => globalThis.__TS_RUNTIME__.activeDriver!;
-
-  return {
-    get: (target: ElementTarget) => globalThis.__TS_RUNTIME__.resolveTargetProxy!(target),
-    getAll: (selector: string) => globalThis.__TS_RUNTIME__.createCollectionProxy!(selector),
-    navigate: (url: string) => driver().navigate(url),
-    back: () => driver().back(),
-    forward: () => driver().forward(),
-    refresh: () => driver().refresh(),
-    setViewport: (width: number, height: number) => driver().setViewport(width, height),
-    wait: (ms: number) => driver().pause(ms),
-    click: async (target: ElementTarget, _textOrOptions?: string | ClickOptions) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.click();
-    },
-    doubleClick: async (target: ElementTarget) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.doubleClick();
-    },
-    rightClick: async (target: ElementTarget) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.rightClick();
-    },
-    type: async (target: ElementTarget, text: string, options?: TypeOptions) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.type(text, options);
-    },
-    clear: async (target: ElementTarget) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.clear();
-    },
-    select: async (target: ElementTarget, option: string) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.select(option);
-    },
-    hover: async (target: ElementTarget) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.hover();
-    },
-    focus: async (target: ElementTarget) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.focus();
-    },
-    dragDrop: async (source: ElementTarget, destination: ElementTarget) => {
-      const srcEl = globalThis.__TS_RUNTIME__.resolveTargetProxy!(source);
-      await srcEl.dragDrop(destination);
-    },
-    scrollIntoView: async (target: ElementTarget) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.scrollIntoView();
-    },
-    scroll: async (options?: ScrollOptions) => {
-      await driver().scroll(options);
-    },
-    swipe: async (options: SwipeOptions) => {
-      await driver().swipe(options);
-    },
-    longPress: async (target: ElementTarget, options?: LongPressOptions | number) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.longPress(options);
-    },
-    pressKey: async (key: KeyOption | string) => {
-      await driver().pressKey(key);
-    },
-    grantPermission: async (name: string) => {
-      await driver().grantPermission(name);
-    },
-    waitForElement: async (target: ElementTarget, timeoutMs?: number) => {
-      const el = globalThis.__TS_RUNTIME__.resolveTargetProxy!(target);
-      await el.waitForElement(timeoutMs);
-    },
-    intercept: async (
-      patternOrOptions: any,
-      maybeMethodOrHandler?: any,
-      maybeFixture?: any,
-      maybeOptions?: any,
-    ): Promise<MockInterceptHandle> => {
-      return await driver().intercept(patternOrOptions, maybeMethodOrHandler, maybeFixture, maybeOptions);
-    },
-    clearMocks: () => {
-      driver().clearMocks();
-    },
-    get browser() {
-      return driver();
-    },
-    env: (globalThis.__TS_RUNTIME__.config.environmentVariables || {}) as SpectraEnv,
-  };
-}
-
-globalThis.__TS_RUNTIME__.buildSpectra = buildSpectra;