Function isCommand

src/commands/interaction/runtime/selector-read.ts:251–328

(
  runtime,
  options,
)

};

export const isCommand: RuntimeCommand<IsCommandOptions, IsCommandResult> = async (
  runtime,
  options,
): Promise<IsCommandResult> => {
  if (!isSupportedPredicate(options.predicate)) {
    throw new AppError(
      'INVALID_ARGS',
      'is requires predicate: visible|hidden|exists|editable|selected|text',
    );
  }
  if (options.predicate === 'text' && !options.expectedText) {
    throw new AppError('INVALID_ARGS', 'is text requires expected text value');
  }
  const includeRects = predicateNeedsRects(options.predicate);
  const capture = await captureSelectorSnapshot(runtime, options, {
    updateSession: true,
    includeRects,
  });
  const chain = parseSelectorChain(options.selector);

  if (options.predicate === 'exists') {
    const matched = findSelectorChainMatch(capture.snapshot.nodes, chain, {
      platform: runtime.backend.platform,
    });
    if (!matched) {
      throw new AppError('COMMAND_FAILED', formatSelectorFailure(chain, [], { unique: false }));
    }
    return {
      predicate: options.predicate,
      pass: true,
      selector: matched.selector.raw,
      matches: matched.matches,
      selectorChain: chain.selectors.map((entry) => entry.raw),
    };
  }

  const resolved = resolveSelectorChain(capture.snapshot.nodes, chain, {
    platform: runtime.backend.platform,
    requireRect: false,
    requireUnique: true,
    disambiguateAmbiguous: false,
  });
  if (!resolved) {
    throw new AppError('COMMAND_FAILED', formatSelectorFailure(chain, [], { unique: true }), {
      command: 'is',
      reason: 'selector_not_found',
      predicate: options.predicate,
      selector: chain.raw,
    });
  }
  const result = evaluateIsPredicate({
    predicate: options.predicate,
    node: resolved.node,
    nodes: capture.snapshot.nodes,
    expectedText: options.expectedText,
    platform: runtime.backend.platform,
  });
  if (!result.pass) {